commandmate 0.49.0 → 0.49.2

package/dist/server/src/lib/prompt-answer-sender.js

@@ -7,7 +7,7 @@
  * the promptType/defaultOptionNumber fallback introduced in Bug1).
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PromptAnswerAbortedError = exports.MultiSelectAnswerRejectedError = exports.MULTI_SELECT_NOT_COMMITTED_REASON = exports.FreeTextAtChoiceOnlyPromptError = exports.FreeTextAnswerRejectedError = exports.FREE_TEXT_AT_MENU_ROW_REASON = exports.PromptAnswerRejectedError = exports.ANSWER_MODE_KEYS_REASON = void 0;
+exports.PromptAnswerRejectedError = exports.PromptAnswerNotDeliveredError = exports.PromptAnswerInputLostError = exports.PromptAnswerAbortedError = exports.MultiSelectAnswerRejectedError = exports.MULTI_SELECT_NOT_COMMITTED_REASON = exports.FreeTextAtChoiceOnlyPromptError = exports.FreeTextAnswerRejectedError = exports.FREE_TEXT_AT_MENU_ROW_REASON = exports.ANSWER_NOT_DELIVERED_REASON = exports.ANSWER_MODE_KEYS_REASON = void 0;
 exports.sendPromptAnswer = sendPromptAnswer;
 const tmux_1 = require("./tmux/tmux");
 const frame_1 = require("../lib/detection/tools/frame");
@@ -19,6 +19,23 @@ const models_1 = require("../types/models");
 const tmux_capture_cache_1 = require("./tmux/tmux-capture-cache");
 const prompt_answer_semantic_1 = require("../lib/prompt-answer-semantic");
 const cli_tool_timing_config_1 = require("../config/cli-tool-timing-config");
+const auto_yes_dialog_gate_1 = require("../lib/polling/auto-yes-dialog-gate");
+const instance_input_lock_1 = require("../lib/session/instance-input-lock");
+const prompt_answer_errors_1 = require("./prompt-answer-errors");
+// Issue #3965: the refusals and their reason codes live in `prompt-answer-errors`
+// and are re-exported here, so every caller keeps importing them from this module.
+var prompt_answer_errors_2 = require("./prompt-answer-errors");
+Object.defineProperty(exports, "ANSWER_MODE_KEYS_REASON", { enumerable: true, get: function () { return prompt_answer_errors_2.ANSWER_MODE_KEYS_REASON; } });
+Object.defineProperty(exports, "ANSWER_NOT_DELIVERED_REASON", { enumerable: true, get: function () { return prompt_answer_errors_2.ANSWER_NOT_DELIVERED_REASON; } });
+Object.defineProperty(exports, "FREE_TEXT_AT_MENU_ROW_REASON", { enumerable: true, get: function () { return prompt_answer_errors_2.FREE_TEXT_AT_MENU_ROW_REASON; } });
+Object.defineProperty(exports, "FreeTextAnswerRejectedError", { enumerable: true, get: function () { return prompt_answer_errors_2.FreeTextAnswerRejectedError; } });
+Object.defineProperty(exports, "FreeTextAtChoiceOnlyPromptError", { enumerable: true, get: function () { return prompt_answer_errors_2.FreeTextAtChoiceOnlyPromptError; } });
+Object.defineProperty(exports, "MULTI_SELECT_NOT_COMMITTED_REASON", { enumerable: true, get: function () { return prompt_answer_errors_2.MULTI_SELECT_NOT_COMMITTED_REASON; } });
+Object.defineProperty(exports, "MultiSelectAnswerRejectedError", { enumerable: true, get: function () { return prompt_answer_errors_2.MultiSelectAnswerRejectedError; } });
+Object.defineProperty(exports, "PromptAnswerAbortedError", { enumerable: true, get: function () { return prompt_answer_errors_2.PromptAnswerAbortedError; } });
+Object.defineProperty(exports, "PromptAnswerInputLostError", { enumerable: true, get: function () { return prompt_answer_errors_2.PromptAnswerInputLostError; } });
+Object.defineProperty(exports, "PromptAnswerNotDeliveredError", { enumerable: true, get: function () { return prompt_answer_errors_2.PromptAnswerNotDeliveredError; } });
+Object.defineProperty(exports, "PromptAnswerRejectedError", { enumerable: true, get: function () { return prompt_answer_errors_2.PromptAnswerRejectedError; } });
 // Issue #3397: the checkbox reading (`hasCheckboxOptions`) lives in
 // `prompt-answer-semantic`, shared with the semantic resolver and Auto-Yes.
 /**
@@ -37,14 +54,6 @@ const cli_tool_timing_config_1 = require("../config/cli-tool-timing-config");
  * has already range-checked against the option list on the FRESH frame.
  */
 const SELECTION_SET_PATTERN = /^\d+(?:,\d+)*$/;
-/**
- * The reason code a caller gets back when a digit meets a `keys`-mode dialog
- * (Issue #2033).
- *
- * Spelled as a constant because it crosses two boundaries: the API refusal body
- * `respond` reads (`/prompt-response`), and the assertions that pin it.
- */
-exports.ANSWER_MODE_KEYS_REASON = 'answer_mode_keys';
 /**
  * The only {@link DialogAnswerMode} a typed digit can actually drive.
  *
@@ -61,156 +70,6 @@ const TEXT_ANSWERABLE_ANSWER_MODE = 'numbered';
  * would otherwise take on a path that runs before every keystroke.
  */
 const GUARD_CAPTURE_LINES = 200;
-/**
- * A prompt answer that was refused BEFORE any key reached the pane.
- *
- * The distinction matters to every caller: a throw from `sendKeys` leaves the
- * terminal in an unknown state, whereas this one is a guarantee that nothing was
- * typed and the dialog is still exactly as the operator left it.
- */
-class PromptAnswerRejectedError extends Error {
-    /** Machine-readable code, currently always {@link ANSWER_MODE_KEYS_REASON}. */
-    reason;
-    /** The dialog family the tool vouched for, e.g. `permission` / `picker`. */
-    dialogKind;
-    /** How that dialog actually takes its answer. */
-    answerMode;
-    constructor(cliToolId, answer, dialog) {
-        super(`Refused to send "${answer}" to ${cliToolId}: its ${dialog.kind} dialog takes `
-            + `'${dialog.answerMode}' input, not a typed number (${exports.ANSWER_MODE_KEYS_REASON}). `
-            + 'The digit would be swallowed and the Enter after it would confirm whatever is '
-            + 'highlighted. Nothing was sent.');
-        this.name = 'PromptAnswerRejectedError';
-        this.reason = exports.ANSWER_MODE_KEYS_REASON;
-        this.dialogKind = dialog.kind;
-        this.answerMode = dialog.answerMode;
-    }
-}
-exports.PromptAnswerRejectedError = PromptAnswerRejectedError;
-/**
- * The reason code a caller gets back when free text meets a prompt whose
- * text-bearing options are all menu rows (Issue #2573).
- *
- * The code `/prompt-response` already answers "this answer cannot be mapped onto
- * a choice, and nothing was sent" with (#1681, #2522), so `respond` reports it
- * without a new branch.
- */
-exports.FREE_TEXT_AT_MENU_ROW_REASON = 'unresolvable_answer';
-/**
- * The sentence for each refusal, built from a tool id and option numbers only.
- *
- * Fixed text, a tool id and option numbers, never the answer (SEC-003, as in
- * `prompt-answer-semantic`): the answer is whatever the operator typed, and
- * `/prompt-response` returns this message to the client verbatim.
- *
- * The two sentences sit side by side on purpose. They differ in the one thing
- * the operator has to act on — what to do next — and that is only comparable
- * when both are readable at once.
- */
-function freeTextRefusalMessage(cliToolId, optionNumbers, detail) {
-    const numbers = optionNumbers.join(', ');
-    if (detail === undefined) {
-        return `Refused to type free text at ${cliToolId}'s prompt: option ${numbers} `
-            + 'reads as taking your own words, but on this screen it is a menu row, not a text field. '
-            + 'The text would be ignored and the Enter after it would confirm whatever is highlighted. '
-            + 'Nothing was sent. Answer with the option number, then send the instructions as a message.';
-    }
-    return `Refused to type free text at ${cliToolId}'s prompt: option ${numbers} is the text field `
-        + `on this screen, but the cursor is on option ${detail.cursorOptionNumber}. The text would be `
-        + `ignored and the Enter after it would confirm option ${detail.cursorOptionNumber}. Nothing `
-        + 'was sent. Move the cursor onto the text field in the terminal and send the text again — '
-        + 'sending its option number does not move the cursor, it selects nothing.';
-}
-/**
- * Free text refused BEFORE any key reached the pane (Issue #2573, #2584).
- *
- * A sibling of {@link PromptAnswerRejectedError}, not a use of it, because the
- * two cite different evidence. That one cites the dialog the tool's own rules
- * vouched for (`dialogKind` / `answerMode`), and no such verdict can decide this
- * case: Command Code has had rules since Issue #2574, and the permission dialog
- * this guard is first about is vouched `numbered` — the verdict that lets a
- * DIGIT through — while the `AskUserQuestion` screen whose free text must keep
- * working is deliberately not recognised by those rules at all
- * (`tools/command-code/permission.ts`). `answerMode` says how a CHOICE is
- * pressed; it says nothing about which row is a text field, nor about which row
- * the cursor is on. So what this one cites is the rows.
- *
- * One class rather than two because `/prompt-response` is out of reach of both
- * Issues' scope and matches this type by `instanceof` to report the refusal at
- * all; {@link FreeTextRefusalKind} is what tells the two cases apart.
- */
-class FreeTextAnswerRejectedError extends Error {
-    /** Machine-readable code, always {@link FREE_TEXT_AT_MENU_ROW_REASON}. */
-    reason;
-    /**
-     * The text-bearing options this refusal is about: the menu rows for
-     * `menu_row`, the measured text field(s) for `cursor_elsewhere`.
-     */
-    optionNumbers;
-    /** Which measurement refused (Issue #2584). */
-    kind;
-    /** The option the Enter would have confirmed, or null for `menu_row`. */
-    cursorOptionNumber;
-    constructor(cliToolId, optionNumbers, detail) {
-        super(freeTextRefusalMessage(cliToolId, optionNumbers, detail));
-        this.name = 'FreeTextAnswerRejectedError';
-        this.reason = exports.FREE_TEXT_AT_MENU_ROW_REASON;
-        this.optionNumbers = optionNumbers;
-        this.kind = detail?.kind ?? 'menu_row';
-        this.cursorOptionNumber = detail?.cursorOptionNumber ?? null;
-    }
-}
-exports.FreeTextAnswerRejectedError = FreeTextAnswerRejectedError;
-/**
- * Free text refused because NO row on the screen takes typed text (Issue #2583).
- *
- * ## The hole #2573 left
- *
- * {@link FreeTextAnswerRejectedError} looks for rows that READ as taking the
- * operator's own words (`requiresTextInput`, i.e. `TEXT_INPUT_PATTERNS`) and
- * only judges the answer when it finds at least one. A permission dialog with
- * no such row was therefore never judged at all, and the text arm typed the
- * answer and pressed Enter. Measured on 2026-09-16 against develop `9f4b4e29`:
- *
- * | tool | dialog | rows | result |
- * |------|--------|------|--------|
- * | Claude Code 2.1.273 | Bash command | `1. Yes` / `2. Yes, and always allow access to …` / `3. Yes, and switch to auto mode` / `4. No` | `success: true`, the `mkdir` RAN |
- * | Antigravity 1.2.3 | Run this command? | `1. Yes, run command` / `2. Yes, and always allow …` / `3. Yes, … (Persist to settings.json)` / `4. No, cancel` | `success: true`, the `mkdir` RAN |
- *
- * Same screens, but with a path containing the word `custom`, `/custom/i`
- * flagged the quoting row and #2573's guard refused. So what was left decided
- * whether a refusal meaning "do not do this" approved instead: the SPELLING of
- * the command being approved.
- *
- * ## What the caller is told, and why the count rather than the rows
- *
- * There is no row to name here — that is the whole condition — so the message
- * cites how many options the screen has and points at the option number. It
- * never quotes the answer (SEC-003, as in `prompt-answer-semantic`): the answer
- * is whatever the operator typed and `/prompt-response` hands this message back
- * to the client verbatim.
- *
- * Shares {@link FREE_TEXT_AT_MENU_ROW_REASON} with its sibling deliberately:
- * the reason code is what `respond` and `/prompt-response` branch on, and both
- * cases are the same promise to the caller — the answer could not be mapped onto
- * a choice and NOTHING was sent.
- */
-class FreeTextAtChoiceOnlyPromptError extends Error {
-    /** Machine-readable code, always {@link FREE_TEXT_AT_MENU_ROW_REASON}. */
-    reason;
-    /** How many options the screen offers, none of which is a text field. */
-    optionCount;
-    constructor(cliToolId, optionCount) {
-        super(`Refused to type free text at ${cliToolId}'s prompt: none of its ${optionCount} options is a `
-            + 'text field on this screen, so the text would be ignored and the Enter after it would '
-            + 'confirm whatever is highlighted. Nothing was sent. Answer with the option number instead, '
-            + 'then send your instructions as a separate message.');
-        this.name = 'FreeTextAtChoiceOnlyPromptError';
-        this.reason = exports.FREE_TEXT_AT_MENU_ROW_REASON;
-        this.optionCount = optionCount;
-    }
-}
-exports.FreeTextAtChoiceOnlyPromptError = FreeTextAtChoiceOnlyPromptError;
 /**
  * The pane to judge the tool's own dialog rules against.
  *
@@ -300,7 +159,7 @@ async function assertAnswerModeAcceptsNumber(params) {
         return null;
     if (dialog.answerMode === TEXT_ANSWERABLE_ANSWER_MODE)
         return dialog;
-    throw new PromptAnswerRejectedError(params.cliToolId, params.answer, dialog);
+    throw new prompt_answer_errors_1.PromptAnswerRejectedError(params.cliToolId, params.answer, dialog);
 }
 /**
  * Resolve the effective SubmitMode from the dialog on screen, promptData, fallback, and default.
@@ -435,11 +294,11 @@ function assertFreeTextHasATextField(params) {
     // a screen that has at least one candidate, and this branch is the screen that
     // has none.
     if (textBearing.length === 0) {
-        throw new FreeTextAtChoiceOnlyPromptError(params.cliToolId, promptData.options.length);
+        throw new prompt_answer_errors_1.FreeTextAtChoiceOnlyPromptError(params.cliToolId, promptData.options.length);
     }
     if (textBearing.some(prompt_detect_multiple_choice_1.isTypedTextFieldOption))
         return;
-    throw new FreeTextAnswerRejectedError(params.cliToolId, textBearing.map((option) => option.number));
+    throw new prompt_answer_errors_1.FreeTextAnswerRejectedError(params.cliToolId, textBearing.map((option) => option.number));
 }
 /**
  * Refuse free text while the cursor is on another row (Issue #2584).
@@ -515,57 +374,8 @@ function assertFreeTextCursorIsOnTheField(params) {
         return;
     if ((0, prompt_detect_multiple_choice_1.isTypedTextFieldOption)(cursor))
         return;
-    throw new FreeTextAnswerRejectedError(params.cliToolId, fields.map((option) => option.number), { kind: 'cursor_elsewhere', cursorOptionNumber: cursor.number });
+    throw new prompt_answer_errors_1.FreeTextAnswerRejectedError(params.cliToolId, fields.map((option) => option.number), { kind: 'cursor_elsewhere', cursorOptionNumber: cursor.number });
 }
-/**
- * The reason code every Command Code multi-select refusal carries
- * (Issue #2755).
- *
- * Shares the shape of {@link ANSWER_MODE_KEYS_REASON} and
- * {@link FREE_TEXT_AT_MENU_ROW_REASON} — a machine-readable code the API and
- * `respond` branch on — and means one thing: **the question was not
- * committed.** What varies is how far the arm got, which
- * {@link MultiSelectAnswerRejectedError.stage} says.
- */
-exports.MULTI_SELECT_NOT_COMMITTED_REASON = 'multi_select_not_committed';
-/**
- * A Command Code checkbox answer that did not reach the agent (Issue #2755).
- *
- * The sibling of {@link PromptAnswerRejectedError} for the two-stage confirm.
- * Unlike that one it does NOT always promise an untouched pane — ticking boxes
- * is the first half of this answer and it may already have happened — so
- * {@link keysSent} says which of the two the caller is looking at. What it does
- * promise in every case is that the question was **not submitted**: the arm
- * stops before the confirm row whenever the screen it re-read is not the one it
- * was asked to answer.
- *
- * Fixed text, a tool id and option numbers only (SEC-003, as in
- * `prompt-answer-semantic`): `/prompt-response` returns this message verbatim.
- */
-class MultiSelectAnswerRejectedError extends Error {
-    /** Machine-readable code, always {@link MULTI_SELECT_NOT_COMMITTED_REASON}. */
-    reason;
-    stage;
-    /** Whether any key reached the pane before the refusal. */
-    keysSent;
-    /** The set the caller asked for, ascending. */
-    wanted;
-    constructor(stage, keysSent, wanted) {
-        super(`The question was not submitted (${stage}). `
-            + (keysSent
-                ? 'Some boxes may have been ticked, but the confirm row was not pressed, so the '
-                    + 'question is still on screen exactly as the pane shows it. '
-                : 'No key was sent. ')
-            + `Requested selection: ${wanted.join(', ')}. Check the terminal and answer it there, or `
-            + 'retry once the screen has settled.');
-        this.name = 'MultiSelectAnswerRejectedError';
-        this.reason = exports.MULTI_SELECT_NOT_COMMITTED_REASON;
-        this.stage = stage;
-        this.keysSent = keysSent;
-        this.wanted = wanted;
-    }
-}
-exports.MultiSelectAnswerRejectedError = MultiSelectAnswerRejectedError;
 /**
  * Is this request a Command Code checkbox answer? (Issue #2755)
  *
@@ -665,10 +475,10 @@ async function recaptureAfterKeys(sessionName) {
  * @throws {MultiSelectAnswerRejectedError} whenever the question was not
  *   committed; `keysSent` says whether the pane was touched.
  */
-async function sendCommandCodeMultiSelectAnswer(sessionName, promptData, wanted, stillCurrent, touch) {
+async function sendCommandCodeMultiSelectAnswer(sessionName, promptData, wanted, stillCurrent, touch, assertOwned = () => { }) {
     const cursor = promptData.options.find((option) => option.isDefault === true);
     if (cursor === undefined) {
-        throw new MultiSelectAnswerRejectedError('cursor-unknown', false, wanted);
+        throw new prompt_answer_errors_1.MultiSelectAnswerRejectedError('cursor-unknown', false, wanted);
     }
     // 1. The symmetric difference, ascending, one digit per press. An empty one
     //    sends nothing at all — the set on screen is already the set asked for,
@@ -679,6 +489,7 @@ async function sendCommandCodeMultiSelectAnswer(sessionName, promptData, wanted,
         ...current.filter((n) => !wanted.includes(n)),
     ].sort((a, b) => a - b);
     if (toggles.length > 0) {
+        assertOwned(false);
         await sendSpecialKeysWhileCurrent(sessionName, toggles.map(String), stillCurrent, touch);
     }
     const keysSent = toggles.length > 0;
@@ -687,7 +498,7 @@ async function sendCommandCodeMultiSelectAnswer(sessionName, promptData, wanted,
     const afterToggle = await recaptureAfterKeys(sessionName);
     assertStillCurrent(stillCurrent, keysSent);
     if (afterToggle === null) {
-        throw new MultiSelectAnswerRejectedError('recapture-failed', keysSent, wanted);
+        throw new prompt_answer_errors_1.MultiSelectAnswerRejectedError('recapture-failed', keysSent, wanted);
     }
     const reading = (0, dialog_1.readCommandCodeQuestionDialog)(afterToggle);
     if (reading.kind !== 'prompt' ||
@@ -695,11 +506,11 @@ async function sendCommandCodeMultiSelectAnswer(sessionName, promptData, wanted,
         reading.prompt.promptData.multiSelect !== true ||
         reading.prompt.promptData.question !== promptData.question ||
         reading.prompt.promptData.options.length !== promptData.options.length) {
-        throw new MultiSelectAnswerRejectedError('screen-changed', keysSent, wanted);
+        throw new prompt_answer_errors_1.MultiSelectAnswerRejectedError('screen-changed', keysSent, wanted);
     }
     const verified = reading.prompt.promptData;
     if (!sameNumbers(tickedNumbers(verified), [...wanted])) {
-        throw new MultiSelectAnswerRejectedError('toggle-mismatch', keysSent, wanted);
+        throw new prompt_answer_errors_1.MultiSelectAnswerRejectedError('toggle-mismatch', keysSent, wanted);
     }
     // 3. Walk to the confirm row and open it. `Down` is the only movement key
     //    measured to be deterministic here: it steps one row at a time through
@@ -710,8 +521,10 @@ async function sendCommandCodeMultiSelectAnswer(sessionName, promptData, wanted,
     //    been built from a slightly older frame.
     const cursorNow = verified.options.find((option) => option.isDefault === true);
     if (cursorNow === undefined) {
-        throw new MultiSelectAnswerRejectedError('cursor-unknown', keysSent, wanted);
+        throw new prompt_answer_errors_1.MultiSelectAnswerRejectedError('cursor-unknown', keysSent, wanted);
     }
+    // Issue #3952 review P2: the input held since the toggles, across the re-read.
+    assertOwned(keysSent);
     await sendSpecialKeysWhileCurrent(sessionName, [...downKeys(verified.options.length - cursorNow.number + 1), 'Enter'], stillCurrent, touch);
     // 4. The second stage. `Submit` opens the Review page and the answer is sent
     //    from there; `Next` advances to the following question, which IS the
@@ -719,15 +532,16 @@ async function sendCommandCodeMultiSelectAnswer(sessionName, promptData, wanted,
     const afterConfirm = await recaptureAfterKeys(sessionName);
     assertStillCurrent(stillCurrent, true);
     if (afterConfirm === null) {
-        throw new MultiSelectAnswerRejectedError('recapture-failed', true, wanted);
+        throw new prompt_answer_errors_1.MultiSelectAnswerRejectedError('recapture-failed', true, wanted);
     }
     const review = (0, selection_shape_1.readCommandCodeReviewPage)(afterConfirm);
     if (review !== null) {
         // Reached with answers still missing — the `d` shape. Confirming it would
         // send `No answer` for questions nobody has been shown (Issue #2755 §7).
         if (review.hasUnansweredWarning) {
-            throw new MultiSelectAnswerRejectedError('review-unanswered', true, wanted);
+            throw new prompt_answer_errors_1.MultiSelectAnswerRejectedError('review-unanswered', true, wanted);
         }
+        assertOwned(true);
         await sendSpecialKeysWhileCurrent(sessionName, ['Enter'], stillCurrent, touch);
         return;
     }
@@ -736,26 +550,125 @@ async function sendCommandCodeMultiSelectAnswer(sessionName, promptData, wanted,
         next.prompt.promptData?.type === 'multiple_choice' &&
         next.prompt.promptData.question !== promptData.question;
     if (!advanced) {
-        throw new MultiSelectAnswerRejectedError('not-committed', true, wanted);
+        throw new prompt_answer_errors_1.MultiSelectAnswerRejectedError('not-committed', true, wanted);
     }
 }
+/** The prompt a frame shows, read as `/prompt-response` verifies one; null when none is answerable. */
+function readAnswerablePrompt(cliToolId, frame) {
+    const { promptCheck, refusal } = (0, auto_yes_dialog_gate_1.assessPromptAnswerability)(cliToolId, frame);
+    if (refusal || !promptCheck?.isPrompt)
+        return null;
+    return promptCheck.promptData ?? null;
+}
+/** A text as compared: runs of whitespace as one, and no cursor glyphs (`❯ 1. Yes` is `1. Yes`). */
+function comparable(text) {
+    return (text ?? '').replace(/[❯›▶]/g, ' ').replace(/\s+/g, ' ').trim();
+}
+function sameText(a, b) {
+    return comparable(a) === comparable(b);
+}
 /**
- * The caller's `stillCurrent` said no after one of the send's waits
- * (Issue #3706): the keys not yet sent were not sent. Keys already typed cannot
- * be taken back, so {@link keysSent} says whether the pane was touched; either
- * way the answer was NOT completed and must not be recorded as one.
+ * Whether two readings are the same prompt to answer: its kind, its wording,
+ * its options' labels and — when both readings have one — what it asks approval
+ * for. The cursor (`isDefault`, the `❯` in the approval block) is not compared:
+ * moving it does not make it another prompt.
  */
-class PromptAnswerAbortedError extends Error {
-    keysSent;
-    constructor(
-    /** Whether any key reached the pane before the stop. */
-    keysSent) {
-        super(`Prompt answer stopped by its caller (${keysSent ? 'some keys were sent' : 'no key was sent'})`);
-        this.keysSent = keysSent;
-        this.name = 'PromptAnswerAbortedError';
+function samePromptTarget(target, now) {
+    if (target.type !== now.type || !sameText(target.question, now.question))
+        return false;
+    if (target.approvalTarget !== undefined && now.approvalTarget !== undefined) {
+        if (!sameText(target.approvalTarget, now.approvalTarget))
+            return false;
+    }
+    if (target.type === 'multiple_choice' && now.type === 'multiple_choice') {
+        if (target.options.length !== now.options.length)
+            return false;
+        return target.options.every((option, i) => sameText(option.label, now.options[i].label));
     }
+    return true;
+}
+/**
+ * The re-check an answer makes once it owns the session's input after another
+ * writer (Issue #3952): the caller still acts (Auto-Yes's `stillCurrent`), and
+ * a fresh capture still shows the prompt the answer was decided for — the one
+ * read off the caller's frame, else the caller's `promptData`, else any
+ * answerable prompt. Returns that fresh reading, or null when it does not.
+ */
+async function answerTargetStillOnScreen(params) {
+    if (params.stillCurrent && !params.stillCurrent())
+        return null;
+    const now = readAnswerablePrompt(params.cliToolId, await (0, tmux_1.capturePane)(params.sessionName, GUARD_CAPTURE_LINES));
+    if (now === null)
+        return null;
+    const target = (params.frame !== undefined ? readAnswerablePrompt(params.cliToolId, params.frame) : null)
+        ?? params.promptData
+        ?? null;
+    return target === null || samePromptTarget(target, now) ? now : null;
+}
+/**
+ * The caller's last look before the first key (review P1-2, P1-b): asked right
+ * before it, whether or not anything was read again — a guard's capture or the
+ * lock's admission is an await the contract can change across.
+ */
+function stillAllowedNow(params) {
+    return params.stillAllowedAtSend === undefined || params.stillAllowedAtSend();
+}
+/**
+ * Run an answer's keys as the session's input writer (Issue #3952): a send in
+ * progress is waited out, and the prompt is read again after it. The keys are
+ * built from that fresh reading (review P1-1: the cursor may have moved), and
+ * the caller's `stillAllowedAtSend` is asked again right before the first key
+ * (review P1-2: the contract may have changed during the wait). Refused, the
+ * answer throws {@link PromptAnswerNotDeliveredError} with nothing typed.
+ */
+async function sendAsInputWriter(params, readMark, send) {
+    let reread = null;
+    const outcome = await (0, instance_input_lock_1.answerUnderInstanceInputLock)(params.sessionName, readMark, async () => {
+        reread = await answerTargetStillOnScreen(params);
+        return reread !== null;
+    }, async (ticket) => {
+        // Review P1-b: always, wait or no wait — see `stillAllowedNow`.
+        if (!stillAllowedNow(params))
+            return 'answer-withheld';
+        // Review P2: every key of the answer goes out only while its ticket is
+        // current; a session replaced part-way gets none of the rest.
+        let lost = false;
+        const owned = () => {
+            if (ticket.isCurrent())
+                return true;
+            lost = true;
+            return false;
+        };
+        const callerStillCurrent = params.stillCurrent;
+        const keys = {
+            stillCurrent: () => owned() && (callerStillCurrent === undefined || callerStillCurrent()),
+            assertOwned: (keysSent) => {
+                if (owned())
+                    return;
+                if (keysSent)
+                    throw new prompt_answer_errors_1.PromptAnswerInputLostError(params.sessionName);
+                throw new prompt_answer_errors_1.PromptAnswerNotDeliveredError('input-lock-lost', params.sessionName);
+            },
+        };
+        try {
+            return await send(reread, keys);
+        }
+        catch (error) {
+            // The joined `stillCurrent` said no because of the ticket, not the
+            // caller: say which, as `assertOwned` does.
+            if (lost && error instanceof prompt_answer_errors_1.PromptAnswerAbortedError) {
+                if (error.keysSent)
+                    throw new prompt_answer_errors_1.PromptAnswerInputLostError(params.sessionName);
+                throw new prompt_answer_errors_1.PromptAnswerNotDeliveredError('input-lock-lost', params.sessionName);
+            }
+            throw error;
+        }
+    });
+    if (!outcome.answered)
+        throw new prompt_answer_errors_1.PromptAnswerNotDeliveredError(outcome.reason, params.sessionName);
+    if (outcome.value !== undefined)
+        throw new prompt_answer_errors_1.PromptAnswerNotDeliveredError(outcome.value, params.sessionName);
 }
-exports.PromptAnswerAbortedError = PromptAnswerAbortedError;
 /**
  * What the tmux call that failed did (Issue #3880), when the error came from
  * the transport (`TmuxSendError`, by name: test doubles of `./tmux/tmux` need
@@ -803,12 +716,15 @@ function withKeysSent(error, touch) {
 /** Stop here when the caller's `stillCurrent` says no (Issue #3706). */
 function assertStillCurrent(stillCurrent, keysSent) {
     if (stillCurrent && !stillCurrent())
-        throw new PromptAnswerAbortedError(keysSent);
+        throw new prompt_answer_errors_1.PromptAnswerAbortedError(keysSent);
 }
 /**
  * `sendSpecialKeys`, asking `stillCurrent` between the keys when the caller
  * gave one (Issue #3706). Without it the call is exactly the old two-argument
- * one, so manual answers and every other caller send as before.
+ * one. Issue #3952 (review P2, fourth contract): every answer typed as the
+ * session's input writer gives one — its ticket's check, joined with Auto-Yes's
+ * generation when there is one — so a manual answer's keys stop too when the
+ * session is replaced between them.
  */
 async function sendSpecialKeysWhileCurrent(sessionName, keys, stillCurrent, touch) {
     if (!stillCurrent) {
@@ -841,7 +757,7 @@ async function sendSpecialKeysWhileCurrent(sessionName, keys, stillCurrent, touc
         // By name rather than `instanceof`: test doubles of `./tmux/tmux` need not
         // export the class.
         if (error instanceof Error && error.name === 'SpecialKeysAbortedError') {
-            throw new PromptAnswerAbortedError(true);
+            throw new prompt_answer_errors_1.PromptAnswerAbortedError(true);
         }
         if (touch && Math.max(delivered, keysDeliveredOf(error)) > 0)
             touch.touched = true;
@@ -872,6 +788,16 @@ function keysDeliveredOf(error) {
  * A failure after a key of the answer reached the pane carries `keysSent: true`
  * (Issue #3839), and a transport failure its `answerDelivery` (Issue #3880);
  * see {@link withKeysSent}.
+ *
+ * Issue #3952: every answer that sends an Enter — the cursor arms, the text arm
+ * with its Enter, the checkbox arm — types as the session's input writer
+ * (`instance-input-lock`), from its first key to its last, so a message send
+ * cannot type between the answer's text and its Enter, and an answer waits for
+ * a send in progress and is read again after it. An `answer_only` digit sends
+ * no Enter and is typed as before.
+ *
+ * @throws {PromptAnswerNotDeliveredError} when the answer waited for another
+ *   writer and was then not typed
  */
 async function sendPromptAnswer(params) {
     const touch = { touched: false };
@@ -885,6 +811,7 @@ async function sendPromptAnswer(params) {
 /** {@link sendPromptAnswer}, noting in `touch` each key that reached the pane. */
 async function sendPromptAnswerKeys(params, touch) {
     const { sessionName, answer, cliToolId, promptData, fallbackPromptType, fallbackDefaultOptionNumber, stillCurrent } = params;
+    const readMark = params.readMark ?? (0, instance_input_lock_1.instanceInputReadMark)();
     // Issue #2755: Command Code's checkbox question, before every guard below.
     // Its answer is a SET (`"1,3"`), which none of them can read — `/^\d+$/` is
     // how all three ask "is this a number?", so a set would be judged as free
@@ -894,7 +821,14 @@ async function sendPromptAnswerKeys(params, touch) {
     // a two-stage confirm, not a digit and an Enter.
     const multiSelect = readMultiSelectRequest(params);
     if (multiSelect !== null) {
-        await sendCommandCodeMultiSelectAnswer(sessionName, multiSelect.promptData, multiSelect.wanted, stillCurrent, touch);
+        await sendAsInputWriter(params, readMark, async (reread, keys) => {
+            // Review P1-1: the toggles come from the ticks on the screen they go
+            // to — read again after a wait — not from the reading the request saw.
+            const shown = reread === null ? multiSelect.promptData : reread;
+            if (shown.type !== 'multiple_choice' || shown.multiSelect !== true)
+                return 'target-changed';
+            await sendCommandCodeMultiSelectAnswer(sessionName, shown, multiSelect.wanted, keys.stillCurrent, touch, keys.assertOwned);
+        });
         (0, tmux_capture_cache_1.invalidateCache)(sessionName);
         return;
     }
@@ -935,39 +869,45 @@ async function sendPromptAnswerKeys(params, touch) {
         && /^\d+$/.test(answer);
     if (isCursorNavMultiChoice) {
         const targetNum = parseInt(answer, 10);
-        let defaultNum;
-        let mcOptions = null;
-        if (promptData?.type === 'multiple_choice') {
-            // Primary path: use fresh promptData
-            mcOptions = promptData.options;
-            const defaultOption = mcOptions.find(o => o.isDefault);
-            defaultNum = defaultOption?.number ?? 1;
-        }
-        else {
-            // Fallback path (Issue #287): promptData is undefined or type mismatch, use fallback fields
-            defaultNum = fallbackDefaultOptionNumber ?? 1;
-        }
-        const offset = targetNum - defaultNum;
-        // Detect multi-select (checkbox) prompts by checking for [ ] in option labels.
-        // Multi-select prompts require: Space to toggle checkbox -> navigate to "Next" -> Enter.
-        // Single-select prompts require: navigate to option -> Enter.
-        // Note: multi-select detection is only possible when promptData succeeded (mcOptions available).
-        const isMultiSelect = mcOptions !== null && (0, prompt_answer_semantic_1.hasCheckboxOptions)(mcOptions);
-        if (isMultiSelect && mcOptions !== null) {
-            // Multi-select: toggle checkbox, then navigate to "Next" and submit
-            const checkboxCount = mcOptions.filter(o => (0, prompt_answer_semantic_1.hasCheckboxOptions)([o])).length;
-            const keys = [
-                ...buildNavigationKeys(offset), // 1. Navigate to target option
-                'Space', // 2. Toggle checkbox
-            ];
-            // 3. Navigate to "Next" button (positioned right after all checkbox options)
-            const downToNext = checkboxCount - targetNum + 1;
-            keys.push(...buildNavigationKeys(downToNext));
-            // 4. Enter to submit
-            keys.push('Enter');
-            await sendSpecialKeysWhileCurrent(sessionName, keys, stillCurrent, touch);
-        }
-        else {
+        /**
+         * The keys for the answer on a screen read as `shown`. Issue #3952 review
+         * P1-1: called again with the prompt as read under the input lock after a
+         * wait, so the offset is from where the cursor IS — a cursor that moved
+         * while the answer waited would otherwise turn "2" into a bare Enter on 1.
+         */
+        const cursorKeys = (shown) => {
+            let defaultNum;
+            let mcOptions = null;
+            if (shown?.type === 'multiple_choice') {
+                // Primary path: use fresh promptData
+                mcOptions = shown.options;
+                const defaultOption = mcOptions.find(o => o.isDefault);
+                defaultNum = defaultOption?.number ?? 1;
+            }
+            else {
+                // Fallback path (Issue #287): promptData is undefined or type mismatch, use fallback fields
+                defaultNum = fallbackDefaultOptionNumber ?? 1;
+            }
+            const offset = targetNum - defaultNum;
+            // Detect multi-select (checkbox) prompts by checking for [ ] in option labels.
+            // Multi-select prompts require: Space to toggle checkbox -> navigate to "Next" -> Enter.
+            // Single-select prompts require: navigate to option -> Enter.
+            // Note: multi-select detection is only possible when promptData succeeded (mcOptions available).
+            const isMultiSelect = mcOptions !== null && (0, prompt_answer_semantic_1.hasCheckboxOptions)(mcOptions);
+            if (isMultiSelect && mcOptions !== null) {
+                // Multi-select: toggle checkbox, then navigate to "Next" and submit
+                const checkboxCount = mcOptions.filter(o => (0, prompt_answer_semantic_1.hasCheckboxOptions)([o])).length;
+                const keys = [
+                    ...buildNavigationKeys(offset), // 1. Navigate to target option
+                    'Space', // 2. Toggle checkbox
+                ];
+                // 3. Navigate to "Next" button (positioned right after all checkbox options)
+                const downToNext = checkboxCount - targetNum + 1;
+                keys.push(...buildNavigationKeys(downToNext));
+                // 4. Enter to submit
+                keys.push('Enter');
+                return keys;
+            }
             // Single-select: navigate and Enter to select
             const navigationKeys = buildNavigationKeys(offset);
             // [Issue #807] Claude Code v2.x AskUserQuestion picker: when selecting the
@@ -978,29 +918,65 @@ async function sendPromptAnswerKeys(params, touch) {
             // the Up/Down navigation already engages the cursor, so no extra nudge is
             // needed. Old-format numbered prompts (isAskUserQuestion unset) keep their
             // exact prior key sequence, so their response behavior is unchanged.
-            const isAskUserQuestionPicker = promptData?.type === 'multiple_choice'
-                && promptData.isAskUserQuestion === true;
-            const keys = (isAskUserQuestionPicker && offset === 0)
+            const isAskUserQuestionPicker = shown?.type === 'multiple_choice'
+                && shown.isAskUserQuestion === true;
+            return (isAskUserQuestionPicker && offset === 0)
                 ? ['Down', 'Up', 'Enter']
                 : [...navigationKeys, 'Enter'];
-            await sendSpecialKeysWhileCurrent(sessionName, keys, stillCurrent, touch);
-        }
+        };
+        await sendAsInputWriter(params, readMark, async (reread, writer) => {
+            // A re-read that is not a choice list says nothing about the cursor:
+            // the keys cannot be placed, so none are typed.
+            if (reread !== null && reread.type !== 'multiple_choice')
+                return 'target-changed';
+            const keys = cursorKeys(reread ?? promptData);
+            writer.assertOwned(false);
+            await sendSpecialKeysWhileCurrent(sessionName, keys, writer.stillCurrent, touch);
+        });
     }
     else {
-        // Standard CLI prompt: send text + Enter (y/n, Approve?, etc.)
-        await (0, tmux_1.sendKeys)(sessionName, answer, false);
-        // Issue #3839: the text is on the pane; a failed Enter after it says so.
-        if (answer !== '')
-            touch.touched = true;
         // Issue #616: Resolve submitMode and determine whether to suppress Enter
         const resolvedSubmitMode = resolveSubmitMode(params, dialog);
-        if (!shouldSuppressEnter(params, resolvedSubmitMode, dialog)) {
-            // Wait a moment for the input to be processed
-            await new Promise(resolve => setTimeout(resolve, cli_tool_timing_config_1.TUI_TEXT_INPUT_WAIT_MS));
-            // Issue #3706: the text is typed; the Enter that submits it is not.
-            assertStillCurrent(stillCurrent, true);
-            // Send Enter
-            await (0, tmux_1.sendKeys)(sessionName, '', true);
+        const typeText = async () => {
+            // Standard CLI prompt: send text + Enter (y/n, Approve?, etc.)
+            await (0, tmux_1.sendKeys)(sessionName, answer, false);
+            // Issue #3839: the text is on the pane; a failed Enter after it says so.
+            if (answer !== '')
+                touch.touched = true;
+        };
+        if (shouldSuppressEnter(params, resolvedSubmitMode, dialog)) {
+            // Issue #3952: one digit and no Enter — nothing a send could split, so
+            // not a writer of the session's input. Review P1-b: the caller's last
+            // look is still taken right before it (the guard above may have awaited
+            // a capture since the caller's own look).
+            if (!stillAllowedNow(params))
+                throw new prompt_answer_errors_1.PromptAnswerNotDeliveredError('answer-withheld', sessionName);
+            await typeText();
+        }
+        else {
+            // Issue #3952: text, wait and Enter as one writer, so no send's body can
+            // be typed in the wait and submitted by this Enter.
+            await sendAsInputWriter(params, readMark, async (reread, writer) => {
+                // Review P1-a: free text read again after a wait is judged on that
+                // reading — a field still there, and the cursor still on it (#2573 /
+                // #2584) — or the Enter after it confirms whatever row the cursor
+                // moved to. A refusal here types nothing, as the one before the wait.
+                if (reread !== null) {
+                    const onScreen = { ...params, promptData: reread };
+                    assertFreeTextHasATextField(onScreen);
+                    assertFreeTextCursorIsOnTheField(onScreen);
+                }
+                writer.assertOwned(false);
+                await typeText();
+                // Wait a moment for the input to be processed
+                await new Promise(resolve => setTimeout(resolve, cli_tool_timing_config_1.TUI_TEXT_INPUT_WAIT_MS));
+                // Issue #3706: the text is typed; the Enter that submits it is not.
+                assertStillCurrent(stillCurrent, true);
+                // Review P2: nor by a session that replaced this one in the wait.
+                writer.assertOwned(answer !== '');
+                // Send Enter
+                await (0, tmux_1.sendKeys)(sessionName, '', true);
+            });
         }
     }
     // Issue #405: Invalidate cache after sending prompt answer