commandmate 0.47.0 → 0.48.0

package/dist/server/src/lib/polling/auto-yes-manual-answer.js

@@ -0,0 +1,122 @@
+"use strict";
+/**
+ * A person's answer through `/prompt-response`, as Auto-Yes's poller sees it
+ * (Issue #3821, review 2).
+ *
+ * Dropping the published decision is not enough to keep the poller's keys off
+ * a confirmation a person is answering: a tick already past its checks — the
+ * ownership check, a wait inside the send — acts for its generation (#3706),
+ * which a manual answer did not touch. So the start of a manual answer
+ *
+ *  - moves the instance's manual-answer sequence on; a tick whose generation
+ *    was taken under an earlier one is no longer current (`isTickCurrent`) and
+ *    sends no further key;
+ *  - holds the instance for {@link MANUAL_ANSWER_HOLD_MS}: a tick that reads a
+ *    confirmation meanwhile leaves it to the person (`answered-by-human`)
+ *    instead of answering what they may be answering right now;
+ *  - drops the published decision.
+ *
+ * How the answer ENDED decides what happens to an answer the poller holds at
+ * that confirmation (Issue #3880, {@link settleManualAnswer}).
+ *
+ * Auto-Yes itself stays on: past the hold the poller answers again.
+ *
+ * In-memory and on `globalThis` (the route and the poller are bundled apart
+ * under `next dev`).
+ *
+ * @module lib/polling/auto-yes-manual-answer
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ANSWERED_BY_HUMAN_DECISION_REASON = exports.MANUAL_ANSWER_HOLD_MS = void 0;
+exports.noteManualAnswerStarted = noteManualAnswerStarted;
+exports.noteManualSendStarting = noteManualSendStarting;
+exports.settleManualAnswer = settleManualAnswer;
+exports.abandonManualSend = abandonManualSend;
+exports.getManualAnswerSeq = getManualAnswerSeq;
+exports.isManualAnswerHolding = isManualAnswerHolding;
+exports.clearManualAnswers = clearManualAnswers;
+const auto_yes_state_1 = require("../../lib/auto-yes-state");
+const global_state_1 = require("../global-state");
+const auto_yes_decision_state_1 = require("./auto-yes-decision-state");
+const auto_yes_poller_state_1 = require("./auto-yes-poller-state");
+/** How long a manual answer keeps the poller off the instance's confirmations. */
+exports.MANUAL_ANSWER_HOLD_MS = auto_yes_state_1.DUPLICATE_RETRY_EXPIRY_MS;
+/** The decision reason a tick withholds under while the hold lasts. */
+exports.ANSWERED_BY_HUMAN_DECISION_REASON = 'answered-by-human';
+const marks = (0, global_state_1.getOrInitGlobal)('__autoYesManualAnswers', () => new Map());
+/** A person began answering on this instance (called before the first key or API call). */
+function noteManualAnswerStarted(compositeKey, at = Date.now()) {
+    marks.set(compositeKey, { seq: (marks.get(compositeKey)?.seq ?? 0) + 1, at });
+    (0, auto_yes_decision_state_1.forgetAutoYesDecision)(compositeKey);
+    return { compositeKey, order: (0, auto_yes_poller_state_1.nextSendOrder)(), attempt: null };
+}
+/**
+ * The person's keys are about to go out (Issue #3880), at the confirmation
+ * `promptData` is — or, when no prompt could be read off the screen (the
+ * capture before the send failed), at an unidentified one. Registered as a
+ * send in flight, so a screen seen gone, a relaunch, or a worktree going away
+ * before it ends keeps its end from recording a hold.
+ */
+function noteManualSendStarting(ticket, promptData) {
+    if (ticket.attempt !== null)
+        return;
+    const screenKey = promptData ? (0, auto_yes_poller_state_1.partialAnswerScreenKey)(promptData) : auto_yes_poller_state_1.UNIDENTIFIED_SCREEN_KEY;
+    ticket.attempt = (0, auto_yes_poller_state_1.beginManualSendAttempt)(ticket.compositeKey, screenKey);
+}
+/**
+ * A person's answer ended (Issue #3880). Starting one does not touch what
+ * Auto-Yes holds — the start only stops the tick under way and holds the
+ * poller off for {@link MANUAL_ANSWER_HOLD_MS} — so a manual send that fails
+ * cannot leave the confirmation free for Auto-Yes to type at again once that
+ * hold passes. Everything is matched to THIS answer (`ticket`), not to the
+ * instance's key alone:
+ *
+ * - `answered` / `not-sent`: the hold recorded before this answer began is
+ *   released (the person answered, or saw the screen and nothing of theirs is
+ *   on it). One recorded since — by another person's send that may be on the
+ *   pane, or a tick's — stays.
+ * - `may-be-on-pane`: the send records a hold at its screen (unidentified
+ *   when none was read), as Auto-Yes's own does: only for the session epoch it
+ *   went to, never over a hold of a send registered after it, and not at all when
+ *   the screen it typed at was seen gone since. And every tick under way stops
+ *   (the manual-answer sequence moves on): one that read no hold before its
+ *   last wait does not type over this one.
+ *
+ * An end nobody reports (the agent's API answered it, the route threw) leaves
+ * the hold as it was.
+ */
+function settleManualAnswer(ticket, outcome, at = Date.now()) {
+    const { compositeKey, attempt } = ticket;
+    if (outcome !== 'may-be-on-pane') {
+        if (attempt !== null)
+            (0, auto_yes_poller_state_1.settleSendAttempt)(attempt, false, at);
+        (0, auto_yes_poller_state_1.releasePartialAnswerToHuman)(compositeKey, ticket.order);
+        return;
+    }
+    if (attempt !== null)
+        (0, auto_yes_poller_state_1.settleSendAttempt)(attempt, true, at);
+    const mark = marks.get(compositeKey);
+    if (mark !== undefined)
+        marks.set(compositeKey, { ...mark, seq: mark.seq + 1 });
+}
+/**
+ * A person's send ended in a way that says nothing of its keys (Issue #3880):
+ * it is no longer in flight, and the hold is left as it was.
+ */
+function abandonManualSend(ticket) {
+    if (ticket.attempt !== null)
+        (0, auto_yes_poller_state_1.settleSendAttempt)(ticket.attempt, false);
+}
+/** The instance's manual-answer sequence (0 until a person answers there). */
+function getManualAnswerSeq(compositeKey) {
+    return marks.get(compositeKey)?.seq ?? 0;
+}
+/** Whether a manual answer began on this instance less than {@link MANUAL_ANSWER_HOLD_MS} ago. */
+function isManualAnswerHolding(compositeKey, now = Date.now()) {
+    const mark = marks.get(compositeKey);
+    return mark !== undefined && now - mark.at < exports.MANUAL_ANSWER_HOLD_MS;
+}
+/** Drop every mark: a test seam. The sequences only ever move forward otherwise. */
+function clearManualAnswers() {
+    marks.clear();
+}

package/dist/server/src/lib/polling/auto-yes-option-effect.js

@@ -0,0 +1,157 @@
+"use strict";
+/**
+ * Auto-Yes option effects - what picking one row of a permission dialog does
+ * (Issue #3822).
+ *
+ * Until #3822 the resolver picked the default row, or row 1, of any numbered
+ * dialog. On every tool measured here the rows of a permission dialog do not
+ * mean the same thing: one allows this call only, the others save a rule
+ * (`don't ask again`, `always allow`, `Persist to settings.json`), switch the
+ * permission mode for the session (`allow all edits`, `Full Access`), or deny.
+ * Where the cursor rests is the tool's choice, not a promise that the row is
+ * the narrow one — agy keeps the `>` where the operator left it — so Auto-Yes
+ * answers only the row that reads as "allow this call once", by its number,
+ * and nothing when no single row reads that way.
+ *
+ * ## Where the wording comes from
+ *
+ * Every rule below is a row read off a live capture in the repository, named
+ * next to it. Nothing is inferred from another tool's wording. A tool without
+ * a table (gemini, vibe-local, opencode, opencode-v2) keeps the pre-#3822
+ * reading: opencode's and OpenCode V2's permission strips are unnumbered and
+ * never reach the resolver as a prompt (they are answered through the hook,
+ * whose `allow` is `allowOnce`), and gemini / vibe-local have no captured
+ * permission dialog to read.
+ *
+ * ## When a dialog counts as a permission dialog
+ *
+ * When at least one of its rows reads as an allow — this call once, a saved
+ * rule, or a mode change. A `No` row alone does not make one: a launch dialog
+ * (`Yes, continue` / `No, quit`, `Yes, I trust this folder` / `No, exit`) is
+ * judged where it always was (the launch-dialog branch, the contract's deny
+ * patterns). A numbered list none of whose rows the tool's table recognises (a
+ * question's options, a dialog whose wording was never captured) keeps the
+ * pre-#3822 default-row reading — this module only narrows what a recognised
+ * permission dialog may be answered with, it does not decide which screens are
+ * dialogs.
+ *
+ * Client-safe: no server-only imports (the resolver is bundled into
+ * `hooks/useAutoYes.ts`).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OPTION_EFFECT_TOOLS = void 0;
+exports.readOptionEffect = readOptionEffect;
+exports.selectAllowOnceOption = selectAllowOnceOption;
+/** `don't` with a straight or a typographic apostrophe. */
+const DONT = "don['’]t";
+/** `No`, alone or followed by its explanation (`No, cancel`, `No, and tell … differently`). */
+const DENY_NO = ['deny', /^No(?:,|$)/];
+/**
+ * Each tool's rows, first match wins. A rule is anchored at the start of the
+ * label and reads only the words that say what the row does, so the command or
+ * path a row quotes after them does not matter.
+ */
+const OPTION_EFFECT_RULES = {
+    // tests/fixtures/canary/permission-dialog.raw.txt, permission-hook-no-decision.raw.txt,
+    // tests/unit/lib/detection/fixtures/claude-live-1708/bash-approval-taskpanel.txt,
+    // tests/fixtures/tui-frame-footer-2776/claude-2.1.278-bash-approval-task-panel.txt
+    claude: [
+        ['allow-once', /^Yes$/],
+        ['allow-persistent', /^Yes, and always allow\b/],
+        ['mode-change', /^Yes, allow all edits\b/],
+        ['mode-change', /^Yes, and switch to\b/],
+        DENY_NO,
+    ],
+    // tests/unit/lib/detection/fixtures/codex-live-1628/approval-{run-command,apply-patch}.txt,
+    // tests/fixtures/codex-dialogs-0157/approval.txt, codex-hooks-review-0148.ts,
+    // tests/fixtures/codex-browser-use-2609/approval-form-browser-use.txt (`Allow` /
+    // `Always allow` / `Cancel`, each followed by its description), and
+    // tests/fixtures/codex-live-2310/dialog-permissions-picker.txt (the approval modes)
+    codex: [
+        ['allow-once', /^Yes$/],
+        ['allow-once', /^Yes, proceed\b/],
+        ['allow-once', /^Allow(?:\s{2,}|$)/],
+        ['allow-persistent', new RegExp(`^Yes, and ${DONT} ask again\\b`)],
+        ['allow-persistent', /^Always allow\b/],
+        ['mode-change', /^Ask for approval\b/],
+        ['mode-change', /^Approve for me\b/],
+        ['mode-change', /^Full Access\b/],
+        ['deny', /^Cancel\b/],
+        DENY_NO,
+    ],
+    // tests/fixtures/antigravity-live-2364/dialog-bash-*.txt, dialog-create-file.txt,
+    // tests/fixtures/strict-respond-3812/permission-run-command.txt. `always allow in
+    // this conversation` is as much a saved rule as `(Persist to settings.json)`:
+    // neither is this call only.
+    antigravity: [
+        ['allow-once', /^Yes$/],
+        ['allow-once', /^Yes, run command$/],
+        ['allow-once', /^Yes, allow creation$/],
+        ['allow-persistent', /^Yes, and always allow\b/],
+        DENY_NO,
+    ],
+    // tests/fixtures/command-code-live-2250/dialog-shell-command.txt, dialog-create-file.txt,
+    // dialog-kill-task-1490.txt, tests/fixtures/command-code-plan-review-2763/after-approve.txt
+    'command-code': [
+        ['allow-once', /^Yes$/],
+        ['allow-persistent', new RegExp(`^Yes, ${DONT} ask again\\b`)],
+        ['mode-change', /^Yes, allow all edits\b/],
+        DENY_NO,
+    ],
+    // tests/unit/lib/detection/fixtures/copilot-live-1885/permission-dialog.txt and
+    // copilot-picker-1895/picker-permissions.txt (`Manual ✓` / `Allow all`, the modes)
+    copilot: [
+        ['allow-once', /^Yes$/],
+        ['allow-persistent', new RegExp(`^Yes, and ${DONT} ask again\\b`)],
+        ['mode-change', /^Manual\b/],
+        ['mode-change', /^Allow all\b/],
+        DENY_NO,
+    ],
+};
+/** Every table, for a caller that does not say which tool drew the dialog. */
+const ANY_TOOL_RULES = Object.values(OPTION_EFFECT_RULES).flat();
+/** The tools whose permission rows are read (the others keep the pre-#3822 reading). */
+exports.OPTION_EFFECT_TOOLS = Object.keys(OPTION_EFFECT_RULES);
+function rulesFor(cliToolId) {
+    if (cliToolId === undefined)
+        return ANY_TOOL_RULES;
+    return OPTION_EFFECT_RULES[cliToolId] ?? null;
+}
+function readWith(rules, label) {
+    const text = label.trim();
+    for (const [effect, pattern] of rules) {
+        if (pattern.test(text))
+            return effect;
+    }
+    return 'unknown';
+}
+/**
+ * What choosing the row labelled `label` does on `cliToolId`'s dialog.
+ *
+ * @param cliToolId - The tool that drew the dialog. Omitted, every tool's
+ *   table is read (the first rule that matches decides); a tool with no table
+ *   reads every row as `unknown`.
+ */
+function readOptionEffect(label, cliToolId) {
+    const rules = rulesFor(cliToolId);
+    return rules === null ? 'unknown' : readWith(rules, label);
+}
+/**
+ * Pick the one "allow this call once" row of a permission dialog.
+ *
+ * @param options - The dialog's rows, as parsed
+ * @param cliToolId - The tool that drew it; see {@link readOptionEffect}
+ */
+function selectAllowOnceOption(options, cliToolId) {
+    const rules = rulesFor(cliToolId);
+    if (rules === null)
+        return { kind: 'not-a-permission-dialog' };
+    const effects = options.map((option) => readWith(rules, option.label));
+    if (!effects.some((effect) => effect === 'allow-once' || effect === 'allow-persistent' || effect === 'mode-change')) {
+        return { kind: 'not-a-permission-dialog' };
+    }
+    const once = options.filter((_option, index) => effects[index] === 'allow-once');
+    if (once.length === 1)
+        return { kind: 'allow-once', option: once[0] };
+    return { kind: 'unidentified', allowOnceCount: once.length };
+}

package/dist/server/src/lib/polling/auto-yes-policy.js

@@ -14,12 +14,17 @@
  * indefinitely. The TTL is what bounds staleness — a task that starts or ends is
  * picked up within it, without this module having to observe task transitions.
  *
+ * Issue #3822: a failed lookup is not cached. It is "contract unknown", which
+ * the answering paths read as withholding, and holding it for the TTL would
+ * keep withholding after the database recovered; the next poll reads again.
+ *
  * @module lib/polling/auto-yes-policy
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AUTO_YES_POLICY_CACHE_TTL_MS = void 0;
 exports.getSessionAutoYesPolicy = getSessionAutoYesPolicy;
 exports.getSessionAutoYesPolicyEntry = getSessionAutoYesPolicyEntry;
+exports.getSessionAutoYesPolicyLookupEntry = getSessionAutoYesPolicyLookupEntry;
 exports.isAutoYesBlockedByPolicy = isAutoYesBlockedByPolicy;
 exports.isSessionAutoYesBlockedByContract = isSessionAutoYesBlockedByContract;
 exports.getSessionContractPolicySummary = getSessionContractPolicySummary;
@@ -29,6 +34,7 @@ const db_1 = require("../../lib/db");
 const db_instance_1 = require("../../lib/db/db-instance");
 const auto_yes_state_1 = require("../../lib/auto-yes-state");
 const logger_1 = require("../../lib/logger");
+const auto_yes_resolver_1 = require("./auto-yes-resolver");
 const logger = (0, logger_1.createLogger)('auto-yes-policy');
 /** How long a resolved policy is reused before the task is looked up again. */
 exports.AUTO_YES_POLICY_CACHE_TTL_MS = 5000;
@@ -54,11 +60,11 @@ function purgeExpired(now) {
  * Read the policy from the active task, or null when no contract governs this
  * instance.
  *
- * A database failure yields null — the unconstrained behaviour. Failing closed
- * here would suppress auto-yes for every user who has no contract at all, which
- * is the population this feature must not touch; the suppressing decisions
- * (`off`, deny patterns) are made inside the resolver only once a contract has
- * actually been read.
+ * Issue #3822: a database failure yields {@link AUTO_YES_POLICY_UNKNOWN}, not
+ * null. It used to yield null — the unconstrained behaviour — so a contract
+ * stating `off` or a deny pattern was answered past whenever one read failed.
+ * Users without a contract are still untouched: a lookup that succeeds and
+ * finds no task is null, as before, and only a lookup that fails withholds.
  */
 function readPolicy(worktreeId, cliToolId, instanceId) {
     try {
@@ -76,7 +82,7 @@ function readPolicy(worktreeId, cliToolId, instanceId) {
             instanceId,
             error: error instanceof Error ? error.message : String(error),
         });
-        return { policy: null, taskId: null };
+        return { policy: auto_yes_resolver_1.AUTO_YES_POLICY_UNKNOWN, taskId: null };
     }
 }
 /**
@@ -85,19 +91,41 @@ function readPolicy(worktreeId, cliToolId, instanceId) {
  *
  * @param worktreeId - Worktree identifier
  * @param cliToolId - CLI tool being polled
+ * For the paths that answer (the poller and the `PermissionRequest` hook):
+ * the resolver reads {@link AUTO_YES_POLICY_UNKNOWN} as withholding (Issue #3822).
+ *
  * @param instanceId - Agent instance id (defaults to the primary, i.e. cliToolId)
- * @returns The contract's autoYes block, or null when no contract governs this instance
+ * @param options - `fresh: true` reads the task past the cache (and refreshes
+ *   it): the poller's last look before a key (Issue #3822), where a contract
+ *   switched or a deny pattern added within the TTL must already count
+ * @returns The contract's autoYes block, null when no contract governs this
+ *   instance, or {@link AUTO_YES_POLICY_UNKNOWN} when the lookup failed
  */
-function getSessionAutoYesPolicy(worktreeId, cliToolId, instanceId) {
-    return lookupEntry(worktreeId, cliToolId, instanceId).policy;
+function getSessionAutoYesPolicy(worktreeId, cliToolId, instanceId, options) {
+    return lookupEntry(worktreeId, cliToolId, instanceId, options?.fresh === true).policy;
 }
 /**
  * The policy and the id of the task it came from, read in ONE lookup (Issue
  * #3724), so a log line naming both cannot pair one task's verdict with another
  * task's id when the cache expires between two reads. `taskId` is null when no
  * contract governs the instance.
+ *
+ * For display only (Issue #3822): a failed lookup reads as no contract here
+ * (`policy` and `taskId` null), never as a contract this lookup did not see.
  */
 function getSessionAutoYesPolicyEntry(worktreeId, cliToolId, instanceId) {
+    const { policy, taskId } = lookupEntry(worktreeId, cliToolId, instanceId);
+    if ((0, auto_yes_resolver_1.isAutoYesPolicyUnknown)(policy))
+        return { policy: null, taskId: null };
+    return { policy, taskId };
+}
+/**
+ * {@link getSessionAutoYesPolicyEntry} for a path that judges the prompt again
+ * (Issue #3822): a failed lookup stays {@link AUTO_YES_POLICY_UNKNOWN} instead of
+ * reading as no contract, so the resolver withholds on it as the tick did.
+ * `taskId` is null when no contract governs the instance or the lookup failed.
+ */
+function getSessionAutoYesPolicyLookupEntry(worktreeId, cliToolId, instanceId) {
     const { policy, taskId } = lookupEntry(worktreeId, cliToolId, instanceId);
     return { policy, taskId };
 }
@@ -137,15 +165,22 @@ function getSessionContractPolicySummary(worktreeId, cliToolId, instanceId) {
         denyPatternCount: policy.denyPatterns.length,
     };
 }
-function lookupEntry(worktreeId, cliToolId, instanceId) {
+function lookupEntry(worktreeId, cliToolId, instanceId, fresh = false) {
     const resolvedInstanceId = instanceId ?? cliToolId;
     const key = (0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, resolvedInstanceId);
     const now = Date.now();
     const cached = policyCache.get(key);
-    if (cached && cached.expiresAt > now) {
+    if (!fresh && cached && cached.expiresAt > now) {
         return cached;
     }
     const { policy, taskId } = readPolicy(worktreeId, cliToolId, resolvedInstanceId);
+    if ((0, auto_yes_resolver_1.isAutoYesPolicyUnknown)(policy)) {
+        // Issue #3822: not cached, so the next lookup reads again. A fresh read
+        // that failed also drops what was cached: it is no longer known to hold.
+        if (fresh)
+            policyCache.delete(key);
+        return { policy, taskId, expiresAt: now };
+    }
     if (policyCache.size >= MAX_CACHE_ENTRIES) {
         purgeExpired(now);
     }

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

@@ -0,0 +1,63 @@
+"use strict";
+/**
+ * Auto-Yes poller: one tick's capture (Issue #2522) (Issue #3783: split out of
+ * `auto-yes-poller.ts`, which re-exports the public names).
+ *
+ * Does not statically import `auto-yes-poller.ts` (no cycle outside the
+ * baseline in `import-cycles-baseline-3482`). Via `cli-session`, opencode's
+ * history feed reaches it back through a dynamic `import()`; that path predates
+ * the split (the poller imported `cli-session` itself) and is no static cycle.
+ *
+ * @module lib/polling/auto-yes-poller-capture
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.capturePollerFrame = capturePollerFrame;
+exports.captureAndCleanOutput = captureAndCleanOutput;
+const async_hooks_1 = require("async_hooks");
+const cli_session_1 = require("../session/cli-session");
+const global_state_1 = require("../global-state");
+const cli_patterns_1 = require("../detection/cli-patterns");
+const auto_yes_config_1 = require("../../config/auto-yes-config");
+/** Where `cli-session` reports whether the capture it runs inside cut the pane's top (Issue #3881 N4). */
+function headCutSink() {
+    return (0, global_state_1.getOrInitGlobal)('__captureHeadCutSink', () => new async_hooks_1.AsyncLocalStorage());
+}
+/**
+ * Capture tmux session output once, keeping both spellings (Issue #2522).
+ *
+ * @internal Exported for testing purposes only.
+ * @param worktreeId - Worktree identifier
+ * @param cliToolId - CLI tool type being polled
+ * @param captureLines - Optional number of lines to capture
+ * @param instanceId - Optional agent instance ID (Issue #896; defaults to primary session)
+ * @returns The tick's raw capture and its cleaned form
+ */
+async function capturePollerFrame(worktreeId, cliToolId, captureLines, instanceId) {
+    const lines = captureLines ?? auto_yes_config_1.FULL_CAPTURE_LINES;
+    const reported = {};
+    const output = await headCutSink().run((headCut) => {
+        reported.headCut = headCut;
+    }, () => (0, cli_session_1.captureSessionOutput)(worktreeId, cliToolId, lines, instanceId));
+    return {
+        raw: output,
+        clean: (0, cli_patterns_1.stripBoxDrawing)((0, cli_patterns_1.stripAnsi)(output)),
+        ...(reported.headCut !== undefined ? { headCut: reported.headCut } : {}),
+    };
+}
+/**
+ * Capture tmux session output and strip ANSI escape codes.
+ *
+ * Kept as the cleaned half of {@link capturePollerFrame} so the many callers and
+ * tests that only ever wanted that string are untouched; `pollAutoYes` takes the
+ * pair. `stripBoxDrawing` still runs exactly once per capture either way.
+ *
+ * @internal Exported for testing purposes only.
+ * @param worktreeId - Worktree identifier
+ * @param cliToolId - CLI tool type being polled
+ * @param captureLines - Optional number of lines to capture
+ * @param instanceId - Optional agent instance ID (Issue #896; defaults to primary session)
+ * @returns Cleaned output string (ANSI stripped)
+ */
+async function captureAndCleanOutput(worktreeId, cliToolId, captureLines, instanceId) {
+    return (await capturePollerFrame(worktreeId, cliToolId, captureLines, instanceId)).clean;
+}

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

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * Auto-Yes poller: the Enter fallback's audit answer and per-session epoch
+ * (Issue #3397) (Issue #3783: split out of `auto-yes-poller.ts`, which
+ * re-exports the public names; the Enter itself — `tryEnterFallback` — and its
+ * fresh-frame check stay there).
+ *
+ * Does not statically import `auto-yes-poller.ts` (no cycle outside the
+ * baseline in `import-cycles-baseline-3482`, which does not count dynamic
+ * `import()`).
+ *
+ * @module lib/polling/auto-yes-poller-enter-fallback
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AUTO_YES_ENTER_FALLBACK_ANSWER = void 0;
+exports.syncEnterFallbackEpoch = syncEnterFallbackEpoch;
+const auto_yes_enter_fallback_1 = require("./auto-yes-enter-fallback");
+/**
+ * The audit row's `answer` for the Enter (Issue #3397): not a digit, so the
+ * History reads as "Auto-Yes pressed Enter" rather than as a chosen option.
+ */
+exports.AUTO_YES_ENTER_FALLBACK_ANSWER = '[Enter]';
+/**
+ * Issue #3397: a session begun since the last tick (a relaunch the poller
+ * outlived) starts with no screen that had its Enter.
+ *
+ * @returns The session epoch the tick reads under
+ */
+function syncEnterFallbackEpoch(compositeKey, pollerState) {
+    const epoch = (0, auto_yes_enter_fallback_1.getEnterFallbackSessionEpoch)(compositeKey);
+    if ((pollerState.enterFallbackEpoch ?? 0) !== epoch) {
+        pollerState.enterFallbackSentKey = null;
+        pollerState.enterFallbackCandidateKey = null;
+        pollerState.enterFallbackEpoch = epoch;
+    }
+    return epoch;
+}