commandmate 0.46.1 → 0.47.2

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/appearance.js

@@ -0,0 +1,165 @@
+"use strict";
+/**
+ * Which appearance of a screen an observation saw (Issue #3755).
+ *
+ * The same trust screen can open, be answered, and open again with every word
+ * the same — and a token issued on the first one must not answer the second.
+ * The server keeps, per instance, the fingerprint of the decision screen it
+ * last observed (kind, question, options, approval target, pane, generation)
+ * and when that fingerprint was first observed. Observing anything else — a
+ * different screen, `composer`, `none`, `unknown`, no session — forgets it, so
+ * the next observation of the same words is a new appearance with a new
+ * `firstSeenAt`, which the token binds (`./token`).
+ *
+ * What this cannot see: the screen going away and coming back between two
+ * observations, with nothing observed in between (observations are opt-in, not
+ * a poll). The two are one appearance here.
+ *
+ * In memory on `globalThis` (the route that issues and the route that verifies
+ * are bundled apart under `next dev`), bounded; forgetting an instance only
+ * makes its next observation a new appearance, which fails closed.
+ *
+ * @module lib/prompt-observation/appearance
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.approvalTargetWithOptionRowsAligned = approvalTargetWithOptionRowsAligned;
+exports.approvalTargetWithoutHighlight = approvalTargetWithoutHighlight;
+exports.screenFingerprint = screenFingerprint;
+exports.noteScreenAppearance = noteScreenAppearance;
+exports.forgetScreenAppearance = forgetScreenAppearance;
+const global_state_1 = require("../../lib/global-state");
+const dialog_block_1 = require("../../lib/detection/tools/dialog-block");
+/** How many instances are tracked at once; the least recently observed is forgotten first. */
+const MAX_TRACKED_INSTANCES = 1024;
+const appearances = (0, global_state_1.getOrInitGlobal)('__promptObservationScreenAppearances', () => new Map());
+/** Whitespace folded, so a re-render that only reflows a row is the same screen. */
+function normalize(text) {
+    return text === null ? null : text.replace(/\s+/g, ' ').trim();
+}
+/**
+ * How many rows under agy's bottom option row may be its wrapped tail: the
+ * allowance `detection/tools/antigravity/dialog.ts` gives the same block
+ * (`LAST_OPTION_TAIL_ROWS`, not exported). A tail longer than this reads as no
+ * block here, which leaves the target as it is (fail closed).
+ */
+const PERMISSION_OPTION_TAIL_ROWS = 12;
+/**
+ * The gutter of an option row: the highlight's glyph or the blank of the others.
+ * The glyphs are the block reader's (`dialog-block.ts`): agy's `>`, and claude's
+ * `❯`, codex's `›` and `●` for the readers that share the poller (#3817).
+ */
+const OPTION_ROW_GUTTER_PATTERN = /^[ \t]*[>\u276F\u203A\u25CF]?[ \t]*/u;
+/**
+ * The rows the shared block reader adopted as option rows, option 1 first, or
+ * null when they cannot be told.
+ *
+ * Taken from the reader itself, never re-judged here: `findNumberedOptionBlock`
+ * names the rows of option 1 (`firstRow`) and of the bottom option (`lastRow`)
+ * only, so option k's row is the `lastRow` of the block the reader finds above
+ * option k+1's row. Between two adopted rows there is no row the reader could
+ * parse as an option (it would have adopted it, or stopped there), so that
+ * block is the same run cut one option shorter. A row the reader folds into a
+ * label — `0. item`, `00. item` — is never in the list.
+ */
+function adoptedOptionRows(rows, block) {
+    const adopted = [block.lastRow];
+    for (let below = block.lastRow; adopted.length < block.options.length - 1;) {
+        const above = (0, dialog_block_1.findNumberedOptionBlock)(rows, below, rows.length);
+        if (above === null || above.firstRow !== block.firstRow || above.lastRow >= below)
+            return null;
+        adopted.unshift(above.lastRow);
+        below = above.lastRow;
+    }
+    adopted.unshift(block.firstRow);
+    return adopted.length === block.options.length ? adopted : null;
+}
+/**
+ * An approval target with the gutters of its option rows made the same, or null
+ * when its option rows cannot be told (Issue #3812, shared since #3817).
+ *
+ * The option block is found the way the readers find it
+ * (`findNumberedOptionBlock`, bottom up to `1.`), and taken only when each label
+ * the block reader read is `sameLabel` to the one the screen names. Only the
+ * gutter of the rows the reader adopted as options ({@link adoptedOptionRows})
+ * is made the same; every row above option 1 (the command, a here-document's
+ * `1. item`, its `>` and its indent) and every row folded into a label
+ * (`0. item` included) stays byte for byte.
+ *
+ * @param sameLabel - Whether the label the block reader read (rows under the
+ *   bottom option folded in) is the one the screen names
+ */
+function approvalTargetWithOptionRowsAligned(approvalTarget, options, sameLabel) {
+    const rows = approvalTarget.split('\n');
+    const block = (0, dialog_block_1.findNumberedOptionBlock)(rows, rows.length, PERMISSION_OPTION_TAIL_ROWS);
+    if (block === null)
+        return null;
+    // The reader folds the rows under the bottom option into its label.
+    const labels = [...block.options];
+    const last = labels.length - 1;
+    if (block.footer !== '')
+        labels[last] = [labels[last], ...block.footer.split('\n')].join(' ').trim();
+    if (labels.length !== options.length || labels.some((label, i) => !sameLabel(label, options[i])))
+        return null;
+    const adopted = adoptedOptionRows(rows, block);
+    if (adopted === null)
+        return null;
+    const optionRows = new Set(adopted);
+    return rows.map((row, i) => (optionRows.has(i) ? row.replace(OPTION_ROW_GUTTER_PATTERN, '  ') : row)).join('\n');
+}
+/**
+ * An approval target with the highlight's mark taken out (Issue #3812).
+ *
+ * agy's permission dialog reads its approval target down to the footer
+ * (`detection/tools/antigravity/dialog.ts`), so its option rows are the tail
+ * of the target and the `>` moves with every ↑/↓. Its option rows are aligned
+ * by {@link approvalTargetWithOptionRowsAligned} when the block's labels are
+ * exactly the screen's `options` — what the reader named.
+ *
+ * Any other kind, a target with no such block, or a block whose labels are not
+ * the screen's, is returned as is: a moved highlight then reads as another
+ * screen, which stops the strict respond rather than letting it through.
+ */
+function approvalTargetWithoutHighlight(kind, approvalTarget, options) {
+    if (approvalTarget === null || kind !== 'antigravity-permission')
+        return approvalTarget;
+    return approvalTargetWithOptionRowsAligned(approvalTarget, options, (read, named) => read === named) ?? approvalTarget;
+}
+/** One fixed form of what a screen asks. The highlight is not in it: moving the cursor is the same appearance. */
+function screenFingerprint(parts) {
+    return JSON.stringify([
+        parts.sessionName,
+        parts.sessionGeneration,
+        parts.kind,
+        normalize(parts.question),
+        parts.options.map(normalize),
+        normalize(approvalTargetWithoutHighlight(parts.kind, parts.approvalTarget, parts.options)),
+    ]);
+}
+function keyOf(instance) {
+    return JSON.stringify([instance.worktreeId, instance.cliToolId, instance.instanceId]);
+}
+/**
+ * Record an observation of a decision screen and return when this appearance
+ * of it was first observed.
+ *
+ * @param fingerprint - {@link screenFingerprint} of the screen
+ */
+function noteScreenAppearance(instance, fingerprint, now) {
+    const key = keyOf(instance);
+    const previous = appearances.get(key);
+    // Re-inserted, so the map's order is least recently observed first.
+    appearances.delete(key);
+    const firstSeenAt = previous?.fingerprint === fingerprint ? previous.firstSeenAt : Math.floor(now);
+    appearances.set(key, { fingerprint, firstSeenAt });
+    while (appearances.size > MAX_TRACKED_INSTANCES) {
+        const oldest = appearances.keys().next().value;
+        if (oldest === undefined)
+            break;
+        appearances.delete(oldest);
+    }
+    return firstSeenAt;
+}
+/** Record an observation of anything else: the instance's last screen has gone. */
+function forgetScreenAppearance(instance) {
+    appearances.delete(keyOf(instance));
+}

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 });