commandmate 0.49.1 → 0.49.2

package/dist/cli/utils/verify-runner.js

@@ -12,7 +12,7 @@
  * @module cli/utils/verify-runner
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MAX_PRINTED_LOG_TAIL_LINES = exports.GATE_NOTICE_LOG_PREFIX = exports.FLAKY_GATE_LABEL = exports.FLAKY_LOG_PREFIX = exports.TIMING_LOG_PREFIX = exports.MUTEX_LOG_PREFIX = exports.WORK_EVIDENCE_GATE_ID = exports.VERIFY_POLL_INTERVAL_MS = void 0;
+exports.MAX_PRINTED_LOG_TAIL_LINES = exports.GATE_NOTICE_LOG_PREFIX = exports.FLAKY_GATE_LABEL = exports.FLAKY_LOG_PREFIX = exports.TIMING_LOG_PREFIX = exports.MUTEX_LOG_PREFIX = exports.WORK_EVIDENCE_GATE_ID = exports.VERIFY_FINAL_READ_GRACE_MS = exports.VERIFY_POLL_INTERVAL_MS = void 0;
 exports.parseTimingMarker = parseTimingMarker;
 exports.formatGateTiming = formatGateTiming;
 exports.parseFlakyMarker = parseFlakyMarker;
@@ -24,6 +24,13 @@ const types_1 = require("../types");
 const api_client_1 = require("./api-client");
 /** Matches the wait command's cadence; runs are minutes long, not seconds. */
 exports.VERIFY_POLL_INTERVAL_MS = 5000;
+/**
+ * Issue #3983: how far past `--timeout` the read taken AT the deadline may run.
+ * The poll sleeps only up to the deadline and reads once more there, so a run
+ * that finished in the last interval still reports its verdict (#1544); this
+ * bounds that one read rather than skipping it.
+ */
+exports.VERIFY_FINAL_READ_GRACE_MS = 2000;
 /** Built-in gate id; mirrors WORK_EVIDENCE_GATE_ID in lib/verification/gate-runner.ts. */
 exports.WORK_EVIDENCE_GATE_ID = 'work-evidence';
 /**
@@ -367,9 +374,21 @@ function withConflictMessage(error, worktreeId) {
  */
 async function runVerification(client, request) {
     const { worktreeId } = request;
+    // Issue #3983: `timeoutSec` bounds the whole command — the start POST and
+    // every run read, each cut at the deadline — not only the gaps between polls.
+    // The one read taken at the deadline gets VERIFY_FINAL_READ_GRACE_MS on top.
+    const startedAt = Date.now();
+    const deadlineAt = request.timeoutSec ? startedAt + request.timeoutSec * 1000 : undefined;
+    const bounded = deadlineAt === undefined ? client : client.withDeadline(deadlineAt);
+    const finalReader = deadlineAt === undefined ? client : client.withDeadline(deadlineAt + exports.VERIFY_FINAL_READ_GRACE_MS);
+    const timedOut = (detail) => {
+        console.error(`Timeout: verification of ${worktreeId} exceeded ${request.timeoutSec}s (${detail})`);
+        return { exitCode: types_1.VerifyExitCode.TIMEOUT, run: lastRun };
+    };
+    let lastRun;
     let runId;
     try {
-        const started = await client.post(`/api/worktrees/${worktreeId}/verify`, {
+        const started = await bounded.post(`/api/worktrees/${worktreeId}/verify`, {
             trigger: request.trigger,
             instanceId: request.instanceId,
             gateIds: request.gateIds,
@@ -378,15 +397,30 @@ async function runVerification(client, request) {
         runId = (0, api_client_1.assertResponseShape)(started, ['runId'], `POST /api/worktrees/${worktreeId}/verify`).runId;
     }
     catch (error) {
+        if ((0, api_client_1.isDeadlineExceeded)(error)) {
+            return timedOut('the server did not answer the start request; a run may have started server-side');
+        }
         throw withConflictMessage(error, worktreeId);
     }
     console.error(`Verifying: ${worktreeId} (run ${runId})`);
-    const startedAt = Date.now();
     const reported = new Set();
     const runPath = `/api/worktrees/${worktreeId}/verify/runs/${runId}`;
-    let lastRun;
+    const stillRunning = `run ${runId} is still running server-side`;
+    let finalRead = false;
     while (true) {
-        const body = await client.get(runPath);
+        let body;
+        try {
+            // A read that starts within the grace of the deadline is read like the
+            // last one: started a few ms before it (a non-final sleep ending there),
+            // it would otherwise be cut before it could answer.
+            const nearDeadline = deadlineAt !== undefined && Date.now() > deadlineAt - exports.VERIFY_FINAL_READ_GRACE_MS;
+            body = await (finalRead || nearDeadline ? finalReader : bounded).get(runPath);
+        }
+        catch (error) {
+            if ((0, api_client_1.isDeadlineExceeded)(error))
+                return timedOut(stillRunning);
+            throw error;
+        }
         const run = (0, api_client_1.assertResponseShape)(body, ['run'], `GET ${runPath}`).run;
         lastRun = run;
         reportGates(run.gates ?? [], reported);
@@ -400,16 +434,18 @@ async function runVerification(client, request) {
             }
             return { exitCode: exitCodeForRunStatus(run.status), run };
         }
-        // Checked after the terminal-status branch so a run that finishes exactly on
-        // the deadline still reports its verdict instead of a timeout.
-        if (request.timeoutSec) {
-            const elapsed = (Date.now() - startedAt) / 1000;
-            if (elapsed >= request.timeoutSec) {
-                console.error(`Timeout: verification of ${worktreeId} exceeded ${request.timeoutSec}s ` +
-                    `(run ${runId} is still running server-side)`);
-                return { exitCode: types_1.VerifyExitCode.TIMEOUT, run: lastRun };
-            }
+        if (deadlineAt === undefined) {
+            await sleep(exports.VERIFY_POLL_INTERVAL_MS);
+            continue;
         }
-        await sleep(exports.VERIFY_POLL_INTERVAL_MS);
+        // Checked after the terminal-status branch so a run that finishes by the
+        // deadline still reports its verdict instead of a timeout.
+        const remaining = deadlineAt - Date.now();
+        if (finalRead || remaining <= 0)
+            return timedOut(stillRunning);
+        // Issue #3983: never sleep past the deadline. Sleeping the full interval put
+        // the last read a few ms after it in real time, and that read was skipped.
+        finalRead = remaining <= exports.VERIFY_POLL_INTERVAL_MS;
+        await sleep(Math.min(exports.VERIFY_POLL_INTERVAL_MS, remaining));
     }
 }

package/dist/lib/cli-tools/session-name.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"session-name.d.ts","sourceRoot":"","sources":["../../../src/lib/cli-tools/session-name.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,EAAqC,KAAK,WAAW,EAAE,MAAM,SAAS,CAAC;AAM9E,+EAA+E;AAC/E,eAAO,MAAM,yBAAyB,QAAkB,CAAC;AAOzD,OAAO,CAAC,MAAM,CAAC;IAEb,IAAI,wBAAwB,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;CACzD;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,IAAI,MAAM,GAAG,IAAI,CAEzD;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAKxE;AAmBD;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAC1C,SAAS,EAAE,MAAM,GAAG,IAAI,EACxB,SAAS,EAAE,WAAW,EACtB,UAAU,EAAE,MAAM,EAClB,UAAU,CAAC,EAAE,MAAM,GAClB,MAAM,CAGR;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,WAAW,EACtB,UAAU,EAAE,MAAM,EAClB,UAAU,CAAC,EAAE,MAAM,GAClB,MAAM,CAKR;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,WAAW,EACtB,UAAU,EAAE,MAAM,EAClB,UAAU,CAAC,EAAE,MAAM,GAClB,MAAM,CAER;AAED,yDAAyD;AACzD,MAAM,WAAW,iBAAiB;IAChC,wDAAwD;IACxD,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,SAAS,EAAE,WAAW,CAAC;IACvB,gFAAgF;IAChF,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,iBAAiB,GAAG,IAAI,CAgBvE"}
+{"version":3,"file":"session-name.d.ts","sourceRoot":"","sources":["../../../src/lib/cli-tools/session-name.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,EAAqC,KAAK,WAAW,EAAE,MAAM,SAAS,CAAC;AAM9E,+EAA+E;AAC/E,eAAO,MAAM,yBAAyB,QAAkB,CAAC;AAazD,OAAO,CAAC,MAAM,CAAC;IAEb,IAAI,wBAAwB,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;CACzD;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,IAAI,MAAM,GAAG,IAAI,CAEzD;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAKxE;AAmBD;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAC1C,SAAS,EAAE,MAAM,GAAG,IAAI,EACxB,SAAS,EAAE,WAAW,EACtB,UAAU,EAAE,MAAM,EAClB,UAAU,CAAC,EAAE,MAAM,GAClB,MAAM,CAGR;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,WAAW,EACtB,UAAU,EAAE,MAAM,EAClB,UAAU,CAAC,EAAE,MAAM,GAClB,MAAM,CAKR;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,WAAW,EACtB,UAAU,EAAE,MAAM,EAClB,UAAU,CAAC,EAAE,MAAM,GAClB,MAAM,CAER;AAED,yDAAyD;AACzD,MAAM,WAAW,iBAAiB;IAChC,wDAAwD;IACxD,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,SAAS,EAAE,WAAW,CAAC;IACvB,gFAAgF;IAChF,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,iBAAiB,GAAG,IAAI,CAgBvE"}

package/dist/lib/cli-tools/session-name.js

@@ -44,8 +44,16 @@ const legacy_session_alias_1 = require("../tmux/legacy-session-alias");
 const SESSION_NAME_PREFIX = 'mcbd-';
 /** Shape of a session-name namespace: 8 lowercase hex digits (Issue #2866). */
 exports.SESSION_NAMESPACE_PATTERN = /^[0-9a-f]{8}$/;
-/** CLI tool ids, longest first, so a longer id is never read as a shorter one. */
-const CLI_TOOL_IDS_LONGEST_FIRST = [...types_1.CLI_TOOL_IDS].sort((a, b) => b.length - a.length);
+/**
+ * CLI tool ids, longest first, so a longer id is never read as a shorter one.
+ *
+ * Read when called, not when this module loads (Issue #3981): modules loaded
+ * early (`session-starting-state`) import this one, and a module-load read of
+ * `CLI_TOOL_IDS` reaches a test's getter mock before it can answer.
+ */
+function cliToolIdsLongestFirst() {
+    return [...types_1.CLI_TOOL_IDS].sort((a, b) => b.length - a.length);
+}
 /**
  * The namespace this process names its sessions with, or null (legacy names).
  *
@@ -150,7 +158,7 @@ function parseSessionName(name) {
         namespace = body.slice(0, dash);
         body = body.slice(dash + 1);
     }
-    const cliToolId = CLI_TOOL_IDS_LONGEST_FIRST.find((id) => body.startsWith(`${id}-`));
+    const cliToolId = cliToolIdsLongestFirst().find((id) => body.startsWith(`${id}-`));
     if (!cliToolId)
         return null;
     const rest = body.slice(cliToolId.length + 1);

package/dist/lib/session/send-attempt-types.d.ts

@@ -54,6 +54,12 @@ export type SendAttemptReason =
  | 'relay-reservation-lost'
 /** `not-sent`: the pane could not be re-read under the input lock, so nothing was typed (#3945). */
  | 'recheck-failed'
+/**
+ * `not-sent`: a body sent as one paste could not be loaded into the tmux
+ * buffer (`load-buffer` failed), so `paste-buffer` never ran and nothing of
+ * the body reached the pane (#4011/#4031).
+ */
+ | 'paste-not-started'
 /** `indeterminate`: the body was typed, did not land intact, and was taken back out best-effort (#2464/#3366). */
  | 'body-not-landed'
 /** `indeterminate`: an autocompletion replaced the body; the line was cleared best-effort (#1501). */
@@ -62,6 +68,16 @@ export type SendAttemptReason =
  | 'submit-unconfirmed'
 /** `indeterminate`: a read of the composer after the failure still shows the body. */
  | 'composer-residue'
+/**
+ * `indeterminate`: the composer did not show the body after Enter, but the
+ * agent did not report the session's first prompt either (#4035).
+ */
+ | 'prompt-unreported'
+/**
+ * `indeterminate`: a send reported `sent`, and the next send found that body
+ * still in the composer before typing its own (#4035).
+ */
+ | 'found-in-composer'
 /** `indeterminate`: any other failure; where it stopped is not known. */
  | 'send-error';
 /** The last send attempt as `prompt --json` publishes it (`lastSend`). */
@@ -77,6 +93,15 @@ export interface LastSendAttempt {
  * send before any body is typed (Issue #3772). Matched by code, never by wording.
  */
 export declare const PLAN_REVIEW_SEND_REFUSED_CODE = "PLAN_REVIEW_SEND_REFUSED";
+/**
+ * `code` on the error a long body's paste throws when `load-buffer` failed
+ * (Issue #4031): `paste-buffer` never ran, so none of the body reached the
+ * pane. The tools wrap the error (`Failed to send message to <tool>: …`) with
+ * it as `cause`, and the send's outcome is read off that chain by code — the
+ * wording is shared with nothing, but a `paste-buffer` failure's is
+ * (`Failed to paste message into tmux session`) and that one is not known safe.
+ */
+export declare const PASTE_NOT_STARTED_CODE = "PASTE_NOT_STARTED";
 /**
  * `code` on the errors the input re-check throws before any key
  * (`recheckComposerBeforeInput`, Issue #3952): a dialog was open, or the pane

package/dist/lib/session/send-attempt-types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"send-attempt-types.d.ts","sourceRoot":"","sources":["../../../src/lib/session/send-attempt-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,gBAAgB,GAAG,UAAU,GAAG,MAAM,GAAG,eAAe,CAAC;AAErE,MAAM,MAAM,iBAAiB;AAC3B,wCAAwC;AACtC,WAAW;AACb,2EAA2E;GACzE,kBAAkB;AACpB,mEAAmE;GACjE,kBAAkB;AACpB,oDAAoD;GAClD,sBAAsB;AACxB,8GAA8G;GAC5G,gBAAgB;AAClB,sEAAsE;GACpE,iBAAiB;AACnB,oEAAoE;GAClE,qBAAqB;AACvB,4EAA4E;GAC1E,oBAAoB;AACtB,qGAAqG;GACnG,aAAa;AACf,gGAAgG;GAC9F,oBAAoB;AACtB,sGAAsG;GACpG,kBAAkB;AACpB,+FAA+F;GAC7F,iBAAiB;AACnB;;;;GAIG;GACD,wBAAwB;AAC1B,oGAAoG;GAClG,gBAAgB;AAClB,kHAAkH;GAChH,iBAAiB;AACnB,sGAAsG;GACpG,wBAAwB;AAC1B,sGAAsG;GACpG,oBAAoB;AACtB,sFAAsF;GACpF,kBAAkB;AACpB,yEAAyE;GACvE,YAAY,CAAC;AAEjB,0EAA0E;AAC1E,MAAM,WAAW,eAAe;IAC9B,kCAAkC;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,gBAAgB,CAAC;IACxB,8FAA8F;IAC9F,MAAM,EAAE,iBAAiB,GAAG,MAAM,CAAC;CACpC;AAED;;;GAGG;AACH,eAAO,MAAM,6BAA6B,6BAA6B,CAAC;AAExE;;;;;GAKG;AACH,eAAO,MAAM,iCAAiC,iCAAiC,CAAC;AAChF,eAAO,MAAM,yBAAyB,yBAAyB,CAAC"}
+{"version":3,"file":"send-attempt-types.d.ts","sourceRoot":"","sources":["../../../src/lib/session/send-attempt-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,gBAAgB,GAAG,UAAU,GAAG,MAAM,GAAG,eAAe,CAAC;AAErE,MAAM,MAAM,iBAAiB;AAC3B,wCAAwC;AACtC,WAAW;AACb,2EAA2E;GACzE,kBAAkB;AACpB,mEAAmE;GACjE,kBAAkB;AACpB,oDAAoD;GAClD,sBAAsB;AACxB,8GAA8G;GAC5G,gBAAgB;AAClB,sEAAsE;GACpE,iBAAiB;AACnB,oEAAoE;GAClE,qBAAqB;AACvB,4EAA4E;GAC1E,oBAAoB;AACtB,qGAAqG;GACnG,aAAa;AACf,gGAAgG;GAC9F,oBAAoB;AACtB,sGAAsG;GACpG,kBAAkB;AACpB,+FAA+F;GAC7F,iBAAiB;AACnB;;;;GAIG;GACD,wBAAwB;AAC1B,oGAAoG;GAClG,gBAAgB;AAClB;;;;GAIG;GACD,mBAAmB;AACrB,kHAAkH;GAChH,iBAAiB;AACnB,sGAAsG;GACpG,wBAAwB;AAC1B,sGAAsG;GACpG,oBAAoB;AACtB,sFAAsF;GACpF,kBAAkB;AACpB;;;GAGG;GACD,mBAAmB;AACrB;;;GAGG;GACD,mBAAmB;AACrB,yEAAyE;GACvE,YAAY,CAAC;AAEjB,0EAA0E;AAC1E,MAAM,WAAW,eAAe;IAC9B,kCAAkC;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,gBAAgB,CAAC;IACxB,8FAA8F;IAC9F,MAAM,EAAE,iBAAiB,GAAG,MAAM,CAAC;CACpC;AAED;;;GAGG;AACH,eAAO,MAAM,6BAA6B,6BAA6B,CAAC;AAExE;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,sBAAsB,CAAC;AAE1D;;;;;GAKG;AACH,eAAO,MAAM,iCAAiC,iCAAiC,CAAC;AAChF,eAAO,MAAM,yBAAyB,yBAAyB,CAAC"}

package/dist/lib/session/send-attempt-types.js

@@ -9,12 +9,21 @@
  * @module lib/session/send-attempt-types
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.INPUT_RECHECK_FAILED_CODE = exports.INPUT_RECHECK_PROMPT_WAITING_CODE = exports.PLAN_REVIEW_SEND_REFUSED_CODE = void 0;
+exports.INPUT_RECHECK_FAILED_CODE = exports.INPUT_RECHECK_PROMPT_WAITING_CODE = exports.PASTE_NOT_STARTED_CODE = exports.PLAN_REVIEW_SEND_REFUSED_CODE = void 0;
 /**
  * `code` on the error a tool throws when a plan review overlay refuses the
  * send before any body is typed (Issue #3772). Matched by code, never by wording.
  */
 exports.PLAN_REVIEW_SEND_REFUSED_CODE = 'PLAN_REVIEW_SEND_REFUSED';
+/**
+ * `code` on the error a long body's paste throws when `load-buffer` failed
+ * (Issue #4031): `paste-buffer` never ran, so none of the body reached the
+ * pane. The tools wrap the error (`Failed to send message to <tool>: …`) with
+ * it as `cause`, and the send's outcome is read off that chain by code — the
+ * wording is shared with nothing, but a `paste-buffer` failure's is
+ * (`Failed to paste message into tmux session`) and that one is not known safe.
+ */
+exports.PASTE_NOT_STARTED_CODE = 'PASTE_NOT_STARTED';
 /**
  * `code` on the errors the input re-check throws before any key
  * (`recheckComposerBeforeInput`, Issue #3952): a dialog was open, or the pane

package/dist/lib/verification/session-kill-ledger.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Record of `mcbd-*` sessions stopped through CommandMate's kill (Issue #3993).
+ *
+ * The `env-clean` gate counts every vanished session of a sibling worktree as a
+ * violation, because a worker killing its neighbour is the #1624 failure. The
+ * orchestrator stops sibling sessions too — `commandmate instances <wt> kill`
+ * when it cleans a worktree up (worktree-cleanup Phase 3), the UI's kill
+ * button, the server's cleanup after sync or a repository removal — and the two
+ * snapshots cannot tell that apart from a worker's kill: on 2026-10-29 four
+ * verification runs of #3957 failed on `- mcbd-…-<another worktree> [other]`
+ * for a cleanup nobody in the worker's transcript had run.
+ *
+ * This ledger is the missing fact: one line per kill, naming the API, the
+ * tmux sessions it actually stopped, the worktree it was for and who asked
+ * (the caller's working directory and tmux session). The gate excuses as little
+ * as it can prove is not the worker's (`env-clean-gate.ts`, `findExternalKill`):
+ * a vanished sibling session is `external` only when a line inside the task's
+ * window names that exact session, was written by the CLI, and its caller is
+ * known to be someone else — a cwd in a sibling directory of the task's
+ * worktree (the primary checkout, another worktree) or a tmux session of
+ * another worktree. Everything else stays a violation, exactly as before:
+ * a worker's own kill, a caller that is nowhere in particular (`/tmp`, `$HOME`),
+ * the route's and the server's lines (a worker can reach the UI and trigger
+ * sync too), and any kill that bypassed CommandMate (`tmux kill-session`), which
+ * records nothing. Those lines are still shown next to the violation.
+ *
+ * Written by the CLI (with its caller), by the kill-session route and by
+ * `session-cleanup.ts`. A CLI kill is therefore recorded twice — the CLI's line
+ * and the route's `http` line — which changes no verdict: only the CLI's line
+ * can excuse anything.
+ *
+ * Machine-wide, like the gate mutex (`machine-lock.ts`): the CLI and the server
+ * write it and the server's gate reads it, so the path is derived from `$HOME` alone —
+ * `~/.commandmate/session-kills/<UTC date>.jsonl` — with an override for tests.
+ * The `commandmate-entries` probe ignores the directory, like `locks`.
+ *
+ * Node built-ins only: the CLI imports this module.
+ *
+ * @module lib/verification/session-kill-ledger
+ */
+/** Directory under `~/.commandmate`; exported for the `commandmate-entries` probe. */
+export declare const SESSION_KILL_LEDGER_DIR_NAME = "session-kills";
+/** Overrides the ledger directory (tests, isolated environments). */
+export declare const SESSION_KILL_LEDGER_ROOT_ENV = "CM_SESSION_KILL_LEDGER_ROOT";
+/** Bumped only when a line stops being readable by this module. */
+export declare const SESSION_KILL_LEDGER_VERSION = 1;
+/** Day files older than this are removed when a new line is written (same as env snapshots). */
+export declare const SESSION_KILL_LEDGER_RETENTION_MS: number;
+/**
+ * What stopped the session: the kill-session API (`POST /api/worktrees/:id/kill-session`,
+ * also behind `instances <wt> kill`), or the server's own cleanup of worktrees
+ * that sync or a repository removal dropped (`lib/session-cleanup.ts`).
+ */
+export type SessionKillApi = 'kill-session' | 'session-cleanup';
+/**
+ * Who wrote the record, which decides how much it says about the caller:
+ *
+ * - `cli` — `commandmate instances … kill`; callerCwd / callerSession are the CLI's own.
+ * - `browser` — the kill-session route, for a same-origin browser request (the UI).
+ * - `http` — the kill-session route, for any other request (the CLI's own POST,
+ *   curl). The caller is unknown, so callerCwd / callerSession are null.
+ * - `server` — the server's cleanup; no request is behind it.
+ *
+ * Only `cli` lines can excuse a removal. `browser` is judged from
+ * `Sec-Fetch-Site` alone, which a header names and a UI-driving worker sends;
+ * `server` cleanup runs after a `commandmate sync` a worker can issue. Both are
+ * kept so the report can say a kill was recorded, not to excuse it.
+ */
+export type SessionKillOrigin = 'cli' | 'browser' | 'http' | 'server';
+export interface SessionKillRecord {
+    version: number;
+    /** Epoch ms of the successful kill. */
+    at: number;
+    api: SessionKillApi;
+    origin: SessionKillOrigin;
+    /** Worktree whose session(s) were stopped. */
+    worktreeId: string;
+    /** Instance the kill was scoped to; null for a whole-worktree kill. */
+    instanceId: string | null;
+    /**
+     * tmux session names the kill actually stopped — the route's `killedSessions`.
+     * The gate matches a vanished session against these exactly, never by the
+     * worktree id (whose prefix another worktree's id can share). Empty when the
+     * writer could not tell, which excuses nothing.
+     */
+    sessionNames: string[];
+    /** Working directory of the process that asked; null when unreadable. */
+    callerCwd: string | null;
+    /** tmux session the caller ran inside; null outside tmux. */
+    callerSession: string | null;
+}
+export declare function defaultSessionKillLedgerRoot(): string;
+export declare function resolveSessionKillLedgerRoot(env?: Record<string, string | undefined>): string;
+/**
+ * Append one kill. Never throws: the kill already happened, and failing the
+ * command over its bookkeeping would only hide that.
+ *
+ * @returns true when the line was written
+ */
+export declare function appendSessionKillRecord(record: SessionKillRecord, root?: string): boolean;
+/** Whether a parsed line is a record this module can use; anything else is skipped. */
+export declare function isSessionKillRecord(value: unknown): value is SessionKillRecord;
+/**
+ * The kills recorded in `[since, until]` (epoch ms, inclusive).
+ *
+ * A missing directory, an unreadable day file and a malformed line all read as
+ * "no record", which only ever excuses less.
+ */
+export declare function readSessionKillRecords(since: number, until: number, root?: string): SessionKillRecord[];
+//# sourceMappingURL=session-kill-ledger.d.ts.map

package/dist/lib/verification/session-kill-ledger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-kill-ledger.d.ts","sourceRoot":"","sources":["../../../src/lib/verification/session-kill-ledger.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAMH,sFAAsF;AACtF,eAAO,MAAM,4BAA4B,kBAAkB,CAAC;AAE5D,qEAAqE;AACrE,eAAO,MAAM,4BAA4B,gCAAgC,CAAC;AAE1E,mEAAmE;AACnE,eAAO,MAAM,2BAA2B,IAAI,CAAC;AAE7C,gGAAgG;AAChG,eAAO,MAAM,gCAAgC,QAA2B,CAAC;AAMzE;;;;GAIG;AACH,MAAM,MAAM,cAAc,GAAG,cAAc,GAAG,iBAAiB,CAAC;AAEhE;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,iBAAiB,GAAG,KAAK,GAAG,SAAS,GAAG,MAAM,GAAG,QAAQ,CAAC;AAKtE,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,uCAAuC;IACvC,EAAE,EAAE,MAAM,CAAC;IACX,GAAG,EAAE,cAAc,CAAC;IACpB,MAAM,EAAE,iBAAiB,CAAC;IAC1B,8CAA8C;IAC9C,UAAU,EAAE,MAAM,CAAC;IACnB,uEAAuE;IACvE,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B;;;;;OAKG;IACH,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,yEAAyE;IACzE,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,6DAA6D;IAC7D,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9B;AAED,wBAAgB,4BAA4B,IAAI,MAAM,CAErD;AAED,wBAAgB,4BAA4B,CAC1C,GAAG,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAe,GACpD,MAAM,CAGR;AAyBD;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,iBAAiB,EACzB,IAAI,GAAE,MAAuC,GAC5C,OAAO,CAaT;AAMD,uFAAuF;AACvF,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,iBAAiB,CAkB9E;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,IAAI,GAAE,MAAuC,GAC5C,iBAAiB,EAAE,CA0BrB"}

package/dist/lib/verification/session-kill-ledger.js

@@ -0,0 +1,174 @@
+"use strict";
+/**
+ * Record of `mcbd-*` sessions stopped through CommandMate's kill (Issue #3993).
+ *
+ * The `env-clean` gate counts every vanished session of a sibling worktree as a
+ * violation, because a worker killing its neighbour is the #1624 failure. The
+ * orchestrator stops sibling sessions too — `commandmate instances <wt> kill`
+ * when it cleans a worktree up (worktree-cleanup Phase 3), the UI's kill
+ * button, the server's cleanup after sync or a repository removal — and the two
+ * snapshots cannot tell that apart from a worker's kill: on 2026-10-29 four
+ * verification runs of #3957 failed on `- mcbd-…-<another worktree> [other]`
+ * for a cleanup nobody in the worker's transcript had run.
+ *
+ * This ledger is the missing fact: one line per kill, naming the API, the
+ * tmux sessions it actually stopped, the worktree it was for and who asked
+ * (the caller's working directory and tmux session). The gate excuses as little
+ * as it can prove is not the worker's (`env-clean-gate.ts`, `findExternalKill`):
+ * a vanished sibling session is `external` only when a line inside the task's
+ * window names that exact session, was written by the CLI, and its caller is
+ * known to be someone else — a cwd in a sibling directory of the task's
+ * worktree (the primary checkout, another worktree) or a tmux session of
+ * another worktree. Everything else stays a violation, exactly as before:
+ * a worker's own kill, a caller that is nowhere in particular (`/tmp`, `$HOME`),
+ * the route's and the server's lines (a worker can reach the UI and trigger
+ * sync too), and any kill that bypassed CommandMate (`tmux kill-session`), which
+ * records nothing. Those lines are still shown next to the violation.
+ *
+ * Written by the CLI (with its caller), by the kill-session route and by
+ * `session-cleanup.ts`. A CLI kill is therefore recorded twice — the CLI's line
+ * and the route's `http` line — which changes no verdict: only the CLI's line
+ * can excuse anything.
+ *
+ * Machine-wide, like the gate mutex (`machine-lock.ts`): the CLI and the server
+ * write it and the server's gate reads it, so the path is derived from `$HOME` alone —
+ * `~/.commandmate/session-kills/<UTC date>.jsonl` — with an override for tests.
+ * The `commandmate-entries` probe ignores the directory, like `locks`.
+ *
+ * Node built-ins only: the CLI imports this module.
+ *
+ * @module lib/verification/session-kill-ledger
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SESSION_KILL_LEDGER_RETENTION_MS = exports.SESSION_KILL_LEDGER_VERSION = exports.SESSION_KILL_LEDGER_ROOT_ENV = exports.SESSION_KILL_LEDGER_DIR_NAME = void 0;
+exports.defaultSessionKillLedgerRoot = defaultSessionKillLedgerRoot;
+exports.resolveSessionKillLedgerRoot = resolveSessionKillLedgerRoot;
+exports.appendSessionKillRecord = appendSessionKillRecord;
+exports.isSessionKillRecord = isSessionKillRecord;
+exports.readSessionKillRecords = readSessionKillRecords;
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+/** Directory under `~/.commandmate`; exported for the `commandmate-entries` probe. */
+exports.SESSION_KILL_LEDGER_DIR_NAME = 'session-kills';
+/** Overrides the ledger directory (tests, isolated environments). */
+exports.SESSION_KILL_LEDGER_ROOT_ENV = 'CM_SESSION_KILL_LEDGER_ROOT';
+/** Bumped only when a line stops being readable by this module. */
+exports.SESSION_KILL_LEDGER_VERSION = 1;
+/** Day files older than this are removed when a new line is written (same as env snapshots). */
+exports.SESSION_KILL_LEDGER_RETENTION_MS = 30 * 24 * 60 * 60 * 1000;
+const DAY_MS = 24 * 60 * 60 * 1000;
+const DAY_FILE_PATTERN = /^(\d{4}-\d{2}-\d{2})\.jsonl$/;
+const SESSION_KILL_APIS = ['kill-session', 'session-cleanup'];
+const SESSION_KILL_ORIGINS = ['cli', 'browser', 'http', 'server'];
+function defaultSessionKillLedgerRoot() {
+    return (0, path_1.join)((0, os_1.homedir)(), '.commandmate', exports.SESSION_KILL_LEDGER_DIR_NAME);
+}
+function resolveSessionKillLedgerRoot(env = process.env) {
+    const override = env[exports.SESSION_KILL_LEDGER_ROOT_ENV];
+    return override && override.trim() !== '' ? override : defaultSessionKillLedgerRoot();
+}
+function dayOf(epochMs) {
+    return new Date(epochMs).toISOString().slice(0, 10);
+}
+function pruneOldDays(root, now) {
+    const oldest = dayOf(now - exports.SESSION_KILL_LEDGER_RETENTION_MS);
+    let names;
+    try {
+        names = (0, fs_1.readdirSync)(root);
+    }
+    catch {
+        return;
+    }
+    for (const name of names) {
+        const day = DAY_FILE_PATTERN.exec(name)?.[1];
+        if (day === undefined || day >= oldest)
+            continue;
+        try {
+            (0, fs_1.rmSync)((0, path_1.join)(root, name), { force: true });
+        }
+        catch {
+            // A day file that cannot be removed is disk use, not a reason to fail a kill.
+        }
+    }
+}
+/**
+ * Append one kill. Never throws: the kill already happened, and failing the
+ * command over its bookkeeping would only hide that.
+ *
+ * @returns true when the line was written
+ */
+function appendSessionKillRecord(record, root = resolveSessionKillLedgerRoot()) {
+    try {
+        (0, fs_1.mkdirSync)(root, { recursive: true, mode: 0o700 });
+        // One short line per append; O_APPEND keeps concurrent writers' lines whole.
+        (0, fs_1.appendFileSync)((0, path_1.join)(root, `${dayOf(record.at)}.jsonl`), `${JSON.stringify(record)}\n`, {
+            encoding: 'utf8',
+            mode: 0o600,
+        });
+        pruneOldDays(root, record.at);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isNullableString(value) {
+    return value === null || typeof value === 'string';
+}
+/** Whether a parsed line is a record this module can use; anything else is skipped. */
+function isSessionKillRecord(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const record = value;
+    return (record.version === exports.SESSION_KILL_LEDGER_VERSION &&
+        typeof record.at === 'number' &&
+        typeof record.api === 'string' &&
+        SESSION_KILL_APIS.includes(record.api) &&
+        typeof record.origin === 'string' &&
+        SESSION_KILL_ORIGINS.includes(record.origin) &&
+        typeof record.worktreeId === 'string' &&
+        record.worktreeId !== '' &&
+        isNullableString(record.instanceId) &&
+        Array.isArray(record.sessionNames) &&
+        record.sessionNames.every((name) => typeof name === 'string') &&
+        isNullableString(record.callerCwd) &&
+        isNullableString(record.callerSession));
+}
+/**
+ * The kills recorded in `[since, until]` (epoch ms, inclusive).
+ *
+ * A missing directory, an unreadable day file and a malformed line all read as
+ * "no record", which only ever excuses less.
+ */
+function readSessionKillRecords(since, until, root = resolveSessionKillLedgerRoot()) {
+    if (!(since <= until))
+        return [];
+    // Nothing older than the retention survives, so a stale baseline costs no extra reads.
+    since = Math.max(since, until - exports.SESSION_KILL_LEDGER_RETENTION_MS - DAY_MS);
+    const records = [];
+    for (let day = Date.parse(`${dayOf(since)}T00:00:00.000Z`); day <= until; day += DAY_MS) {
+        let text;
+        try {
+            text = (0, fs_1.readFileSync)((0, path_1.join)(root, `${dayOf(day)}.jsonl`), 'utf8');
+        }
+        catch {
+            continue;
+        }
+        for (const line of text.split('\n')) {
+            if (line.trim() === '')
+                continue;
+            let parsed;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (isSessionKillRecord(parsed) && parsed.at >= since && parsed.at <= until) {
+                records.push(parsed);
+            }
+        }
+    }
+    return records;
+}

package/dist/server/locales/en/worktree.json

@@ -1138,6 +1138,7 @@
     "promptResponse": {
         "refused": "Your answer was not sent because the dialog has changed. Please check the screen.",
         "failed": "Could not send the answer. Please try again.",
+        "partial": "The answer stopped part-way: some of its keys may have reached the agent. Check the screen before answering again.",
         "stuckHint": "If sending does not work, operate the terminal in direct input mode.",
         "stuckHintLink": "Switch to direct input",
         "unanswerable": "CommandMate cannot operate this screen. Use direct input mode instead.",
@@ -1169,6 +1170,7 @@
             "nothingToSubmit": "There is no comment to submit. Add a comment first.",
             "invalidRequest": "That action does not fit this screen. Nothing was sent.",
             "notActive": "Nothing was sent: no plan review is on screen.",
+            "inputLost": "Stopped part-way: some keys may have reached the agent. Check the screen before trying again.",
             "generic": "Could not send."
         },
         "composerNotice": "The plan is waiting for your review — approve, cancel or comment.",

package/dist/server/locales/ja/worktree.json

@@ -1138,6 +1138,7 @@
     "promptResponse": {
         "refused": "ダイアログの状態が変わったため送信できませんでした。画面を確認してください。",
         "failed": "送信に失敗しました。もう一度お試しください。",
+        "partial": "回答の途中で止まりました。一部のキーが届いた可能性があります。画面を確認してから答え直してください。",
         "stuckHint": "送信がうまくいかない場合は、直接入力モードで操作してください。",
         "stuckHintLink": "直接入力に切り替える",
         "unanswerable": "この画面は CommandMate から操作できません。直接入力モードで操作してください。",
@@ -1169,6 +1170,7 @@
             "nothingToSubmit": "送るコメントがありません。先にコメントを追加してください。",
             "invalidRequest": "この画面では送れない操作です。何も送っていません。",
             "notActive": "計画のレビュー画面が表示されていないため、何も送っていません。",
+            "inputLost": "途中で止まりました。一部のキーが届いた可能性があります。画面を確認してから操作し直してください。",
             "generic": "送信できませんでした。"
         },
         "composerNotice": "計画の確認待ちです。承認・取り消し・コメントを選んでください",

package/dist/server/src/config/cli-tool-timing-config.js

@@ -20,7 +20,7 @@
  * All values are preserved from the original literals (no behavior change).
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LIVENESS_CONFIRM_DELAY_MS = exports.CLAUDE_ENV_SANITIZE_WAIT_MS = exports.OPENCODE_V2_COMPOSER_WAIT_MS = exports.OPENCODE_V2_EXIT_WAIT_MS = exports.COMMAND_CODE_INIT_WAIT_MS = exports.VIBE_LOCAL_DOUBLE_ENTER_WAIT_MS = exports.COPILOT_EXIT_WAIT_MS = exports.OPENCODE_INTERRUPT_SECOND_ESCAPE_DELAY_MS = exports.OPENCODE_EXIT_WAIT_MS = exports.CODEX_DIALOG_SETTLE_MS = exports.TUI_EXIT_WAIT_MS = exports.TUI_INTERRUPT_SETTLE_MS = exports.TUI_MESSAGE_PROCESSED_WAIT_MS = exports.TUI_TEXT_INPUT_WAIT_MS = exports.TUI_SESSION_CREATE_WAIT_MS = void 0;
+exports.LIVENESS_CONFIRM_DELAY_MS = exports.OPENCODE_V2_COMPOSER_WAIT_MS = exports.OPENCODE_V2_EXIT_WAIT_MS = exports.COMMAND_CODE_INIT_WAIT_MS = exports.VIBE_LOCAL_DOUBLE_ENTER_WAIT_MS = exports.COPILOT_EXIT_WAIT_MS = exports.OPENCODE_INTERRUPT_SECOND_ESCAPE_DELAY_MS = exports.OPENCODE_EXIT_WAIT_MS = exports.CODEX_DIALOG_SETTLE_MS = exports.TUI_EXIT_WAIT_MS = exports.TUI_INTERRUPT_SETTLE_MS = exports.TUI_MESSAGE_PROCESSED_WAIT_MS = exports.TUI_TEXT_INPUT_WAIT_MS = exports.TUI_SESSION_CREATE_WAIT_MS = void 0;
 /**
  * Wait (ms) after `createSession()` before sending the first keys, giving tmux
  * time to spin up the session.
@@ -156,12 +156,6 @@ exports.OPENCODE_V2_EXIT_WAIT_MS = 3000;
  * Site: opencode-v2 sendMessage().
  */
 exports.OPENCODE_V2_COMPOSER_WAIT_MS = 15000;
-/**
- * Wait (ms) for the `unset CLAUDECODE` command to reach the shell while
- * sanitizing the session environment (empirically determined).
- * Site: session-key-sender sanitizeSessionEnvironment().
- */
-exports.CLAUDE_ENV_SANITIZE_WAIT_MS = 100;
 /**
  * Wait (ms) between the two liveness readings that must agree before a reuse
  * path re-sends a launch command (Issue #2070).

package/dist/server/src/lib/auto-yes-poller.js

@@ -10,7 +10,11 @@
  * Dependencies: auto-yes-state.ts (composite keys / state), polling/* (prompt
  * detection, resolver, policy, dialog gate, session epoch, poller state,
  * decision record), cli-tools/*, session/cli-session.ts, tmux/*, detection/*,
- * db/*, tasks/*.
+ * db/*, tasks/*. Split out of this file (Issue #3893): auto-yes-poller-tick.ts
+ * (tick reading / no-prompt bookkeeping / decision recorder),
+ * auto-yes-poller-answer-target.ts (answer target), auto-yes-poller-session-presence.ts
+ * (whether a failed capture's session is gone) and auto-yes-poller-keys.ts
+ * (which composite keys have a poller entry).
  *
  * Issue #3821: this poller (with the hook / API adjudication) is what answers
  * automatically. The browser no longer answers, and the Enter sent to a choice

package/dist/server/src/lib/cli-tools/antigravity.js

@@ -267,7 +267,9 @@ class AntigravityTool extends base_1.BaseCLITool {
             // screen is this window's to confirm; the poller records nothing for it.
             (0, antigravity_startup_trust_1.beginStartupWindow)(sessionName);
             try {
-                await (0, tmux_1.sendKeys)(sessionName, (0, launch_screen_1.withLaunchScreenCleared)(launchCommand), true);
+                // Issue #3981: in one writer's turn of the input lock; the waits below
+                // stay outside it.
+                await this.typeLaunchLines(sessionName, [(0, launch_screen_1.withLaunchScreenCleared)(launchCommand)]);
                 // Wait for agy to initialize
                 await new Promise((resolve) => setTimeout(resolve, ANTIGRAVITY_INIT_WAIT_MS));
                 // Poll until the interactive prompt is ready (handles the trust dialog)
@@ -494,7 +496,8 @@ class AntigravityTool extends base_1.BaseCLITool {
         }
         catch (error) {
             const errorMessage = (0, errors_1.getErrorMessage)(error);
-            throw new Error(`Failed to send message to Antigravity: ${errorMessage}`);
+            // Issue #4031: the cause keeps a failed `load-buffer`'s code (`classifySendFailure`).
+            throw new Error(`Failed to send message to Antigravity: ${errorMessage}`, { cause: error });
         }
     }
     /**