@humwick/runner 0.130.5 → 0.130.6

package/src/adapters/claude-permission.ts

@@ -19,7 +19,7 @@ export const claudePermissionPromptHandler: ProviderPermissionPromptHandler = {
 const RECOMMENDED_LABEL = /\(recommended\)\s*$/i;
 const DECISION_TITLE_MAX = 200;
 
-// #2914: AskUserQuestion → operator decision, 1:1. Claude marks its pick with a "(Recommended)" label.
+// AskUserQuestion → operator decision, 1:1. Claude marks its pick with a "(Recommended)" label.
 function claudeDecisionRequest(body: Record<string, unknown>): OperatorDecisionFileInput | undefined {
   const toolInput = isRecord(body.tool_input) ? body.tool_input : {};
   if (body.tool_name !== "AskUserQuestion" || !Array.isArray(toolInput.questions)) return undefined;
@@ -116,7 +116,7 @@ function claudePermissionHookResponse(decision: ProviderPermissionDecisionInput,
       hookSpecificOutput: {
         hookEventName: "PreToolUse",
         permissionDecision: "deny",
-        permissionDecisionReason: decisionReasonMessage(decision, "Dismissed from Agent Relay dashboard"),
+        permissionDecisionReason: decisionReasonMessage(decision, "Dismissed from Humwick dashboard"),
       },
     };
   }
@@ -150,7 +150,7 @@ function claudePermissionHookResponse(decision: ProviderPermissionDecisionInput,
       hookEventName,
       decision: {
         behavior: "deny",
-        message: decisionReasonMessage(decision, "Denied from Agent Relay dashboard"),
+        message: decisionReasonMessage(decision, "Denied from Humwick dashboard"),
         interrupt: decision.decision === "abort",
       },
     },
@@ -188,7 +188,7 @@ function claudeResolvedPermissionPrompt(view: InteractivePrompt, decision: Provi
   };
 }
 
-// #1173: AskUserQuestion's PreToolUse hook is answered with `deny` immediately (see
+// AskUserQuestion's PreToolUse hook is answered with `deny` immediately (see
 // control-server.ts) so Claude flushes its buffered reasoning instead of blocking on the human.
 // The user's actual answer arrives afterward as a normal injected prompt, not as a hook
 // response — this renders that prompt's text from the same view/decision shape the old
@@ -199,7 +199,7 @@ function claudeAnswerInjectionPrompt(view: InteractivePrompt, decision: Provider
   const rows = resolvedQuestionRows(questions, decision.answers, "(no answer given)");
   const qa = rows.map((row) => `Q: ${row.question}\nA: ${row.answer}`).join("\n\n");
   return [
-    "This was answered by the user via the Agent Relay dashboard — the AskUserQuestion tool call itself was intercepted and will not resolve; it will not return a result. Here is their answer:",
+    "This was answered by the user via the Humwick dashboard — the AskUserQuestion tool call itself was intercepted and will not resolve; it will not return a result. Here is their answer:",
     qa,
     "Continue the task using their answer(s) above — do not call AskUserQuestion again for the same question(s), and do not wait for the original tool call to return.",
   ].join("\n\n");

package/src/adapters/claude-prompt-gates.ts

@@ -18,16 +18,16 @@ export interface ClaudeLaunchPromptGatePrevention {
 type PaneGateMatch = { message?: string };
 
 /**
- * #1651 — how much authority a pane match is allowed to carry.
+ * how much authority a pane match is allowed to carry.
  *
  * `advisory` is the only correct value for a gate detected purely from TUI geometry. It
  * produces a {@link PaneObservation} and NOTHING else: no keystroke (the concept no longer
  * exists in this file), no ProviderStatusUpdate, hence no status, no `clear`, no
- * providerState. #1611/#1615/#1621/#1637/#1642 each tried to make one of these gates safe by
+ * providerState. Each tried to make one of these gates safe by
  * tightening its string matcher; the matcher was never the problem — granting a string match
  * the authority to mutate state was.
  *
- * The retired usage-limit pane gate (#1664) is deliberately not represented here: provider
+ * The retired usage-limit pane gate is deliberately not represented here: provider
  * state comes from structured provider failures, never a pane scrape.
  */
 
@@ -53,7 +53,7 @@ export interface ClaudePromptGatePaneContext {
 }
 
 export interface ClaudePromptGatePaneResult {
-  /** #1651 — always present when a gate reached minDetections. Diagnostic only. */
+  /** always present when a gate reached minDetections. Diagnostic only. */
   observation?: PaneObservation;
   /** Kept for callers which assert absence; `never` makes a status impossible to emit. */
   status?: never;
@@ -87,7 +87,7 @@ export const claudeConfigPromptGatePreventions: ClaudeConfigPromptGatePrevention
     id: "workspace-trust",
     description: "Trust the managed spawn cwd and clear project onboarding.",
     apply(seed, { config }) {
-      // #2254 — seed EVERY key CC may resolve this cwd under (lexical, realpath, git
+      // seed EVERY key CC may resolve this cwd under (lexical, realpath, git
       // canonical root), not just the lexical worktree path. Host-base launches, which
       // never reach this seed, get the same keys written into the shared config by
       // ensureClaudeWorkspaceTrust on the launch path.
@@ -117,7 +117,7 @@ export const claudeLaunchPromptGatePreventions: ClaudeLaunchPromptGatePrevention
 const WORKSPACE_TRUST_PROMPT = /do you trust (?:the files in )?(?:this folder|this project|this directory)|accessing workspace|quick safety check|yes,? ?I trust this folder/i;
 
 const panePromptGates: ClaudePanePromptGate[] = [
-  // #1651 — the five gates below are ADVISORY. Each used to type a key into a live pane the
+  // the five gates below are ADVISORY. Each used to type a key into a live pane the
   // instant `claudePaneIsBusy` happened to read false, then publish a fabricated
   // idle + clear:["subagent"]. Two independent hazards, both realized:
   //   - the four Enter gates SUBMIT whatever text is already sitting in the composer;
@@ -135,7 +135,7 @@ const panePromptGates: ClaudePanePromptGate[] = [
     label: "Workspace trust",
     policy: "accept-trusted-workspace",
     minDetections: 2,
-    // #2254 — CC 2.1.233 reworded this modal ("Accessing workspace" / "Quick safety check:
+    // CC 2.1.233 reworded this modal ("Accessing workspace" / "Quick safety check:
     // Is this a project you created or one you trust?" / "Yes, I trust this folder"), so the
     // old "do you trust this folder" matcher never fired and the wedge was silent. Both
     // wordings are matched now. Still ADVISORY (see the block comment above): the actual
@@ -180,14 +180,14 @@ const panePromptGates: ClaudePanePromptGate[] = [
       ? { message: lineMatching(text, /welcome to Claude Code/i) }
       : null,
   },
-  // #1514 (review finding 3) — the "Exit anyway / Move to background / Stay"
+  // (review finding 3) — the "Exit anyway / Move to background / Stay"
   // confirmation is deliberately NOT a live pane-watcher gate. Auto-pressing Enter
   // on a session that did NOT initiate shutdown is unsafe: it could submit stray
   // input or dismiss an unrelated modal on an attached/live session. This dialog is
   // only ever the right thing to answer under an explicit Relay shutdown, so it is
   // handled solely by the runner's shutdown grace loop (confirmClaudeExitDialogUnderGrant
   // in claude-exit.ts) — which runs only after this runner sent `/exit` under a one-shot
-  // grant. #1647 made that structural rather than advisory: this file cannot even import
+  // grant. Made that structural rather than advisory: this file cannot even import
   // the exit writers (claude-exit.guard.test.ts fails the build if it ever does). The
   // orphan safety net for a session already wedged mid-shutdown is the orchestrator's
   // wedged-session reaper, not a keypress into a live pane.

package/src/adapters/claude-prompt-hook.ts

@@ -1,10 +1,10 @@
-// #2664 — Claude's UserPromptSubmit hook fires only when Claude accepts an Enter: at queue time
+// Claude's UserPromptSubmit hook fires only when Claude accepts an Enter: at queue time
 // for a busy agent and never again on dequeue, and not at all for a swallowed Enter. A matching
 // hook fired after our Enter is therefore the acceptance proof; the composer read is only a fallback.
 
 // Transport changes observed on Claude Code 2.1.284-2.1.285, and nothing else: image paths it attached
 // become leading [Image #N] chips, and a long paste arrives inside a <pasted_content> wrapper, even
-// a single-line one (#3081). The whitespace around the wrapper and its body varies by release, so
+// a single-line one. The whitespace around the wrapper and its body varies by release, so
 // both are compared trimmed.
 // Image pastes also collapse blank-line runs (including the runner's attachment separator).
 const LEADING_IMAGE_CHIPS = /^(?:\[Image #\d+\])+/;

package/src/adapters/claude-session-capture.ts

@@ -31,13 +31,13 @@ const REASONING_POLL_MS = 1_200;
 // Bounded the same way as control-server.ts's resolvedApprovals so a long session's dedup
 // guard (see emittedStepKeys) can't grow without limit.
 const EMITTED_STEP_KEY_LIMIT = 2048;
-// #2919 — a prompt still queued at a Stop was enqueued after the turn's last tool boundary, so it
+// a prompt still queued at a Stop was enqueued after the turn's last tool boundary, so it
 // sits in the transcript's last entries; a bounded tail read finds it.
 const QUEUE_SCAN_BYTES = 256 * 1024;
 const HOOKED_PROMPT_LIMIT = 8;
 
 export class ClaudeSessionCapture {
-  // #2664 — every UserPromptSubmit hook; the proof that Claude accepted a submitted prompt.
+  // every UserPromptSubmit hook; the proof that Claude accepted a submitted prompt.
   readonly promptHooks = new ClaudePromptHookLedger();
   private narrativeFlushEntryCount = 0;
   private reasoningTail?: ReasoningTailState;
@@ -50,7 +50,7 @@ export class ClaudeSessionCapture {
   // it can re-derive the exact same step signatures the earlier tail already emitted. Seeding
   // each new tail's `seen` set from this closes that gap regardless of the exact timing.
   private emittedStepKeys = new Set<string>();
-  // #2919 — recent UserPromptSubmit prompts. Claude hooks a prompt submitted mid-turn when it queues
+  // recent UserPromptSubmit prompts. Claude hooks a prompt submitted mid-turn when it queues
   // it and never again when it runs it. Pruned at every Stop to the ones still queued.
   private hookedPrompts: string[] = [];
   private sessionEventCb: (event: ProviderSessionEvent) => void = () => {};
@@ -93,7 +93,7 @@ export class ClaudeSessionCapture {
     const flushCount = this.narrativeFlushEntryCount;
     this.narrativeFlushEntryCount = 0;
 
-    // #2840 — the reasoning tail already mirrors each narration line as its own row, so the
+    // the reasoning tail already mirrors each narration line as its own row, so the
     // turn-final (and the report built from it) is the closing text only.
     const closingOnly = ctx.chatCaptureMode === "final" || ctx.reasoningCapture !== false;
     let body = extractHookAssistantMessage(input.lastAssistantMessage);
@@ -145,7 +145,7 @@ export class ClaudeSessionCapture {
     ctx.log(input.firedAt === undefined ? "hook check-in carried no firedAt; submits stay on composer confirmation" : "hook check-in: stamped hook path verified");
   }
 
-  /** #2919 — whether a prompt Claude already hooked is still queued, so it runs next with no hook of its own. */
+  /** whether a prompt Claude already hooked is still queued, so it runs next with no hook of its own. */
   private async hookedPromptStillQueued(transcriptPath: string): Promise<boolean> {
     if (!this.hookedPrompts.length) return false;
     const queued = pendingQueuedPrompts(await readTranscriptTail(transcriptPath)).map((prompt) => prompt.trim());
@@ -174,7 +174,7 @@ export class ClaudeSessionCapture {
     }
   }
 
-  // #3411 — runs whatever reasoningCapture says: its tool steps carry the paths area memory matches,
+  // runs whatever reasoningCapture says: its tool steps carry the paths area memory matches,
   // and the session mirror drops the steps from chat when reasoningCapture is off.
   private startReasoningTail(transcriptPath: string, ctx: ProviderSessionTurnContext): void {
     this.stopSessionTrace();

package/src/adapters/claude-session-probe.ts

@@ -1,4 +1,4 @@
-// #766/#768 — Claude Code's intrinsic, machine-readable session probe.
+// Claude Code's intrinsic, machine-readable session probe.
 //
 // Claude Code ≥2.1.119 writes `$CLAUDE_CONFIG_DIR/sessions/<pid>.json` and rewrites
 // it on every status transition. It carries an authoritative `status` field
@@ -33,7 +33,7 @@ export const CLAUDE_PROBE_MIN_VERSION = "2.1.119";
 /**
  * The probe half of an activity read: the mapped 3-valued activity (undefined when the probe is
  * absent/old/unparseable → the caller falls back to the pane) plus `busyStale`: the busy verdict
- * predates a turn-cancelling keystroke relay itself sent (#1621). Age never discredits it (#3026):
+ * predates a turn-cancelling keystroke relay itself sent. Age never discredits it:
  * Claude writes neither probe nor transcript during a long think, so a frozen busy is held and the
  * notify-only prolonged-hold watchdog surfaces a turn that really died out of band.
  */
@@ -45,7 +45,7 @@ export function claudeProbeVerdict(
   if (activity !== "busy" || !reading || opts.paneInterruptAt === undefined || reading.updatedAt === null) {
     return { activity, busyStale: false };
   }
-  // #1642 — a transcript append after the interrupt means the cancel did not take.
+  // a transcript append after the interrupt means the cancel did not take.
   const cancelDidNotTake = opts.lastActivityAt !== undefined && opts.lastActivityAt > opts.paneInterruptAt;
   return { activity, busyStale: reading.updatedAt <= opts.paneInterruptAt && !cancelDidNotTake };
 }
@@ -61,9 +61,9 @@ export interface ClaudeSessionReading {
   procStart: string | null;
   /** `updatedAt` epoch-ms of the last probe write, or null. */
   updatedAt: number | null;
-  /** Claude's own session UUID (#1235) — names the transcript file. Null when absent. */
+  /** Claude's own session UUID — names the transcript file. Null when absent. */
   sessionId: string | null;
-  /** The session's cwd (#1235) — slugified into the transcript's project dir. Null when absent. */
+  /** The session's cwd — slugified into the transcript's project dir. Null when absent. */
   cwd: string | null;
   /** True iff a present, parseable, version-gated probe produced `status`. */
   available: boolean;
@@ -72,7 +72,7 @@ export interface ClaudeSessionReading {
 const UNAVAILABLE: ClaudeSessionReading = { status: "unknown", waitingFor: null, version: null, procStart: null, updatedAt: null, sessionId: null, cwd: null, available: false };
 
 /**
- * Process-liveness seam for the staleness guard (#769 P1-B), injectable in tests.
+ * Process-liveness seam for the staleness guard, injectable in tests.
  *   procStartOf — the start-time token of a LIVE pid (to compare against the probe's
  *     `procStart`), or null when the pid is dead/unreadable. Catches both a frozen
  *     probe from a SIGKILLed claude AND a sub-second pid-reuse window (a reused pid
@@ -89,7 +89,7 @@ function procStatStartTime(stat: string): string | null {
   return stat.slice(stat.lastIndexOf(")") + 1).trim().split(/\s+/)[19] ?? null;
 }
 
-// #1838 rows 14/15 — off-loop: the 4s reconciler / 1.5s turn-watch tick never blocks on the read.
+// rows 14/15 — off-loop: the 4s reconciler / 1.5s turn-watch tick never blocks on the read.
 async function readProcStartTimeAsync(pid: number): Promise<string | null> {
   try {
     return procStatStartTime(await readFile(`/proc/${pid}/stat`, "utf8"));
@@ -98,7 +98,7 @@ async function readProcStartTimeAsync(pid: number): Promise<string | null> {
   }
 }
 
-// #3151 — off Linux, Claude stamps procStart as `ps -o lstart=` in UTC ("Sun Oct 25 13:01:19 2026").
+// off Linux, Claude stamps procStart as `ps -o lstart=` in UTC ("Sun Oct 25 13:01:19 2026").
 const PS_LSTART_TIMEOUT_MS = 5_000;
 const psLstartArgv = (pid: number): string[] => ["ps", "-o", "lstart=", "-p", String(pid)];
 const psLstartEnv = (): Record<string, string | undefined> => ({ ...process.env, TZ: "UTC", LC_ALL: "C" });
@@ -125,9 +125,9 @@ export async function readPsLstartUtcAsync(pid: number): Promise<string | null>
 // the probe on a status *transition*, so a legitimately busy turn keeps a frozen
 // `updatedAt` for its whole duration (verified: a 90s+ busy turn never rewrote it).
 // A staleness threshold would force a long busy turn back to the pane-scrape and
-// reintroduce the #766 idle-while-working bug; pid-liveness + procStart cover the
+// reintroduce the idle-while-working bug; pid-liveness + procStart cover the
 // SIGKILL-frozen and pid-reuse cases without that hazard. `available` is not
-// time-gated, and neither is the busy verdict (#3026, see claudeProbeVerdict).
+// time-gated, and neither is the busy verdict.
 /** The off-loop probe liveness check for `platform`: `/proc` on Linux, UTC `ps` lstart elsewhere. */
 export function claudeProbeLivenessAsync(
   platform: string = process.platform,
@@ -208,7 +208,7 @@ export function parseClaudeSessionProbe(raw: string, minVersion = CLAUDE_PROBE_M
 /**
  * Read + parse the probe for `pid` under `configHome`. Missing file (older CC, a config home the
  * runner can't resolve, or claude not yet started) → unavailable, so the caller falls back to the
- * pane-scrape. Off-loop (#1838): every caller is a timer tick or the async `/exit` correlator.
+ * pane-scrape. Off-loop: every caller is a timer tick or the async `/exit` correlator.
  */
 export async function readClaudeSessionStatusAsync(
   configHome: string,
@@ -223,7 +223,7 @@ export async function readClaudeSessionStatusAsync(
   }
   const reading = parseClaudeSessionProbe(raw, opts.minVersion ?? CLAUDE_PROBE_MIN_VERSION);
   if (!reading.available) return reading;
-  // #769 P1-B: a frozen probe from a SIGKILLed claude (or a reused pid) would report a stale
+  // P1-B: a frozen probe from a SIGKILLed claude (or a reused pid) would report a stale
   // busy/shell forever. Verify the pid still belongs to the same process.
   const live = opts.liveness ?? DEFAULT_LIVENESS_ASYNC;
   if (reading.procStart) {
@@ -252,7 +252,7 @@ export function claudeProbeArgsFor(process: ManagedProcess, tmuxSession: string,
 }
 
 /**
- * #2261 — a clear-commit probe reading: Claude's own session UUID together with the pid it was
+ * a clear-commit probe reading: Claude's own session UUID together with the pid it was
  * read for. A committed `/clear` mints a NEW session, so a rotation of `sessionId` OBSERVED FOR
  * THE SAME PID is machine-readable proof the loaded conversation is gone.
  */
@@ -261,7 +261,7 @@ export interface ClaudeClearSessionReading { sessionId: string; pid: number }
 /**
  * Read one, or null for every "could not find out" outcome: no resolvable pid, no probe file, a
  * version-gated-out or liveness-failed reading (`available === false`, which is what rules out a
- * SIGKILL-frozen probe and a reused pid — #769 P1-B), or a probe carrying no sessionId at all.
+ * SIGKILL-frozen probe and a reused pid — P1-B), or a probe carrying no sessionId at all.
  * Deliberately total (never throws, never distinguishes flavours of absence): its only consumer
  * treats anything short of a confirmed same-pid rotation as no evidence.
  */
@@ -276,7 +276,7 @@ export async function readClaudeClearSessionAsync(args: ManagedClaudeProbeArgs):
 }
 
 /**
- * #2261 — bind a clear-commit reader to ONE pane pid, resolved up front.
+ * bind a clear-commit reader to ONE pane pid, resolved up front.
  *
  * The barrier polls ~50 times inside its 10s budget. Re-resolving the pane pid per poll spawned a
  * `tmux display-message` each time (the pid is undefined for a tmux launch), and — worse — let the
@@ -299,7 +299,7 @@ export async function bindClaudeClearSessionReader(
 export type ClaudeClearSessionVerdict = "rotated" | "unchanged" | "unknown";
 
 /**
- * #2261 — compare a pre-clear reading against a current one. Both must be present AND describe the
+ * compare a pre-clear reading against a current one. Both must be present AND describe the
  * SAME pid; anything else is `unknown`, never a verdict. A `rotated` verdict is positive proof the
  * clear committed; an `unchanged` one is positive proof it has NOT (yet) — the probe is
  * authoritative in both directions whenever it is readable on both sides.
@@ -327,10 +327,10 @@ export async function readManagedClaudeStatusAsync(
 }
 
 /**
- * The transcript JSONL path Claude Code writes for a session (#1235). Claude stores
+ * The transcript JSONL path Claude Code writes for a session. Claude stores
  * per-cwd transcripts at `<configHome>/projects/<cwd-slug>/<sessionId>.jsonl`, where
  * the slug replaces every non-alphanumeric char in the absolute cwd with `-` (verified
- * live on CC 2.1.205: `/home/u/p/.agent-relay/x` → `-home-u-p--agent-relay-x`). This is
+ * live on CC 2.1.205: `/home/u/p/.humwick/x` → `-home-u-p--humwick-x`). This is
  * the hookless path the monitorless turn-watch feeds to the transcript reasoning tail so
  * isolated/lean Claude workers (no Stop/UserPromptSubmit hooks) still mirror chat.
  */
@@ -344,16 +344,16 @@ export function claudeTranscriptPath(configHome: string, cwd: string, sessionId:
 }
 
 /**
- * #1642 — the transcript's last-modified time in epoch-ms, or undefined when it can't be read
+ * the transcript's last-modified time in epoch-ms, or undefined when it can't be read
  * (absent/old probe with no sessionId+cwd, or the file not yet created). Claude appends to this
  * JSONL on every turn event, so its mtime is the runner's hookless "events still flowing"
  * heartbeat — the signal that keeps an actively-streaming turn's frozen busy probe from being
  * aged out to the pane. A failed stat is silence, never a claim the turn ended: undefined leaves
- * #1621 untouched.
+ * untouched.
  *
- * #1838 rows 14/15 — the only caller (the busy reconciler / turn watch, via activityFromProbeOrPane)
+ * rows 14/15 — the only caller (the busy reconciler / turn watch, via activityFromProbeOrPane)
  * is now off the event loop, so this is the sole variant and uses `fs/promises`. (The synchronous
- * version was removed in the #1838 round-3 review: it had no production callers once the hot path
+ * version was removed in the round-3 review: it had no production callers once the hot path
  * went async — see the critical-loop ratchet note for claude-session-probe.ts.)
  */
 export async function claudeTranscriptMtimeMsAsync(
@@ -371,7 +371,7 @@ export async function claudeTranscriptMtimeMsAsync(
 }
 
 /**
- * Resolve the live transcript path for the managed claude via its session probe (#1235): the
+ * Resolve the live transcript path for the managed claude via its session probe: the
  * probe carries `sessionId` + `cwd`, and the runner knows the config home. undefined when the
  * probe is absent/old or the pid can't be resolved (graceful degrade: no native capture).
  */
@@ -389,13 +389,13 @@ export async function resolveManagedClaudeTranscriptPathAsync(args: {
 }
 
 /**
- * Map the intrinsic probe status to the 3-valued activity. The whole point of #766:
+ * Map the intrinsic probe status to the 3-valued activity. The whole point:
  *   busy       → busy   — a turn is running, foreground tools included; the old
  *                         pane-scrape misread it as idle and force-cleared.
  *   idle/shell → idle   — `shell` is Claude's `idle` while a background local_bash task
  *                         is alive (2.1.310: `status==="idle" && hasLiveLocalBash`).
  *                         Relay's own monitor is one, so a managed session at rest
- *                         reads `shell`, including right after an ESC (#2202).
+ *                         reads `shell`, including right after an ESC.
  *   waiting    → unknown — a permission/input dialog is a parked (not done) turn, so
  *                          we neither assert compute-busy nor let the backstop clear
  *                          the live turn. `waitingFor` is surfaced separately for

package/src/adapters/claude-shutdown.ts

@@ -1,10 +1,10 @@
-// #1647 — the Claude tmux shutdown sequence: observe, correlate, and only then
-// (maybe) exit gracefully. Split out of ./claude at the #300 ratchet; the adapter
+// the Claude tmux shutdown sequence: observe, correlate, and only then
+// (maybe) exit gracefully. Split out of ./claude at the ratchet; the adapter
 // keeps the watcher teardown and delegates the rest here.
 //
 // The policy itself lives in ./claude-exit. This module is the caller that samples
 // live state and drives the loop.
-import { managedTmuxSocketName, prepareTmuxPaneStop, prepareTmuxStop, tmuxHasSession, type PreparedTmuxStop } from "@humwick/sdk/tmux-utils";
+import { prepareTmuxPaneStop, prepareTmuxStop, tmuxHasSession, type PreparedTmuxStop } from "@humwick/sdk/tmux-utils";
 import { tmuxOwnerIdFromEnv } from "../config";
 import type { ManagedProcess, ShutdownOutcome } from "../adapter";
 import { claudeProbeActivity, claudeProbeArgsFor, readManagedClaudeStatusAsync, type ClaudeProbeLivenessAsync } from "./claude-session-probe";
@@ -43,10 +43,10 @@ export async function observeClaudeExitState(
   fallbackEpoch: number,
   seams: { liveness?: ClaudeProbeLivenessAsync; capturePane?: typeof captureTmuxPaneAsync } = {},
 ): Promise<ClaudeExitObservation> {
-  // #3152 — the shared off-loop reader, so a macOS `ps` lstart procStart binds this reading too.
+  // the shared off-loop reader, so a macOS `ps` lstart procStart binds this reading too.
   const managed = await readManagedClaudeStatusAsync(claudeProbeArgsFor(process, sessionName, socketName), seams.liveness);
   const reading = managed?.reading;
-  // #3186 — a managed Claude at rest reads `shell` (Relay's monitor is a live background task).
+  // a managed Claude at rest reads `shell` (Relay's monitor is a live background task).
   const probeIdle = reading?.available === true && claudeProbeActivity(reading.status) === "idle";
   let turn: ClaudeTurnState = probeIdle ? "ended" : reading?.available === true ? "live" : "unknown";
   if (turn === "ended") {
@@ -75,7 +75,7 @@ export interface ClaudeShutdownDeps {
   observe?: (process: ManagedProcess, sessionName: string, socketName?: string) => ClaudeExitObservation | Promise<ClaudeExitObservation>;
   submitExit?: (grant: ClaudeExitGrant) => Promise<unknown>;
   confirmExit?: (grant: ClaudeExitGrant) => unknown;
-  // #1746 — the reap now returns a terminal outcome (it verifies death, it does not merely
+  // the reap now returns a terminal outcome (it verifies death, it does not merely
   // fire a kill-session). Tests that only care that the reap ran may still return void.
   reap?: (sessionName: string, socketName?: string) => ShutdownOutcome | void | Promise<ShutdownOutcome | void>;
   sleep?: (ms: number) => Promise<unknown>;
@@ -119,7 +119,7 @@ export async function shutdownClaudeTmux(
       // Session disappearance still requires verification of the captured descendants.
       if (!hasSession(sessionName, socketName)) return stop();
       if (!grant) {
-        // #1647 — the guard that would have saved the coordinator. A turn that is live
+        // the guard that would have saved the coordinator. A turn that is live
         // (or that we cannot positively confirm has ended) authorizes nothing, so we
         // keep waiting and let the out-of-band reap below terminate the process if the
         // turn never settles.
@@ -134,7 +134,7 @@ export async function shutdownClaudeTmux(
         }
       } else {
         // `/exit` while a background task is running raises Claude's "Exit anyway /
-        // Move to background / Stay" confirmation (#1514). Answering it is allowed ONLY
+        // Move to background / Stay" confirmation. Answering it is allowed ONLY
         // through the same grant that submitted that `/exit`, and only for a dialog that
         // was not already on screen beforehand.
         confirmExit(grant);
@@ -143,9 +143,9 @@ export async function shutdownClaudeTmux(
     }
   }
 
-  // The out-of-band backstop, and the path #1647 prefers: it terminates the process
+  // The out-of-band backstop, and the path prefers: it terminates the process
   // without typing anything into the pane, so it is always reached when the guard above
-  // declines to authorize a graceful exit. #1746 — this is now a VERIFIED, escalating
+  // declines to authorize a graceful exit. This is now a VERIFIED, escalating
   // force-kill that returns a terminal outcome, not a fire-and-forget kill-session.
   return stop();
 }
@@ -156,7 +156,7 @@ async function prepareClaudeStop(sessionName: string, socketName: string | undef
       at: new Date().toISOString(), name, socket, ...failure,
     })),
   })))(sessionName, socketName);
-  const preparePane = async () => socketName === managedTmuxSocketName(sessionName)
+  const preparePane = async () => socketName !== undefined
     ? (deps.preparePaneStop ?? prepareTmuxPaneStop)({ name: sessionName, socket: socketName, owner: tmuxOwnerIdFromEnv() }).catch(() => undefined)
     : undefined;
   let fallback = await preparePane();