Skip to content

feat(slack): code-channel worktree, diff view and context bar - #28305

Merged
bolichen97 merged 2 commits into
mainfrom
feat/slack-code-worktree-diff
Nov 5, 2026
Merged

bolichen97 merged 2 commits into
mainfrom
feat/slack-code-worktree-diff

Conversation

@kyleseaman

@kyleseaman kyleseaman commented Nov 2, 2026 •

Copy link
Copy Markdown
Contributor

Builds on #21410, merged into main on 2026-11-04. This PR's two commits: the worktree, diff view and context bar, then #21437's dashboard marking for code-channel sessions (merged into this branch by the owner on 2026-11-02).

Why this is a separate PR. This code was part of #21410. It was split out at the owner's direction (2026-11-02) for one reason: #21410's diff had grown past 1 MB, and the AI review lanes refuse any diff over 1,000,000 bytes. It is the code first reviewed as #21412 and merged into #21410, together with the fixes it gained in review there. Nothing about the design changed in the split. #21437, stacked on this branch, was then merged into it, so this PR also carries the dashboard side of code channels.

  • feat(slack): code channels core #21410 ships the Code channels switch and its defaults, opening, binding, routing and stopping a code channel, sender attribution, and thread follow-ups. A code channel's session runs in its project folder.
  • This PR ships the per-channel git worktree that session runs in, the Code-tab diff view and the context bar (repo, branch, PR, CI), and the switch description's "context bar, a diff tab" wording, which feat(slack): code channels core #21410 leaves out because feat(slack): code channels core #21410 alone does not turn them on.
  • It also ships (commit 2, from feat(slack): mark code-channel sessions in the dashboard #21437) the dashboard marking: a code-channel session is marked as one in the sidebar and the session header, with a link that opens that channel; its workers fold under their conductor; and any session linked to a Slack thread gets a header link to that thread.

Problem / Motivation

Goal: Each Slack code channel gets its own workspace, and its dashboard session is visibly a code channel. In a git project the channel's session runs in a per-channel worktree on its own branch, cut from the session's project folder (falling back to the project folder itself only when the worktree cannot be made), and the channel shows a Code-tab diff view and a context bar (repo, branch, PR, CI). A folder that is not a git project is used as it is. In the dashboard, a session that runs a code channel is marked as one in the sidebar and the session header, with a link that opens that channel, and its conductor's workers fold under it behind one line that says what the crew needs. Any session linked to a Slack thread, whether mirrored to one or started in one, gets a header link that opens that thread, whether or not code channels are on (the owner's build-9 ask: a session he started in Slack showed no Slack link).

Why it matters

Without the workspace, every code channel works on the shared checkout of its project, two channels on one repo step on each other, and nothing in Slack shows what a channel's work changed.

Slack Code is meant to be one session seen from two windows. If the dashboard side cannot tell a user which sessions are code channels, or take them to the channel, the dashboard half of the feature is invisible. And a crew should read as one task whose single line says what it needs, without hiding anything that needs the user.

Not a goal

  • Opening, routing, binding and stopping code channels, and the Code channels switch and defaults (feat(slack): code channels core #21410).
  • A channel canvas; runtime slash commands.
  • Agent tools, commands and wrap-up itself. The dashboard only displays the wrapped_up_at stamp the wrap-up work sets.
  • Publishing work_aggregate: that is feat(slack): conductor work board in code channels #21993's row model. This PR only renders it.
  • Any dashboard change for a session with no code-channel binding and no Slack thread, and, while code channels are off, anything beyond the Slack-thread header link. Parents that are not code-channel conductors keep today's rows.

What changed

Commit 1: worktree, diff view and context bar

Moving part What it does
Worktree workspace/git_ops.py cuts a worktree on a channel-derived branch (slack/<slug>-<hash>) from the repo's default branch through the follow-up card's worktree path (sandboxed git, config hooks disabled). Before the channel's session is created (workspace.core.plan_session, called from routing._bind_channel) the channel gets its own folder under the code channels folder whose project is that worktree, so the session and every worker a conductor files under it start there. A worktree deleted by hand while its branch is kept is checked out again at the same destination (refused for filter repos, as the first cut is). Non-git projects, missing projects, filter repos, hosts without a sandbox and gh missing or signed out degrade without an error.
Preparation An existing channel's workspace is prepared before its session takes a turn: in-channel routing and the first turn await it, and a gateway-start sweep prepares every live (not archived, not wrapped-up) binding. A channel whose folder record was lost gets it back from the folder whose project is its session directory. Turn admission (dashboard and Slack) awaits the same preparation with no timeout. While a worktree should exist but does not and a retry is left (a git error, or a bind that raised), the turn is refused with a "send it again" row instead of running in the shared checkout. Refusals are capped at three attempts per channel and project, after which the turn runs in its project as before. A context-bar failure never refuses a ready worktree.
Identity gate Before the gateway reads a worktree for the diff, git confirms it from both sides: the recorded path is a registered linked worktree of the repository at the channel branch's destination, and asked from that path git reports the repository's own common directory. A forged .git/worktrees/<name> entry and a directory (or link) swapped in at the destination are refused. The agent switching branches or detaching HEAD inside its own tree keeps it verified.
Remembered root The binding remembers the checkout the worktree was cut from (Binding.repo_root, copied from workspace.core.planned_root at bind; a replacement keeps it). A lost workspace record is rebuilt from that root only when the gate still confirms the tree, never from the worktree itself, and a confirmed tree is adopted as it stands.
Diff view After each turn of any session in the channel's folder the Code tab shows the diff against the base (committed, staged, unstaged and new files, three lines of context as git's own), capped at Slack's 1,000,000-byte view limit with a truncation note. Untracked files are read by directory fd (no symlinked root or parent, no hard link, no FIFO swapped in after the lstat); where fds are unavailable an untracked-only change keeps the tab, omitted under the truncation note. Every Slack-bound string goes through the installed credential policy.
Context bar Repo and branch, then PR and CI once a PR exists, from the dashboard PR chip's own provider read; at most five items, labels redacted.
Store The per-channel workspace record (slack-code-channel-workspaces.json) names the worktree the gateway reads outside any sandbox, so it sits in the data home's fenced routing directory beside the code-channel store: refused to agent file tools, masked in every sandbox tier. A store that cannot be read abandons a write instead of rewriting it empty; display reads answer empty.
Gate Acts only when features.code_channels_enabled holds. A feature_disabled / missing_scope / not_allowed_token_type answer to a workspace write is reported to the feature's latch.

Where it lives: src/kiro_crew/slack/code_channels/workspace/ (new), the install hook in slack/code_channels/__init__.py, the calls in routing._bind_channel, _dispatch_directed and _deliver_first_turn, and the "Code-channel workspace" section of docs/system-specs/modules/slack-gateway.md.

Prior art from pganapathy80's slack-code-channels-preview branch (#15175) is reused and credited in the commit.

Commit 2: code-channel sessions in the dashboard (#21437)

  • Slot data. slack/code_channels/dashboard_view.py turns a binding into code_channel {channel_name, status (archived > wrapped_up > active), web_url: Slack's app_redirect link, empty unless the ids are well formed}. Only a person's views carry it: the bare list never does, and dashboard/ws_event_scope.py strips it from app WebSocket rows. While the store is still loading, Slack-linked rows carry code_channel_pending instead, so no thread link flashes before the badge. With the gate shut the store is never read.
  • Keeping it current. slack/code_channels/lifecycle.py handles channel archive, unarchive and rename (and group_*), subscribed in slack-manifest.yaml under #@code_channels. Bound channels only, nothing while the gate is shut, one channel's events in order; a foreign workspace's event is refused, SEL-audited.
  • Sidebar row. The Slack mark in a fixed 10px box plus a small external-link glyph, so it reads as a link named "Open #channel in Slack" (tooltip adds an archived or wrapped-up state). An archived mark is greyed AND wears an archive glyph, never colour alone. No channel text in the row; the agent name yields first so the time keeps its room.
  • Session header. The full link in the header's chip pattern: Slack mark, #channel (truncated, full name in the tooltip), state words, link glyph. A session linked to a Slack thread gets a link to slack.com/archives/<C>/p<ts> (ids validated; "Replies paused" when paused). A session started in a Slack thread is not a mirror, so dashboard/state_parts/slots_frame.py also sends that thread as slack_origin_channel / slack_origin_thread_ts and the header links it the same way. On a phone, which draws no session header, the same link (code channel's, else the thread's) is a row in the top bar's ⋯ menu (MobileTopBar.tsx, shared slackLinkTarget). No URL carries a dashboard credential.
  • Workers fold under their conductor (folder view and unfiled rows): a code-channel conductor's direct workers hide behind a chevron + count, collapsed by default, open state persisted (mc-sidebar-conductor-expanded). Nothing folds while a search or filter narrows the list; the open session or a pinned worker never folds. Open workers keep the sidebar's one content column (docs/decisions/2026-10-09-folder-glyph-sits-on-its-connector-line.md), marked by an out-of-flow rail. Display only; scoped to code-channel conductors. The row's crew marks live in pages/chat-sidebar/CodeChannelCrewRow.tsx, so SessionRow.tsx stays under the file-line cap.
  • The conductor's line (pages/chat-sidebar/codeChannelCrew.ts), worst first: waiting on you > stuck / interrupted > working > done > idle. With work_aggregate present (contract below) its state, label and counts render as given; null or absent, the slot list's states. In both, a worker waiting on the user always takes the line and lights the attention dot. A tool approval reads in the worker row's own words ("Needs approval · approve git push"); a question card or sub-agent approval reads "Waiting on you". The conductor's own ask or stall keeps its own line.
  • Strings. New strings in all 12 catalogs, plurals registered in pluralKeys.json.

work_aggregate contract

Published by #21993 at cc01bfb; this PR consumes the same shape (WorkAggregate, website/src/types/index.chat.ts). An optional field on the conductor's dashboard slot, delivered by the existing slot patch (no new poll), null when there are no workers:

work_aggregate: {
  "state":  "waiting" | "stuck" | "working" | "done" | "idle",  // already resolved worst first: not re-ranked here
  "label":  string,                                               // already redacted: rendered verbatim
  "counts": { "working": n, "waiting": n, "stuck": n, "done": n, "total": n }
}

A shape this build cannot read (unknown state, non-string label, missing counts) is treated as absent.

Backwards compatibility

Compatible: the workspace is behind the code-channels gate; with it shut nothing there runs. A code channel bound before this PR gets its worktree on its next turn start (or at the next gateway start). Its session moves there when the dashboard applies the project change; otherwise it keeps the shared checkout until an operator sets the session's project to the worktree (the spec section says how).

code_channel and code_channel_pending are new optional keys on slot rows (the dashboard also reads an optional work_aggregate, which nothing in this PR sets), and the new Slack events are subscribed only under the code_channels switch. slack_origin_channel and slack_origin_thread_ts are new additive string keys on every serialized slot (empty unless the session was started in a Slack thread), ungated by the code_channels switch on purpose: they carry the Slack-born session's thread for its header link. They reach exactly the audiences the existing slack_channel / slack_thread_ts already reach, app tokens included, and carry the same kind of value (a channel id and a thread ts, no names, no message text, no credential). slack_linked keeps its meaning (False for a Slack-born session). A client that ignores the keys sees today's payload.

Removes nothing: no field, route or event is deleted or tightened. Folding hides worker rows from the folder view's default display only; each stays one chevron away, on its session page, in search and in History.

Premise (for the maintainer override)

First Principles flags the Slack-thread header link (SlackThreadLink, ChatTitleOverlay.tsx) and the slack_origin_* slot fields as reaching sessions outside the code-channel gate. That is intentional and owner-approved: the owner asked for it after build 9, when a session he started in Slack showed no Slack link in its header, and on 2026-10-23 ruled to keep it with this work rather than split it out. The link appears only for a session that is already linked to a Slack thread (mirrored or Slack-born), opens Slack's own permalink built from validated ids, and carries no dashboard credential. The fields are additive and back-compatible (see Backwards compatibility). The Goal above states this scope.

First Principles also flags the work_aggregate reader as having no producer in this tree. It is the dashboard half of a contract whose producer is #21993's work-board row model, still open on another branch. Both halves were built against one written shape so the stack can merge in either order. Until #21993 lands the field is absent: the sidebar falls back to slot data, and the "stuck" and "done" lines don't appear. The crew line ranks code-channel workers from slot data, which lib/crewWorkers.ts (Crew Mode's ledger grouping) does not read, and Crew Mode roots are excluded from the fold.

Tests

  • test_slack_code_channel_workspace.py: worktree cut and reuse, branch naming, diff assembly and the byte cap, untracked-file reads (symlinked root/parent, hard link, FIFO swap, descriptor leaks), the context bar's bounds and redaction, PR/CI lookup, refresh dedup and races, the latch, degraded hosts, the gateway-start sweep and preparation before a turn.
  • test_slack_code_channel_workspace_rebuild.py: the identity gate (branch switch, detached HEAD, forged registration, swapped destination), rebuilding a lost record from the remembered checkout (feature worktree origin, hostile x/.git submodule, unconfirmed root ignored, worktree never remembered), a deleted worktree whose branch is kept checked out again (and never in a filter repo, where git would run the filter), the lost folder recovered, the unreadable store never rewritten empty, and a refresh whose store write fails logs and returns with the lock released.
  • test_slack_code_channels_store_fence.py: the workspace store sits in the routing directory and every sandbox tier masks it.
  • test_slack_code_channels_routing.py: a reopened session keeps or refreshes the remembered root; an existing channel's workspace is prepared before routing.
  • test_security_posture.py: the two workspace modules are registered redaction sinks.
  • test_slack_thread_session_binding.py: serialize_slot on a slack:<ts> self-link ships slack_linked False plus the origin ids; a dashboard mirror, a Slack session mirroring another thread, an empty channel and a non-Slack origin ship none.
  • test_slack_code_channels_dashboard.py: URL building rejects malformed ids; status precedence; view shape; gate shut never reads the store; an unread store is warmed off the loop and re-pushed; viewer scoping through HTTP and WebSocket (a member sees no other session's channel, an app caller never sees either key).
  • test_slack_code_channels_lifecycle.py: archive/unarchive/rename, unbound channel, feature off, refused or mismatched workspace, per-channel ordering (mutation-checked).
  • website/src/components/CodeChannelBadge.test.tsx, website/src/test/ChatPage.mobileTopBarActions.test.tsx, website/src/pages/chat-sidebar/codeChannelCrew.test.ts and website/src/test/ChatSidebar.codeChannelCrew.test.tsx (real sidebar): the row mark and header link, the phone ⋯ menu row, the fold (collapsed by default, persisted, ordinary parents unchanged), work_aggregate in all five states with fallback, and the approval rule on line and dot. Mutation-checked.
  • Browser harnesses on the built SPA: capture-slack-code-channel-row-fit.mjs, capture-slack-code-channel-crew.mjs, capture-slack-code-channel-badge.mjs.

Manual verification

No live Slack Code pilot workspace is available; git behaviour is tested against real throwaway repositories, Slack against recorded payloads. The dashboard UI was checked in a real browser (Playwright) against the built SPA with canned slots shaped as the backend serializes them, by the three harnesses above, which assert the DOM before each shot.

Screenshots / video

The same Slack Code panel at this head: the Code channels description says what turning it on lets the app do, including the context bar and diff tab this PR adds, before the permission count. #21410 carries the rest of the panel's states (off, open pickers, folder modal, warnings). Rendered from this head's frontend with the Slack settings API stubbed (placeholder data only: example folder, agent and model names; no tokens, workspace ids or hosts).

Slack Code settings panel

Dashboard marking (from #21437; earlier before/after shots are in its evidence comment):

Before After
Sidebar row, 180px before row 180px after row 180px
Workers, a hidden worker needs approval before crew 260px after waiting on you 260px
Workers expanded after expanded 260px
Header, session started in Slack (evidence) before Slack-born header after Slack-born header

after header

Dark Light
Row, active channel row active dark row active light
Row, archived channel row archived dark row archived light

Fold opening and closing (260px, dark): fold open and close

Known gaps

  • A mirrored thread's chip reads "Slack thread": the slot carries the thread's channel id, not its name. Its permalink carries no workspace, so a user signed into several workspaces may land in the wrong one.
  • The row mark's click target is its 10px box. The fold's chevron sits inside the row's button role, as the conductor lane's chevron does.
  • Turning code channels on or off (or the app losing the scope) does not re-push the slot list; badges follow on the next push.
  • An archive or rename while code channels are off, or while the gateway is down, is not replayed, so that channel keeps its last known state until its next event.

Sensitive change

Scope: this PR adds 2 lines and removes none on a Sensitive Change Review path: two _REDACTION_SINKS rows in security_posture_sinks_delivery.py for the workspace modules. They moved here from #21410 with the modules they name; their text is unchanged. Commit 2 (#21437) touches no Sensitive Change Review path. No protection list changes; exfil.py is not touched.

## Sensitive change review
- Head commit: 53677fcc2ed321f46a085ecc4b5066fe34ce5546
- What rule changed: two _REDACTION_SINKS rows in security_posture_sinks_delivery.py's _DELIVERY_SINKS: slack/code_channels/workspace/context_bar.py (its labels) and slack/code_channels/workspace/service.py (its diff view). No protection list changes. The workspace store (routing/slack-code-channel-workspaces.json) is protected by the existing "routing" entries: the read+write sensitive floor (_CREW_SECRET_LEAVES), the sandbox mask (_CREW_HIDDEN_LEAVES) and pre-creation (_CREW_PRECREATE_HIDDEN_DIR_LEAVES).
- Before -> after (what was allowed/blocked, now): Before, the posture panel did not list these two modules and the redactor-call drift test would fail on them. After, they are listed. For the workspace store: agent file tools refuse reads and writes and every sandbox tier hides it, so an agent cannot point the gateway's diff read at another path.
- Worst case if wrong (breaks commands / leaks secret / locks user out): A posture row misdescribes one module's redaction on the Security panel. If the routing fence were wrong, an agent could rewrite the worktree path the gateway reads for the diff; the identity gate (git confirms the tree from both sides) still refuses a path that is not the channel's own linked worktree.
- Evidence checked (which sandbox result proves it): test_slack_code_channels_store_fence.py (the workspace store in routing/, masked in standard/cc/strict). test_security_posture.py: removing either row makes test_every_redactor_call_site_is_a_registered_sink_or_allowlisted name that module. test_slack_code_channel_workspace_rebuild.py: forged registration and swapped destination are refused.
- No regression:
  - Tools still work (which tools/commands were run, result): the sandbox, security and posture suites pass on this head.
  - Backward compatible (old config / old data / old callers still work, how checked): only the gateway reads the workspace store; a record missing a field loads with it empty.
  - Existing tests (which suites passed on this head): On this head: flake8, isort, the black gate, comment-history, docs lint, file-line cap, mypy and Semgrep (diff) pass; 831 targeted backend tests pass (test_slack_code_channel_workspace*.py, test_slack_code_channels_*.py, test_slack_code_channel_turn_end.py, test_security_posture*.py, test_slack_thread_session_binding.py, test_slack_post_message_call_sites.py, test_slack_code_settings.py) and 1,721 related frontend tests (77 files, the i18n suites included) pass with tsc and eslint clean.
- How to undo: Remove the two rows (the drift test then fails for those modules).

Related Issues

Part of #15175. work_aggregate contract: #21993 (cc01bfb). Includes #21437.

Checklist

  • At most two commits (one is the norm), with a Conventional Commits title.
  • Existing tests pass and new tests added for new functionality
  • Self-review completed; code follows project style guidelines
  • Documentation updated (if applicable)
  • No secrets, credentials, or internal references in the diff

@kyleseaman
kyleseaman requested review from a team and KiroCrewCaptain as code owners November 2, 2026 16:09
@kyleseaman
kyleseaman requested review from chenmingwei23 and removed request for a team November 2, 2026 16:09
@kyleseaman kyleseaman mentioned this pull request Nov 2, 2026
5 tasks done
@github-actions

github-actions Bot commented Nov 2, 2026 •

Copy link
Copy Markdown
Contributor

Sensitive Change Review

Sensitive files changed:

  • src/kiro_crew/security_posture_sinks_delivery.py

  • @kyleseaman posted a complete reasoning template for 53677fc.

@github-actions

github-actions Bot commented Nov 2, 2026 •

Copy link
Copy Markdown
Contributor

UX Review (Opus 5.5) — ✅ PASS (a BLOCK with no Trigger and no Outcome does not block)

UX-level review of 53677fcc2ed321f46a085ecc4b5066fe34ce5546 — updated in place on each push. A BLOCK verdict blocks PR readiness; PASS does not.

UX-Verdict: PASS

cannot evaluate: missing the phone top bar's Slack mark and its new ⋯ menu link, the "Task done" and header-archived states, the "Replies paused" thread chip, and the "worktree is not ready" error card. No supplied screenshot shows any of them.

Evidence gaps

  • Phone top bar (MobileTopBar.tsx): the CodeChannelMark glyph beside the title, and the new ⋯ menu row "Open #name in Slack" / "Open this Slack thread". Neither appears in any screenshot. Needs a phone-width still with the menu open.
  • wrapped_up state ("Task done" and its CircleCheck), on both the sidebar row and the header chip. Shots 12 and 13 show only "Channel archived", and only on a row. Needs a row still and a header still for a finished task, plus the archived header chip.
  • SlackThreadLink paused tone, "Replies paused" (dashed chip). Shot 08 shows only the active thread chip. Needs a still of the paused chip.
  • Error card code_channel_worktree_not_ready ("This code channel's worktree is not ready, so the message was not run. Send it again in a moment."). No still shows it in the chat.
  • Folded crew lines other than "Needs approval": "Waiting on you", "N stuck", "N interrupted", "N of M done" and the working spinner, plus the attention marks for interrupted and unread. Only the approval state is shown (shot 05).
  • Shots 02 and 04 show row badges the diff no longer renders: a wide boxed mark, a dashed archive mark and a #fix-kirocrew-issue-… row pill. They are not evidence for this revision; replace them with current renders.

Notes

  • Expanding the crew (shot 05 → shot 06) changes the conductor row's line from "Needs approval" to "Thinking…". The reader asked "which status is the real one". Keep a muted marker on the expanded conductor, such as the existing CodeChannelCrewAttentionMark shield, so the approval doesn't seem to vanish when the crew opens.
  • Shot 06 has a faint "22452 ×" ghosted over the selected row's title, and the reader couldn't identify it. Check that the row's hover action strip doesn't paint over the title at rest.

[UX-REVIEWED] 53677fc

Description read

[DESCRIPTION-READ] 0c7bb7be8d55dfeea7b3dd87cab4b08440d49705702b89bd2b3068debc900513

That sha256 names everything this verdict read: the PR description, plus the 16 evidence file(s) the workflow collected from it and handed this review. It covers that evidence because the media strip replaces every attachment URL with the same placeholder, so an edit swapping one attachment for another would leave the description's captured text identical while what this review judged changed. Recompute it with .github/scripts/pr-description-capture.sh over the same inputs; if it differs, the description or that evidence changed after this verdict was formed and any finding drawn from either is unproven.

@github-actions github-actions Bot added the readiness: checking Automated validation is still running label Nov 2, 2026
@github-actions

github-actions Bot commented Nov 2, 2026 •

Copy link
Copy Markdown
Contributor

Design Review (Opus 5.5) — ✅ PASS

Design-level review of 53677fcc2ed321f46a085ecc4b5066fe34ce5546 — updated in place on each push. A BLOCK verdict blocks PR readiness; PASS does not.

Design-Verdict: PASS

Nothing blocks: the feature is behind features.code_channels_enabled, the worktree refusal is capped and bounded by git's own timeouts, and the slot changes only add fields.

Notes

  • The description is cut off before ## Backwards compatibility, so that section went unchecked. The patch removes no key, route or field: the removed lines are refactors of _slot_links and the sidebar renderers.

[DESIGN-REVIEWED] 53677fc

Description read

[DESCRIPTION-READ] 2e2f1ec5b832d4c3fdcc0545fe655894890486e6e7fe4f99b117c3b23a250916

That sha256 names everything this verdict read: the PR description, plus the 1 evidence file(s) the workflow collected from it and handed this review. It covers that evidence because the media strip replaces every attachment URL with the same placeholder, so an edit swapping one attachment for another would leave the description's captured text identical while what this review judged changed. Recompute it with .github/scripts/pr-description-capture.sh over the same inputs; if it differs, the description or that evidence changed after this verdict was formed and any finding drawn from either is unproven.

@github-actions

github-actions Bot commented Nov 2, 2026 •

Copy link
Copy Markdown
Contributor

First Principles Review (Opus 5.5) — ✅ PASS

Premise-level review of 53677fcc2ed321f46a085ecc4b5066fe34ce5546 — why this exists and whether the shipped surface is the smallest honest version. Updated in place on each push. A BLOCK verdict blocks PR readiness; PASS does not.

First-Principles-Verdict: PASS

Every item stays behind features.code_channels_enabled, which is off by default. The worktree, diff view and context bar are covered by rfc-slack-code-channels.md, which is in-progress on base.

Notes

  • Item 9 — one consumer, generalized: _SCOPE_LISTENERS: list[...] and on_scopes_recorded have exactly one caller, features.on_scopes_recorded(_on_scopes) in workspace/__init__.py (grepped on_scopes_recorded: 1 call site plus the definition). Subtraction: replace the list with a single optional callback slot, or have the sweep run off the connect probe's existing return path.

What this change ships

Inventory (10 items) — 9 justified

Intent: give each Slack code channel its own git worktree and diff/context view, and mark code-channel sessions in the dashboard. ADDITION.

  1. In a git project, a code channel's session runs in its own worktree on a slack/<slug>-<hash> branch — justified
  2. The Code tab shows the channel's diff after each turn, capped at 1 MB — justified
  3. The context bar shows repo, branch, PR and CI — justified
  4. A turn is refused with a "send it again" row while the worktree is not ready, at most three times — justified
  5. When the gateway starts, it prepares the workspace of every live binding — justified
  6. Sidebar and header show a code-channel badge that links to the channel — justified
  7. A conductor's workers fold under it behind one crew line — justified
  8. Any session linked to a Slack thread gets a header link to that thread — justified
  9. A new scope-recorded listener registry in slack/features.py — one consumer, generalized
  10. New manifest events for channel archive, unarchive and rename update the badge — justified

[FIRST-PRINCIPLES-REVIEWED] 53677fc

Description read

[DESCRIPTION-READ] f1fdbe54559811c2835af8314fc0b0874114c386f736c4f2d09b57b85a2debb5

That sha256 names the PR description this verdict read. Recompute it with .github/scripts/pr-description-capture.sh; if it differs, the description changed after this verdict was formed and any finding drawn from the description is unproven.

@github-actions

github-actions Bot commented Nov 2, 2026 •

Copy link
Copy Markdown
Contributor

GPT 6.1 Review — ✅ human override accepted

Human judgment by @kyleseaman overrides the GPT 6.1 finding for 53677fcc2ed321f46a085ecc4b5066fe34ce5546; the recorded reason is authoritative for this commit.

[GPT-OVERRIDE] 53677fc

This comment is updated in place on each push.

The model was not re-run because an authorized human decision supersedes it.

False positive or not applicable? A repository writer can comment:
/ai-review override gpt 53677fcc2ed321f46a085ecc4b5066fe34ce5546 false-positive: <reason, 20 to 500 characters>

@github-actions

github-actions Bot commented Nov 2, 2026 •

Copy link
Copy Markdown
Contributor

Opus 5.5 Review — ✅ no blocking findings

Reviewed 53677fcc2ed321f46a085ecc4b5066fe34ce5546 — this comment is updated in place on each push.

Review details

No findings.

[OPUS-REVIEWED] 53677fc

Verdict parsed from the review's SHA-scoped output markers for commit 53677fcc2ed321f46a085ecc4b5066fe34ce5546.

False positive or not applicable? A repository writer can comment:
/ai-review override fable 53677fcc2ed321f46a085ecc4b5066fe34ce5546 false-positive: <reason, 20 to 500 characters>

@github-actions github-actions Bot added readiness: action required A blocking check or review needs attention readiness: checking Automated validation is still running and removed readiness: checking Automated validation is still running readiness: action required A blocking check or review needs attention labels Nov 2, 2026
@kyleseaman
kyleseaman force-pushed the feat/slack-code-channels-core branch from c00a7d5 to 5622600 Compare November 2, 2026 17:39
@kyleseaman
kyleseaman force-pushed the feat/slack-code-worktree-diff branch from 1574eff to 68c383c Compare November 2, 2026 17:45
@github-actions github-actions Bot added merge conflict Branch has merge conflicts with its base — author must resolve before merge readiness: action required A blocking check or review needs attention and removed merge conflict Branch has merge conflicts with its base — author must resolve before merge readiness: checking Automated validation is still running labels Nov 2, 2026
@kyleseaman
kyleseaman force-pushed the feat/slack-code-channels-core branch from 5622600 to dbc4fa5 Compare November 2, 2026 18:33
@github-actions github-actions Bot added the merge conflict Branch has merge conflicts with its base — author must resolve before merge label Nov 2, 2026
@kyleseaman
kyleseaman force-pushed the feat/slack-code-worktree-diff branch from 68c383c to b0ecebd Compare November 2, 2026 18:38
@github-actions github-actions Bot added readiness: checking Automated validation is still running and removed readiness: action required A blocking check or review needs attention merge conflict Branch has merge conflicts with its base — author must resolve before merge labels Nov 2, 2026
@kyleseaman
kyleseaman force-pushed the feat/slack-code-channels-core branch from dbc4fa5 to 221bbfd Compare November 2, 2026 18:49
@kyleseaman
kyleseaman force-pushed the feat/slack-code-channels-core branch from f5a0afb to 8a5bc3a Compare November 3, 2026 14:15
@github-actions github-actions Bot added the merge conflict Branch has merge conflicts with its base — author must resolve before merge label Nov 3, 2026
@kyleseaman
kyleseaman force-pushed the feat/slack-code-worktree-diff branch from c3bfd0c to 523a819 Compare November 3, 2026 14:30
@github-actions github-actions Bot added readiness: checking Automated validation is still running readiness: action required A blocking check or review needs attention and removed readiness: action required A blocking check or review needs attention merge conflict Branch has merge conflicts with its base — author must resolve before merge readiness: checking Automated validation is still running labels Nov 3, 2026
@kyleseaman
kyleseaman force-pushed the feat/slack-code-channels-core branch from 8a5bc3a to 24b200e Compare November 3, 2026 16:54
@kyleseaman

Copy link
Copy Markdown
Contributor Author

GPT findings on the previous head are fixed at 6b59d0b, now on #21410's new head.

  • Prepare timeout (a turn ran in the shared checkout when the bind outlasted the hook timeout): the turn-start hook list is now a single preparer that admission awaits with no timeout. If a worktree should exist but does not and a retry is left (a git error, or a bind that raised: ensure(strict=True)), the turn is refused with a "send it again" row and never runs in the shared checkout.
  • The refusals are bounded: three attempts per channel and project, counted per project, and raised binds are counted per process. After that the turn runs in its project, as it did before the gate. Context-bar failures, and store writes after the answer is known (a settled skip, a session already pointed at its tree), never refuse a turn.
  • The cold-store finding is fixed in the core (feat(slack): code channels core #21410).
  • Fail-first tests are in test_slack_code_channel_workspace_rebuild.py: ..._refused_only_while_a_retry_is_left, test_a_context_bar_that_fails_to_publish_never_refuses_a_ready_worktree, test_spent_bind_attempts_do_not_carry_over_to_a_new_project, test_a_bind_that_always_raises_... and test_an_unwritable_store_never_refuses_a_turn_whose_outcome_is_known.
  • Main has grown SessionRow.tsx, so ExecutorCrewChip moves unchanged to chat-sidebar/ExecutorCrewChip.tsx. That keeps the file under the 2,000-line cap.

@kyleseaman

Copy link
Copy Markdown
Contributor Author

Opus finding turn_admission.py:331 (the "worktree not ready" row could not be localized) is fixed at 114a546.

  • The row now carries meta.notice = code_channel_worktree_not_ready, a new GATEWAY_NOTICE_CODE_CHANNEL_WORKTREE_NOT_READY token.
  • The token has a matching NOTICE_FAMILIES (error card), COPY_KEY and LEGACY row in gatewayNotice.ts, plus the capture fixture and catalog copy in all 12 locales and en-XA.
  • test_slack_code_channel_dashboard_turn_workspace.py asserts the token and fails without it. The pinned counts in test_transient_notice_parity.py and gatewayNotice.test.tsx are updated.
  • The branch is rebased onto feat(slack): code channels core #21410's 12d80cda95, which carries the LinkedRoute delivery fix.

@kyleseaman

Copy link
Copy Markdown
Contributor Author

The three upheld findings on 114a546 are fixed at 5337519, now rebased onto #21410's 2dcf4d42aa.

  • First Principles (diff.py had its own dir-fd walk): _walk_beneath and _DIR_FD_OK are deleted. _read_leaf now walks with pinned_fs.open_pinned_descendant_dir, is gated on supports_pinned_walk(), and refuses a hard-link alias on the open descriptor with refuse_hardlink_alias. The existing symlink, hard-link, FIFO and fd-leak tests pass unchanged, and a new test asserts that untracked reads go through pinned_fs. The render_untracked tests moved to test_slack_code_channel_workspace_untracked.py to stay under the line cap.
  • GPT codeChannelCrew.ts:332 (a folded crew's wording was kept stale): sameCrewView now compares approval. Fail-first test in codeChannelCrew.test.ts.
  • Opus service.py:707 (refusals that can never pass were retried): git_ops.create_or_adopt_worktree returns WorktreeRefused for 403/409, and for a 400 with no commit to branch from. It maps to the settled skip worktree_refused, audited as denied with the reason, so the session runs in its project from the first turn. Anything that can pass is still retried: a 5xx, a failed git worktree add, a kept branch whose re-checkout failed, and a held ref lock ("Branch already exists"). Fail-first tests are in test_slack_code_channel_workspace_rebuild.py.
  • Two fresh-context reviews: the first's finding (a kept branch was settled after a transient failure) is fixed, and the second came back CLEAN. Posture rows are byte-identical.

@kyleseaman

Copy link
Copy Markdown
Contributor Author

Fixed at a32cdb9, rebased onto #21410's 9695b66623:

  • GPT git_ops.py:274 (adopted the main checkout): _registered_path_for no longer returns the first-listed tree or the repository root. A channel branch checked out in the shared checkout now takes the bounded retry path, and the turn runs in its project after three attempts, never in that checkout as the channel's worktree. Fail-first test: test_slack_code_channel_workspace_rebuild.py::test_a_channel_branch_checked_out_in_the_shared_checkout_is_never_adopted. The reviewer also confirmed it against real git.
  • Opus turn_admission.py:332 (the refusal was invisible in Slack): the "worktree is not ready" text is now the module constant _WORKTREE_NOT_READY_TEXT. It goes on the dashboard row as before and is also delivered to the channel top-level, through recipient._deliver_linked_slack_message (as the auth-required refusal does). A dashboard-only session is unaffected. The fail-first assertion is in test_slack_code_channel_dashboard_turn_workspace.py, and the notice-parity test still finds the site.
  • A fresh-context review found it CLEAN. Posture rows are byte-identical.

@kyleseaman

Copy link
Copy Markdown
Contributor Author

GPT finding service.py:1042 (the cached PR was shown for another repository or branch) is fixed at 28d9f00.

  • A new record field, pr_for (host/owner/name@branch), names the checkout the cached PR belongs to.
  • _refresh_pr sets it when a PR is found. On none, on a detached HEAD or no forge remote, and when gh can't answer and pr_for doesn't match the current checkout, it clears the PR. It keeps the PR (dropping its CI) only when gh can't answer and the checkout is the same.
  • _bar_state publishes the PR only while pr_for matches, so the context bar never links another checkout's PR.
  • Fail-first test: test_slack_code_channel_workspace.py::test_gh_signed_out_never_shows_another_checkouts_pr[branch|remote]. ..._keeps_the_last_known_pr_and_drops_its_ci still passes.
  • A fresh-context review checked every pr_* reader and writer, record loading and the identity parity, and found it CLEAN. Posture rows are byte-identical.

@kyleseaman

Copy link
Copy Markdown
Contributor Author

Kyle: one First Principles note (non-blocking, PASS) on the worktree/diff PR that a product decision settles. Please post this as a plain PR comment if you agree; the override line below is held for the final head and is not to be posted yet.

Rebuilding a lost workspace record from the remembered checkout (Binding.repo_root). The note says no lost-record case is cited and suggests treating a missing record as "no worktree" instead. A record can be lost when the workspace store is unreadable or reset (it is never rewritten empty, but it can be missing), or after an upgrade from an earlier build of this feature. Without the rebuild, a channel whose record is gone silently falls back to the shared project checkout. Its worktree, branch and diff base are then lost, and two channels on one repo can clash again, which is the problem this PR exists to fix. This is the remembered-root design you chose earlier (option B: remember it, don't infer it). The rebuild only adopts a tree that git confirms from both sides is the channel's own linked worktree.

Decision: keep the rebuild (owner decision).

Override (only if the First Principles lane turns BLOCK on this item; for the final head, not now):
/ai-review override first-principles <final-head-sha> owner-decision: lost-record rebuild from the remembered checkout is the owner's chosen design (option B) <link to this comment>


Carried over from #21437 (merged into this branch), for the same plain comment:

Keeping the work_aggregate reader (First Principles BLOCK on #21437). I'm keeping it in this PR. It is the dashboard half of a contract whose producer is #21993's work-board row model ({state, label, counts} on a conductor's slot, delivered by the ordinary slot patch), which is still open on another branch. The two halves were deliberately built against one written shape, so the stack can merge in either order. Until #21993 lands the field is simply absent: the sidebar falls back to slot data, and the "stuck" and "done" lines don't appear. The PR description and code comments say nothing in this tree sets it yet, so nothing claims otherwise. The cost of keeping it is one small, fully tested branch. Removing it would mean shipping the same contract again in #21993 and reviewing it twice. The review's two notes don't change this. The crew line ranks code-channel workers from slot data (approval, interrupted, working), which lib/crewWorkers.ts (Crew Mode's ledger grouping) does not read, and Crew Mode roots are excluded from the fold. The three capture-slack-code-channel-*.mjs scripts are the browser checks this PR's evidence comes from, the same as the other website/scripts/capture-* harnesses.

The Slack-thread header link and slack_origin_* fields reaching sessions outside the code-channel gate. Intentional and owner-approved (your build-9 ask; your 2026-10-23 ruling kept it with this work). The PR body's "Premise" section states it.

Decision: keep both (owner decision).

@kyleseaman

Copy link
Copy Markdown
Contributor Author

Sensitive change review

  • Head commit: 28d9f00
  • What rule changed: two _REDACTION_SINKS rows in security_posture_sinks_delivery.py's _DELIVERY_SINKS: slack/code_channels/workspace/context_bar.py (its labels) and slack/code_channels/workspace/service.py (its diff view). No protection list changes. The workspace store (routing/slack-code-channel-workspaces.json) is protected by the existing "routing" entries: the read+write sensitive floor (_CREW_SECRET_LEAVES), the sandbox mask (_CREW_HIDDEN_LEAVES) and pre-creation (_CREW_PRECREATE_HIDDEN_DIR_LEAVES).
  • Before -> after (what was allowed/blocked, now): Before, the posture panel did not list these two modules and the redactor-call drift test would fail on them. After, they are listed. For the workspace store: agent file tools refuse reads and writes and every sandbox tier hides it, so an agent cannot point the gateway's diff read at another path.
  • Worst case if wrong (breaks commands / leaks secret / locks user out): A posture row misdescribes one module's redaction on the Security panel. If the routing fence were wrong, an agent could rewrite the worktree path the gateway reads for the diff; the identity gate (git confirms the tree from both sides) still refuses a path that is not the channel's own linked worktree.
  • Evidence checked (which sandbox result proves it): test_slack_code_channels_store_fence.py (the workspace store in routing/, masked in standard/cc/strict). test_security_posture.py: removing either row makes test_every_redactor_call_site_is_a_registered_sink_or_allowlisted name that module. test_slack_code_channel_workspace_rebuild.py: forged registration and swapped destination are refused.
  • No regression:
    • Tools still work (which tools/commands were run, result): the sandbox, security and posture suites pass on this head.
    • Backward compatible (old config / old data / old callers still work, how checked): only the gateway reads the workspace store; a record missing a field loads with it empty.
    • Existing tests (which suites passed on this head): On this head: flake8, isort, the black gate, comment-history, docs lint, file-line cap, mypy and Semgrep (diff) pass; 831 targeted backend tests pass (test_slack_code_channel_workspace*.py, test_slack_code_channels_.py, test_slack_code_channel_turn_end.py, test_security_posture.py, test_slack_thread_session_binding.py, test_slack_post_message_call_sites.py, test_slack_code_settings.py) and 1,721 related frontend tests (77 files, the i18n suites included) pass with tsc and eslint clean.
  • How to undo: Remove the two rows (the drift test then fails for those modules).

@kyleseaman

Copy link
Copy Markdown
Contributor Author

Sensitive change review

  • Head commit: a73200c
  • What rule changed: two _REDACTION_SINKS rows in security_posture_sinks_delivery.py's _DELIVERY_SINKS: slack/code_channels/workspace/context_bar.py (its labels) and slack/code_channels/workspace/service.py (its diff view). No protection list changes. The workspace store (routing/slack-code-channel-workspaces.json) is protected by the existing "routing" entries: the read+write sensitive floor (_CREW_SECRET_LEAVES), the sandbox mask (_CREW_HIDDEN_LEAVES) and pre-creation (_CREW_PRECREATE_HIDDEN_DIR_LEAVES).
  • Before -> after (what was allowed/blocked, now): Before, the posture panel did not list these two modules and the redactor-call drift test would fail on them. After, they are listed. For the workspace store: agent file tools refuse reads and writes and every sandbox tier hides it, so an agent cannot point the gateway's diff read at another path.
  • Worst case if wrong (breaks commands / leaks secret / locks user out): A posture row misdescribes one module's redaction on the Security panel. If the routing fence were wrong, an agent could rewrite the worktree path the gateway reads for the diff; the identity gate (git confirms the tree from both sides) still refuses a path that is not the channel's own linked worktree.
  • Evidence checked (which sandbox result proves it): test_slack_code_channels_store_fence.py (the workspace store in routing/, masked in standard/cc/strict). test_security_posture.py: removing either row makes test_every_redactor_call_site_is_a_registered_sink_or_allowlisted name that module. test_slack_code_channel_workspace_rebuild.py: forged registration and swapped destination are refused.
  • No regression:
    • Tools still work (which tools/commands were run, result): the sandbox, security and posture suites pass on this head.
    • Backward compatible (old config / old data / old callers still work, how checked): only the gateway reads the workspace store; a record missing a field loads with it empty.
    • Existing tests (which suites passed on this head): On this head: flake8, isort, the black gate, comment-history, docs lint, file-line cap, mypy and Semgrep (diff) pass; 831 targeted backend tests pass (test_slack_code_channel_workspace*.py, test_slack_code_channels_.py, test_slack_code_channel_turn_end.py, test_security_posture.py, test_slack_thread_session_binding.py, test_slack_post_message_call_sites.py, test_slack_code_settings.py) and 1,721 related frontend tests (77 files, the i18n suites included) pass with tsc and eslint clean.
  • How to undo: Remove the two rows (the drift test then fails for those modules).

A Slack code channel bound to a session whose project is a git repo now
runs in its own worktree, cut on a channel-derived branch from the
repo's default branch through the follow-up card's worktree path. Before
the channel's session is created it gets its own folder under the code
channels folder whose project is that worktree, so the session and every
worker a conductor files under it start there. After each turn of any
session in that folder the channel's Code tab shows the diff against the
base (committed, staged, unstaged and new files, capped at Slack's
1,000,000-byte view limit with a truncation note) and the context bar
shows repo and branch, then PR and CI once a PR exists. PR state and CI
come from the dashboard PR chip's own provider read.

The workspace acts only when features.code_channels_enabled holds: the
Slack Code toggle is on and the install can use code channels. A
feature_disabled, missing_scope or not_allowed_token_type answer to a
workspace write is reported to the feature's latch, which turns code
channels off for the process. Non-git projects, missing projects,
filter repos, hosts without a sandbox and gh missing or signed out
degrade without an error.

The worktree identity gate refuses a forged registration in the shared git
dir and a directory swapped in at the destination. A lost workspace record
is rebuilt from the checkout the binding remembers (repo_root), never from
the worktree itself, and an unreadable store abandons a write instead of
rewriting it empty. An untracked-only change whose files cannot be read by
fd keeps the diff tab, omitted under the truncation note.

Co-authored-by: pganapathy80 <26177755+pganapathy80@users.noreply.github.com>
* feat(slack): mark code-channel sessions in the dashboard

Sidebar row and session header show a Slack code channel chip with a link to the channel and its archived / wrapped-up state. The row chip keeps its Slack mark whole, yields width after the agent name, drops its link glyph before the channel name, and goes icon-only below a readable floor; the time never shrinks. Slack channel_archive / unarchive / rename events update the binding.

* feat(slack): code-channel row mark, header links, folded worker crews

Sidebar rows carry the Slack mark alone, a link named 'Open #channel in Slack'. The session header carries the full link (mark, #channel, state, link glyph); a session mirrored to a Slack thread gets a header link to its thread (paused state shown; hidden while code channels are still loading). In the folder view a code-channel conductor's direct workers fold under its row behind a persisted disclosure. The conductor's status line reports the crew worst-first (waiting on you > stuck/interrupted > working > done > idle) from slot data, and from the conductor slot's optional work_aggregate {state, label, counts} when published; a hidden worker's approval or unread result always surfaces on the conductor row.

A session started in a Slack thread is not slack_linked (its thread is
where it lives, not a mirror), so serialize_slot shipped empty
slack_channel/slack_thread_ts and SlackThreadLink drew nothing.

serialize_slot now also ships slack_origin_channel and
slack_origin_thread_ts for a genuine Slack-origin self-link, keeping
slack_linked False so sidebar, menu and mirror semantics are unchanged.
SlackThreadLink links those ids when the session is not mirrored and
reads paused from the origin row. While the code-channel store is
unread, rows carrying an origin thread are marked code_channel_pending
too, so a bound session never flashes the thread link.
@kyleseaman

Copy link
Copy Markdown
Contributor Author

/ai-review override gpt 53677fc deferred #30481: Folder-only watch misses unfiled workers on the channel worktree; the Code tab goes stale but nothing breaks or leaks. Not security. Fix tracked in #30481.

@github-actions

github-actions Bot commented Nov 5, 2026

Copy link
Copy Markdown
Contributor

Human judgment recorded

@kyleseaman recorded a deferred release (class deferred) for the gpt AI finding on 53677fcc2ed321f46a085ecc4b5066fe34ce5546.

Folder-only watch misses unfiled workers on the channel worktree; the Code tab goes stale but nothing breaks or leaks. Not security. Fix tracked in #30481.

This decision applies only to this commit. A new push requires a new judgment.

@kyleseaman

Copy link
Copy Markdown
Contributor Author

Sensitive change review

  • Head commit: 53677fc
  • What rule changed: two _REDACTION_SINKS rows in security_posture_sinks_delivery.py's _DELIVERY_SINKS: slack/code_channels/workspace/context_bar.py (its labels) and slack/code_channels/workspace/service.py (its diff view). No protection list changes. The workspace store (routing/slack-code-channel-workspaces.json) is protected by the existing "routing" entries: the read+write sensitive floor (_CREW_SECRET_LEAVES), the sandbox mask (_CREW_HIDDEN_LEAVES) and pre-creation (_CREW_PRECREATE_HIDDEN_DIR_LEAVES).
  • Before -> after (what was allowed/blocked, now): Before, the posture panel did not list these two modules and the redactor-call drift test would fail on them. After, they are listed. For the workspace store: agent file tools refuse reads and writes and every sandbox tier hides it, so an agent cannot point the gateway's diff read at another path.
  • Worst case if wrong (breaks commands / leaks secret / locks user out): A posture row misdescribes one module's redaction on the Security panel. If the routing fence were wrong, an agent could rewrite the worktree path the gateway reads for the diff; the identity gate (git confirms the tree from both sides) still refuses a path that is not the channel's own linked worktree.
  • Evidence checked (which sandbox result proves it): test_slack_code_channels_store_fence.py (the workspace store in routing/, masked in standard/cc/strict). test_security_posture.py: removing either row makes test_every_redactor_call_site_is_a_registered_sink_or_allowlisted name that module. test_slack_code_channel_workspace_rebuild.py: forged registration and swapped destination are refused.
  • No regression:
    • Tools still work (which tools/commands were run, result): the sandbox, security and posture suites pass on this head.
    • Backward compatible (old config / old data / old callers still work, how checked): only the gateway reads the workspace store; a record missing a field loads with it empty.
    • Existing tests (which suites passed on this head): On this head: flake8, isort, the black gate, comment-history, docs lint, file-line cap, mypy and Semgrep (diff) pass; 831 targeted backend tests pass (test_slack_code_channel_workspace*.py, test_slack_code_channels_.py, test_slack_code_channel_turn_end.py, test_security_posture.py, test_slack_thread_session_binding.py, test_slack_post_message_call_sites.py, test_slack_code_settings.py) and 1,721 related frontend tests (77 files, the i18n suites included) pass with tsc and eslint clean.
  • How to undo: Remove the two rows (the drift test then fails for those modules).

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants