commandmate 0.47.2 → 0.49.0

package/dist/server/src/lib/tmux/tmux.js

@@ -4,7 +4,7 @@
  * Provides functions to manage tmux sessions for Claude CLI integration
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DIRECT_INPUT_TEXT_CHUNK_BYTES = exports.REPAINT_INVALIDATE_DELAY_MS = exports.NAVIGATION_KEY_VALUES = exports.SPECIAL_KEY_VALUES = exports.SpecialKeysAbortedError = void 0;
+exports.DIRECT_INPUT_TEXT_CHUNK_BYTES = exports.REPAINT_INVALIDATE_DELAY_MS = exports.NAVIGATION_KEY_VALUES = exports.SPECIAL_KEY_VALUES = exports.SpecialKeysAbortedError = exports.TmuxSendError = void 0;
 exports.exactTarget = exactTarget;
 exports.reconcileSessionGeometry = reconcileSessionGeometry;
 exports.hasSession = hasSession;
@@ -14,6 +14,7 @@ exports.getPaneCurrentCommand = getPaneCurrentCommand;
 exports.listSessions = listSessions;
 exports.createSession = createSession;
 exports.sendKeys = sendKeys;
+exports.deliveryOfExecFailure = deliveryOfExecFailure;
 exports.isSendableSpecialKey = isSendableSpecialKey;
 exports.sendSpecialKeys = sendSpecialKeys;
 exports.capturePane = capturePane;
@@ -23,6 +24,7 @@ exports.ensureSession = ensureSession;
 exports.sendSpecialKey = sendSpecialKey;
 exports.clearInputLine = clearInputLine;
 exports.clearComposerLine = clearComposerLine;
+exports.clearComposerPasteToken = clearComposerPasteToken;
 exports.isAllowedSpecialKey = isAllowedSpecialKey;
 exports.sendSpecialKeysAndInvalidate = sendSpecialKeysAndInvalidate;
 exports.sendDirectInputAndInvalidate = sendDirectInputAndInvalidate;
@@ -462,8 +464,9 @@ async function createSession(sessionNameOrOptions, cwd) {
  * @param sendEnter - Whether to send Enter key after the command (default: true)
  * @param options - {@link SendKeysOptions}; pass `{ literal: true }` for text
  *
- * @throws {Error} If session doesn't exist, command fails, or `literal` is
- *   combined with `sendEnter`
+ * @throws {TmuxSendError} If session doesn't exist, command fails, or `literal` is
+ *   combined with `sendEnter`; its `delivery` says whether the keys may be on
+ *   the pane (Issue #3880). A normal return is `delivered`: tmux exited 0.
  *
  * @example
  * ```typescript
@@ -476,7 +479,7 @@ async function createSession(sessionNameOrOptions, cwd) {
  */
 async function sendKeys(sessionName, keys, sendEnter = true, options) {
     if (options?.literal && sendEnter) {
-        throw new Error('sendKeys: { literal: true } cannot be combined with sendEnter — a trailing C-m would be typed as text. Send Enter as a separate key.');
+        throw new TmuxSendError('sendKeys: { literal: true } cannot be combined with sendEnter — a trailing C-m would be typed as text. Send Enter as a separate key.', 'not-started', 0);
     }
     // execFile() passes arguments directly without shell interpretation,
     // so no shell-level escaping is needed
@@ -496,9 +499,45 @@ async function sendKeys(sessionName, keys, sendEnter = true, options) {
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
-        throw new Error(`Failed to send keys to tmux session: ${errorMessage}`);
+        throw new TmuxSendError(`Failed to send keys to tmux session: ${errorMessage}`, deliveryOfExecFailure(error), 0);
     }
 }
+/**
+ * A `sendKeys` / `sendSpecialKeys` that failed, with how far it got
+ * (Issue #3880). The message is the one these functions always threw.
+ */
+class TmuxSendError extends Error {
+    delivery;
+    keysDelivered;
+    constructor(message, 
+    /** What the call that failed did; a failed call is never `delivered`. */
+    delivery, 
+    /** How many keys before it tmux was seen to take (`sendSpecialKeys`; 0 for `sendKeys`). */
+    keysDelivered) {
+        super(message);
+        this.delivery = delivery;
+        this.keysDelivered = keysDelivered;
+        this.name = 'TmuxSendError';
+    }
+}
+exports.TmuxSendError = TmuxSendError;
+/**
+ * Which {@link KeyDeliveryState} a rejected `execFile` of `tmux send-keys` is
+ * (Issue #3880). Read off the error's shape, never its wording: an exit status
+ * (`code` a number) is tmux refusing the command, an errno string (`ENOENT`)
+ * is a process that never ran, and anything else — `killed` by the timeout, a
+ * `signal`, an error of no known shape — may have left the key on the pane.
+ */
+function deliveryOfExecFailure(error) {
+    if (typeof error !== 'object' || error === null)
+        return 'indeterminate';
+    const { code, killed, signal } = error;
+    if (killed === true || (typeof signal === 'string' && signal !== ''))
+        return 'indeterminate';
+    if (typeof code === 'number' || typeof code === 'string')
+        return 'not-started';
+    return 'indeterminate';
+}
 /**
  * Allowed tmux special key names for sendSpecialKeys() (multi-key TUI navigation).
  * Used for cursor-based navigation sequences (e.g., ['Down', 'Down', 'Enter']).
@@ -607,7 +646,9 @@ exports.SpecialKeysAbortedError = SpecialKeysAbortedError;
  * @param sessionName - Target session name
  * @param keys - Array of tmux special key names (e.g., ['Down', 'Down', 'Space', 'Enter'])
  * @param options - Optional `shouldContinue`, asked after each delay (Issue #3706)
- * @throws {Error} If any key name is not in the allowed set, or if tmux command fails
+ * @throws {TmuxSendError} If any key name is not in the allowed set (`not-started`,
+ *   nothing sent), or if a tmux command fails — with the keys before it that
+ *   tmux took and what the failing call did (Issue #3880)
  * @throws {SpecialKeysAbortedError} If `shouldContinue` returned false between two keys
  */
 async function sendSpecialKeys(sessionName, keys, options) {
@@ -616,12 +657,15 @@ async function sendSpecialKeys(sessionName, keys, options) {
     // Validate all keys are in the allowed set (command injection prevention)
     for (const key of keys) {
         if (!ALLOWED_SPECIAL_KEYS.has(key)) {
-            throw new Error(`Invalid special key: ${key}`);
+            throw new TmuxSendError(`Invalid special key: ${key}`, 'not-started', 0);
         }
     }
+    // Issue #3880: the keys tmux was seen to take, for the error of a later one.
+    let delivered = 0;
     try {
         for (let i = 0; i < keys.length; i++) {
             await execFileAsync('tmux', ['send-keys', '-t', exactTarget(sessionName), keys[i]], { timeout: DEFAULT_TIMEOUT });
+            delivered = i + 1;
             // Delay between key presses (skip after the last key)
             if (i < keys.length - 1) {
                 await new Promise(resolve => setTimeout(resolve, SPECIAL_KEY_DELAY_MS));
@@ -635,7 +679,7 @@ async function sendSpecialKeys(sessionName, keys, options) {
         if (error instanceof SpecialKeysAbortedError)
             throw error;
         const errorMessage = error instanceof Error ? error.message : String(error);
-        throw new Error(`Failed to send special keys to tmux session: ${errorMessage}`);
+        throw new TmuxSendError(`Failed to send special keys to tmux session: ${errorMessage}`, deliveryOfExecFailure(error), delivered);
     }
 }
 /**
@@ -903,6 +947,30 @@ async function clearComposerLine(sessionName) {
         throw new Error(`Failed to clear tmux composer line: ${errorMessage}`);
     }
 }
+/**
+ * Send one `C-e` + `BSpace` pass: take a collapsed paste placeholder out of the
+ * composer (Issue #3937).
+ *
+ * codex folds a pasted body into one `[Pasted Content N chars]` placeholder.
+ * `C-e`+`C-u` left one in place for all 12 passes (`composer-clear:not-cleared`,
+ * 2026-10-25), and one `BSpace` sent by hand removed it whole. The caller
+ * ({@link module:lib/session/composer-clear}) sends this only when the composer
+ * shows that placeholder and nothing else — after `C-e` the cursor sits right
+ * behind it — and reads the frame back afterwards like any other pass. Same
+ * literal-keys / one-invocation rules as {@link clearComposerLine}.
+ *
+ * @param sessionName - Target session name
+ * @throws {Error} If the tmux command fails
+ */
+async function clearComposerPasteToken(sessionName) {
+    try {
+        await execFileAsync('tmux', ['send-keys', '-t', exactTarget(sessionName), 'C-e', 'BSpace'], { timeout: DEFAULT_TIMEOUT });
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to clear tmux composer paste placeholder: ${errorMessage}`);
+    }
+}
 /**
  * Type guard for navigation key validation (special-keys API).
  * Returns true if the key is in the NAVIGATION_KEY_VALUES set AND sendSpecialKeys()
@@ -965,7 +1033,9 @@ exports.REPAINT_INVALIDATE_DELAY_MS = 250;
  * Drop the cached frame again once the TUI has had time to repaint.
  *
  * Fire-and-forget on purpose: the route must not wait 250 ms to answer, and the
- * work is one `Map.delete`. The timer is `unref()`ed where the runtime supports
+ * work is synchronous and small — `invalidateCache` drops the cached frame and
+ * the inflight capture and advances the session's generation (Issue #3734), so
+ * a capture started before the repaint is not written back either. The timer is `unref()`ed where the runtime supports
  * it so a pending invalidation can never hold a process (or a test runner) open.
  */
 function scheduleRepaintInvalidation(sessionName) {

package/dist/server/src/lib/verification/gate-runner.js

@@ -21,7 +21,7 @@
  * @module lib/verification/gate-runner
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VerificationConflictError = exports.FLAKY_LOG_PREFIX = exports.MUTEX_WAIT_SKIP_REASON = exports.MUTEX_LOG_PREFIX = exports.WORKTREE_INDEX_ENV = exports.WORKTREE_ID_ENV = exports.MAX_CONCURRENT_VERIFICATIONS = exports.CONFIG_GATE_ID = exports.ENV_CLEAN_GATE_ID = exports.SCOPE_GATE_ID = exports.WORK_EVIDENCE_GATE_ID = void 0;
+exports.VerificationConflictError = exports.TIMING_LOG_PREFIX = exports.FLAKY_LOG_PREFIX = exports.MUTEX_WAIT_SKIP_REASON = exports.MUTEX_LOG_PREFIX = exports.WORKTREE_INDEX_ENV = exports.WORKTREE_ID_ENV = exports.MAX_CONCURRENT_VERIFICATIONS = exports.CONFIG_GATE_ID = exports.ENV_CLEAN_GATE_ID = exports.SCOPE_GATE_ID = exports.WORK_EVIDENCE_GATE_ID = void 0;
 exports.waitForVerification = waitForVerification;
 exports.cancelVerification = cancelVerification;
 exports.startVerification = startVerification;
@@ -87,6 +87,9 @@ const ENV_CLEAN_GATE_COMMAND = 'lsof -iTCP -sTCP:LISTEN / tmux list-sessions / $
  * once turns a verification request into a fork bomb on a developer laptop.
  * Excess runs queue rather than fail: the run row already exists and its
  * caller has the id, so a queued run is honest about what will happen.
+ *
+ * A bound on gates *executing*, not on runs open: a run waiting for a gate's
+ * `mutex` gives its slot back for the wait (Issue #3884, see RunSlot).
  */
 exports.MAX_CONCURRENT_VERIFICATIONS = 2;
 /** Grace period between SIGTERM and SIGKILL for a gate that overran. */
@@ -144,6 +147,33 @@ exports.MUTEX_WAIT_SKIP_REASON = 'reason=mutex-wait';
  * cannot import this module — `tsconfig.cli.json` compiles `src/cli/**` alone.
  */
 exports.FLAKY_LOG_PREFIX = '[flaky]';
+/**
+ * Marker line carrying a command gate's waits and its execution, apart, into
+ * `log_tail` (Issue #3884).
+ *
+ * `[timing] queue=<s> mutex=<s> run=<s>`: `queue` is the time the run waited
+ * for a {@link MAX_CONCURRENT_VERIFICATIONS} slot before and during this gate
+ * (the first command gate also carries the run's initial queue), `mutex` the
+ * time it waited for the gate's machine-wide lock, and `run` the gate's own
+ * command — `duration_ms`, which still never includes either wait (#1771).
+ * Three numbers because "this run took 40 minutes" has three different fixes:
+ * fewer runs at once, fewer heavy gates, or a faster suite.
+ *
+ * The last line, so the first line keeps meaning what it meant (the skip
+ * reason a reader of a `skipped` gate takes, the `[mutex]` / `[flaky]` marker
+ * the CLI reads). Written only for a gate that has a `mutex` or that waited for
+ * a slot: a gate that did neither has no wait to report, and its log stays
+ * byte-identical to before the marker existed. Travels on `log_tail` like
+ * `waited=` does, so it reaches `verify --json` and `verify show` without a
+ * migration; the history listing, which carries no log, reads this one line
+ * into numbers (verification-db.ts parseGateTiming, the `timing` of a gate
+ * summary — keep the two formats in step).
+ */
+exports.TIMING_LOG_PREFIX = '[timing]';
+function timingMarker(waits, runMs) {
+    return (`${exports.TIMING_LOG_PREFIX} queue=${formatSeconds(waits.queueMs)} ` +
+        `mutex=${formatSeconds(waits.mutexMs)} run=${formatSeconds(runMs)}`);
+}
 /**
  * Runs a gate is allowed. Not derived from `retryOnFail` at the call site: the
  * marker states the number so a reader of stored history never has to look up
@@ -204,13 +234,43 @@ function notRun(logTail) {
 // =============================================================================
 let activeVerifications = 0;
 const slotWaiters = [];
-function acquireSlot() {
+/**
+ * @param priority queue ahead of every run still waiting to start (Issue #3884).
+ *        Used by a run that gave its slot back while it waited for a gate's
+ *        `mutex` and now holds that machine-wide lock: every second it spends
+ *        here is a second the lock is held with nothing running under it.
+ */
+function acquireSlot(priority = false, cancellation) {
     if (activeVerifications < exports.MAX_CONCURRENT_VERIFICATIONS) {
         activeVerifications += 1;
-        return Promise.resolve();
+        return Promise.resolve(true);
     }
     return new Promise((resolve) => {
-        slotWaiters.push(resolve);
+        let settled = false;
+        let unregister = () => { };
+        const grant = () => {
+            settled = true;
+            unregister();
+            resolve(true);
+        };
+        if (priority)
+            slotWaiters.unshift(grant);
+        else
+            slotWaiters.push(grant);
+        // Issue #3884 N3: a cancelled wait leaves the queue instead of waiting for
+        // whatever the other slots are executing. Leaving takes nothing, so there
+        // is nothing to hand back.
+        if (cancellation) {
+            unregister = cancellation.register(() => {
+                if (settled)
+                    return;
+                settled = true;
+                const at = slotWaiters.indexOf(grant);
+                if (at >= 0)
+                    slotWaiters.splice(at, 1);
+                resolve(false);
+            });
+        }
     });
 }
 function releaseSlot() {
@@ -223,6 +283,63 @@ function releaseSlot() {
     }
     activeVerifications -= 1;
 }
+/**
+ * One run's hold on a {@link MAX_CONCURRENT_VERIFICATIONS} slot (Issue #3884 H-11).
+ *
+ * The slot bounds what *executes*, not what waits. A run used to take its slot
+ * up front and keep it while a gate queued for its `mutex` (`cpu.heavy`, up to
+ * the gate's whole `timeoutSec`), so one run holding the lock and one waiting
+ * for it filled both slots, and a third run could not start even its 5-second
+ * `lint`. {@link runGateAttempt} now hands the slot back while it waits for the
+ * lock and takes it again — ahead of the runs still waiting to start — once the
+ * lock is held. At most {@link MAX_CONCURRENT_VERIFICATIONS} gates still
+ * execute at once, and the heavy gates stay one per machine under their mutex,
+ * so the load a gate is judged under does not grow.
+ *
+ * No deadlock: a run waiting for a lock holds no slot, so every slot holder is
+ * executing a gate, and each gate ends within its own `timeoutSec`.
+ *
+ * Also the clock for the `queue=` of {@link TIMING_LOG_PREFIX}: the time spent
+ * waiting for a slot since the last {@link RunSlot.takeQueuedMs}.
+ */
+class RunSlot {
+    held = false;
+    queuedMs = 0;
+    get isHeld() {
+        return this.held;
+    }
+    /**
+     * @param cancellation when given, a cancel abandons the wait (Issue #3884 N3)
+     * @returns false when the wait was abandoned: no slot is held
+     */
+    async acquire(priority = false, cancellation) {
+        if (this.held)
+            return true;
+        // Only a real queue counts: a free slot is taken without a wait, and a
+        // gate that never waited must not grow a `queue=0.0s` line (its log stays
+        // byte-identical to before #3884).
+        const queued = activeVerifications >= exports.MAX_CONCURRENT_VERIFICATIONS;
+        const startedAt = Date.now();
+        const taken = await acquireSlot(priority, cancellation);
+        this.held = taken;
+        if (queued)
+            this.queuedMs += Math.max(1, Date.now() - startedAt);
+        return taken;
+    }
+    /** Idempotent: a slot already handed back is not released twice. */
+    release() {
+        if (!this.held)
+            return;
+        this.held = false;
+        releaseSlot();
+    }
+    /** The slot wait accumulated since the previous call, and reset it. */
+    takeQueuedMs() {
+        const queued = this.queuedMs;
+        this.queuedMs = 0;
+        return queued;
+    }
+}
 /**
  * In-flight runs, so callers (tests, and the CLI in Phase 1-4) can await a run
  * that {@link startVerification} deliberately did not wait for.
@@ -310,9 +427,10 @@ const cancellations = new Map();
  * stopped something.
  *
  * A run cancelled while it is still queued behind
- * {@link MAX_CONCURRENT_VERIFICATIONS} answers `requested`: the latch is set,
- * so it will start nothing, but it closes its own row only once a slot reaches
- * it. The caller polls, which it is doing anyway.
+ * {@link MAX_CONCURRENT_VERIFICATIONS} leaves the queue at once and closes
+ * `cancelled` (Issue #3909); it used to answer `requested` and close only once
+ * a slot reached it. `requested` is now only a run whose gate is still winding
+ * down when the budget runs out.
  */
 async function cancelVerification(runId) {
     const cancellation = cancellations.get(runId);
@@ -578,7 +696,7 @@ function machineLockPathFor(name) {
  * across both, so a retry never keeps a machine-wide resource out of another
  * worktree's hands for a run that has already failed once.
  */
-async function runGateAttempt(gate, worktreePath, maxLogTailBytes, gateEnv, cancellation) {
+async function runGateAttempt(gate, worktreePath, maxLogTailBytes, gateEnv, cancellation, slot, waits) {
     const mutex = gate.mutex;
     if (!mutex) {
         return runCommand(gate.command, worktreePath, gate.timeoutSec, maxLogTailBytes, gateEnv, cancellation);
@@ -591,10 +709,25 @@ async function runGateAttempt(gate, worktreePath, maxLogTailBytes, gateEnv, canc
     // cancelled while queued behind the lock used to stay `running` for up to
     // half an hour — holding the worktree against the very endpoint that exists
     // to release it.
+    //
+    // Issue #3884 H-11: the run's slot is handed back for as long as the lock is
+    // busy (never when it is free — `onWait` fires only once a claim has failed),
+    // and taken back ahead of the runs still waiting to start. See RunSlot.
     const lock = await (0, machine_lock_1.acquireMachineLock)(mutex, {
         timeoutMs: gate.timeoutSec * 1000,
         shouldAbandon: () => cancellation.cancelled,
+        onWait: () => slot.release(),
     });
+    waits.mutexMs += lock.waitedMs;
+    // Taken back even when the lock was not: the run goes on to record (or run)
+    // the gates after this one, and those are under the same bound. Not by a
+    // cancelled run (#3884 N3): it executes nothing more, and waiting for the
+    // gates the other slots are running would keep its worktree held past the
+    // cancel endpoint's budget. The wait for the slot is cancellable too — the
+    // latch is read below, and the lock released, once it returns.
+    if (!cancellation.cancelled)
+        await slot.acquire(true, cancellation);
+    waits.queueMs += slot.takeQueuedMs();
     if (!lock.acquired) {
         const recordedAt = Date.now();
         return {
@@ -646,14 +779,28 @@ async function runGateAttempt(gate, worktreePath, maxLogTailBytes, gateEnv, canc
  * came free) and an `error` (the command could not be spawned) never started a
  * command, so there is no verdict to seek a second opinion on.
  */
-async function runCommandGate(gate, worktreePath, maxLogTailBytes, gateEnv, cancellation) {
-    const first = await runGateAttempt(gate, worktreePath, maxLogTailBytes, gateEnv, cancellation);
+async function runCommandGate(gate, worktreePath, maxLogTailBytes, gateEnv, cancellation, slot) {
+    // The slot wait since the previous command gate (for the first one, since
+    // the run was opened) belongs to this gate: it is what kept it from starting.
+    const waits = { queueMs: slot.takeQueuedMs(), mutexMs: 0 };
+    const outcome = await runCommandGateAttempts(gate, worktreePath, maxLogTailBytes, gateEnv, cancellation, slot, waits);
+    if (!gate.mutex && waits.queueMs === 0)
+        return outcome;
+    return {
+        ...outcome,
+        logTail: `${outcome.logTail ? `${outcome.logTail}\n` : ''}${timingMarker(waits, outcome.durationMs)}`,
+    };
+}
+/** {@link runCommandGate}'s attempts, with the waits they accumulate. */
+async function runCommandGateAttempts(gate, worktreePath, maxLogTailBytes, gateEnv, cancellation, slot, waits) {
+    const attempt = () => runGateAttempt(gate, worktreePath, maxLogTailBytes, gateEnv, cancellation, slot, waits);
+    const first = await attempt();
     // A cancelled attempt reports `skipped`, so the retry below is already ruled
     // out by the status check: an operator's Stop must not buy a second run of
     // the very command they stopped.
     if (gate.retryOnFail !== 1 || first.status !== 'failed')
         return first;
-    const second = await runGateAttempt(gate, worktreePath, maxLogTailBytes, gateEnv, cancellation);
+    const second = await attempt();
     if (second.status !== 'passed' && second.status !== 'failed') {
         // The retry reached no verdict of its own, so there is nothing to compare
         // the first run against. The first run's FAIL stands unchanged — reporting
@@ -1024,7 +1171,9 @@ async function executeRun(db, runId, worktreeId, worktreePath,
 /** Issue #2043: which agent instance the run is judging, for the second witness. */
 instanceId, config, selection, baseRef, task, detachedContract, envClean, 
 /** Issue #2063: the operator's Stop switch for this run. */
-cancellation) {
+cancellation, 
+/** Issue #3884: handed back while a gate waits for its mutex. */
+slot) {
     const { maxLogTailBytes, skipInPrimaryCheckout } = config.options;
     const { runWorkEvidence, gates } = selection;
     // Issue #2043. A thunk rather than a number so the store is read at the
@@ -1209,7 +1358,7 @@ cancellation) {
             statuses.push(recordNotRun(gate.id, gate.command, gate.source, run_verdict_vocabulary_1.PRIMARY_CHECKOUT_SKIP_LOG).status);
             continue;
         }
-        const outcome = await runGate(gate.id, gate.command, gate.source, () => runCommandGate(gate, worktreePath, maxLogTailBytes, gateEnv(), cancellation));
+        const outcome = await runGate(gate.id, gate.command, gate.source, () => runCommandGate(gate, worktreePath, maxLogTailBytes, gateEnv(), cancellation, slot));
         statuses.push(outcome.status);
     }
     // The loop's own check cannot see a cancel that landed during the LAST gate:
@@ -1487,8 +1636,15 @@ async function startVerification(input) {
         baseline: resolvedSelection.runEnvClean && taskId ? (0, env_snapshot_1.loadEnvSnapshot)(taskId) : null,
         decision: envCleanDecision,
     };
+    const slot = new RunSlot();
     const completion = (async () => {
-        await acquireSlot();
+        // Issue #3909: the run's first wait for a slot is abandonable too, as the
+        // re-take after a mutex wait has been since #3884 N3. A run cancelled here
+        // used to stay queued (and `running`, holding its worktree) until one of
+        // the two executing gates ended, so the cancel endpoint answered
+        // `requested`. An abandoned wait holds no slot; `slot.release()` below is
+        // idempotent, so the `finally` hands nothing back for it.
+        await slot.acquire(false, cancellation);
         let terminalStatus = 'error';
         try {
             // Cancelled while queued behind MAX_CONCURRENT_VERIFICATIONS: nothing was
@@ -1499,7 +1655,7 @@ async function startVerification(input) {
                 (0, db_1.finishVerificationRun)(db, run.id, 'cancelled');
                 return 'cancelled';
             }
-            const status = await executeRun(db, run.id, input.worktreeId, input.worktreePath, input.instanceId, resolvedConfig, resolvedSelection, baseRef, task, detachedContract, envCleanContext, cancellation);
+            const status = await executeRun(db, run.id, input.worktreeId, input.worktreePath, input.instanceId, resolvedConfig, resolvedSelection, baseRef, task, detachedContract, envCleanContext, cancellation, slot);
             terminalStatus = status;
             (0, db_1.finishVerificationRun)(db, run.id, status);
             return status;
@@ -1526,7 +1682,7 @@ async function startVerification(input) {
             // after the task transition so the run's own history is complete before
             // anything is said about it.
             notifyRunFailure(db, input, run.id, taskId, terminalStatus);
-            releaseSlot();
+            slot.release();
             inFlight.delete(run.id);
             cancellations.delete(run.id);
         }

package/dist/server/src/lib/verification/machine-lock.js

@@ -161,6 +161,7 @@ async function acquireMachineLock(name, options) {
     // A stale record is broken at most once per token, so a directory nobody can
     // remove degrades into ordinary waiting instead of a spin loop.
     const broken = new Set();
+    let waiting = false;
     for (;;) {
         // Issue #2063. Checked before the claim as well as after the sleep, so a
         // caller that was already cancelled when it got here never takes a lock it
@@ -210,6 +211,10 @@ async function acquireMachineLock(name, options) {
         if (now >= deadline) {
             return { acquired: false, waitedMs: now - startedAt, heldBy: describeOwner(holder) };
         }
+        if (!waiting) {
+            waiting = true;
+            options.onWait?.();
+        }
         await sleep(Math.min(pollIntervalMs, deadline - now));
     }
 }

package/dist/server/src/lib/ws-server.js

@@ -738,7 +738,11 @@ function handleDisconnect(ws) {
     // what it obtains instead of registering it on a socket that is gone.
     clientInfo.terminalSubscriptionSeq += 1;
     if (clientInfo.terminalSubscription) {
-        void clientInfo.terminalSubscription.unsubscribe();
+        // Issue #3749: not awaited, so a rejection would otherwise surface as an
+        // unhandled rejection.
+        clientInfo.terminalSubscription.unsubscribe().catch(() => {
+            // Best-effort cleanup on disconnect.
+        });
         clientInfo.terminalSubscription = null;
     }
     // Remove client from clients map
@@ -792,7 +796,13 @@ async function handleTerminalSubscribe(ws, message) {
         // Detached before the await, so a request arriving meanwhile neither
         // releases it a second time nor has its own registration cleared by ours.
         clientInfo.terminalSubscription = null;
-        await previous.unsubscribe();
+        try {
+            await previous.unsubscribe();
+        }
+        catch {
+            // Issue #3749: best-effort, like the other teardowns. Letting it throw
+            // ended this handler here and the new subscribe silently never happened.
+        }
     }
     if (!isCurrent())
         return;
@@ -972,7 +982,7 @@ async function handleTerminalUnsubscribe(ws) {
         return;
     // Issue #3733: also withdraws a subscribe still in flight, which would
     // otherwise register after this and keep streaming.
-    clientInfo.terminalSubscriptionSeq += 1;
+    const seq = ++clientInfo.terminalSubscriptionSeq;
     const subscription = clientInfo.terminalSubscription;
     if (!subscription) {
         return;
@@ -985,6 +995,11 @@ async function handleTerminalUnsubscribe(ws) {
     catch {
         // Best-effort cleanup during terminal unsubscribe.
     }
+    // Issue #3749: a subscribe that started while the teardown was awaited may
+    // already have said `connected:true`; a `connected:false` sent after it
+    // would contradict the subscription that is now live.
+    if (clients.get(ws) !== clientInfo || clientInfo.terminalSubscriptionSeq !== seq)
+        return;
     sendTerminalEvent(ws, { type: 'terminal_status', connected: false });
 }
 // ---------------------------------------------------------------------------

package/dist/server/src/types/auto-yes-answer-mode.js

@@ -0,0 +1,38 @@
+"use strict";
+/**
+ * How Auto-Yes answers a question the agent asks (Issue #3863).
+ *
+ * - `recommended` (おまかせ, the default) — a single-select question on the
+ *   screen is answered too: the option whose title ends in a recommendation
+ *   marker (`(Recommended)` / `（推奨）` / `(推奨)`), or the default (the
+ *   cursor, else option 1) when none does. A question it cannot read that far
+ *   (two markers, a marker on a free-text or multi-select row, a title it
+ *   cannot tell from its description) is left to a human.
+ * - `careful` (慎重) — a question is never answered; it is left to a human
+ *   (`question-left-to-human`).
+ *
+ * The two differ only there. Permissions are answered alike (the one "allow
+ * this call once" row, #3822), and what a contract's `autoYes` block withholds
+ * stays withheld under either (the contract is the ceiling; the answer mode is
+ * below it).
+ *
+ * Set each time Auto-Yes is turned on (worktree × instance). Turning it on
+ * from off — or after it ran out — starts at `recommended` unless a mode is
+ * given; turning it on again while it is on keeps the mode it has.
+ *
+ * Dependency-free so the CLI build (`tsconfig.cli.json`, no path aliases) can
+ * import it by a relative path.
+ *
+ * @module types/auto-yes-answer-mode
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_AUTO_YES_ANSWER_MODE = exports.AUTO_YES_ANSWER_MODES = void 0;
+exports.isAutoYesAnswerMode = isAutoYesAnswerMode;
+/** Every {@link AutoYesAnswerMode}, the default first. */
+exports.AUTO_YES_ANSWER_MODES = ['recommended', 'careful'];
+/** The mode of a grant that names none: one turned on without a mode, or kept from before the field. */
+exports.DEFAULT_AUTO_YES_ANSWER_MODE = 'recommended';
+/** Type guard for a value read off a request body or the wire. */
+function isAutoYesAnswerMode(value) {
+    return value === 'recommended' || value === 'careful';
+}

package/dist/server/src/types/auto-yes-decision.js

@@ -0,0 +1,61 @@
+"use strict";
+/**
+ * Auto-Yes's decision about the confirmation on screen, as published
+ * (Issue #3821).
+ *
+ * The server's Auto-Yes poller is the only thing that answers a screen
+ * confirmation automatically (the browser no longer does, and the Enter on an
+ * unreadable screen is gone). What it decided for the confirmation it last
+ * judged is published next to the prompt it was judged for, so the answer
+ * surfaces know whether a human has to answer it:
+ *
+ * - `answering` — an automatic answer to this confirmation is under way (being
+ *   sent, or sent and the screen not redrawn yet);
+ * - `withheld` — Auto-Yes has left this confirmation to a human, with a
+ *   `reason` (the contract, a screen it cannot read, a question, no poller
+ *   running for the instance, …);
+ * - `none` — no confirmation, or one not judged yet. Never read as answering.
+ *
+ * Client-safe: no imports but the dependency-free answer mode (Issue #3863),
+ * so the browser hooks and the server read one shape.
+ *
+ * @module types/auto-yes-decision
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NO_AUTO_ANSWER_DECISION_REASON = exports.SERVER_POLLER_INACTIVE_DECISION_REASON = void 0;
+exports.isAutoYesAnswering = isAutoYesAnswering;
+exports.laterAutoYesDecision = laterAutoYesDecision;
+/** The reasons this record adds to the poller's suppression reasons. */
+exports.SERVER_POLLER_INACTIVE_DECISION_REASON = 'server-poller-inactive';
+exports.NO_AUTO_ANSWER_DECISION_REASON = 'no-auto-answer';
+/**
+ * Whether the answer panel may stay hidden under Auto-Yes for a prompt with
+ * this decision: only while an automatic answer is under way. A missing
+ * decision (an older server, a delivery path that did not carry it) is not
+ * `answering`.
+ */
+function isAutoYesAnswering(decision) {
+    return decision?.state === 'answering';
+}
+/**
+ * Of two decisions about the SAME prompt window, the one observed later
+ * (Issue #3821). The HTTP poll and the push deliver the same payload over two
+ * paths whose arrival order is not their build order; a decision observed
+ * before the one already applied is not applied over it.
+ *
+ * Only for the same confirmation (`confirmation`): a window with the same
+ * question and options may approve something else, and a decision about
+ * another confirmation — or one that does not say which (`confirmation`
+ * absent on one side only) — is dropped for the one this delivery carries,
+ * whatever their times. Two without the field are compared by time.
+ *
+ * @param previous - What is applied now for this window, if anything
+ * @param next - What this delivery carries
+ */
+function laterAutoYesDecision(previous, next) {
+    if (previous === undefined || next === undefined)
+        return next;
+    if ((previous.confirmation ?? null) !== (next.confirmation ?? null))
+        return next;
+    return next.observedAt < previous.observedAt ? previous : next;
+}

package/dist/server/src/types/auto-yes.js

@@ -10,3 +10,9 @@
  * `AutoYesToggleParams` from the component keep working unchanged.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAutoYesAnswerMode = exports.DEFAULT_AUTO_YES_ANSWER_MODE = exports.AUTO_YES_ANSWER_MODES = void 0;
+// Issue #3863: the answer mode, declared dependency-free for the CLI build.
+var auto_yes_answer_mode_1 = require("./auto-yes-answer-mode");
+Object.defineProperty(exports, "AUTO_YES_ANSWER_MODES", { enumerable: true, get: function () { return auto_yes_answer_mode_1.AUTO_YES_ANSWER_MODES; } });
+Object.defineProperty(exports, "DEFAULT_AUTO_YES_ANSWER_MODE", { enumerable: true, get: function () { return auto_yes_answer_mode_1.DEFAULT_AUTO_YES_ANSWER_MODE; } });
+Object.defineProperty(exports, "isAutoYesAnswerMode", { enumerable: true, get: function () { return auto_yes_answer_mode_1.isAutoYesAnswerMode; } });