commandmate 0.24.0 → 0.26.0

package/dist/cli/types/index.js

@@ -29,6 +29,26 @@ var ExitCode;
 exports.WaitExitCode = {
     SUCCESS: 0,
     PROMPT_DETECTED: 10,
+    /**
+     * `--fail-on-upstream-fault`: the agent came back to its composer with an
+     * upstream (model API) failure on the frame (Issue #1839).
+     *
+     * Its own code rather than SUCCESS because the two mean opposite things to a
+     * caller: SUCCESS says "the turn ran, judge the result", this says "the turn
+     * never ran, send it again". Measured on 2026-08-20 against a stub upstream
+     * answering 529, Claude 2.1.236 returns to the composer ~3 s after the send
+     * having executed nothing, and `wait --verify` reports 21 (no work evidence) —
+     * which reads as "the agent worked and produced nothing" and is why #1834 saw
+     * twelve retries burned on a session that only needed to be re-sent later.
+     *
+     * Its own code rather than riding PROMPT_DETECTED (10) because nothing is
+     * waiting to be answered: `respond` has nothing to send here.
+     *
+     * 11 is deliberately shared with {@link SkillExitCode.BLOCKED}: the two
+     * commands' codes are separate namespaces, and 11 is the first value free of
+     * PROMPT_DETECTED.
+     */
+    UPSTREAM_FAULT: 11,
     TIMEOUT: 124,
 };
 /**
@@ -56,6 +76,12 @@ exports.VerifyExitCode = {
  */
 exports.WAIT_EXIT_CODE_PRIORITY = [
     exports.WaitExitCode.PROMPT_DETECTED,
+    // Issue #1839: below PROMPT_DETECTED because a prompt is actionable right now
+    // and an upstream fault is not, and above the verify verdicts because a turn
+    // that never ran makes those verdicts meaningless — reporting VERIFY_FAILED
+    // for a worktree whose agent never executed is the misattribution #1839 exists
+    // to end.
+    exports.WaitExitCode.UPSTREAM_FAULT,
     exports.VerifyExitCode.VERIFY_FAILED,
     exports.VerifyExitCode.NOT_STARTED,
     exports.WaitExitCode.TIMEOUT,

package/dist/cli/utils/verify-runner.d.ts

@@ -10,12 +10,47 @@
  *
  * @module cli/utils/verify-runner
  */
-import type { VerificationRunStatus, VerificationRunView } from '../types/api-responses';
+import type { VerificationFlakyDetail, VerificationRunStatus, VerificationRunView } from '../types/api-responses';
 import { ApiClient } from './api-client';
 /** Matches the wait command's cadence; runs are minutes long, not seconds. */
 export declare const VERIFY_POLL_INTERVAL_MS = 5000;
 /** Built-in gate id; mirrors WORK_EVIDENCE_GATE_ID in lib/verification/gate-runner.ts. */
 export declare const WORK_EVIDENCE_GATE_ID = "work-evidence";
+/**
+ * Marker a mutexed gate writes into its log tail; mirrors MUTEX_LOG_PREFIX in
+ * lib/verification/gate-runner.ts (Issue #1771).
+ *
+ * Mirrored rather than imported because `tsconfig.cli.json` compiles
+ * `src/cli/**` alone with no path aliases, so the CLI bundle never pulls in the
+ * server's dependency graph. `tests/unit/verification/gate-mutex.test.ts` pins
+ * the two together by importing both.
+ */
+export declare const MUTEX_LOG_PREFIX = "[mutex]";
+/**
+ * Marker a retried gate writes into its log tail; mirrors FLAKY_LOG_PREFIX in
+ * lib/verification/gate-runner.ts (Issue #1772).
+ *
+ * Mirrored rather than imported for the same reason the mutex prefix is, and
+ * pinned to the runner's spelling by `tests/unit/verification/gate-flaky.test.ts`.
+ */
+export declare const FLAKY_LOG_PREFIX = "[flaky]";
+/**
+ * Label a gate whose two runs disagreed. Not a `VerificationGateStatus`: the
+ * schema has no such status and #1772 added no migration, so FLAKY is a reading
+ * of the marker laid over the stored `passed`/`failed` verdict.
+ */
+export declare const FLAKY_GATE_LABEL = "FLAKY";
+/**
+ * Read a retried gate's two runs back out of its log tail (Issue #1772).
+ *
+ * `verification_gate_results` stores one status, one exit code and one duration,
+ * so the second run's numbers only exist in the log — the same carrier
+ * work-evidence's counts and the scope gate's evidence already use.
+ *
+ * @returns null when the gate was never retried, which is every gate that did
+ *          not declare `retryOnFail: 1` and every one that passed first time.
+ */
+export declare function parseFlakyMarker(logTail: string | null | undefined): VerificationFlakyDetail | null;
 /**
  * Lines of a failing gate's log echoed to stderr before the rest becomes a
  * count (#1683).

package/dist/cli/utils/verify-runner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"verify-runner.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/verify-runner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,KAAK,EAEV,qBAAqB,EACrB,mBAAmB,EAGpB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,SAAS,EAAiC,MAAM,cAAc,CAAC;AAExE,8EAA8E;AAC9E,eAAO,MAAM,uBAAuB,OAAO,CAAC;AAE5C,0FAA0F;AAC1F,eAAO,MAAM,qBAAqB,kBAAkB,CAAC;AAErD;;;;;;;GAOG;AACH,eAAO,MAAM,0BAA0B,KAAK,CAAC;AAE7C,MAAM,WAAW,mBAAmB;IAClC,UAAU,EAAE,MAAM,CAAC;IACnB,uEAAuE;IACvE,OAAO,EAAE,QAAQ,GAAG,MAAM,CAAC;IAC3B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,2EAA2E;IAC3E,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,gEAAgE;IAChE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,2EAA2E;IAC3E,YAAY,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAC;IACnC,iFAAiF;IACjF,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB,6DAA6D;IAC7D,GAAG,CAAC,EAAE,mBAAmB,CAAC;CAC3B;AAUD;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,qBAAqB,GAAG,MAAM,CAW1E;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,EAAE,GAAG,IAAI,GAAG,SAAS,CAOnF;AAuGD;;;;GAIG;AACH,wBAAsB,eAAe,CACnC,MAAM,EAAE,SAAS,EACjB,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC,mBAAmB,CAAC,CAyD9B"}
+{"version":3,"file":"verify-runner.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/verify-runner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,KAAK,EACV,uBAAuB,EAEvB,qBAAqB,EACrB,mBAAmB,EAGpB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,SAAS,EAAiC,MAAM,cAAc,CAAC;AAExE,8EAA8E;AAC9E,eAAO,MAAM,uBAAuB,OAAO,CAAC;AAE5C,0FAA0F;AAC1F,eAAO,MAAM,qBAAqB,kBAAkB,CAAC;AAErD;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,YAAY,CAAC;AAU1C;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,YAAY,CAAC;AAE1C;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,UAAU,CAAC;AAoBxC;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GACjC,uBAAuB,GAAG,IAAI,CAehC;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,0BAA0B,KAAK,CAAC;AAE7C,MAAM,WAAW,mBAAmB;IAClC,UAAU,EAAE,MAAM,CAAC;IACnB,uEAAuE;IACvE,OAAO,EAAE,QAAQ,GAAG,MAAM,CAAC;IAC3B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,2EAA2E;IAC3E,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,gEAAgE;IAChE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,2EAA2E;IAC3E,YAAY,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAC;IACnC,iFAAiF;IACjF,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB,6DAA6D;IAC7D,GAAG,CAAC,EAAE,mBAAmB,CAAC;CAC3B;AAUD;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,qBAAqB,GAAG,MAAM,CAW1E;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,EAAE,GAAG,IAAI,GAAG,SAAS,CAOnF;AAuID;;;;GAIG;AACH,wBAAsB,eAAe,CACnC,MAAM,EAAE,SAAS,EACjB,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC,mBAAmB,CAAC,CAyD9B"}

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

@@ -12,7 +12,8 @@
  * @module cli/utils/verify-runner
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MAX_PRINTED_LOG_TAIL_LINES = exports.WORK_EVIDENCE_GATE_ID = exports.VERIFY_POLL_INTERVAL_MS = void 0;
+exports.MAX_PRINTED_LOG_TAIL_LINES = exports.FLAKY_GATE_LABEL = exports.FLAKY_LOG_PREFIX = exports.MUTEX_LOG_PREFIX = exports.WORK_EVIDENCE_GATE_ID = exports.VERIFY_POLL_INTERVAL_MS = void 0;
+exports.parseFlakyMarker = parseFlakyMarker;
 exports.exitCodeForRunStatus = exitCodeForRunStatus;
 exports.parseGateIds = parseGateIds;
 exports.runVerification = runVerification;
@@ -22,6 +23,79 @@ const api_client_1 = require("./api-client");
 exports.VERIFY_POLL_INTERVAL_MS = 5000;
 /** Built-in gate id; mirrors WORK_EVIDENCE_GATE_ID in lib/verification/gate-runner.ts. */
 exports.WORK_EVIDENCE_GATE_ID = 'work-evidence';
+/**
+ * Marker a mutexed gate writes into its log tail; mirrors MUTEX_LOG_PREFIX in
+ * lib/verification/gate-runner.ts (Issue #1771).
+ *
+ * Mirrored rather than imported because `tsconfig.cli.json` compiles
+ * `src/cli/**` alone with no path aliases, so the CLI bundle never pulls in the
+ * server's dependency graph. `tests/unit/verification/gate-mutex.test.ts` pins
+ * the two together by importing both.
+ */
+exports.MUTEX_LOG_PREFIX = '[mutex]';
+/**
+ * Time a gate spent queued for its `mutex`, as written by the runner.
+ *
+ * Anchored to the start of a line so a gate whose own output happens to contain
+ * `waited=` cannot supply the number.
+ */
+const MUTEX_WAITED_PATTERN = /^\[mutex\] [^\n]*?\bwaited=([0-9]+(?:\.[0-9]+)?s)/m;
+/**
+ * Marker a retried gate writes into its log tail; mirrors FLAKY_LOG_PREFIX in
+ * lib/verification/gate-runner.ts (Issue #1772).
+ *
+ * Mirrored rather than imported for the same reason the mutex prefix is, and
+ * pinned to the runner's spelling by `tests/unit/verification/gate-flaky.test.ts`.
+ */
+exports.FLAKY_LOG_PREFIX = '[flaky]';
+/**
+ * Label a gate whose two runs disagreed. Not a `VerificationGateStatus`: the
+ * schema has no such status and #1772 added no migration, so FLAKY is a reading
+ * of the marker laid over the stored `passed`/`failed` verdict.
+ */
+exports.FLAKY_GATE_LABEL = 'FLAKY';
+/**
+ * The runner's marker line, anchored to the start of a line so a gate whose own
+ * output happens to print `outcome=` cannot supply the numbers.
+ */
+const FLAKY_PATTERN = /^\[flaky\] runs=(\d+) outcome=(flaky|fail) exit=(\S+) duration=(\S+) verdict=(pass|fail)$/m;
+/** `n/a` is what the runner writes for a run killed by a signal. */
+function parseExitField(value) {
+    return /^-?\d+$/.test(value) ? Number(value) : null;
+}
+/** `45.0s` back into milliseconds; anything else is a value we cannot read. */
+function parseDurationField(value) {
+    const match = /^([0-9]+(?:\.[0-9]+)?)s$/.exec(value);
+    return match ? Math.round(Number(match[1]) * 1000) : null;
+}
+/**
+ * Read a retried gate's two runs back out of its log tail (Issue #1772).
+ *
+ * `verification_gate_results` stores one status, one exit code and one duration,
+ * so the second run's numbers only exist in the log — the same carrier
+ * work-evidence's counts and the scope gate's evidence already use.
+ *
+ * @returns null when the gate was never retried, which is every gate that did
+ *          not declare `retryOnFail: 1` and every one that passed first time.
+ */
+function parseFlakyMarker(logTail) {
+    if (!logTail)
+        return null;
+    const match = FLAKY_PATTERN.exec(logTail);
+    if (!match)
+        return null;
+    return {
+        runs: Number(match[1]),
+        outcome: match[2],
+        exitCodes: match[3].split(',').map(parseExitField),
+        durationsMs: match[4].split(',').map(parseDurationField),
+        verdict: match[5],
+        // Kept verbatim so the GATE line prints exactly what the runner wrote,
+        // rather than a re-rendering that could round differently.
+        exit: match[3],
+        duration: match[4],
+    };
+}
 /**
  * Lines of a failing gate's log echoed to stderr before the rest becomes a
  * count (#1683).
@@ -83,11 +157,27 @@ function formatDetail(gate) {
         return reason ? reason.slice(0, 160) : 'not run';
     }
     const parts = [];
-    if (gate.exitCode !== null && gate.exitCode !== undefined)
-        parts.push(`exit=${gate.exitCode}`);
-    if (gate.durationMs !== null && gate.durationMs !== undefined) {
-        parts.push(`${(gate.durationMs / 1000).toFixed(1)}s`);
+    // A retried gate reports both runs (#1772). The stored columns hold only the
+    // run whose verdict was recorded, so printing them would silently drop half
+    // of the evidence the retry exists to produce.
+    const flaky = parseFlakyMarker(gate.logTail);
+    if (flaky) {
+        parts.push(`exit=${flaky.exit}`, flaky.duration);
     }
+    else {
+        if (gate.exitCode !== null && gate.exitCode !== undefined)
+            parts.push(`exit=${gate.exitCode}`);
+        if (gate.durationMs !== null && gate.durationMs !== undefined) {
+            parts.push(`${(gate.durationMs / 1000).toFixed(1)}s`);
+        }
+    }
+    // After the duration and never merged into it (#1771): the duration is what
+    // the gate's command took, the wait is what the machine made it queue for.
+    // Adding them would hide contention inside a number that timeout budgets and
+    // "did this gate get slower" are read from.
+    const waited = MUTEX_WAITED_PATTERN.exec(gate.logTail ?? '');
+    if (waited)
+        parts.push(`waited=${waited[1]}`);
     return parts.join(', ');
 }
 /**
@@ -105,8 +195,26 @@ function formatDetail(gate) {
 function formatGateSource(gate) {
     return gate.source === 'contract' ? ' [contract]' : '';
 }
+/**
+ * The verdict word on a gate's line.
+ *
+ * FLAKY displaces PASS/FAIL rather than being appended to it (Issue #1772),
+ * because the whole point is that neither of those two words was true of this
+ * gate: it failed and then it passed. How the run *counted* it is not lost —
+ * `flakyIsPass` decided the stored status, which is what the RESULT line and
+ * the exit code are built from, so a FLAKY line on a `RESULT failed` run reads
+ * exactly as it should.
+ *
+ * A gate that failed twice keeps FAIL: the retry agreed, and nothing about it
+ * was flaky.
+ */
+function gateLabel(gate) {
+    if (parseFlakyMarker(gate.logTail)?.outcome === 'flaky')
+        return exports.FLAKY_GATE_LABEL;
+    return GATE_LABELS[gate.status] ?? gate.status.toUpperCase();
+}
 function formatGateLine(gate) {
-    const label = GATE_LABELS[gate.status] ?? gate.status.toUpperCase();
+    const label = gateLabel(gate);
     const detail = formatDetail(gate);
     const head = detail ? `GATE ${gate.gateId} ${label} (${detail})` : `GATE ${gate.gateId} ${label}`;
     return `${head}${formatGateSource(gate)}`;

package/dist/server/src/config/activity-bar-config.js

@@ -9,7 +9,7 @@
  *   - `src/components/worktree/ActivityPane.tsx`
  *   - `src/components/worktree/WorktreeDetailRefactored.tsx`
  *
- * The Activity Bar is a 48px-wide vertical bar that hosts 7 activities.
+ * The Activity Bar is a 48px-wide vertical bar that hosts the activities below.
  * Re-clicking the active icon toggles the ActivityPane closed (null).
  */
 Object.defineProperty(exports, "__esModule", { value: true });
@@ -33,6 +33,10 @@ exports.ACTIVITIES = [
     { id: 'todo', labelKey: 'activityBar.todo', icon: lucide_react_1.ListTodo },
     // Issue #1441: worktree-scoped Skill install/uninstall management.
     { id: 'skills', labelKey: 'activityBar.skills', icon: lucide_react_1.Sparkles },
+    // Issue #1816: the execution contract and the verification gates. Appended
+    // rather than inserted so the existing ArrowUp/ArrowDown order — which users
+    // and tests both index by position — is unchanged.
+    { id: 'verification', labelKey: 'activityBar.verification', icon: lucide_react_1.ShieldCheck },
 ];
 /**
  * Set of valid ActivityId values for runtime validation.

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

@@ -296,7 +296,43 @@ async function detectAndRespondToPrompt(worktreeId, pollerState, cliToolId, clea
         if (isDuplicatePrompt(pollerState, promptKey)) {
             return 'duplicate';
         }
-        // 3. Resolve auto answer under the execution contract's policy (Issue #1547).
+        // 3. Issue #1829: codex's own launch dialogs are CodexTool.waitForReady()'s
+        // to answer, not the poller's. Every one of them defaults to option 1, and
+        // the base rules answer the default:
+        //
+        //   "Hooks need review"  -> 1. Review hooks   (undoes Issue #1760; the pane
+        //                           then sits two screens deep in a review UI that
+        //                           only `t`/`esc` leave, reported as `running`)
+        //   "Update available"   -> 1. Update now     (undoes Issue #890; runs
+        //                           `npm install -g @openai/codex`, killing codex)
+        //   "Do you trust …"     -> 1. Yes, continue
+        //
+        // waitForReady answers the same screens deliberately and differently ('3',
+        // '2', '1' — each without a trailing Enter), but only during startSession,
+        // while this poller runs on its own 2s phase for the life of the session.
+        // Whichever sees the dialog first decides, so the fix is to leave them all
+        // to the tool. Auto-answer layer only: detectPrompt above still reports the
+        // prompt, so the human keeps seeing the screen and the response poller
+        // still notifies them about it.
+        const launchDialog = cliToolId === 'codex' ? (0, cli_patterns_1.getCodexLifecycleDialog)(cleanOutput) : null;
+        if (launchDialog) {
+            // Recorded through the #1684 channel so `capture --json` and `cmate wait`
+            // can name the reason instead of showing a worker that went quiet.
+            (0, auto_yes_suppression_state_1.recordPolicySuppression)(worktreeId, cliToolId, instanceId, {
+                reason: 'agent-launch-dialog',
+                mode: null,
+                promptType: promptDetection.promptData.type,
+            });
+            logger.warn('poller:auto-yes-skipped-launch-dialog', {
+                worktreeId,
+                cliToolId,
+                instanceId,
+                dialog: launchDialog,
+                promptType: promptDetection.promptData.type,
+            });
+            return 'no_answer';
+        }
+        // 4. Resolve auto answer under the execution contract's policy (Issue #1547).
         // Auto-Yes calls detectPrompt directly instead of going through
         // status-detector, so this is the only place the policy can gate an
         // auto-answer: a prompt the policy withholds is left for a human, and the
@@ -328,7 +364,7 @@ async function detectAndRespondToPrompt(worktreeId, pollerState, cliToolId, clea
         if (answer === null) {
             return 'no_answer';
         }
-        // 4. Send answer to tmux (Issue #896: resolve the instance-specific session)
+        // 5. Send answer to tmux (Issue #896: resolve the instance-specific session)
         const manager = manager_1.CLIToolManager.getInstance();
         const cliTool = manager.getTool(cliToolId);
         const sessionName = cliTool.getSessionName(worktreeId, instanceId);
@@ -343,10 +379,10 @@ async function detectAndRespondToPrompt(worktreeId, pollerState, cliToolId, clea
         finally {
             (0, tmux_capture_cache_1.invalidateCache)(sessionName);
         }
-        // 5. Update timestamp and reset error count
+        // 6. Update timestamp and reset error count
         updateLastServerResponseTimestamp(compositeKey, Date.now());
         resetErrorCount(compositeKey);
-        // 6. Record answered prompt key and timestamp
+        // 7. Record answered prompt key and timestamp
         pollerState.lastAnsweredPromptKey = promptKey;
         pollerState.lastAnsweredAt = Date.now();
         logger.info('poller:response-sent', { worktreeId, cliToolId, instanceId });

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

@@ -11,7 +11,7 @@
  * auto-yes-poller.ts -> auto-yes-state.ts -> path-validator.ts
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.THINKING_CHECK_LINE_COUNT = exports.MAX_CONCURRENT_POLLERS = exports.MAX_CONSECUTIVE_ERRORS = exports.MAX_BACKOFF_MS = exports.DUPLICATE_RETRY_EXPIRY_MS = exports.COOLDOWN_INTERVAL_MS = exports.POLLING_INTERVAL_MS = exports.executeRegexWithTimeout = exports.COMPOSITE_KEY_SEPARATOR = void 0;
+exports.THINKING_CHECK_LINE_COUNT = exports.MAX_CONCURRENT_POLLERS = exports.MAX_CONSECUTIVE_ERRORS = exports.MAX_BACKOFF_MS = exports.DUPLICATE_RETRY_EXPIRY_MS = exports.COOLDOWN_INTERVAL_MS = exports.POLLING_INTERVAL_MS = exports.STOP_MATCH_EXCERPT_CONTEXT_LINES = exports.STOP_MATCH_EXCERPT_TRUNCATION_MARKER = exports.STOP_MATCH_EXCERPT_MAX_BYTES = exports.executeRegexWithTimeout = exports.COMPOSITE_KEY_SEPARATOR = void 0;
 exports.buildCompositeKey = buildCompositeKey;
 exports.extractWorktreeId = extractWorktreeId;
 exports.extractCliToolId = extractCliToolId;
@@ -21,6 +21,7 @@ exports.getAutoYesState = getAutoYesState;
 exports.setAutoYesEnabled = setAutoYesEnabled;
 exports.disableAutoYes = disableAutoYes;
 exports.clearAllAutoYesStates = clearAllAutoYesStates;
+exports.truncateToUtf8Bytes = truncateToUtf8Bytes;
 exports.checkStopCondition = checkStopCondition;
 exports.deleteAutoYesState = deleteAutoYesState;
 exports.getAutoYesStateCompositeKeys = getAutoYesStateCompositeKeys;
@@ -204,9 +205,12 @@ function setAutoYesEnabled(worktreeId, cliToolId, enabled, duration, stopPattern
  * @param cliToolId - CLI tool type (default: 'claude')
  * @param reason - Optional reason for disabling ('expired' | 'stop_pattern_matched')
  * @param instanceId - Optional instance identifier (Issue #896; defaults to primary)
+ * @param stopMatchedText - Optional excerpt of what the stop pattern matched
+ *   (Issue #1694). Deliberately *not* carried over from the existing state: it
+ *   belongs to `reason`, so a disable for any other reason stores none.
  * @returns Updated auto-yes state
  */
-function disableAutoYes(worktreeId, cliToolId = 'claude', reason, instanceId) {
+function disableAutoYes(worktreeId, cliToolId = 'claude', reason, instanceId, stopMatchedText) {
     const key = buildCompositeKey(worktreeId, cliToolId, instanceId);
     const existing = autoYesStates.get(key);
     const state = {
@@ -215,6 +219,7 @@ function disableAutoYes(worktreeId, cliToolId = 'claude', reason, instanceId) {
         expiresAt: existing?.expiresAt ?? 0,
         stopPattern: existing?.stopPattern,
         stopReason: reason,
+        stopMatchedText,
     };
     autoYesStates.set(key, state);
     return state;
@@ -235,6 +240,103 @@ function clearAllAutoYesStates() {
  */
 var auto_yes_config_2 = require("../config/auto-yes-config");
 Object.defineProperty(exports, "executeRegexWithTimeout", { enumerable: true, get: function () { return auto_yes_config_2.executeRegexWithTimeout; } });
+/**
+ * Maximum size of the stop-pattern excerpt, in UTF-8 bytes, marker included
+ * (Issue #1694).
+ *
+ * The excerpt answers one question — "is this a real stop or did a build log
+ * happen to contain the pattern?" (#1678 A-5) — and a couple of lines answer
+ * it. The cap is a hard bound rather than a hint because `cleanOutput` is a
+ * whole terminal frame and a greedy pattern can match all of it, and because
+ * the value rides in every `capture --json` poll for the rest of the session.
+ */
+exports.STOP_MATCH_EXCERPT_MAX_BYTES = 400;
+/**
+ * Appended when the excerpt was cut to fit {@link STOP_MATCH_EXCERPT_MAX_BYTES}.
+ *
+ * Cutting silently would make a fragment read as the whole match, which is the
+ * wrong conclusion in exactly the triage this field exists for.
+ */
+exports.STOP_MATCH_EXCERPT_TRUNCATION_MARKER = '…[truncated]';
+/** Lines of context kept on either side of the match (Issue #1694). */
+exports.STOP_MATCH_EXCERPT_CONTEXT_LINES = 1;
+/** Shared encoder for byte-length math (UTF-8 by spec). */
+const utf8Encoder = new TextEncoder();
+/** UTF-8 byte length of a string. */
+function utf8ByteLength(text) {
+    return utf8Encoder.encode(text).length;
+}
+/**
+ * Cut `text` down to `maxBytes` UTF-8 bytes, marker included, never splitting a
+ * character (Issue #1694).
+ *
+ * The budget is measured in bytes rather than characters because the excerpt is
+ * copied verbatim into a JSON payload, and a Japanese terminal frame costs 3
+ * bytes per character — a character cap would let one frame publish three times
+ * the intended payload.
+ *
+ * @internal Exported for testing purposes only.
+ * @param text - Text to bound
+ * @param maxBytes - Byte ceiling for the returned string (marker included)
+ * @returns `text` unchanged when it already fits, otherwise a prefix of it with
+ *   {@link STOP_MATCH_EXCERPT_TRUNCATION_MARKER} appended
+ */
+function truncateToUtf8Bytes(text, maxBytes = exports.STOP_MATCH_EXCERPT_MAX_BYTES) {
+    if (utf8ByteLength(text) <= maxBytes)
+        return text;
+    const budget = maxBytes - utf8ByteLength(exports.STOP_MATCH_EXCERPT_TRUNCATION_MARKER);
+    if (budget <= 0)
+        return exports.STOP_MATCH_EXCERPT_TRUNCATION_MARKER;
+    let used = 0;
+    let kept = '';
+    // for..of iterates code points, so a surrogate pair is never halved.
+    for (const char of text) {
+        const size = utf8ByteLength(char);
+        if (used + size > budget)
+            break;
+        kept += char;
+        used += size;
+    }
+    return kept + exports.STOP_MATCH_EXCERPT_TRUNCATION_MARKER;
+}
+/**
+ * Build the excerpt shown for a stop-pattern hit (Issue #1694).
+ *
+ * Whole lines, not the raw match: a pattern like `error` matched against a
+ * terminal frame yields the six characters `error`, which tells the operator
+ * nothing about whether it came from the agent asking a question or from a
+ * dependency's build log scrolling past. The surrounding line is the smallest
+ * unit that carries that.
+ *
+ * @param regex - The already-constructed stop pattern (no `g` flag, so `exec`
+ *   is position-independent and does not disturb the caller's `test`)
+ * @param output - ANSI-stripped terminal output the pattern matched
+ * @returns Bounded excerpt, or null when the match cannot be located
+ */
+function buildStopMatchExcerpt(regex, output) {
+    let match;
+    try {
+        match = regex.exec(output);
+    }
+    catch {
+        return null;
+    }
+    if (!match)
+        return null;
+    const matchStart = match.index;
+    const matchEnd = matchStart + match[0].length;
+    const lines = output.split('\n');
+    const firstLine = output.slice(0, matchStart).split('\n').length - 1;
+    const lastLine = output.slice(0, matchEnd).split('\n').length - 1;
+    const from = Math.max(0, firstLine - exports.STOP_MATCH_EXCERPT_CONTEXT_LINES);
+    const to = Math.min(lines.length - 1, lastLine + exports.STOP_MATCH_EXCERPT_CONTEXT_LINES);
+    const raw = lines.slice(from, to + 1).join('\n');
+    // Terminal frames are padded with blank lines and trailing spaces; those are
+    // pure noise here and eat the byte budget. A whitespace-only match keeps its
+    // raw form rather than becoming an empty, unexplained field.
+    const trimmed = raw.trim();
+    return truncateToUtf8Bytes(trimmed.length > 0 ? trimmed : raw);
+}
 /**
  * Check if the terminal output matches the stop condition pattern.
  * If matched, disables auto-yes for the worktree/agent.
@@ -275,7 +377,10 @@ function checkStopCondition(compositeKey, cleanOutput, onStopMatched) {
             return false;
         }
         if (matched) {
-            disableAutoYes(worktreeId, cliToolId, 'stop_pattern_matched', instanceId);
+            // Issue #1694: what matched, not just that something did. Built here
+            // because this is the only frame that still holds the output.
+            const stopMatchedText = buildStopMatchExcerpt(regex, cleanOutput) ?? undefined;
+            disableAutoYes(worktreeId, cliToolId, 'stop_pattern_matched', instanceId, stopMatchedText);
             if (onStopMatched) {
                 onStopMatched(compositeKey);
             }

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

@@ -136,15 +136,19 @@ class AntigravityTool extends base_1.BaseCLITool {
             await new Promise((resolve) => setTimeout(resolve, cli_tool_timing_config_1.TUI_SESSION_CREATE_WAIT_MS));
             // Start agy in interactive mode, optionally pinned to a model.
             //
-            // Issue #1762: `prepareAgentLaunch` merges CommandMate's named hook into
+            // Issue #1762: the launch merges CommandMate's named hook into
             // `~/.gemini/config/hooks.json` — agy's single global config, shared with
             // gemini's tree and with whatever the user has in it — and prefixes
             // `CM_HOOK_URL`. That variable is the *only* correlation channel agy has:
             // its payloads carry no `cwd`, its hooks run in `~/.gemini/config`, and
             // one file serves every worktree on the machine. `--model` is appended
-            // after, so the env prefix stays in front of the command.
-            // `CM_AGENT_HOOKS_INJECT=0` returns bare `agy`, unchanged from before.
-            const base = (0, agent_session_lifecycle_1.prepareAgentLaunch)({ worktreeId, cliToolId: sources_1.ANTIGRAVITY_CLI_TOOL_ID, instanceId }, this.command).command;
+            // after the rendered line, so the env assignments stay in front of the
+            // command. `CM_AGENT_HOOKS_INJECT=0` returns bare `agy`, unchanged.
+            const base = (0, agent_session_lifecycle_1.buildAgentLaunchCommandLine)({
+                target: { worktreeId, cliToolId: sources_1.ANTIGRAVITY_CLI_TOOL_ID, instanceId },
+                executablePath: this.command,
+                worktreePath,
+            });
             const launchCommand = model ? `${base} --model ${shellSingleQuote(model)}` : base;
             await (0, tmux_1.sendKeys)(sessionName, launchCommand, true);
             // Wait for agy to initialize

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

@@ -31,33 +31,6 @@ const CODEX_POLL_INTERVAL_MS = 1000;
 const CODEX_INIT_MAX_ATTEMPTS = 30;
 /** Timeout for waiting for prompt before sending a message */
 const CODEX_PROMPT_WAIT_TIMEOUT_MS = 15000;
-/**
- * Anchors of codex's "Hooks need review" dialog (Issue #1760, measured on
- * codex-cli 0.147.0):
- *
- * ```
- *  Hooks need review
- *  5 hooks are new or changed.
- *  Hooks can run outside the sandbox after you trust them.
- *
- * > 1. Review hooks
- *   2. Trust all and continue
- *   3. Continue without trusting (hooks won't run)
- * ```
- *
- * It has to be handled here rather than in `getCodexActiveDialog`, which
- * classifies it as `null`: its wording matches none of that function's three
- * anchors (`Skip until next version` / `Do you trust` / `Press enter to
- * continue`). Measured consequence of leaving it alone, on a pane with the
- * generated `hooks.json` present: `isCodexPromptReady` stays false for the full
- * 30-attempt window and the session is then handed to `sendMessage` still
- * sitting on the dialog. Every launch, because "continue without trusting" is
- * not remembered — verified by relaunching and getting the same screen.
- *
- * Both strings are required so a "hooks" mention elsewhere cannot select an
- * option on a live prompt.
- */
-const CODEX_HOOKS_REVIEW_ANCHORS = ['Hooks need review', 'Continue without trusting'];
 /**
  * Option 3, "Continue without trusting (hooks won't run)".
  *
@@ -72,21 +45,57 @@ const CODEX_HOOKS_REVIEW_ANCHORS = ['Hooks need review', 'Continue without trust
  * Sent alone, like the other numbered dialogs (Issue #890): codex confirms a
  * numbered selection instantly, and a trailing Enter would land on the next
  * screen. Verified live — the prompt was ready on the following poll.
+ *
+ * Re-verified on codex-cli 0.148.0 for Issue #1829, against the objection that
+ * the dialog's own footer says `Press enter to confirm`. With the trust hashes
+ * invalidated and Auto-Yes off, a session launched onto this dialog reached
+ * `› Ask Codex to do anything` and then ran the message it was sent — on the
+ * `'3'` alone. The footer and the number key are not exclusive: the number
+ * selects AND confirms, Enter confirms the highlighted option. That is also why
+ * a trailing Enter is so costly here — the number having already advanced the
+ * screen, the Enter lands on the NEXT one, which is precisely how a pane ends up
+ * two screens deep in the hooks review UI.
  */
 const CODEX_HOOKS_REVIEW_DECLINE_KEY = '3';
+/**
+ * How many times `waitForReady` may press `esc` to climb out of codex's hooks
+ * review screens (Issue #1829).
+ *
+ * Two is the depth of the UI — detail -> list -> closed — and the cap exists
+ * because the alternative is one press per poll: 30 keystrokes into whatever is
+ * really on screen if the classifier is ever wrong about a frame. Two spare
+ * presses cover a redraw landing between capture and send.
+ */
+const CODEX_HOOKS_SCREEN_MAX_ESCAPES = 4;
 /**
  * Whether the pane is sitting on the hooks review dialog.
  *
  * Position-independent on purpose, unlike `getCodexActiveDialog`: the only
  * caller checks `isCodexPromptReady` first and returns when a genuine prompt
  * exists, so residual dialog text above a live prompt is never reached, and a
- * one-shot guard stops the key being sent twice.
+ * one-shot guard stops the key being sent twice. Callers OUTSIDE this launch
+ * sequence must use `getCodexLifecycleDialog` instead, which is position-based.
+ *
+ * The dialog has to be handled here rather than in `getCodexActiveDialog`, which
+ * classifies it as `null`: its wording matches none of that function's three
+ * anchors (`Skip until next version` / `Do you trust` / `Press enter to
+ * continue`). Measured consequence of leaving it alone, on a pane with the
+ * generated `hooks.json` present: `isCodexPromptReady` stays false for the full
+ * 30-attempt window and the session is then handed to `sendMessage` still
+ * sitting on the dialog. Every launch, because "continue without trusting" is
+ * not remembered — verified by relaunching and getting the same screen.
+ *
+ * The anchors themselves live in `detection/cli-patterns` (Issue #1829): the
+ * Auto-Yes poller has to recognise the same screen in order to keep its hands
+ * off it, and two copies of the anchors would be two chances to disagree about
+ * what this dialog is.
  *
  * @param output - ANSI-stripped pane capture
  * @returns True when both anchors of the dialog are present
+ * @see CODEX_HOOKS_REVIEW_ANCHORS
  */
 function isCodexHooksReviewDialog(output) {
-    return CODEX_HOOKS_REVIEW_ANCHORS.every((anchor) => output.includes(anchor));
+    return cli_patterns_1.CODEX_HOOKS_REVIEW_ANCHORS.every((anchor) => output.includes(anchor));
 }
 /**
  * Codex CLI tool implementation
@@ -157,7 +166,11 @@ class CodexTool extends base_1.BaseCLITool {
             // Falls back to the bare command on any failure and when
             // `CM_AGENT_HOOKS_INJECT=0`; a session that starts without hooks is the
             // pre-#1760 status quo, and a session that fails to start is not.
-            const launchCommand = (0, agent_session_lifecycle_1.prepareAgentLaunch)({ worktreeId, cliToolId: sources_1.CODEX_CLI_TOOL_ID, instanceId }, this.command).command;
+            const launchCommand = (0, agent_session_lifecycle_1.buildAgentLaunchCommandLine)({
+                target: { worktreeId, cliToolId: sources_1.CODEX_CLI_TOOL_ID, instanceId },
+                executablePath: this.command,
+                worktreePath,
+            });
             // Start Codex CLI in interactive mode
             await (0, tmux_1.sendKeys)(sessionName, launchCommand, true);
             // Wait for Codex to initialize
@@ -185,6 +198,7 @@ class CodexTool extends base_1.BaseCLITool {
         let updateDialogHandled = false;
         let trustDialogHandled = false;
         let hooksReviewHandled = false;
+        let hooksScreenEscapes = 0;
         for (let i = 0; i < CODEX_INIT_MAX_ATTEMPTS; i++) {
             try {
                 const rawOutput = await (0, tmux_1.capturePane)(sessionName, 50);
@@ -208,6 +222,25 @@ class CodexTool extends base_1.BaseCLITool {
                     await new Promise((resolve) => setTimeout(resolve, cli_tool_timing_config_1.CODEX_DIALOG_SETTLE_MS));
                     continue;
                 }
+                // Issue #1829: back out of the two screens the hooks dialog leads to.
+                // Confirming its option 1 -- which the Auto-Yes poller did on two live
+                // sessions, and which a human can do too -- opens a review UI whose only
+                // exits are `t` and `esc`. `t` is out: it writes `[hooks.state…]` into
+                // the operator's own ~/.codex/config.toml, the grant Issue #1760
+                // declined on their behalf. So `esc`, once per poll until the screens
+                // are gone. Before this, nothing sent either key: the whole 30-attempt
+                // window elapsed, waitForReady returned as if ready, and the session was
+                // left parked there -- reported as `running`, because neither screen
+                // carries an option, a confirm footer or a thinking indicator.
+                const hooksScreen = (0, cli_patterns_1.getCodexLifecycleDialog)(output);
+                if ((hooksScreen === 'hooks-list' || hooksScreen === 'hooks-detail') &&
+                    hooksScreenEscapes < CODEX_HOOKS_SCREEN_MAX_ESCAPES) {
+                    await (0, tmux_1.sendSpecialKey)(sessionName, 'Escape');
+                    hooksScreenEscapes++;
+                    logger.info('codex-hooks-screen-escaped');
+                    await new Promise((resolve) => setTimeout(resolve, cli_tool_timing_config_1.CODEX_DIALOG_SETTLE_MS));
+                    continue;
+                }
                 // Issue #892: classify the bottom-most ACTIVE dialog by position. A dialog
                 // whose text is only residual scrollback above a genuine prompt returns
                 // null here, so no stray key is sent after it has been dismissed.