commandmate 0.46.1 → 0.47.0

package/dist/server/src/lib/polling/response-poller-core.js

@@ -533,6 +533,135 @@ function splitPollerKey(pollerKey) {
         instanceId: pollerKey.slice(separatorIndex + 1),
     };
 }
+/** Old worktree ID -> new worktree ID, skipping empty and no-op pairs. */
+function collectRenameTargets(renames) {
+    const targets = new Map();
+    for (const { oldId, newId } of renames) {
+        if (!oldId || !newId || oldId === newId)
+            continue;
+        targets.set(oldId, newId);
+    }
+    return targets;
+}
+/** Sort every running poller under a renamed ID into a move or an abandoned stop. */
+function planRunningPollerMoves(targets, resolveCliToolId) {
+    const moves = [];
+    const abandoned = [];
+    for (const pollerKey of Array.from(exports.activePollers.keys())) {
+        const parts = splitPollerKey(pollerKey);
+        if (!parts)
+            continue;
+        const newWorktreeId = targets.get(parts.worktreeId);
+        if (!newWorktreeId)
+            continue;
+        const cliToolId = resolveCliToolId(parts.worktreeId, parts.instanceId);
+        if (!cliToolId) {
+            abandoned.push({ pollerKey, newWorktreeId });
+            continue;
+        }
+        moves.push({
+            oldKey: pollerKey,
+            newKey: getPollerKey(newWorktreeId, cliToolId, parts.instanceId),
+            newWorktreeId,
+            cliToolId,
+            instanceId: parts.instanceId,
+        });
+    }
+    return { moves, abandoned };
+}
+/** Phase 1 of the migration for the moved pollers (see the caller). */
+function liftMovedPollers(moves, carried) {
+    for (const move of moves) {
+        const timerId = exports.activePollers.get(move.oldKey);
+        if (timerId)
+            clearTimeout(timerId);
+        exports.activePollers.delete(move.oldKey);
+        // Issue #2223: retire the ownership token as well. A tick that is inside
+        // `checkForResponse()` right now cannot be cancelled by `clearTimeout`, and
+        // without this it would resume, find its key gone and — before #2223 —
+        // still be able to act on the old worktree ID. Marked superseded rather
+        // than merely stopped: Phase 2 below arms a replacement chain, so the old
+        // tick's snapshot would land on top of the new one's.
+        const retired = coordinator.owners.get(move.oldKey);
+        if (retired) {
+            retired.superseded = true;
+            retired.stopped = true;
+            coordinator.owners.delete(move.oldKey);
+        }
+        coordinator.pendingRestart.delete(move.oldKey);
+        carried.set(move.newKey, { startedAt: exports.pollingStartTimes.get(move.oldKey) });
+        exports.pollingStartTimes.delete(move.oldKey);
+        (0, tui_accumulator_1.clearTuiAccumulator)(move.oldKey);
+    }
+}
+/** The paused chains under a renamed ID, keyed old -> new (see the caller). */
+function collectPausedMoves(targets) {
+    const pausedMoves = [];
+    for (const pollerKey of Array.from(coordinator.pausedOnPrompt)) {
+        const parts = splitPollerKey(pollerKey);
+        if (!parts)
+            continue;
+        const newWorktreeId = targets.get(parts.worktreeId);
+        if (!newWorktreeId)
+            continue;
+        pausedMoves.push({ oldKey: pollerKey, newKey: `${newWorktreeId}:${parts.instanceId}` });
+    }
+    return pausedMoves;
+}
+/** The held scrapes under a renamed ID, keyed old -> new (see the caller). */
+function collectPendingMoves(targets, abandonedKeys) {
+    const pendingMoves = [];
+    for (const pollerKey of (0, pending_scraped_response_1.listPendingScrapedResponseKeys)()) {
+        if (abandonedKeys.has(pollerKey))
+            continue;
+        const parts = splitPollerKey(pollerKey);
+        if (!parts)
+            continue;
+        const newWorktreeId = targets.get(parts.worktreeId);
+        if (!newWorktreeId)
+            continue;
+        pendingMoves.push({ oldKey: pollerKey, newKey: `${newWorktreeId}:${parts.instanceId}`, newWorktreeId });
+    }
+    return pendingMoves;
+}
+/** Stop the chains on destinations that no source vacates (see the caller). */
+function stopDisplacedPollers(moves, pausedMoves, pendingMoves, abandonedKeys) {
+    const vacated = new Set([
+        ...moves.map((move) => move.oldKey),
+        ...pausedMoves.map((move) => move.oldKey),
+        ...pendingMoves.map((move) => move.oldKey),
+    ]);
+    // A held scrape moved on its own (no chain, no pause) changes the key's
+    // owner just the same, so its destination is handled alike (#3663 review).
+    const occupied = new Set([
+        ...moves.map((move) => move.newKey),
+        ...pausedMoves.map((move) => move.newKey),
+        ...pendingMoves.map((move) => move.newKey),
+    ]);
+    for (const pollerKey of occupied) {
+        if (vacated.has(pollerKey) || abandonedKeys.has(pollerKey))
+            continue;
+        const held = coordinator.owners.has(pollerKey) ||
+            exports.activePollers.has(pollerKey) ||
+            coordinator.pausedOnPrompt.has(pollerKey) ||
+            (0, pending_scraped_response_1.hasPendingScrapedResponse)(pollerKey);
+        if (!held)
+            continue;
+        stopPollingByKey(pollerKey);
+        logger.warn('poller:migrate-displaced', { pollerKey });
+    }
+}
+/** Phase 2 of the migration: restart each moved poller (see the caller). */
+function restartMovedPollers(moves, carried) {
+    for (const move of moves) {
+        const startedAt = carried.get(move.newKey)?.startedAt;
+        exports.pollingStartTimes.set(move.newKey, startedAt ?? Date.now());
+        if (isFullScreenTui(move.cliToolId)) {
+            (0, tui_accumulator_1.initTuiAccumulator)(move.newKey);
+        }
+        scheduleNextResponsePoll(move.newWorktreeId, move.cliToolId, move.instanceId);
+    }
+}
 /**
  * Move every running response poller from a renamed worktree ID to the new one
  * (Issue #1621 Phase 3).
@@ -585,36 +714,10 @@ function splitPollerKey(pollerKey) {
  * @returns One entry per poller that was moved
  */
 function migrateResponsePollerWorktreeIds(renames, resolveCliToolId) {
-    const targets = new Map();
-    for (const { oldId, newId } of renames) {
-        if (!oldId || !newId || oldId === newId)
-            continue;
-        targets.set(oldId, newId);
-    }
+    const targets = collectRenameTargets(renames);
     if (targets.size === 0)
         return [];
-    const moves = [];
-    const abandoned = [];
-    for (const pollerKey of Array.from(exports.activePollers.keys())) {
-        const parts = splitPollerKey(pollerKey);
-        if (!parts)
-            continue;
-        const newWorktreeId = targets.get(parts.worktreeId);
-        if (!newWorktreeId)
-            continue;
-        const cliToolId = resolveCliToolId(parts.worktreeId, parts.instanceId);
-        if (!cliToolId) {
-            abandoned.push({ pollerKey, newWorktreeId });
-            continue;
-        }
-        moves.push({
-            oldKey: pollerKey,
-            newKey: getPollerKey(newWorktreeId, cliToolId, parts.instanceId),
-            newWorktreeId,
-            cliToolId,
-            instanceId: parts.instanceId,
-        });
-    }
+    const { moves, abandoned } = planRunningPollerMoves(targets, resolveCliToolId);
     // Phase 1: stop every affected timer and lift the state off the old keys.
     // Done for the whole batch before any write so a swap cannot self-collide.
     const carried = new Map();
@@ -628,28 +731,7 @@ function migrateResponsePollerWorktreeIds(renames, resolveCliToolId) {
         const inFlight = coordinator.running.get(move.oldKey);
         return inFlight !== undefined && inFlight.owner === coordinator.owners.get(move.oldKey);
     });
-    for (const move of moves) {
-        const timerId = exports.activePollers.get(move.oldKey);
-        if (timerId)
-            clearTimeout(timerId);
-        exports.activePollers.delete(move.oldKey);
-        // Issue #2223: retire the ownership token as well. A tick that is inside
-        // `checkForResponse()` right now cannot be cancelled by `clearTimeout`, and
-        // without this it would resume, find its key gone and — before #2223 —
-        // still be able to act on the old worktree ID. Marked superseded rather
-        // than merely stopped: Phase 2 below arms a replacement chain, so the old
-        // tick's snapshot would land on top of the new one's.
-        const retired = coordinator.owners.get(move.oldKey);
-        if (retired) {
-            retired.superseded = true;
-            retired.stopped = true;
-            coordinator.owners.delete(move.oldKey);
-        }
-        coordinator.pendingRestart.delete(move.oldKey);
-        carried.set(move.newKey, { startedAt: exports.pollingStartTimes.get(move.oldKey) });
-        exports.pollingStartTimes.delete(move.oldKey);
-        (0, tui_accumulator_1.clearTuiAccumulator)(move.oldKey);
-    }
+    liftMovedPollers(moves, carried);
     // Stop the abandoned pollers before any dedup state is written: the stop
     // clears every cache under its key, and that key can be the destination of
     // another move in this batch (A:x paused → B:x while B:x is abandoned).
@@ -670,31 +752,11 @@ function migrateResponsePollerWorktreeIds(renames, resolveCliToolId) {
     // never see it — but it is holding the response hash for the turn it paused
     // on, and `/respond` will resume it under the NEW ID. Move the hash and the
     // pause mark with it; the chain itself stays paused until that resume.
-    const pausedMoves = [];
-    for (const pollerKey of Array.from(coordinator.pausedOnPrompt)) {
-        const parts = splitPollerKey(pollerKey);
-        if (!parts)
-            continue;
-        const newWorktreeId = targets.get(parts.worktreeId);
-        if (!newWorktreeId)
-            continue;
-        pausedMoves.push({ oldKey: pollerKey, newKey: `${newWorktreeId}:${parts.instanceId}` });
-    }
+    const pausedMoves = collectPausedMoves(targets);
     // Issue #3663: every held scrape under a renamed worktree ID moves — a
     // running chain's, a paused chain's, and one whose chain is already gone.
     // The abandoned ones were written above and are no longer held.
-    const pendingMoves = [];
-    for (const pollerKey of (0, pending_scraped_response_1.listPendingScrapedResponseKeys)()) {
-        if (abandonedKeys.has(pollerKey))
-            continue;
-        const parts = splitPollerKey(pollerKey);
-        if (!parts)
-            continue;
-        const newWorktreeId = targets.get(parts.worktreeId);
-        if (!newWorktreeId)
-            continue;
-        pendingMoves.push({ oldKey: pollerKey, newKey: `${newWorktreeId}:${parts.instanceId}`, newWorktreeId });
-    }
+    const pendingMoves = collectPendingMoves(targets, abandonedKeys);
     // Issue #3663: a destination a chain (running or paused) moves onto, that no
     // source of this batch vacates, may already be held by another chain — B:x
     // running while A:x moves to B:x. That chain loses the key, so it is stopped
@@ -703,30 +765,7 @@ function migrateResponsePollerWorktreeIds(renames, resolveCliToolId) {
     // no longer hold or drop anything, and its caches are cleared before the
     // moved state is written. A destination nothing is on is left alone, and so
     // is every other instance of the destination worktree.
-    const vacated = new Set([
-        ...moves.map((move) => move.oldKey),
-        ...pausedMoves.map((move) => move.oldKey),
-        ...pendingMoves.map((move) => move.oldKey),
-    ]);
-    // A held scrape moved on its own (no chain, no pause) changes the key's
-    // owner just the same, so its destination is handled alike (#3663 review).
-    const occupied = new Set([
-        ...moves.map((move) => move.newKey),
-        ...pausedMoves.map((move) => move.newKey),
-        ...pendingMoves.map((move) => move.newKey),
-    ]);
-    for (const pollerKey of occupied) {
-        if (vacated.has(pollerKey) || abandonedKeys.has(pollerKey))
-            continue;
-        const held = coordinator.owners.has(pollerKey) ||
-            exports.activePollers.has(pollerKey) ||
-            coordinator.pausedOnPrompt.has(pollerKey) ||
-            (0, pending_scraped_response_1.hasPendingScrapedResponse)(pollerKey);
-        if (!held)
-            continue;
-        stopPollingByKey(pollerKey);
-        logger.warn('poller:migrate-displaced', { pollerKey });
-    }
+    stopDisplacedPollers(moves, pausedMoves, pendingMoves, abandonedKeys);
     // Issue #3553: the dedup state of the whole batch moves in one call per map
     // family, each lifting every source before writing any destination. Re-keyed
     // pair by pair, a swap left A with its own state and B empty.
@@ -766,14 +805,7 @@ function migrateResponsePollerWorktreeIds(renames, resolveCliToolId) {
             : [];
     }));
     // Phase 2: restart each poller under its new identity.
-    for (const move of moves) {
-        const startedAt = carried.get(move.newKey)?.startedAt;
-        exports.pollingStartTimes.set(move.newKey, startedAt ?? Date.now());
-        if (isFullScreenTui(move.cliToolId)) {
-            (0, tui_accumulator_1.initTuiAccumulator)(move.newKey);
-        }
-        scheduleNextResponsePoll(move.newWorktreeId, move.cliToolId, move.instanceId);
-    }
+    restartMovedPollers(moves, carried);
     // Issue #2230: the pause marks of the chains collected above follow their
     // hashes (moved with the batch). All removed before any is added, for the
     // same swap reason.

package/dist/server/src/lib/prompt-observation/kinds.js

@@ -0,0 +1,123 @@
+"use strict";
+/**
+ * The screen kinds a prompt observation publishes (Issue #3755, #3746 A-3).
+ *
+ * ## Why a vocabulary of its own
+ *
+ * `promptData.type` (`yes_no` / `multiple_choice` / `unclassified`) says how a
+ * parsed prompt is answered, and agy's status detector
+ * (`detection/tools/antigravity/detect.ts`) publishes the folder-trust screen,
+ * the `/model` picker and the slash popup under ONE reason
+ * (`antigravity_selection_list`). Neither can say "this is the trust screen and
+ * not the picker", which is exactly what a caller about to answer one of them
+ * has to be sure of (#3746 P4-1). So the values a caller may branch on — and
+ * that the strict `respond` (#3756) may make a send condition — live here, and
+ * are never mixed into `promptData.type` or read back from the detector's
+ * reason.
+ *
+ * A kind is added only for a screen whose reading is pinned to a measured
+ * frame. Everything else that waits on a human is `unknown`: an unmeasured
+ * screen must not borrow a measured screen's name.
+ *
+ * ## No imports, on purpose
+ *
+ * The CLI (`tsconfig.cli.json`) compiles with `"paths": {}` and reaches a
+ * module under `src/lib` only by a relative path whose graph uses no `@/`
+ * alias (the arrangement `lib/session/prompt-view` documents). `prompt` and
+ * `wait` import these values from here rather than restating them.
+ *
+ * @module lib/prompt-observation/kinds
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXITING_STRICT_ANSWERS = exports.UNNUMBERED_STRICT_RESPOND_KINDS = exports.STRICT_RESPOND_KINDS = exports.NO_PROMPT_OBSERVATION_KINDS = exports.PROMPT_OBSERVATION_KINDS = exports.PROMPT_OBSERVATION_SCHEMA_VERSION = void 0;
+exports.isPromptObservationKind = isPromptObservationKind;
+exports.isDecisionKind = isDecisionKind;
+exports.isStrictRespondKind = isStrictRespondKind;
+exports.isExitingStrictAnswer = isExitingStrictAnswer;
+/** `schemaVersion` of the observation payload. Bumped when a field changes meaning. */
+exports.PROMPT_OBSERVATION_SCHEMA_VERSION = 1;
+/**
+ * Every kind an observation can publish.
+ *
+ * - `antigravity-trust` — agy's first-run folder trust screen (`Do you trust
+ *   the contents of this project?` over `> Yes, I trust this folder` /
+ *   `No, exit`). Unnumbered; Enter confirms the highlighted row.
+ * - `antigravity-model-picker` — agy's `/model` picker (`Switch Model`): the
+ *   1.1.27 layout (`antigravity-live-2364/picker-switch-model.txt`) and the
+ *   1.4 one with a search box (`prompt-observation-3797/`, Issue #3797).
+ * - `antigravity-permission` — agy's numbered permission dialog (command
+ *   execution, file creation; `tests/fixtures/antigravity-live-2364/dialog-*`),
+ *   ending on its `tab Amend` footer. agy's numbered login-method screen is
+ *   not one (`unknown`).
+ * - `antigravity-slash-menu` — agy's slash-command popup.
+ * - `composer` — no confirmation: the agent sits at its input box.
+ * - `none` — no confirmation, and not at the input box either (working).
+ * - `unknown` — something waits on a human and no measured reading names it.
+ */
+exports.PROMPT_OBSERVATION_KINDS = [
+    'antigravity-trust',
+    'antigravity-model-picker',
+    'antigravity-permission',
+    'antigravity-slash-menu',
+    'composer',
+    'none',
+    'unknown',
+];
+/** The two kinds that mean "nothing on screen is asking for a decision". */
+exports.NO_PROMPT_OBSERVATION_KINDS = ['composer', 'none'];
+/** Whether `value` is one of {@link PROMPT_OBSERVATION_KINDS}. */
+function isPromptObservationKind(value) {
+    return typeof value === 'string' && exports.PROMPT_OBSERVATION_KINDS.includes(value);
+}
+/** Whether `kind` is a screen that asks for a decision (neither `composer` nor `none`). */
+function isDecisionKind(kind) {
+    return !exports.NO_PROMPT_OBSERVATION_KINDS.includes(kind);
+}
+/**
+ * The kinds the strict `respond` (Issue #3756) answers. Every other kind is
+ * refused before a key: the `/model` picker's effort slider is not read, the
+ * slash popup is a menu of the composer, and `unknown` is never answered.
+ */
+exports.STRICT_RESPOND_KINDS = ['antigravity-trust', 'antigravity-permission'];
+/** Whether `kind` is one of {@link STRICT_RESPOND_KINDS}. */
+function isStrictRespondKind(kind) {
+    return typeof kind === 'string' && exports.STRICT_RESPOND_KINDS.includes(kind);
+}
+/**
+ * Strict kinds whose rows carry no number: answered only by a label, which is
+ * sent as ↑/↓ and Enter. An option number or `--default` is refused there.
+ */
+exports.UNNUMBERED_STRICT_RESPOND_KINDS = ['antigravity-trust'];
+/**
+ * Per strict kind, the answer whose consequence is the agent exiting (Issue
+ * #3788): its 1-based position, valid only on a screen that shows exactly
+ * `optionCount` options AND whose row at that position reads `label`. agy's
+ * trust screen offers `Yes, I trust this folder` then `No, exit` (measured:
+ * `tests/fixtures/prompt-observation-3755/antigravity-trust.txt`,
+ * `antigravity-live-2364/trust-dialog.txt`), and agy exits on the second.
+ *
+ * The three conditions only narrow: a screen drawn in another order, with
+ * another number of rows, or with another wording has no exiting answer, and
+ * its outcome stays `indeterminate` (exit 41).
+ *
+ * Only after such an answer may a shell back in front of the pane be read as
+ * the session having ended: after any other answer it is the agent falling
+ * over (a crash, a failed start), which the answer did not ask for. A kind
+ * absent here has no exiting answer.
+ */
+exports.EXITING_STRICT_ANSWERS = {
+    // eslint-disable-next-line no-restricted-syntax -- agy's drawn option row, matched against the screen, not display text
+    'antigravity-trust': { position: 2, optionCount: 2, label: 'No, exit' },
+};
+/**
+ * Whether answering option `position` (1-based) of a `kind` screen showing
+ * `options` (labels in draw order) exits the agent: the declared position, the
+ * declared number of options, and the declared label at that position (runs of
+ * spaces folded, ends trimmed; case kept).
+ */
+function isExitingStrictAnswer(kind, position, options) {
+    const exiting = exports.EXITING_STRICT_ANSWERS[kind];
+    if (exiting === undefined || exiting.position !== position || exiting.optionCount !== options.length)
+        return false;
+    return options[position - 1].replace(/\s+/g, ' ').trim() === exiting.label;
+}

package/dist/server/src/lib/prompt-observation/types.js

@@ -0,0 +1,14 @@
+"use strict";
+/**
+ * The payload of one prompt observation (Issue #3755): what
+ * `GET /api/worktrees/:id/current-output?observe=1` adds as `promptObservation`,
+ * what `commandmate prompt --json` prints, and what `commandmate wait` adds to
+ * its exit-10 payload as `observation`.
+ *
+ * Types only, and importable from the CLI for the reason `./kinds` gives: the
+ * two imports outside this directory (`polling/auto-yes-suppression-reason`,
+ * `session/send-attempt-types`) have no imports of their own.
+ *
+ * @module lib/prompt-observation/types
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/server/src/lib/push/prompt-push-gate.js

@@ -56,6 +56,43 @@
  * it resolves in seconds, and the reminder below is what catches it when it
  * does not.
  *
+ * ## "About to answer" has a deadline (Issue #3757)
+ *
+ * Nothing recorded is not proof that Auto-Yes is answering. A screen the poller
+ * cannot read at all (agy's folder-trust screen was the measured case: the
+ * poller read no prompt, so it recorded nothing) looked exactly like the
+ * common case above, and the wait was held silent until the ten-minute
+ * reminder. So the hold lasts {@link AUTO_YES_ANSWER_GRACE_MS} — time for the
+ * poller to answer or to record why it did not — and a wait still open after
+ * that notifies as `auto-yes-not-answered`. `waiting-push-notifier` asks again
+ * when the hold ends.
+ *
+ * The hold is NOT counted from `waitingSince`. That is the wait's identity,
+ * not when anyone saw it: it can be a hook's timestamp older than the probe
+ * that opened the edge, and it stays frozen across several prompts of one
+ * episode. It is counted from {@link autoYesHoldStartedAt}: the later of the
+ * moment the gate first held this episode and the poller's last answer, so a
+ * second prompt right after an answer gets a full hold of its own. Both
+ * producers ask through {@link decideAndLogPromptPush} and share that origin.
+ *
+ * ## The hold reaches the session wait's tick (Issue #3791)
+ *
+ * The 9 s assume the poller's next tick is at most a cooldown away. Its ticks
+ * are a poll interval, a cooldown or the thinking interval (5 s) apart — inside
+ * the 9 s — with two exceptions. An error backoff (up to `MAX_BACKOFF_MS`) is
+ * not waited for: a poller failing in a row is the least likely to answer, and
+ * a broken Auto-Yes is when a human most needs the notification. The session
+ * wait is: a capture that found no session puts the next tick `MAX_BACKOFF_MS`
+ * away, and a session started meanwhile (`send --auto-yes` enables Auto-Yes
+ * before the session exists) gets its first prompt answered on that tick. So
+ * when the hold begins while that tick is pending, it lasts until the tick plus
+ * two ticks (answer, or the Enter fallback's second look):
+ * {@link autoYesHoldEndsAt}. The tick is read once, and only counts while the
+ * poller that scheduled it is still the one running — a poller stopped or
+ * replaced meanwhile will not tick. Issue #3796: the session's creation brings
+ * that tick forward to a poll interval, and the hold follows it — the tick is
+ * only ever read earlier than it was when the hold began.
+ *
  * ## The reminder is never muted
  *
  * `runEscalationTick` has already established that the wait is still open — it
@@ -71,12 +108,141 @@
  * @module lib/push/prompt-push-gate
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.AUTO_YES_HOLD_MAX_AGE_MS = exports.AUTO_YES_ANSWER_AFTER_TICK_MS = exports.AUTO_YES_ANSWER_GRACE_MS = void 0;
+exports.autoYesHoldStartedAt = autoYesHoldStartedAt;
+exports.autoYesHoldEndsAt = autoYesHoldEndsAt;
+exports.forgetAutoYesHold = forgetAutoYesHold;
+exports.clearAutoYesHolds = clearAutoYesHolds;
 exports.decidePromptPush = decidePromptPush;
 exports.isPromptPushSuppressed = isPromptPushSuppressed;
+exports.decideAndLogPromptPush = decideAndLogPromptPush;
 const auto_yes_state_1 = require("../../lib/auto-yes-state");
 const logger_1 = require("../../lib/logger");
 const auto_yes_suppression_state_1 = require("../../lib/polling/auto-yes-suppression-state");
+const global_state_1 = require("../../lib/global-state");
 const logger = (0, logger_1.createLogger)('push/prompt-gate');
+/**
+ * How long a wait with nothing recorded about it is held as "Auto-Yes is
+ * answering" (Issue #3757), from {@link autoYesHoldStartedAt}. The poller
+ * answers a prompt it can read on the tick that sees it and records a reason
+ * on the same tick when it will not, but that tick can be a cooldown away
+ * (`COOLDOWN_INTERVAL_MS` after an answer, as long while thinking), and the
+ * Enter fallback needs one more tick: a cooldown plus two ticks, 9 s.
+ */
+exports.AUTO_YES_ANSWER_GRACE_MS = Math.max(3 * auto_yes_state_1.POLLING_INTERVAL_MS, auto_yes_state_1.COOLDOWN_INTERVAL_MS + 2 * auto_yes_state_1.POLLING_INTERVAL_MS);
+/** compositeKey -> the hold of that session's current episode. globalThis per #1736. */
+const autoYesHolds = (0, global_state_1.getOrInitGlobal)('__promptPushAutoYesHolds', () => new Map());
+/**
+ * Where this wait's `auto-yes-answering` hold is counted from (Issue #3757):
+ * the later of the moment the gate first held this episode (recorded here on
+ * the first call) and the Auto-Yes poller's last answer to this session.
+ *
+ * The poller's answer is read off its state on `globalThis`
+ * (`__autoYesPollerStates`, `lastServerResponseTimestamp`) rather than through
+ * `auto-yes-poller`, which imports `response-checker`, which imports this gate.
+ *
+ * @param now - Epoch ms of the decision; recorded as the start of a new hold
+ */
+function autoYesHoldStartedAt(input, now) {
+    const key = (0, auto_yes_state_1.buildCompositeKey)(input.worktreeId, input.cliToolId, input.instanceId);
+    sweepStaleAutoYesHolds(now);
+    let hold = autoYesHolds.get(key);
+    if (hold === undefined || hold.since !== input.waitingSince) {
+        hold = { since: input.waitingSince, firstHeldAt: now, sessionWaitTick: pendingSessionWaitTick(key, now) };
+        autoYesHolds.set(key, hold);
+    }
+    // Issue #3770: Auto-Yes switched off and on again inside one episode starts a
+    // fresh hold; the old origin would read the poller's silence while it was off
+    // as "did not answer".
+    const enabledAt = (0, auto_yes_state_1.getAutoYesState)(input.worktreeId, input.cliToolId, input.instanceId)?.enabledAt;
+    if (enabledAt !== undefined && enabledAt > hold.firstHeldAt && enabledAt <= now)
+        hold.firstHeldAt = enabledAt;
+    const lastAnswer = globalThis.__autoYesPollerStates?.get(key)?.lastServerResponseTimestamp ?? null;
+    return lastAnswer !== null ? Math.max(hold.firstHeldAt, lastAnswer) : hold.firstHeldAt;
+}
+/**
+ * How long after the poller's tick the hold still lasts (Issue #3791): that
+ * tick answers, or records why not, and the Enter fallback answers on the tick
+ * after it — the "two ticks" of {@link AUTO_YES_ANSWER_GRACE_MS}.
+ */
+exports.AUTO_YES_ANSWER_AFTER_TICK_MS = 2 * auto_yes_state_1.POLLING_INTERVAL_MS;
+/**
+ * The Auto-Yes poller's pending session-wait tick (Issue #3791), read off its
+ * state on `globalThis` for the same reason as `lastServerResponseTimestamp`.
+ * Only a tick due after `now`, and no further than the session wait puts it.
+ */
+function pendingSessionWaitTick(key, now) {
+    const poller = globalThis.__autoYesPollerStates?.get(key);
+    const at = poller?.sessionWaitTickAt;
+    if (poller === undefined || at === undefined || at <= now)
+        return undefined;
+    return { at: Math.min(at, now + auto_yes_state_1.MAX_BACKOFF_MS), poller, heldAt: now };
+}
+/**
+ * Issue #3796: when the session wait's tick the hold counts on actually comes.
+ * The tick read when the hold began, brought forward when the poller ticked
+ * early — its session was created, and it rescheduled the tick a poll interval
+ * away (`sessionWaitTickAt`), or already ran it (`sessionWaitTickRanAt`,
+ * `sessionAppearedAt`) — only times since the hold began count. Only
+ * ever earlier: a session wait scheduled after the hold began does not extend
+ * it (#3791).
+ */
+function effectiveSessionWaitTickAt(tick) {
+    let at = tick.at;
+    for (const t of [tick.poller.sessionWaitTickAt, tick.poller.sessionWaitTickRanAt, tick.poller.sessionAppearedAt]) {
+        if (t !== undefined && t >= tick.heldAt && t < at)
+            at = t;
+    }
+    return at;
+}
+/**
+ * When this wait's `auto-yes-answering` hold ends (Issue #3791): a full
+ * {@link AUTO_YES_ANSWER_GRACE_MS} after {@link autoYesHoldStartedAt}, and not
+ * before {@link AUTO_YES_ANSWER_AFTER_TICK_MS} past the session wait's tick
+ * pending when the hold began — while the poller that scheduled it still runs.
+ *
+ * @param now - Epoch ms of the decision; recorded as the start of a new hold
+ */
+function autoYesHoldEndsAt(input, now) {
+    const startedAt = autoYesHoldStartedAt(input, now);
+    const key = (0, auto_yes_state_1.buildCompositeKey)(input.worktreeId, input.cliToolId, input.instanceId);
+    const tick = autoYesHolds.get(key)?.sessionWaitTick;
+    const graceEndsAt = startedAt + exports.AUTO_YES_ANSWER_GRACE_MS;
+    // A poller stopped or replaced since (disable, off → on) will not tick.
+    if (tick === undefined || globalThis.__autoYesPollerStates?.get(key) !== tick.poller)
+        return graceEndsAt;
+    // Kept on the hold: an earlier tick once adopted is not lost when the poller
+    // later reschedules (an ordinary tick after a failed capture, a new session
+    // wait) — the hold never moves back out.
+    tick.at = effectiveSessionWaitTickAt(tick);
+    return Math.max(graceEndsAt, tick.at + exports.AUTO_YES_ANSWER_AFTER_TICK_MS);
+}
+/** A hold older than this is dropped (Issue #3770): its episode is long over. */
+exports.AUTO_YES_HOLD_MAX_AGE_MS = 60 * 60 * 1000;
+function sweepStaleAutoYesHolds(now) {
+    for (const [key, hold] of autoYesHolds) {
+        if (now - hold.firstHeldAt >= exports.AUTO_YES_HOLD_MAX_AGE_MS)
+            autoYesHolds.delete(key);
+    }
+}
+/**
+ * Drop the hold of one session (Issue #3770): Auto-Yes went off, or the
+ * episode closed.
+ *
+ * @param since - Issue #3776: drop it only when it is this episode's hold. A
+ *   caller retiring one episode must not take the next episode's origin with it
+ *   (that hold would start over, and its notification come up to a hold late).
+ *   Omitted, the session's hold goes whatever its episode.
+ */
+function forgetAutoYesHold(key, since) {
+    if (since !== undefined && autoYesHolds.get(key)?.since !== since)
+        return;
+    autoYesHolds.delete(key);
+}
+/** Forget every hold. Test seam. */
+function clearAutoYesHolds() {
+    autoYesHolds.clear();
+}
 /**
  * Decide whether this prompt notification is worth a human's attention.
  *
@@ -97,6 +263,10 @@ function decidePromptPush(input) {
     if (input.escalated === true) {
         return { suppress: false, reason: 'escalation-reminder' };
     }
+    const holdEndsAt = input.holdEndsAt ?? (input.holdStartedAt !== undefined ? input.holdStartedAt + exports.AUTO_YES_ANSWER_GRACE_MS : undefined);
+    if (holdEndsAt !== undefined && (input.now ?? Date.now()) >= holdEndsAt) {
+        return { suppress: false, reason: 'auto-yes-not-answered' };
+    }
     return { suppress: true, reason: 'auto-yes-answering' };
 }
 /**
@@ -111,7 +281,23 @@ function decidePromptPush(input) {
  * so the line is only there for the "why did this one ring?" question.
  */
 function isPromptPushSuppressed(input) {
-    const decision = decidePromptPush(input);
+    return decideAndLogPromptPush(input).suppress;
+}
+/**
+ * {@link isPromptPushSuppressed}, with the whole decision handed back — for the
+ * caller that has to ask again when an `auto-yes-answering` hold ends
+ * (`waiting-push-notifier`, Issue #3757).
+ */
+function decideAndLogPromptPush(input, options = {}) {
+    let decision = decidePromptPush(input);
+    if (decision.reason === 'auto-yes-inactive') {
+        forgetAutoYesHold((0, auto_yes_state_1.buildCompositeKey)(input.worktreeId, input.cliToolId, input.instanceId));
+    }
+    // Issue #3757: only a wait that reached the hold gets an origin recorded.
+    if (decision.reason === 'auto-yes-answering' && input.holdStartedAt === undefined && input.holdEndsAt === undefined) {
+        const now = input.now ?? Date.now();
+        decision = decidePromptPush({ ...input, now, holdEndsAt: autoYesHoldEndsAt(input, now) });
+    }
     const context = {
         worktreeId: input.worktreeId,
         cliToolId: input.cliToolId,
@@ -122,9 +308,15 @@ function isPromptPushSuppressed(input) {
         ...(decision.stopReason !== undefined ? { stopReason: decision.stopReason } : {}),
         ...(decision.suppressedBy !== undefined ? { suppressedBy: decision.suppressedBy } : {}),
     };
-    if (decision.suppress)
+    // A re-ask at the end of a hold (Issue #3757) that holds again was already
+    // logged when the hold began.
+    if (decision.suppress && options.recheck === true)
+        logger.debug('prompt-push-suppressed', context);
+    else if (decision.suppress)
         logger.info('prompt-push-suppressed', context);
+    else if (decision.reason === 'auto-yes-not-answered')
+        logger.info('prompt-push-allowed', context);
     else
         logger.debug('prompt-push-allowed', context);
-    return decision.suppress;
+    return decision;
 }