@sjawhar/claude-envoy 1.6.0 → 1.7.1

package/.claude-plugin/plugin.json

@@ -2,5 +2,5 @@
   "name": "claude-envoy",
   "description": "Deliver Envoy events as Claude Code channel notifications and expose Envoy MCP tools.",
   "mcpServers": "./.mcp.json",
-  "version": "1.6.0"
+  "version": "1.7.1"
 }

package/.omp-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-envoy",
-  "version": "1.6.0",
+  "version": "1.7.1",
   "description": "Deliver Envoy events as Claude Code channel notifications and expose Envoy MCP tools.",
   "mcpServers": {}
 }

package/AGENTS.md

@@ -113,9 +113,9 @@ Dispatch asks stay on Dispatch.
 | Oh My Pi plugin manifest | `.omp-plugin/plugin.json` | Empty `mcpServers`, which is how omp is told this plugin has no MCP server: the channel server exits without Claude Code's session identity, and omp gets Envoy and Dispatch from `@sjawhar/pi-envoy`. omp reads this file before `.claude-plugin/plugin.json` and a manifest `mcpServers` replaces `.mcp.json` rather than merging; omitting the key falls through to `.mcp.json` and relaunches the server. Claude Code never reads it. Its `version` equals `package.json`'s (tested); omp reads only the file's `mcpServers` and that it exists, never its `version`. |
 | Skills | `skills/agent-secrets`, `skills/asd-ste100`, `skills/envoy`, `skills/dispatch`, `skills/dispatch-first`, `skills/dispatch-writing-specs`, `skills/outside-message`, `skills/plain-words` | Relative symlinks into the root `skills/`; the plugin ships only these eight, the ones a standalone Claude Code session uses (the rest belong to Legion roles on Oh My Pi; README "Skills"). The pack resolves them, not the install: `bun pm pack` packs a link as nothing at all, so `package.json`'s `prepack` (`scripts/pack-skills.sh`) replaces each link with the skill's own files, which `files`' `skills/**` then packs, and its `postpack` puts the links back. `scripts/check-packed-skills.sh` reads them back out of the tarball for `release.yaml`'s `claude_envoy_build`, and `tests/packed-skills.test.ts` packs a tarball of its own. |
 | Built bundle | `dist/`, `scripts/build.ts`, `scripts/verify-build.sh` | Built, never committed: `release.yaml`'s `claude_envoy_build` builds it and packs it into the tarball it publishes to npm (its `bun run verify-build <tar>` builds it twice in a scratch directory, checks it as the release will and packs it, writing no file of the checkout, and nothing a person runs locally writes `dist/` or `legion/`; the jobs that run `verify-build` are named in its header and the jobs that run `release-push.sh extract-built` in that subcommand's paragraph; convention below), and `bun scripts/build.ts --out <dir>` builds a runnable copy outside the repository. The plugin cache has no `node_modules`, so the four executables (the channel server, the session hook, the title hook and the `dispatch` CLI, `BUNDLE_ENTRYPOINTS`) ship bundled, with `dist/THIRD_PARTY_NOTICES` (the inlined packages' licenses, from Bun's metafile through the root `scripts/third-party-notices.ts`); the build runs only on the pinned Bun (`.bun-version`). A mode folded into an existing bundle is paid for by that bundle's every other mode: an ESM entrypoint evaluates its whole module graph before it reads `argv`, which is why the title hook has an entrypoint of its own and why a hook on a blocking event is weighed by what its bundle imports, not by what its mode runs. |
-| The `dispatch` CLI | `bin/dispatch` (the shim, mode 755), `dist/dispatch.js` (built from `../envoy-client/bin/dispatch.ts`), `hooks/session-hook.ts` | Claude Code puts the plugin's `bin/` on the Bash tool's `PATH`. The `open-asks` hook writes `export DISPATCH_HOST=claude` and `export ENVOY_CONFIG_FILE='<path>'` (the envoy.json Claude Code's rule picks, `$CLAUDE_CONFIG_DIR/envoy.json` when that is set; single-quoted, the form Claude Code's PowerShell bridge also reads) to `CLAUDE_ENV_FILE`, each unless the file already holds that line, since every `SessionStart` of a session runs it; with no workable file location (a relative `CLAUDE_CONFIG_DIR`, `ENVOY_CONFIG_FILE` or `XDG_CONFIG_HOME`) it writes no `ENVOY_CONFIG_FILE` line. The command reads the file `ENVOY_CONFIG_FILE` names whenever `DISPATCH_HOST` is set. A Bash that takes nothing from that file, as a subagent's can (anthropics/claude-code#46696), has `DISPATCH_HOST` unset and the `CLAUDE_CODE_CHILD_SESSION=1` Claude Code sets in every Bash, so its `dispatch` command takes host `claude` and reads `CLAUDE_CONFIG_DIR` itself, by the plugin's own rule. The command reads the session id from `CLAUDE_CODE_SESSION_ID`, which Claude Code sets fresh in every Bash command and moves on `/clear`. The command prints the follow notice itself, once per ask. |
+| The `dispatch` CLI | `bin/dispatch` (the shim, mode 755), `dist/dispatch.js` (built from `../envoy-client/bin/dispatch.ts`), `hooks/session-hook.ts` | Claude Code puts the plugin's `bin/` on the Bash tool's `PATH`. The `open-asks` hook writes `export DISPATCH_HOST=claude` and `export ENVOY_CONFIG_FILE='<path>'` (the envoy.json Claude Code's rule picks, `$CLAUDE_CONFIG_DIR/envoy.json` when that is set; single-quoted, which Claude Code's PowerShell bridge reads for a value holding no quote; `singleQuoted` in `hooks/session-hook.ts` gives the rest) to `CLAUDE_ENV_FILE`, each unless the file already holds that line, since every `SessionStart` of a session runs it; with no workable file location (a relative `CLAUDE_CONFIG_DIR`, `ENVOY_CONFIG_FILE` or `XDG_CONFIG_HOME`) it writes no `ENVOY_CONFIG_FILE` line. For a Legion pane (`LEGION_STATE_DIR` set) it writes the pane's jj attribution overlay too, and keeps exactly one `export JJ_CONFIG='<chain>'` line in that file: the line replaces an earlier one in its place rather than joining it, since a resume or a compaction of the same session id runs the hook again over the file it already wrote and the chain it resolves can differ, where two such lines in one sourced file would leave which overlay wins to the order they were written in. When no overlay could be written the file is left as it is, no line written and none removed: `CLAUDE_ENV_FILE` is `<config>/session-env/<session id>/sessionstart-hook-<n>.sh` (read on the pinned 2.1.311), one file per session id, so a `/clear` gets a new and empty one and a line already there names this same session's own overlay, still on disk — removing it would leave the session with neither trailer, where keeping it leaves it the one it had. The command reads the file `ENVOY_CONFIG_FILE` names whenever `DISPATCH_HOST` is set. A Bash that takes nothing from that file, as a subagent's can (anthropics/claude-code#46696), has `DISPATCH_HOST` unset and the `CLAUDE_CODE_CHILD_SESSION=1` Claude Code sets in every Bash, so its `dispatch` command takes host `claude` and reads `CLAUDE_CONFIG_DIR` itself, by the plugin's own rule. The command reads the session id from `CLAUDE_CODE_SESSION_ID`, which Claude Code sets fresh in every Bash command and moves on `/clear`. The command prints the follow notice itself, once per ask. |
 | Channel configuration | `.mcp.json`, `bin/envoy-channel.ts` | Launch is `bun ${CLAUDE_PLUGIN_ROOT}/dist/envoy-channel.js`; stdout remains pure MCP protocol. The `env` block passes through `CLAUDE_PROJECT_DIR` only — an unset `${VAR}` is substituted literally, so optional inputs are inherited, never listed. |
-| Hook command | `hooks/hooks.json`, `hooks/session-hook.ts`, `hooks/session-title-hook.ts` | Two bundles. `dist/session-hook.js` takes its mode as an argument — `open-asks`, `dispatch-first` or `answers`, plus `answers-refresh`, which only the `answers` mode starts and hooks.json never names; an argument naming none of them throws — and each mode is a hook of its own, because Claude Code caps each hook's output at 10,000 characters. `open-asks` (every `SessionStart`) names the `dispatch` command's host and hands on the session's envoy.json in `CLAUDE_ENV_FILE`, records the current session id per Claude process, records the session's chosen title and injects the open-asks summary; always exits 0. `dispatch-first` (every `SessionStart`, and every `SubagentStart`, since a subagent runs the same `dispatch` command) injects the `dispatch-first` skill as `hookSpecificOutput.additionalContext` under the input's `hook_event_name` when Dispatch is configured, reading `${CLAUDE_PLUGIN_ROOT}/skills/dispatch-first/SKILL.md` at run time and exiting non-zero naming it when it is missing. On a resume or fork Claude Code adds a SessionStart hook's context only when the transcript does not already hold the same text (measured on 2.1.283), so a resumed session keeps one copy and one opened without the skill gets it; the hook itself checks nothing. `answers` (every `SessionStart`, and every `SubagentStart`) injects what people wrote to the session in the last 72 hours as `hookSpecificOutput.additionalContext`: `readSessionAnswers` from `@legion/envoy-client/session-answers` for the input's `session_id` (at `SubagentStart` the parent's, which `tests/answers-claude.test.ts` checks on the real binary), the list pi-envoy puts on every model request, or its failure line naming why when a read failed and no list read before has an item to show, and nothing when there is nothing to show, Dispatch answered its own `404 NOT_FOUND` "no route for …" (`isNoAnswersRoute`, which `dispatch answers` cannot read past either; the hook then writes the read's `notice`, naming that Dispatch, to stderr, one line per process), or Dispatch is not configured; a proxy's 404 page or a 200 that is no answers list is a failed read. Its bound is counted from its process's start, Bun's start-up included: it prints by `ANSWERS_BY_MS` (800 ms, `SESSION_ANSWERS_DEADLINE_MS`), or `ANSWERS_LEAST_WAIT_MS` (150 ms) after its code begins when the start-up took longer, carrying the last list read from `answers.json` in the session's Dispatch state directory (`readSessionAnswers` works it out from `env`) when Dispatch has not answered, then waits on `sessionAnswersSettled` for `ANSWERS_SETTLE_MS` (50 ms) more so a read that answered late still writes that file for the next hook, and calls `process.exit(0)` whatever happened, a malformed input included (stderr names why), so nothing still in flight holds it. Dispatch is resolved with `commands: "kept"` first; a fresh process has kept no `!` command's outcome, so when that resolution is off with an error the mode starts the refresher: this bundle again (`process.execPath`, `Bun.main`) in mode `answers-refresh` with the session id and project directory, detached (its own session, so a signal to the hook's process group does not reach it), stdio ignored (so it holds none of the hook's pipes) and `unref()`ed, unless `answers-refresh.lock` in the session's state directory names a live refresher (its pid; a lock older than 30 s, or whose pid is gone, is stale). The refresher takes that lock (`wx`; a second one exits at once, so a burst of `SubagentStart` hooks runs the command once), resolves Dispatch with commands run, so `envoy-config`'s run of the command ends in its own process with its own clean-up (the group killed at the 10 s timeout, the stdout file's directory removed), reads with a 12 s deadline (which writes `answers.json`), writes `{finished_at, dispatch_url, text, notice}` to `answers-refresh.json` and removes the lock. The hook polls that file every 20 ms until its print deadline and carries its `text`, and reports its `notice` on stderr, when it finished after the hook started; otherwise it carries the last list read from the Dispatch URL envoy.json names now (`sessionDispatchUrl`, resolved before the wait without reading the token, passed as `readSessionAnswers`' `dispatchUrl`; a list another Dispatch answered never stands in) or the failure line naming that the command had not finished, and exits, so the next hook carries the list the refresher read. Its `timeout` is 5. Measured with Dispatch hanging: about 870 ms wall from spawn to exit; healthy, about 220 ms. `dist/session-title-hook.js` (every `UserPromptSubmit`, no argument) records the payload's `session_title` — the name a person gave the session, which Claude Code hands a hook and the plugin nowhere else — under `${CLAUDE_PLUGIN_DATA}/titles/`, and removes that file when the field is absent or blank, which is how a rename is undone. It writes nothing to stdout and exits 0 whatever happens, a payload that is not JSON included (`open-asks` and `dispatch-first` still fail loudly on one), because Claude Code adds a `UserPromptSubmit` hook's stdout to the model's context and reads its exit code 2 as a block of the prompt, and a cosmetic title may do neither; a failure goes to stderr. Claude Code blocks the user's prompt on it, so it is a bundle apart from the other two and keeps zod, the Dispatch client and `session-settings` out of its import graph (`src/session-state.ts` holds the file helpers for that reason, `src/session-identity.ts` imports zod and is not reachable from here): 5 kB and ~68 ms against the shared bundle's 811 kB and ~165 ms, the latter all but 3 ms of it bare `bun` start-up. It checks the payload itself — a non-empty string `session_id`, an optional string `session_title` — rather than carry a schema library. Its `timeout` is 5, not the 20 the `open-asks` and `dispatch-first` hooks carry. |
+| Hook command | `hooks/hooks.json`, `hooks/session-hook.ts`, `hooks/session-title-hook.ts` | Two bundles. `dist/session-hook.js` takes its mode as an argument — `open-asks`, `dispatch-first` or `answers`, plus `answers-refresh`, which only the `answers` mode starts and hooks.json never names; an argument naming none of them throws — and each mode is a hook of its own, because Claude Code caps each hook's output at 10,000 characters. `open-asks` (every `SessionStart`) names the `dispatch` command's host and hands on the session's envoy.json in `CLAUDE_ENV_FILE`, records the current session id per Claude process, records the session's chosen title and injects the open-asks summary; always exits 0. For a Legion pane (`LEGION_STATE_DIR` set) it writes the pane's jj attribution overlay under that directory too, and keeps exactly one `export JJ_CONFIG='<chain>'` line in `CLAUDE_ENV_FILE`: the line replaces an earlier one in its place rather than joining it, since a resume or a compaction of the same session id runs the hook again over the file it already wrote and the chain it resolves can differ; when no overlay could be written the file is left as it is, no line written and none removed, since `CLAUDE_ENV_FILE` is one file per session id (`<config>/session-env/<session id>/sessionstart-hook-<n>.sh`, read on the pinned 2.1.311) — a `/clear` gets a new and empty one, and a line already there names this same session's own overlay, still on disk and still correct. `dispatch-first` (every `SessionStart`, and every `SubagentStart`, since a subagent runs the same `dispatch` command) injects the `dispatch-first` skill as `hookSpecificOutput.additionalContext` under the input's `hook_event_name` when Dispatch is configured, reading `${CLAUDE_PLUGIN_ROOT}/skills/dispatch-first/SKILL.md` at run time and exiting non-zero naming it when it is missing. On a resume or fork Claude Code adds a SessionStart hook's context only when the transcript does not already hold the same text (measured on 2.1.283), so a resumed session keeps one copy and one opened without the skill gets it; the hook itself checks nothing. `answers` (every `SessionStart`, and every `SubagentStart`) injects what people wrote to the session in the last 72 hours as `hookSpecificOutput.additionalContext`: `readSessionAnswers` from `@legion/envoy-client/session-answers` for the input's `session_id` (at `SubagentStart` the parent's, which `tests/answers-claude.test.ts` checks on the real binary), the list pi-envoy puts on every model request, or its failure line naming why when a read failed and no list read before has an item to show, and nothing when there is nothing to show, Dispatch answered its own `404 NOT_FOUND` "no route for …" (`isNoAnswersRoute`, which `dispatch answers` cannot read past either; the hook then writes the read's `notice`, naming that Dispatch, to stderr, one line per process), or Dispatch is not configured; a proxy's 404 page or a 200 that is no answers list is a failed read. Its bound is counted from its process's start, Bun's start-up included: it prints by `ANSWERS_BY_MS` (800 ms, `SESSION_ANSWERS_DEADLINE_MS`), or `ANSWERS_LEAST_WAIT_MS` (150 ms) after its code begins when the start-up took longer, carrying the last list read from `answers.json` in the session's Dispatch state directory (`readSessionAnswers` works it out from `env`) when Dispatch has not answered, then waits on `sessionAnswersSettled` for `ANSWERS_SETTLE_MS` (50 ms) more so a read that answered late still writes that file for the next hook, and calls `process.exit(0)` whatever happened, a malformed input included (stderr names why), so nothing still in flight holds it. Dispatch is resolved with `commands: "kept"` first; a fresh process has kept no `!` command's outcome, so when that resolution is off with an error the mode starts the refresher: this bundle again (`process.execPath`, `Bun.main`) in mode `answers-refresh` with the session id and project directory, detached (its own session, so a signal to the hook's process group does not reach it), stdio ignored (so it holds none of the hook's pipes) and `unref()`ed, unless `answers-refresh.lock` in the session's state directory names a live refresher (its pid; a lock older than 30 s, or whose pid is gone, is stale). The refresher takes that lock (`wx`; a second one exits at once, so a burst of `SubagentStart` hooks runs the command once), resolves Dispatch with commands run, so `envoy-config`'s run of the command ends in its own process with its own clean-up (the group killed at the 10 s timeout, the stdout file's directory removed), reads with a 12 s deadline (which writes `answers.json`), writes `{finished_at, dispatch_url, text, notice}` to `answers-refresh.json` and removes the lock. The hook polls that file every 20 ms until its print deadline and carries its `text`, and reports its `notice` on stderr, when it finished after the hook started; otherwise it carries the last list read from the Dispatch URL envoy.json names now (`sessionDispatchUrl`, resolved before the wait without reading the token, passed as `readSessionAnswers`' `dispatchUrl`; a list another Dispatch answered never stands in) or the failure line naming that the command had not finished, and exits, so the next hook carries the list the refresher read. Its `timeout` is 5. Measured with Dispatch hanging: about 870 ms wall from spawn to exit; healthy, about 220 ms. `dist/session-title-hook.js` (every `UserPromptSubmit`, no argument) records the payload's `session_title` — the name a person gave the session, which Claude Code hands a hook and the plugin nowhere else — under `${CLAUDE_PLUGIN_DATA}/titles/`, and removes that file when the field is absent or blank, which is how a rename is undone. It writes nothing to stdout and exits 0 whatever happens, a payload that is not JSON included (`open-asks` and `dispatch-first` still fail loudly on one), because Claude Code adds a `UserPromptSubmit` hook's stdout to the model's context and reads its exit code 2 as a block of the prompt, and a cosmetic title may do neither; a failure goes to stderr. Claude Code blocks the user's prompt on it, so it is a bundle apart from the other two and keeps zod, the Dispatch client and `session-settings` out of its import graph (`src/session-state.ts` holds the file helpers for that reason, `src/session-identity.ts` imports zod and is not reachable from here): 5 kB and ~68 ms against the shared bundle's 811 kB and ~165 ms, the latter all but 3 ms of it bare `bun` start-up. It checks the payload itself — a non-empty string `session_id`, an optional string `session_title` — rather than carry a schema library. Its `timeout` is 5, not the 20 the `open-asks` and `dispatch-first` hooks carry. |
 | Real Claude Code test | `tests/answers-claude.test.ts`, `/.claude-code-pin`, `/.github/actions/install-claude-code` | The `answers` hook on the real binary: Claude Code runs with this package as `--plugin-dir`, an isolated HOME and `CLAUDE_CONFIG_DIR`, and one stand-in as its Messages endpoint (`ANTHROPIC_BASE_URL`, server-sent events as the API streams them) and Dispatch (`DISPATCH_URL`); each case reads the list off the Messages request after the moment: startup (`claude -p --session-id`), `--resume <id>`, `/compact` sent in stream-json as `legion claude-bridge` sends turns, and a subagent (the stand-in answers with an `Agent` tool call, the API name of Claude Code's Task tool). `LEGION_TEST_CLAUDE` names the binary; the test skips without it, except on GitHub Actions, where the claude-envoy job installs the release `.claude-code-pin` pins (`bun add` into the runner's temp directory). A pin bump that changes a request shape is fixed in that file. |
 | Inbound channel server | `src/envoy-channel-server.ts`, `src/envoy-off.ts` | MCP capability, notification queue, NATS registration, session-id handoff, role persistence, rejected-frame replies, and the Envoy tools, on the envoy.json Claude Code's rule picks (`@legion/envoy-client/session-settings`); why a section is off, and that inbound messages are off, goes to stderr once as `envoy-channel: <notice>`. `runEnvoyChannelServer` chooses between that server and the two reduced modes of `src/envoy-off.ts`. With Envoy off it runs `serveEnvoyOff` instead: an MCP server that lists no tool, refuses every call with `Envoy is off for this session: <why>` (the section's notice or error), opens no NATS connection and calls no listener, and exits 0 when stdin ends or on SIGTERM, SIGINT or SIGHUP. With Envoy on and inbound messages off (`inbound.off`: no NATS server, from `envoy.natsUrls` or `ENVOY_NATS_URL`, or its seed refused), it serves the tools on `inboundOffChannelSession`: no NATS connection, nothing registered with the listener, an empty inbox, `envoy_subscribe` refused naming why, and a role `envoy_role_set` claims still persisted. |
 | Channel gate | `src/claude-channel.ts` | Whether Claude Code loaded this server as a channel, which it never tells the server: the command line of the nearest ancestor whose program is `claude` (`claudeCommandLine`; Claude Code may run the server through a shell prefix or a `bun` shim), read from `/proc` (exact, with its stdout's terminal and its directory) or `ps` (split on whitespace), against Claude Code's own gate as of 2.1.301: a `plugin:claude-envoy@…` entry when `CLAUDE_PLUGIN_ROOT` says it runs as a plugin, any `server:` entry from a bare config; `--channels` entries before development ones; `--dangerously-load-development-channels` only in an interactive session (`asksForPrintMode`, the arguments skipped as Claude Code's scanner skips them, and a terminal on stdout where `/proc` shows it); the marketplace it is loaded from (`loadedMarketplace`: `inline` for `--plugin-dir`, else the cache's, compared after Claude Code's cache-name sanitizing); for `--channels`, `allowedChannelPlugins` (object or `plugin@marketplace` entries, each invalid one dropped alone) from the managed source that owns it (`remote-settings.json`, else `managed-settings.json` with its non-dot drop-ins; under `managedSourcesBehavior: "merge"` the highest that sets it). Not loaded, the session registers `capabilities: []`. `ENVOY_CHANNEL_LOADED=1`/`0` overrides it. A command line it cannot read, or no `claude` ancestor, counts as loaded, and so does one Node overwrote with `process.title = "claude"` (on Linux, the title alone followed by NUL padding, whatever the executable's name; elsewhere one word from a program named `node…`). |

package/dist/dispatch.js

@@ -15531,7 +15531,7 @@ var dispatchToolSpecs = [
       verdict: "pass",
       commit: "1111111111111111111111111111111111111111"
     },
-    description: "Record one result of one check of an issue's Verification document, and print the " + "pull-request body line it implies. The check is named by its block id, or, when two " + "Verification documents in reach share that id, by its canonical reference " + "(dispatch://KEY/artifact/verification-md#b-<id>); 409 CHECK_AMBIGUOUS names them, and an " + "id no Verification document of the issue or of an issue above it holds is 400 " + "UNKNOWN_CHECK. A pass counting any failed, skipped or excluded case contradicts itself " + "and is 400 RESULT_CONTRADICTS. The result is recorded against the check's own issue, so " + "a child's run of a parent's check appears under that check. A closed issue takes a " + "result only for a check whose when is after_merge or default_branch \u2014 the production " + "check after the merge \u2014 and refuses every other one with 409 ISSUE_CLOSED, as it refuses " + "every other write. Write the printed line into the pull-request body unchanged: it is " + "the one grammar every writer uses, and it carries no link to Dispatch. " + ISSUE_REFERENCE,
+    description: "Record one result of one check of an issue's Verification document, and print the " + "pull-request body line it implies. The check is named by its block id, or, when two " + "Verification documents in reach share that id, by its canonical reference " + "(dispatch://KEY/artifact/verification-md#b-<id>); 409 CHECK_AMBIGUOUS names them, and an " + "id no Verification document of the issue or of an issue above it holds is 400 " + "UNKNOWN_CHECK. A pass counting any failed, skipped or excluded case contradicts itself " + "and is 400 RESULT_CONTRADICTS. Dispatch asks GitHub whether the repository of the " + "check's issue holds the commit: one it does not hold is 400 RESULT_COMMIT_UNKNOWN, " + "naming the commit and that owner/repo, so record the result after the commit is pushed. " + "A repository Dispatch cannot read records the result as before. " + "The result is recorded against the check's own issue, so " + "a child's run of a parent's check appears under that check. A closed issue takes a " + "result only for a check whose when is after_merge or default_branch \u2014 the production " + "check after the merge \u2014 and refuses every other one with 409 ISSUE_CLOSED, as it refuses " + "every other write. Write the printed line into the pull-request body unchanged: it is " + "the one grammar every writer uses, and it carries no link to Dispatch. " + ISSUE_REFERENCE,
     arguments: (z) => ({
       issue: z.string().describe(ISSUE_REFERENCE),
       check: z.string().describe("The check block's id, or its canonical reference dispatch://KEY/artifact/verification-md#b-<id> when the id is not unique among the issue's Verification document and those of the issues above it."),
@@ -17536,7 +17536,7 @@ import { promisify } from "util";
 // ../envoy-client/src/machine.ts
 import { hostname as hostname3 } from "os";
 function machineID() {
-  return process.env["ENVOY_MACHINE_ID"] || hostname3();
+  return process.env["ENVOY_MACHINE_ID"] || process.env["AGENTBOX_HOST"] || hostname3();
 }
 
 // ../envoy-client/src/dispatch-cwd.ts
@@ -20629,7 +20629,7 @@ import { randomUUID } from "crypto";
 import { renameSync as renameSync2, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
 import { homedir } from "os";
 import { join as join2 } from "path";
-var SESSION_ID = /^[A-Za-z0-9._-]{1,128}$/;
+var SESSION_ID_PATH_SEGMENT = /^[A-Za-z0-9._-]{1,128}$/;
 var PRIVATE_FILE = 384;
 function sessionStateRoot(env) {
   const stateDir = env["DISPATCH_STATE_DIR"];
@@ -20638,7 +20638,7 @@ function sessionStateRoot(env) {
   return join2(env["XDG_STATE_HOME"] || join2(homedir(), ".local", "state"), "dispatch");
 }
 function sessionDirectory(env, sessionId) {
-  if (!SESSION_ID.test(sessionId) || sessionId === "." || sessionId === "..") {
+  if (!SESSION_ID_PATH_SEGMENT.test(sessionId) || sessionId === "." || sessionId === "..") {
     throw new Error(`dispatch: the session id ${JSON.stringify(sessionId)} is not 1-128 letters, digits, ".", "_" or "-"`);
   }
   return join2(sessionStateRoot(env), "sessions", sessionId);
@@ -22198,7 +22198,7 @@ function formatCheckResults(results) {
     if (latest === undefined) {
       return `${head}no result yet. ${check.text}`;
     }
-    return `${head}${latest.verdict} at ${latest.commit_sha.slice(0, 12)} by ${latest.role}, ${latest.currency ?? "unknown"}. ${check.text}`;
+    return `${head}${latest.verdict} at ${latest.commit_sha} by ${latest.role}, ${latest.currency ?? "unknown"}. ${check.text}`;
   });
   return [`Checks of ${results.issue}:`, ...lines].join(`
 `);
@@ -23945,7 +23945,7 @@ Document token: ${listed.token}`,
         ...optional
       });
       return {
-        text: `Recorded ${recorded.result.verdict} for check ${recorded.result.check_block_id} of ${recorded.result.check_issue_key} at ${recorded.result.commit_sha.slice(0, 12)}, as ${recorded.result.role}.
+        text: `Recorded ${recorded.result.verdict} for check ${recorded.result.check_block_id} of ${recorded.result.check_issue_key} at ${recorded.result.commit_sha}, as ${recorded.result.role}.
 
 Pull request body line:
 ${recorded.line}`,

package/dist/envoy-channel.js

@@ -37180,7 +37180,7 @@ var dispatchToolSpecs = [
       verdict: "pass",
       commit: "1111111111111111111111111111111111111111"
     },
-    description: "Record one result of one check of an issue's Verification document, and print the " + "pull-request body line it implies. The check is named by its block id, or, when two " + "Verification documents in reach share that id, by its canonical reference " + "(dispatch://KEY/artifact/verification-md#b-<id>); 409 CHECK_AMBIGUOUS names them, and an " + "id no Verification document of the issue or of an issue above it holds is 400 " + "UNKNOWN_CHECK. A pass counting any failed, skipped or excluded case contradicts itself " + "and is 400 RESULT_CONTRADICTS. The result is recorded against the check's own issue, so " + "a child's run of a parent's check appears under that check. A closed issue takes a " + "result only for a check whose when is after_merge or default_branch \u2014 the production " + "check after the merge \u2014 and refuses every other one with 409 ISSUE_CLOSED, as it refuses " + "every other write. Write the printed line into the pull-request body unchanged: it is " + "the one grammar every writer uses, and it carries no link to Dispatch. " + ISSUE_REFERENCE,
+    description: "Record one result of one check of an issue's Verification document, and print the " + "pull-request body line it implies. The check is named by its block id, or, when two " + "Verification documents in reach share that id, by its canonical reference " + "(dispatch://KEY/artifact/verification-md#b-<id>); 409 CHECK_AMBIGUOUS names them, and an " + "id no Verification document of the issue or of an issue above it holds is 400 " + "UNKNOWN_CHECK. A pass counting any failed, skipped or excluded case contradicts itself " + "and is 400 RESULT_CONTRADICTS. Dispatch asks GitHub whether the repository of the " + "check's issue holds the commit: one it does not hold is 400 RESULT_COMMIT_UNKNOWN, " + "naming the commit and that owner/repo, so record the result after the commit is pushed. " + "A repository Dispatch cannot read records the result as before. " + "The result is recorded against the check's own issue, so " + "a child's run of a parent's check appears under that check. A closed issue takes a " + "result only for a check whose when is after_merge or default_branch \u2014 the production " + "check after the merge \u2014 and refuses every other one with 409 ISSUE_CLOSED, as it refuses " + "every other write. Write the printed line into the pull-request body unchanged: it is " + "the one grammar every writer uses, and it carries no link to Dispatch. " + ISSUE_REFERENCE,
     arguments: (z) => ({
       issue: z.string().describe(ISSUE_REFERENCE),
       check: z.string().describe("The check block's id, or its canonical reference dispatch://KEY/artifact/verification-md#b-<id> when the id is not unique among the issue's Verification document and those of the issues above it."),
@@ -44745,7 +44745,7 @@ function normalizeEnvoyUrl(value) {
 // ../envoy-client/src/machine.ts
 import { hostname as hostname3 } from "os";
 function machineID() {
-  return process.env["ENVOY_MACHINE_ID"] || hostname3();
+  return process.env["ENVOY_MACHINE_ID"] || process.env["AGENTBOX_HOST"] || hostname3();
 }
 
 // ../envoy-client/src/transport.ts
@@ -46450,7 +46450,7 @@ import { randomUUID } from "crypto";
 import { renameSync, rmSync as rmSync2, writeFileSync } from "fs";
 import { homedir as homedir2 } from "os";
 import { join as join2 } from "path";
-var SESSION_ID = /^[A-Za-z0-9._-]{1,128}$/;
+var SESSION_ID_PATH_SEGMENT = /^[A-Za-z0-9._-]{1,128}$/;
 var PRIVATE_FILE = 384;
 function sessionStateRoot(env) {
   const stateDir = env["DISPATCH_STATE_DIR"];
@@ -46459,7 +46459,7 @@ function sessionStateRoot(env) {
   return join2(env["XDG_STATE_HOME"] || join2(homedir2(), ".local", "state"), "dispatch");
 }
 function sessionDirectory(env, sessionId) {
-  if (!SESSION_ID.test(sessionId) || sessionId === "." || sessionId === "..") {
+  if (!SESSION_ID_PATH_SEGMENT.test(sessionId) || sessionId === "." || sessionId === "..") {
     throw new Error(`dispatch: the session id ${JSON.stringify(sessionId)} is not 1-128 letters, digits, ".", "_" or "-"`);
   }
   return join2(sessionStateRoot(env), "sessions", sessionId);
@@ -48941,7 +48941,7 @@ function formatCheckResults(results) {
     if (latest === undefined) {
       return `${head}no result yet. ${check.text}`;
     }
-    return `${head}${latest.verdict} at ${latest.commit_sha.slice(0, 12)} by ${latest.role}, ${latest.currency ?? "unknown"}. ${check.text}`;
+    return `${head}${latest.verdict} at ${latest.commit_sha} by ${latest.role}, ${latest.currency ?? "unknown"}. ${check.text}`;
   });
   return [`Checks of ${results.issue}:`, ...lines].join(`
 `);
@@ -50688,7 +50688,7 @@ Document token: ${listed.token}`,
         ...optional
       });
       return {
-        text: `Recorded ${recorded.result.verdict} for check ${recorded.result.check_block_id} of ${recorded.result.check_issue_key} at ${recorded.result.commit_sha.slice(0, 12)}, as ${recorded.result.role}.
+        text: `Recorded ${recorded.result.verdict} for check ${recorded.result.check_block_id} of ${recorded.result.check_issue_key} at ${recorded.result.commit_sha}, as ${recorded.result.role}.
 
 Pull request body line:
 ${recorded.line}`,
@@ -55082,9 +55082,9 @@ var import_nats2 = __toESM(require_mod4(), 1);
 
 // package.json
 var name = "@sjawhar/claude-envoy";
-var version2 = "1.6.0";
+var version2 = "1.7.1";
 var legion = {
-  daemonApiVersion: 51
+  daemonApiVersion: 52
 };
 
 // src/channel-forwarder.ts

package/dist/session-hook.js

@@ -14530,7 +14530,7 @@ var dispatchToolSpecs = [
       verdict: "pass",
       commit: "1111111111111111111111111111111111111111"
     },
-    description: "Record one result of one check of an issue's Verification document, and print the " + "pull-request body line it implies. The check is named by its block id, or, when two " + "Verification documents in reach share that id, by its canonical reference " + "(dispatch://KEY/artifact/verification-md#b-<id>); 409 CHECK_AMBIGUOUS names them, and an " + "id no Verification document of the issue or of an issue above it holds is 400 " + "UNKNOWN_CHECK. A pass counting any failed, skipped or excluded case contradicts itself " + "and is 400 RESULT_CONTRADICTS. The result is recorded against the check's own issue, so " + "a child's run of a parent's check appears under that check. A closed issue takes a " + "result only for a check whose when is after_merge or default_branch \u2014 the production " + "check after the merge \u2014 and refuses every other one with 409 ISSUE_CLOSED, as it refuses " + "every other write. Write the printed line into the pull-request body unchanged: it is " + "the one grammar every writer uses, and it carries no link to Dispatch. " + ISSUE_REFERENCE,
+    description: "Record one result of one check of an issue's Verification document, and print the " + "pull-request body line it implies. The check is named by its block id, or, when two " + "Verification documents in reach share that id, by its canonical reference " + "(dispatch://KEY/artifact/verification-md#b-<id>); 409 CHECK_AMBIGUOUS names them, and an " + "id no Verification document of the issue or of an issue above it holds is 400 " + "UNKNOWN_CHECK. A pass counting any failed, skipped or excluded case contradicts itself " + "and is 400 RESULT_CONTRADICTS. Dispatch asks GitHub whether the repository of the " + "check's issue holds the commit: one it does not hold is 400 RESULT_COMMIT_UNKNOWN, " + "naming the commit and that owner/repo, so record the result after the commit is pushed. " + "A repository Dispatch cannot read records the result as before. " + "The result is recorded against the check's own issue, so " + "a child's run of a parent's check appears under that check. A closed issue takes a " + "result only for a check whose when is after_merge or default_branch \u2014 the production " + "check after the merge \u2014 and refuses every other one with 409 ISSUE_CLOSED, as it refuses " + "every other write. Write the printed line into the pull-request body unchanged: it is " + "the one grammar every writer uses, and it carries no link to Dispatch. " + ISSUE_REFERENCE,
     arguments: (z) => ({
       issue: z.string().describe(ISSUE_REFERENCE),
       check: z.string().describe("The check block's id, or its canonical reference dispatch://KEY/artifact/verification-md#b-<id> when the id is not unique among the issue's Verification document and those of the issues above it."),
@@ -16540,7 +16540,7 @@ import { promisify } from "util";
 // ../envoy-client/src/machine.ts
 import { hostname as hostname3 } from "os";
 function machineID() {
-  return process.env["ENVOY_MACHINE_ID"] || hostname3();
+  return process.env["ENVOY_MACHINE_ID"] || process.env["AGENTBOX_HOST"] || hostname3();
 }
 
 // ../envoy-client/src/dispatch-cwd.ts
@@ -19633,7 +19633,7 @@ import { randomUUID } from "crypto";
 import { renameSync, rmSync, writeFileSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
-var SESSION_ID = /^[A-Za-z0-9._-]{1,128}$/;
+var SESSION_ID_PATH_SEGMENT = /^[A-Za-z0-9._-]{1,128}$/;
 var PRIVATE_FILE = 384;
 function sessionStateRoot(env) {
   const stateDir = env["DISPATCH_STATE_DIR"];
@@ -19642,7 +19642,7 @@ function sessionStateRoot(env) {
   return join(env["XDG_STATE_HOME"] || join(homedir(), ".local", "state"), "dispatch");
 }
 function sessionDirectory(env, sessionId) {
-  if (!SESSION_ID.test(sessionId) || sessionId === "." || sessionId === "..") {
+  if (!SESSION_ID_PATH_SEGMENT.test(sessionId) || sessionId === "." || sessionId === "..") {
     throw new Error(`dispatch: the session id ${JSON.stringify(sessionId)} is not 1-128 letters, digits, ".", "_" or "-"`);
   }
   return join(sessionStateRoot(env), "sessions", sessionId);
@@ -21202,7 +21202,7 @@ function formatCheckResults(results) {
     if (latest === undefined) {
       return `${head}no result yet. ${check.text}`;
     }
-    return `${head}${latest.verdict} at ${latest.commit_sha.slice(0, 12)} by ${latest.role}, ${latest.currency ?? "unknown"}. ${check.text}`;
+    return `${head}${latest.verdict} at ${latest.commit_sha} by ${latest.role}, ${latest.currency ?? "unknown"}. ${check.text}`;
   });
   return [`Checks of ${results.issue}:`, ...lines].join(`
 `);
@@ -22949,7 +22949,7 @@ Document token: ${listed.token}`,
         ...optional
       });
       return {
-        text: `Recorded ${recorded.result.verdict} for check ${recorded.result.check_block_id} of ${recorded.result.check_issue_key} at ${recorded.result.commit_sha.slice(0, 12)}, as ${recorded.result.role}.
+        text: `Recorded ${recorded.result.verdict} for check ${recorded.result.check_block_id} of ${recorded.result.check_issue_key} at ${recorded.result.commit_sha}, as ${recorded.result.role}.
 
 Pull request body line:
 ${recorded.line}`,
@@ -26589,6 +26589,119 @@ function sessionEnvoySettings(file, env, options) {
   });
 }
 
+// ../pi-shared/src/jj-attribution.ts
+import { realpathSync } from "fs";
+import { mkdir, rename, writeFile } from "fs/promises";
+import path2 from "path";
+var UUID = "[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}";
+var JJ_CONFIG_PATH_TIMEOUT_MS = 1e4;
+var TOP_LEVEL_TRANSCRIPT = new RegExp(`^\\d{4}-\\d{2}-\\d{2}T[\\d-]+Z_(${UUID})\\.jsonl$`);
+var ATTRIBUTION_OVERLAY = /^omp-attribution-.*\.toml$/;
+var ISSUE_KEY3 = /^[A-Z][A-Z0-9]{1,9}-[0-9]+$/;
+var FIRST_RAW_CODE = 32;
+var DEL_CODE = 127;
+function resolvedWorkspace(workspace) {
+  if (!workspace)
+    return;
+  try {
+    return realpathSync(workspace);
+  } catch {
+    return;
+  }
+}
+function tomlBasicString(workspace) {
+  for (let at = 0;at < workspace.length; at += 1) {
+    const code = workspace.charCodeAt(at);
+    if (code < FIRST_RAW_CODE || code === DEL_CODE)
+      return;
+  }
+  return `"${workspace.replaceAll("\\", "\\\\").replaceAll('"', "\\\"")}"`;
+}
+function withoutOverlays(chain) {
+  return chain.split(":").filter((entry) => entry && !ATTRIBUTION_OVERLAY.test(path2.basename(entry))).join(":");
+}
+async function userConfigChain(timeoutMs = JJ_CONFIG_PATH_TIMEOUT_MS, env = process.env) {
+  try {
+    const child = Bun.spawn(["jj", "config", "path", "--user"], {
+      detached: true,
+      env,
+      stdin: "ignore",
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const killGroup = () => {
+      try {
+        process.kill(-child.pid, "SIGKILL");
+      } catch {}
+    };
+    const exited = child.exited.finally(killGroup);
+    const completed = Promise.all([
+      exited,
+      new Response(child.stdout).text(),
+      new Response(child.stderr).text()
+    ]);
+    const stdout = await new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        killGroup();
+        resolve(undefined);
+      }, timeoutMs);
+      completed.then(([code, output]) => {
+        clearTimeout(timer);
+        resolve(code === 0 ? output : undefined);
+      }, () => {
+        clearTimeout(timer);
+        resolve(undefined);
+      });
+    });
+    if (stdout === undefined)
+      return;
+    const paths = stdout.split(`
+`).filter(Boolean);
+    return paths.length > 0 ? paths.join(":") : undefined;
+  } catch {
+    return;
+  }
+}
+async function exportJjSessionAttribution(sessionId, stateDir, options = {}) {
+  const { issueKey, workspace, env = process.env, resolveBase = userConfigChain } = options;
+  if (!SESSION_ID_PATH_SEGMENT.test(sessionId))
+    return;
+  const overlay = path2.join(stateDir, `omp-attribution-${sessionId}.toml`);
+  const active = env["JJ_CONFIG"];
+  if (active?.split(":").includes(overlay))
+    return active;
+  const base = (active ? withoutOverlays(active) : "") || await resolveBase();
+  if (!base)
+    return;
+  const sessionTrailer = `Omp-Session: ${sessionId}`;
+  const scopedTo = issueKey !== undefined && ISSUE_KEY3.test(issueKey) && workspace ? tomlBasicString(workspace) : undefined;
+  const contents = `[templates]
+commit_trailers = '"${sessionTrailer}"'
+` + (scopedTo === undefined ? "" : `
+[[--scope]]
+--when.workspaces = [${scopedTo}]
+[--scope.templates]
+` + `commit_trailers = '"${sessionTrailer}\\nDispatch: ${issueKey}"'
+`);
+  try {
+    await mkdir(stateDir, { recursive: true });
+    const tmp = `${overlay}.${process.pid}.tmp`;
+    await writeFile(tmp, contents);
+    await rename(tmp, overlay);
+    const chain = `${base}:${overlay}`;
+    env["JJ_CONFIG"] = chain;
+    return chain;
+  } catch {
+    env["JJ_CONFIG"] = base;
+    return;
+  }
+}
+function paneAttributionOptions(env) {
+  const issueKey = env["LEGION_ISSUE_TRAILER"];
+  const workspace = resolvedWorkspace(env["LEGION_WORKSPACE"]);
+  return { ...issueKey ? { issueKey } : {}, ...workspace ? { workspace } : {} };
+}
+
 // src/claude-session.ts
 function configuredValue(value) {
   return value !== undefined && value.trim().length > 0 ? value : undefined;
@@ -26612,13 +26725,13 @@ import { basename as basename2, join as join6 } from "path";
 
 // src/session-state.ts
 import { readFileSync as readFileSync5 } from "fs";
-import { mkdir, readdir, rename, rm, stat, utimes, writeFile } from "fs/promises";
+import { mkdir as mkdir2, readdir, rename as rename2, rm, stat, utimes, writeFile as writeFile2 } from "fs/promises";
 import { dirname as dirname2, join as join5 } from "path";
 async function writeAtomicStateFile(file, contents) {
-  await mkdir(dirname2(file), { recursive: true, mode: 448 });
+  await mkdir2(dirname2(file), { recursive: true, mode: 448 });
   const temporary = `${file}.${process.pid}.${crypto.randomUUID()}.tmp`;
-  await writeFile(temporary, contents, { mode: 384 });
-  await rename(temporary, file);
+  await writeFile2(temporary, contents, { mode: 384 });
+  await rename2(temporary, file);
 }
 async function touchStateFile(file) {
   const now = new Date;
@@ -26791,23 +26904,49 @@ var RefreshOutcome = object({
 });
 var ANSWERS_TIMING_FILE = "ENVOY_ANSWERS_TIMING_FILE";
 var DISPATCH_HOST_LINE = "export DISPATCH_HOST=claude";
-function appendOnce(envFile, line) {
-  let written = "";
+var JJ_CONFIG_EXPORT = "export JJ_CONFIG=";
+var JJ_BASE_CHAIN_TIMEOUT_MS = 3000;
+function singleQuoted(value) {
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
+function envFileText(envFile) {
   try {
-    written = readFileSync6(envFile, "utf8");
+    return readFileSync6(envFile, "utf8");
   } catch (error) {
     if (!hasErrnoCode(error, "ENOENT"))
       throw error;
+    return "";
   }
-  if (written.split(`
-`).includes(line))
-    return;
+}
+function appendLine(envFile, written, line) {
   const separator = written === "" || written.endsWith(`
 `) ? "" : `
 `;
   appendFileSync(envFile, `${separator}${line}
 `);
 }
+function appendOnce(envFile, line) {
+  const written = envFileText(envFile);
+  if (written.split(`
+`).includes(line))
+    return;
+  appendLine(envFile, written, line);
+}
+function replaceOnce(envFile, prefix, line) {
+  const written = envFileText(envFile);
+  const lines = written.split(`
+`);
+  const at = lines.findIndex((existing) => existing.startsWith(prefix));
+  if (at === -1) {
+    appendLine(envFile, written, line);
+    return;
+  }
+  if (lines[at] === line)
+    return;
+  lines[at] = line;
+  writeAtomically(envFile, lines.join(`
+`));
+}
 async function openAsks(raw) {
   const input = OpenAsksInput.parse(raw);
   const envFile = process.env["CLAUDE_ENV_FILE"];
@@ -26815,7 +26954,22 @@ async function openAsks(raw) {
   if (envFile) {
     appendOnce(envFile, DISPATCH_HOST_LINE);
     if (chosen.path !== null) {
-      appendOnce(envFile, `export ENVOY_CONFIG_FILE='${chosen.path.replaceAll("'", "'\\''")}'`);
+      appendOnce(envFile, `export ENVOY_CONFIG_FILE=${singleQuoted(chosen.path)}`);
+    }
+    const stateDir = process.env["LEGION_STATE_DIR"];
+    if (stateDir) {
+      try {
+        const chain = await exportJjSessionAttribution(input.session_id, stateDir, {
+          ...paneAttributionOptions(process.env),
+          resolveBase: () => userConfigChain(JJ_BASE_CHAIN_TIMEOUT_MS)
+        });
+        if (chain !== undefined) {
+          replaceOnce(envFile, JJ_CONFIG_EXPORT, `${JJ_CONFIG_EXPORT}${singleQuoted(chain)}`);
+        }
+      } catch (error) {
+        process.stderr.write(`envoy: could not export the jj attribution \u2014 ${messageFor(error)}
+`);
+      }
     }
   }
   const pluginData = process.env["CLAUDE_PLUGIN_DATA"];

package/hooks/session-hook.ts

@@ -3,7 +3,7 @@
 // characters, so a long open-asks summary or answers list sharing a command with the skill could
 // push it out.
 //
-// open-asks (every SessionStart: startup, resume, clear, compact, fork). Three jobs:
+// open-asks (every SessionStart: startup, resume, clear, compact, fork). Four jobs:
 // 1. Name Claude Code as the `dispatch` command's host and hand on the session's envoy.json:
 //    append `export DISPATCH_HOST=claude` and `export ENVOY_CONFIG_FILE='<path>'` (the file
 //    Claude Code's rule picks, `$CLAUDE_CONFIG_DIR/envoy.json` when that is set) to
@@ -12,12 +12,32 @@
 //    reads the file ENVOY_CONFIG_FILE names whenever DISPATCH_HOST is set. A subagent's Bash can
 //    lack what that file holds (anthropics/claude-code#46696); the `dispatch` command it runs then
 //    takes host `claude` from `CLAUDE_CODE_CHILD_SESSION=1` and reads `CLAUDE_CONFIG_DIR` itself.
-//    The path is single-quoted, the one form Claude Code's PowerShell
-//    bridge also reads. The command reads the session id from `CLAUDE_CODE_SESSION_ID`, which
+//    The path is single-quoted (`singleQuoted`, whose doc gives what Claude Code's
+//    PowerShell bridge reads of that form). The command reads the session id from `CLAUDE_CODE_SESSION_ID`, which
 //    Claude Code sets fresh in each Bash command, so a `/clear` needs nothing more here.
-// 2. Record the CURRENT session id for this Claude process so the channel
+// 2. For a Legion pane (`LEGION_STATE_DIR` set), write the pane's jj attribution overlay under
+//    that directory and hand on the jj config chain it layers over: `export JJ_CONFIG='<chain>'`
+//    in the same file, so every jj commit a Bash command of the session makes carries an
+//    `Omp-Session: <id>` trailer, and a `Dispatch: <KEY>` line too for a pane whose environment
+//    names an issue key, scoped to that pane's own workspace — which of the pane's variables say
+//    so, and how, is `paneAttributionOptions`
+//    (`exportJjSessionAttribution`, `@legion/pi-shared/jj-attribution`). The
+//    hook writes it, not the claim boot: that boot is the MCP server Claude Code spawns as a
+//    child, and a child cannot change its parent's environment. This line replaces an earlier one
+//    rather than joining it: exactly one `export JJ_CONFIG=` stands however many times the hook
+//    runs, since a resume or a compaction of the same session id runs it again over the file it
+//    already wrote and the chain it resolves can differ, and two such lines in one sourced file
+//    would leave which overlay wins to the order they were written in. A session that is no
+//    Legion pane gets nothing, and an overlay that could not be written (no jj, or a jj that
+//    never answers inside its 3 s) costs the session that one export and nothing else: a line an
+//    earlier run of this same id wrote is left as it stands, since `CLAUDE_ENV_FILE` is
+//    `<config>/session-env/<session id>/sessionstart-hook-<n>.sh` on the pinned Claude Code
+//    2.1.311 — one file per session id, so a `/clear`, which gives the session a new id, gets a
+//    new and empty one — and a line already there names this same session's own overlay, still on
+//    disk and still correct.
+// 3. Record the CURRENT session id for this Claude process so the channel
 //    server, which keeps the id it was spawned with, can follow a `/clear`.
-// 3. Put the session's open Dispatch asks into the model's context, after one `envoy: <warning>`
+// 4. Put the session's open Dispatch asks into the model's context, after one `envoy: <warning>`
 //    line for each file the read found and did not read (a checkout's `.opencode/envoy.json`,
 //    naming its rename), as the other plugins' start notices and the `dispatch` command name it.
 // Plain stdout becomes context; it always exits 0 so a Dispatch outage never
@@ -87,6 +107,11 @@ import {
   sessionDispatchSettings,
   sessionDispatchUrl,
 } from "@legion/envoy-client/session-settings"
+import {
+  exportJjSessionAttribution,
+  paneAttributionOptions,
+  userConfigChain,
+} from "@legion/pi-shared/jj-attribution"
 import { z } from "zod"
 import { claudeProjectDirectory, configuredValue } from "../src/claude-session"
 import { sessionHandoffFile, writeSessionHandoff } from "../src/session-identity"
@@ -149,20 +174,75 @@ const RefreshOutcome = z.object({
 const ANSWERS_TIMING_FILE = "ENVOY_ANSWERS_TIMING_FILE"
 
 const DISPATCH_HOST_LINE = "export DISPATCH_HOST=claude"
+/** What an overlay export line starts with: the one line of the env file this hook replaces
+ *  rather than adds to. */
+const JJ_CONFIG_EXPORT = "export JJ_CONFIG="
+/** The bound on resolving jj's own user config chain for the overlay, inside the 20 s hooks.json
+ *  gives this hook: 3 s of jj and then 3 s of the Dispatch read (`OPEN_ASKS_TIMEOUT_MS`) still
+ *  leave the session its summary. Not `JJ_CONFIG_PATH_TIMEOUT_MS`, which is the Oh My Pi lane's
+ *  bound inside the 30 s that harness gives its session-start handler. A jj that never answers
+ *  costs the session the export and nothing else. */
+const JJ_BASE_CHAIN_TIMEOUT_MS = 3_000
 
-/** Appends `line` to the env file, once: every SessionStart of the session runs this. */
-function appendOnce(envFile: string, line: string): void {
-  let written = ""
+/** `value` as a single-quoted shell word: Claude Code sources this file before every bash command
+ *  of the session, so a path or a config chain holding a space, a quote or a `$` must reach the
+ *  shell as one word. A single quote inside the value ends the quoting, is passed as an escaped
+ *  quote of its own, and opens it again. Claude Code's PowerShell bridge reads the single-quoted
+ *  form of a value holding no quote; the `'\''` escape is POSIX `sh`'s, and that bridge's value
+ *  grammar, read on the pinned 2.1.311, does not take it, so a line carrying one is no line the
+ *  bridge can read — which costs the whole file there, and costs a Legion pane nothing, since
+ *  Legion panes are not on Windows. */
+function singleQuoted(value: string): string {
+  return `'${value.replaceAll("'", "'\\''")}'`
+}
+
+/** What the env file holds, and "" when it does not exist yet: Claude Code names the file before
+ *  any hook has written it. */
+function envFileText(envFile: string): string {
   try {
-    written = readFileSync(envFile, "utf8")
+    return readFileSync(envFile, "utf8")
   } catch (error) {
     if (!hasErrnoCode(error, "ENOENT")) throw error
+    return ""
   }
-  if (written.split("\n").includes(line)) return
+}
+
+/** Appends `line` to the env file as a line of its own, `written` being what `envFileText` read:
+ *  a file not ending in a newline gets one first, so the line never joins the last one. */
+function appendLine(envFile: string, written: string, line: string): void {
   const separator = written === "" || written.endsWith("\n") ? "" : "\n"
   appendFileSync(envFile, `${separator}${line}\n`)
 }
 
+/** Appends `line` to the env file, once: every SessionStart of the session runs this. */
+function appendOnce(envFile: string, line: string): void {
+  const written = envFileText(envFile)
+  if (written.split("\n").includes(line)) return
+  appendLine(envFile, written, line)
+}
+
+/** Writes `line` to the env file as the only line starting with `prefix`, replacing an earlier
+ *  one in its place and appending when there is none: a resume or a compaction of the same
+ *  session id runs the hook again over the file it already wrote, and the chain it resolves can
+ *  differ, where two `export JJ_CONFIG=` lines in one sourced file would leave which overlay wins
+ *  to the order they were written in. Every other line keeps its text and its place.
+ *  A replacement is written through a temporary file and a rename, so a process that dies
+ *  mid-write leaves the shell the whole old file, never a truncated one; with no earlier line it
+ *  appends, as `appendOnce` does (`appendLine`), rather than rewriting what another hook may be
+ *  appending to. */
+function replaceOnce(envFile: string, prefix: string, line: string): void {
+  const written = envFileText(envFile)
+  const lines = written.split("\n")
+  const at = lines.findIndex((existing) => existing.startsWith(prefix))
+  if (at === -1) {
+    appendLine(envFile, written, line)
+    return
+  }
+  if (lines[at] === line) return
+  lines[at] = line
+  writeAtomically(envFile, lines.join("\n"))
+}
+
 async function openAsks(raw: unknown): Promise<void> {
   const input = OpenAsksInput.parse(raw)
   const envFile = process.env["CLAUDE_ENV_FILE"]
@@ -172,7 +252,34 @@ async function openAsks(raw: unknown): Promise<void> {
   if (envFile) {
     appendOnce(envFile, DISPATCH_HOST_LINE)
     if (chosen.path !== null) {
-      appendOnce(envFile, `export ENVOY_CONFIG_FILE='${chosen.path.replaceAll("'", "'\\''")}'`)
+      appendOnce(envFile, `export ENVOY_CONFIG_FILE=${singleQuoted(chosen.path)}`)
+    }
+    const stateDir = process.env["LEGION_STATE_DIR"]
+    if (stateDir) {
+      try {
+        // The pane's own key and workspace, by the rule both harnesses read those two variables
+        // by (`paneAttributionOptions`).
+        const chain = await exportJjSessionAttribution(input.session_id, stateDir, {
+          ...paneAttributionOptions(process.env),
+          resolveBase: () => userConfigChain(JJ_BASE_CHAIN_TIMEOUT_MS),
+        })
+        // An overlay that could not be written leaves the file as it is: no line written, and
+        // none removed. `CLAUDE_ENV_FILE` is
+        // `<config>/session-env/<session id>/sessionstart-hook-<n>.sh` on the pinned Claude Code
+        // 2.1.311, so the file belongs to this session id alone: an `export JJ_CONFIG=` line
+        // already in it was written by an earlier run of this same id — a resume or a compaction
+        // — and names this same session's own overlay, still on disk and still correct. Removing
+        // it after a jj that did not answer would leave the session with neither trailer, where
+        // keeping it leaves the session the trailer it already had.
+        if (chain !== undefined) {
+          replaceOnce(envFile, JJ_CONFIG_EXPORT, `${JJ_CONFIG_EXPORT}${singleQuoted(chain)}`)
+        }
+      } catch (error) {
+        // The overlay writer swallows its own failures, but replacing a line writes a temporary
+        // file beside the env file, which needs its directory writable where appending
+        // above did not: attribution must cost the session neither its exports nor its summary.
+        process.stderr.write(`envoy: could not export the jj attribution — ${messageFor(error)}\n`)
+      }
     }
   }
   const pluginData = process.env["CLAUDE_PLUGIN_DATA"]

package/legion/skills/legion-worker/SKILL.md

@@ -48,7 +48,7 @@ Read each by its `skill://` link: a read by path stops at 300 lines.
 
 ## Every role pushes its own commits
 
-- Before a push, read `jj -R "$LEGION_WORKSPACE" log -r 'ancestors(@, 5)'` (earlier phases' commits in it are expected) and run the identity check (`skill://legion-worker/references/default-branch-check.md`). Add no attribution trailer: the pane's jj adds `Omp-Session:`.
+- Before a push, run the identity check (`skill://legion-worker/references/default-branch-check.md`) and then, with the `$default` it set, read your branch's own commit messages: `jj -R "$LEGION_WORKSPACE" log -r "${default}@origin..@" -T 'description ++ "\n"'` — earlier phases' commits in it are expected; never `ancestors(@, 5)`, which stops at five where one measurement found branches of 12 and 28 commits, and never `description.first_line()`, which shows no trailer. Invent no trailer of your own: the pane's jj appends `Omp-Session:` to every commit the pane's shell makes, in any jj repository, and, for a repository the deployment names, the issue line `Dispatch: <KEY>` beside it, that one scoped to the pane's own workspace. A jj repository you clone or create under that workspace is stamped like the workspace, so a commit you make in one carries this deployment's issue key: clone a repository you will push elsewhere outside `$LEGION_WORKSPACE`, and push no commit made under it to a repository that takes no issue key. Three commits carry neither — one `git` made in the colocated workspace, one another process made outside the pane's shell, and, on the Claude harness, one a subagent's bash made, which may not carry the session's environment file (anthropics/claude-code#46696, which `packages/claude-envoy/hooks/session-hook.ts` records and ships a `dispatch` fallback for, though one measurement on the pinned release found those exports present there). A commit of yours that shows a line short is cured by describing it again, since the trailer is appended when a description is set. A re-describe appends the issue line only where the shell it runs in has the pane's jj config overlay, so it adds nothing in a shell that carries none — a subagent's bash, or a pane whose overlay the writer could not make. Where it adds nothing, write the line yourself: put `Dispatch: $LEGION_ISSUE_TRAILER` into the description as a trailer line of its own, and only when `LEGION_ISSUE_TRAILER` is set, since that variable is the deployment's own name for the key this repository takes, and an unset one means the repository takes no key and the line belongs in no commit of it. Look because a base branch can require the issue line in the commit that lands: a squash builds that message from the branch's commit messages, and it leaves a merge commit's message out, so the line belongs in an ordinary commit.
 - Only work is pushed: code, red tests, a forward merge, a rewrite, and the empty commit that carries the pull request onto the commit you pushed (the bullet below). No commit message carries a line or bracket keyword that stops GitHub's workflows (`[skip ci]` and its kin), since every head needs its own checks and a base that requires a check will not merge a head whose checks never ran. Retro pushes nothing: it records what the work taught with `dispatch comment` on the issue.
 - **After a push, read the pull request's head and check that it is your commit.** A branch and a pull request are two objects on GitHub: the push moves the branch, and GitHub then moves the pull request onto the new commit, which is what starts its checks. Twice on 2026-11-05 it did not, and the newer commit got no checks while Legion read, tested and would have merged the older one. The step applies once the branch has an open pull request, whose number your task's `Pull request:` line names (`gh pr list --repo <the issue's repository> --head legion/<KEY> --state open --json number --jq '.[0].number'` when it names none): run `gh pr view <n> --repo <the issue's repository> --json headRefOid --jq .headRefOid` about ten seconds after your push, again about ten seconds later, and a last time about thirty seconds after that, with a read that gives the pushed commit ending the step there and only the last read deciding a mismatch, and compare each answer with the commit you pushed, which `jj -R "$LEGION_WORKSPACE" log -r legion/<KEY>@origin --no-graph -T commit_id` prints in the 40 characters `headRefOid` answers in. This read is of the pull request's own head and of no check, so the wait it makes is not a wait on CI (`skill://legion-worker/references/pr-body.md#never-waiting-on-ci`). When the last read still is not your commit, carry the pull request with a commit of its own, an empty one when your work is complete and an empty one just as much when `@` holds work of yours, since a push of a commit the branch already holds moves no ref; the push section of your role prompt gives the one `jj` recipe, which leaves `@` and everything in it where it is. A new head makes every result recorded at the old head older, so record each `before_merge` check again at the new head. When that second push does not carry the pull request either, tell your architect the commit you pushed, the head each read gave and the time of each, and end the turn with a WAITING line naming that answer rather than completing: a phase completed here hands the next role a commit the pull request does not name. The push you make to answer an update task is the exception: that task has you answer the daemon and end the turn at once, so make this read in your next turn, before your phase completes. The merger pushes nothing, so this step never falls to it; it reports a mismatch it sees to the architect.
 - A planner whose issue moved back from implementing starts on the remote tip, `jj -R "$LEGION_WORKSPACE" new legion/<KEY>@origin`, so a commit it makes never sits on the implementer's unpushed commits.

package/legion/skills/legion-worker/references/pr-body.md

@@ -35,7 +35,7 @@ later phase keeps it current rather than replacing it:
 
 **Checks:** one line per `check` block of the issue's Verification document, in the document's
 order, each the line `dispatch result` printed when the result was recorded:
-- Check <block id> (<when>): <pass|fail> at <the commit's first 12 characters>, recorded by <role>. <the check's first words>
+- Check <block id> (<when>): <pass|fail> at <the commit>, recorded by <role>. <the check's first words>
 - Check <block id> (after_merge): not yet run
 
 **Fast-follow:** "none", or one named cleanup item in a file this pull request does not touch, and where it will land.
@@ -103,6 +103,12 @@ unit suite is not it. A unit or integration test is a regression lock, never the
 check. The agent that develops the change records its results this way before the merge, and
 whatever blocks a check is fixed, not skipped (*When no surface reaches the changed path*, below).
 
+**Record a result after the commit is pushed.** Dispatch asks GitHub whether the repository of
+the check's issue holds the commit, and refuses a result at one it does not hold with `400
+RESULT_COMMIT_UNKNOWN`, naming the commit and the repository; a commit that is still only local
+is such a commit. Where Dispatch cannot read the repository at all it stores the result as
+before, and the result reads `unknown`.
+
 **A check that cannot fail is not a result.** Before a check counts as evidence, show it
 failing: the negative control is that demonstration, run on the same command with a deliberately
 wrong input or call. A check whose pass survives empty output, a missing file or the wrong head

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sjawhar/claude-envoy",
-  "version": "1.6.0",
+  "version": "1.7.1",
   "license": "Apache-2.0",
   "description": "Claude Code channel plugin for Legion's Envoy bus",
   "type": "module",
@@ -19,7 +19,7 @@
     "AGENTS.md"
   ],
   "legion": {
-    "daemonApiVersion": 51
+    "daemonApiVersion": 52
   },
   "repository": {
     "type": "git",