commandmate 0.49.2 → 0.49.3

package/dist/server/src/lib/session/claude-session.js

@@ -815,7 +815,10 @@ async function sendMessageToClaude(worktreeId, message, instanceId) {
     // (`❯ ` can pass for Claude's prompt) — wait for that launch, or, holding the
     // input lock as the send service does, refuse with nothing typed (R1).
     await (0, session_launch_flight_1.settleSessionLaunch)(sessionName, 'Claude Code');
-    await (0, session_key_sender_1.sendMessageToSession)(sessionName, message, exports.CLAUDE_POST_PROMPT_DELAY, exports.CLAUDE_SEND_PROMPT_WAIT_TIMEOUT);
+    await (0, session_key_sender_1.sendMessageToSession)(sessionName, message, exports.CLAUDE_POST_PROMPT_DELAY, exports.CLAUDE_SEND_PROMPT_WAIT_TIMEOUT, 
+    // Issue #4048: the instance this send is for, so the first prompt's hook
+    // check reads that instance's entry — the same one the name resolves to.
+    { worktreeId, instanceId });
 }
 /**
  * Capture Claude session output

package/dist/server/src/lib/session/current-output-builder.js

@@ -237,7 +237,7 @@ function readAgentEvents(worktreeId, cliToolId, instanceId, resolvedInstanceId)
  * every value below is derived from the arguments, and nothing is assigned
  * outside this function.
  */
-function composePromptData({ worktreeId, cliToolId, instanceId, output, captureWindowLines, statusResult, startingSince, promptWaiting, askUserQuestion, eventSource, }) {
+function composePromptData({ worktreeId, cliToolId, respondInstanceId, output, captureWindowLines, statusResult, startingSince, promptWaiting, askUserQuestion, eventSource, }) {
     const scraperPromptWaiting = statusResult.hasActivePrompt;
     // Issue #1726: the agent's own account of what it asked. It contributes only
     // where some other layer has already established that a dialog is on screen —
@@ -338,9 +338,9 @@ function composePromptData({ worktreeId, cliToolId, instanceId, output, captureW
         : scraperPromptWaiting
             ? correctedPromptData ??
                 scraperPromptData ??
-                (structuredFacts ? (0, structured_prompt_1.buildStructuredPromptData)(worktreeId, structuredFacts, instanceId) : null)
+                (structuredFacts ? (0, structured_prompt_1.buildStructuredPromptData)(worktreeId, structuredFacts, respondInstanceId) : null)
             : structuredFacts
-                ? (0, structured_prompt_1.buildStructuredPromptData)(worktreeId, structuredFacts, instanceId)
+                ? (0, structured_prompt_1.buildStructuredPromptData)(worktreeId, structuredFacts, respondInstanceId)
                 : null;
     // Issue #2870: whether `/prompt-response` would answer the prompt published
     // above, read by the SAME function it re-verifies with. In #2868 `promptData`
@@ -813,7 +813,7 @@ async function buildPayload(db, worktreeId, cliToolId, instanceId) {
     const { structuredFacts, promptData, promptAnswerable } = composePromptData({
         worktreeId,
         cliToolId,
-        instanceId,
+        respondInstanceId: resolvedInstanceId,
         output,
         captureWindowLines,
         statusResult,
@@ -921,7 +921,9 @@ async function buildPayload(db, worktreeId, cliToolId, instanceId) {
             worktreeId,
             cliToolId,
             instanceId: resolvedInstanceId,
-            respondInstanceId: instanceId,
+            // Issue #4063: the instance the live payload's question names, so the
+            // row says the same `respond` whichever caller wrote it.
+            respondInstanceId: resolvedInstanceId,
             state: promptWaiting,
             facts: structuredFacts,
         });

package/dist/server/src/lib/session/instance-input-lock.js

@@ -61,6 +61,7 @@ exports.currentInstanceInputTicket = currentInstanceInputTicket;
 exports.withInstanceInputLock = withInstanceInputLock;
 exports.instanceInputReadMark = instanceInputReadMark;
 exports.instanceInputLaunchReadMark = instanceInputLaunchReadMark;
+exports.instanceInputGenerationMark = instanceInputGenerationMark;
 exports.answerUnderInstanceInputLock = answerUnderInstanceInputLock;
 exports.leaveCarriedPasteMark = leaveCarriedPasteMark;
 exports.getCarriedPasteMark = getCarriedPasteMark;
@@ -70,6 +71,7 @@ exports.invalidateInstanceInput = invalidateInstanceInput;
 exports.isInputBoundaryRefusal = isInputBoundaryRefusal;
 exports.observeInputStart = observeInputStart;
 exports.noteInputStart = noteInputStart;
+exports.noteInputTicket = noteInputTicket;
 exports.noteDispatchStart = noteDispatchStart;
 exports.noteDispatchFailed = noteDispatchFailed;
 exports.resetInstanceInputLocks = resetInstanceInputLocks;
@@ -364,6 +366,18 @@ function instanceInputReadMark() {
 function instanceInputLaunchReadMark() {
     return (generationSeq.exclusiveEvents ?? 0) + (generationSeq.sharedReleases ?? 0);
 }
+/**
+ * The generation counter as it stands now (Issue #4065): every ticket granted
+ * from here on carries a larger generation. A send request reads it once, at
+ * its outermost entry (the send route before it reads the body; the send
+ * service for the timer and relay), and a refusal it records before any lock
+ * was granted to it carries the value — so it is not taken over the record of
+ * a send granted after the request began. Process-wide, like the generations
+ * themselves; 0 before any grant.
+ */
+function instanceInputGenerationMark() {
+    return generationSeq.last;
+}
 function skipOfLockError(error) {
     const code = typeof error === 'object' && error !== null ? error.code : undefined;
     if (code === exports.INSTANCE_INPUT_LOCK_TIMEOUT_CODE)
@@ -584,12 +598,16 @@ const inputStartScope = (0, global_state_1.getOrInitGlobal)('__instanceInputStar
  *   {@link noteInputStart}, so a caller can read state as of the moment the
  *   body started going in (Issue #3957: the send route's open-turn reading). A
  *   throw is logged and does not fail the send.
+ * @param request - Issue #4065: told, synchronously and as it happens, the
+ *   generation of the body's input lock ({@link noteInputTicket}) and a
+ *   dispatch ({@link noteDispatchStart}) — so a send that throws afterwards
+ *   still leaves them with the caller.
  * @returns `fn`'s value, and the moment input started — null when nothing in
  *   `fn` noted one (a path that never types a body: opencode's HTTP delivery,
  *   or a send refused before its first key). Never set when `fn` throws.
  */
-async function observeInputStart(fn, onStart, boundary) {
-    const observer = { at: null, onStart, boundary, dispatchOpen: false };
+async function observeInputStart(fn, onStart, boundary, request) {
+    const observer = { at: null, onStart, boundary, dispatchOpen: false, request };
     const value = await inputStartScope.run(observer, fn);
     return { value, inputStartedAt: observer.at };
 }
@@ -623,6 +641,25 @@ function runBoundaryHook(observer, at, kind) {
         throw error instanceof InputBoundaryRefusedError ? error : new InputBoundaryRefusedError(error);
     }
 }
+/**
+ * Tell the request observing this context the generation its body's input
+ * lock was granted under (Issue #4065). Called by the shared sender right
+ * after its lock is granted or joined — never for a launch key, an answer, a
+ * trust dialog or copilot's `/model` and selection-list keys, whose tickets
+ * are not the body's. Synchronous, never throws; outside an
+ * {@link observeInputStart} context it does nothing.
+ */
+function noteInputTicket(ticket) {
+    const observer = inputStartScope.getStore();
+    if (observer?.request?.onTicket === undefined)
+        return;
+    try {
+        observer.request.onTicket(ticket.generation);
+    }
+    catch (error) {
+        logger.warn('input-ticket-observer-failed', { error: error instanceof Error ? error.message : String(error) });
+    }
+}
 /**
  * Note that a body is about to be DISPATCHED without being typed (Issue #3957):
  * opencode's HTTP send, which reports no input start. Runs the required
@@ -636,6 +673,14 @@ function noteDispatchStart(now = new Date()) {
         return;
     runBoundaryHook(observer, now, 'dispatch');
     observer.dispatchOpen = true;
+    // Issue #4065: after the required hook, so a refused dispatch — nothing went
+    // out — is not reported as one.
+    try {
+        observer.request?.onDispatch?.();
+    }
+    catch (error) {
+        logger.warn('dispatch-start-observer-failed', { error: error instanceof Error ? error.message : String(error) });
+    }
 }
 /**
  * Say how a dispatch noted by {@link noteDispatchStart} ended when it did not

package/dist/server/src/lib/session/prompt-submit-receipt.js

@@ -27,16 +27,19 @@
  * @module lib/session/prompt-submit-receipt
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.reportsPrompts = reportsPrompts;
 exports.notePromptSubmitSession = notePromptSubmitSession;
 exports.notePromptSubmitHook = notePromptSubmitHook;
 exports.getPromptSubmitTarget = getPromptSubmitTarget;
 exports.readPromptSubmitReceipt = readPromptSubmitReceipt;
 exports.noteSubmittedBody = noteSubmittedBody;
+exports.findSubmittedBody = findSubmittedBody;
 exports.matchesSubmittedBody = matchesSubmittedBody;
 exports.clearPromptSubmitReceipts = clearPromptSubmitReceipts;
 const crypto_1 = require("crypto");
 const auto_yes_state_1 = require("../../lib/auto-yes-state");
 const global_state_1 = require("../../lib/global-state");
+const send_attempt_state_1 = require("../../lib/session/send-attempt-state");
 /** How many sessions are tracked at once; the least recently started is forgotten first. */
 const MAX_TRACKED_SESSIONS = 1024;
 /**
@@ -49,13 +52,41 @@ const sessionByInstance = (0, global_state_1.getOrInitGlobal)('__promptSubmitSes
 function instanceKey(target) {
     return (0, auto_yes_state_1.buildCompositeKey)(target.worktreeId, target.cliToolId, target.instanceId);
 }
-/** The tools whose prompt hook is trusted as proof of a submit. */
+/**
+ * The tools whose prompt hook is trusted as proof of a submit — and, since
+ * Issue #4048, the only ones whose `lastSend` a found body may demote.
+ */
 function reportsPrompts(cliToolId) {
     // Claude only. codex's hooks run in a machine-wide daemon that can file a
     // turn under the wrong instance (#2874), and copilot's arrive out of order
     // (#1903); neither is evidence about one pane's composer.
     return cliToolId === 'claude';
 }
+/**
+ * The entry a send looks at (Issue #4048). By name alone, the name's entry. With
+ * an explicit target, the same entry only when the target's instance currently
+ * maps to this very name and the entry is that instance's — a target and a name
+ * that disagree are no entry at all, so nothing about another instance (or a
+ * generation the instance no longer runs under this name) is taken as proof.
+ * Looking never registers or resets anything.
+ */
+function entryFor(sessionName, cliToolId, expected) {
+    const entry = sessions.get(sessionName);
+    if (entry === undefined || expected === undefined)
+        return entry;
+    let key;
+    try {
+        key = instanceKey({ worktreeId: expected.worktreeId, cliToolId, instanceId: expected.instanceId });
+    }
+    catch {
+        return undefined;
+    }
+    if (sessionByInstance.get(key) !== sessionName)
+        return undefined;
+    if (instanceKey(entry.target) !== key)
+        return undefined;
+    return entry;
+}
 /**
  * A session's generation began here (`beginAgentSession`). Forgets what was
  * known about the previous process in the same pane name.
@@ -88,25 +119,49 @@ function notePromptSubmitHook(target, event, at) {
     if (entry === undefined)
         return;
     entry.lastEventAt = at;
-    if (event === 'user_prompt_submit')
+    if (event === 'user_prompt_submit') {
         entry.lastPromptAt = at;
+        // Issue #4048: the agent took a prompt, so a body the screen alone called
+        // submitted is no longer one to look for — the late report was that body's,
+        // or a later send went through after it. Either way no later send may find
+        // it and demote a record (review: X restored after Y's success).
+        entry.submittedBody = null;
+    }
 }
-/** The instance a session this server started runs, or null. */
-function getPromptSubmitTarget(sessionName) {
-    return sessions.get(sessionName)?.target ?? null;
+/**
+ * The instance a session this server started runs, or null. With `expected`
+ * (Issue #4048), null unless the explicit target names the same entry.
+ */
+function getPromptSubmitTarget(sessionName, expected) {
+    if (expected === undefined)
+        return sessions.get(sessionName)?.target ?? null;
+    return entryFor(sessionName, expected.cliToolId, expected)?.target ?? null;
 }
 /**
  * Whether the screen's B/F verdict for a send whose first Enter went in at
  * `enteredAt` needs the agent's own report (Issue #4035).
+ *
+ * `expected` (Issue #4048) is the instance the send was made for; a name that
+ * does not resolve to that instance's entry answers `not-required` (never
+ * `received`), exactly as a session this server did not start.
+ *
+ * Known limit, kept as it is (Issue #4048 item 3): the question is asked on
+ * every read, and a session whose first hook (`SessionStart`) has not arrived
+ * by the read-back is answered `not-required` — the screen's B/F verdict then
+ * stands and the send returns at once, before a hook that is only late could
+ * turn it into `awaited`. Pinned by `prompt-submit-receipt-4048.test.ts`.
  */
-function readPromptSubmitReceipt(sessionName, cliToolId, enteredAt) {
+function readPromptSubmitReceipt(sessionName, cliToolId, enteredAt, expected) {
     if (!reportsPrompts(cliToolId))
         return 'not-required';
-    const entry = sessions.get(sessionName);
+    const entry = entryFor(sessionName, cliToolId, expected);
     if (entry === undefined || entry.target.cliToolId !== cliToolId)
         return 'not-required';
     if (entry.lastPromptAt !== null && entry.lastPromptAt >= enteredAt)
         return 'received';
+    // Issue #4048 item 3 (known limit): no hook yet from this process — the
+    // screen decides, and a `SessionStart` that arrives after this read is not
+    // waited for.
     if (entry.lastEventAt === null || entry.lastEventAt < entry.startedAt)
         return 'not-required';
     if (entry.lastPromptAt !== null && entry.lastPromptAt >= entry.startedAt)
@@ -122,31 +177,45 @@ function digest(text) {
 /**
  * The sender reported this body submitted on this session from the screen
  * alone — not for one the agent's hook reported, which did leave.
+ *
+ * `expected` (Issue #4048): with an explicit target, nothing is noted unless it
+ * names the same entry as the session name.
  */
-function noteSubmittedBody(sessionName, message) {
-    const entry = sessions.get(sessionName);
+function noteSubmittedBody(sessionName, message, expected) {
+    const entry = expected === undefined ? sessions.get(sessionName) : entryFor(sessionName, expected.cliToolId, expected);
     if (entry === undefined)
         return;
     const body = compact(message);
     entry.submittedBody = {
         full: digest(body),
         prefix: body.length >= BODY_PREFIX_CHARS ? digest(body.slice(0, BODY_PREFIX_CHARS)) : null,
+        messageDigest: (0, send_attempt_state_1.sendMessageDigest)(message),
     };
 }
 /**
- * Whether a composer read is the body last reported submitted on this session:
- * the whole of it, or — for a read long enough — its beginning.
+ * The body last reported submitted on this session, when a composer read is it
+ * — the whole of it, or (for a read long enough) its beginning — or null.
+ * `messageDigest` is the attempt's digest, for demoting only that attempt's
+ * record (Issue #4048).
  */
-function matchesSubmittedBody(sessionName, composerText) {
-    const body = sessions.get(sessionName)?.submittedBody;
+function findSubmittedBody(sessionName, composerText, expected) {
+    const entry = expected === undefined ? sessions.get(sessionName) : entryFor(sessionName, expected.cliToolId, expected);
+    const body = entry?.submittedBody;
     if (body === null || body === undefined)
-        return false;
+        return null;
     const read = compact(composerText);
     if (read === '')
-        return false;
-    if (digest(read) === body.full)
-        return true;
-    return body.prefix !== null && read.length >= BODY_PREFIX_CHARS && digest(read.slice(0, BODY_PREFIX_CHARS)) === body.prefix;
+        return null;
+    const matched = digest(read) === body.full ||
+        (body.prefix !== null && read.length >= BODY_PREFIX_CHARS && digest(read.slice(0, BODY_PREFIX_CHARS)) === body.prefix);
+    return matched ? { messageDigest: body.messageDigest } : null;
+}
+/**
+ * Whether a composer read is the body last reported submitted on this session:
+ * the whole of it, or — for a read long enough — its beginning.
+ */
+function matchesSubmittedBody(sessionName, composerText) {
+    return findSubmittedBody(sessionName, composerText) !== null;
 }
 /** Forget every session (tests). */
 function clearPromptSubmitReceipts() {

package/dist/server/src/lib/session/prompt-waiting-guard.js

@@ -24,6 +24,7 @@ exports.PROMPT_WAITING_CODE = void 0;
 exports.isPromptWaiting = isPromptWaiting;
 exports.promptWaitingMessage = promptWaitingMessage;
 const manager_1 = require("../../lib/cli-tools/manager");
+const respond_target_1 = require("../../lib/session/respond-target");
 const cli_session_1 = require("../../lib/session/cli-session");
 const status_detector_1 = require("../../lib/detection/status-detector");
 const status_capture_config_1 = require("../../config/status-capture-config");
@@ -133,11 +134,16 @@ async function isPromptWaiting(worktreeId, cliToolId, instanceId, options) {
  * waiting. A request for the primary instance (no `instanceId`) gets the
  * sentence as before.
  *
+ * Issue #4049: a request that named only a tool other than the worktree
+ * default gets ` --agent <tool>` instead (the caller decides, through
+ * `respondAgentFor`), since a bare `respond` goes to the default tool.
+ *
  * @param blockedBy - Which layer refused; omitted callers get the plain message
  * @param instanceId - The instance the refused request named, if any
+ * @param agent - The tool to name when no instance was named (`respondAgentFor`)
  */
-function promptWaitingMessage(worktreeId, blockedBy, instanceId) {
-    const target = instanceId ? ` --instance ${instanceId}` : '';
+function promptWaitingMessage(worktreeId, blockedBy, instanceId, agent) {
+    const target = (0, respond_target_1.respondTargetFlags)(instanceId, agent);
     const base = `${worktreeId} is waiting on a prompt. Sending now would type into the ` +
         `prompt's input line instead of reaching the agent, and would leave that ` +
         `text in place for the next answer. Answer the prompt first: ` +

package/dist/server/src/lib/session/respond-target.js

@@ -0,0 +1,82 @@
+"use strict";
+/**
+ * Where the `respond` a server-side guidance sentence names has to go
+ * (Issue #4049).
+ *
+ * #4031 gave the PROMPT_WAITING refusal and the structured-dialog question a
+ * ` --instance <id>` when the request named an instance. A request that named
+ * only a tool (`send … --agent codex`) still got a bare `commandmate respond
+ * <id> <answer>`, and the CLI resolves a bare `respond` to the worktree's
+ * default tool — so the answer could reach a different agent than the one that
+ * is waiting.
+ *
+ * Type-only imports and string building, like `structured-prompt`, so the
+ * client bundle that reads that module can read this one too.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.respondTargetFlags = respondTargetFlags;
+exports.respondAgentFor = respondAgentFor;
+exports.commandCodePlanReviewSendMessage = commandCodePlanReviewSendMessage;
+/**
+ * The flags that aim a `respond` (or `send`) at the waiting session, by the
+ * CLI's own order (`targetFlags` in `src/cli/utils/follow-up-command.ts`): an
+ * instance first, else a tool, else nothing — the sentence as it was before.
+ *
+ * @param instanceId - The instance the request named, if any
+ * @param agent - The tool to name when no instance was named (see {@link respondAgentFor})
+ */
+function respondTargetFlags(instanceId, agent) {
+    if (instanceId)
+        return ` --instance ${instanceId}`;
+    if (agent)
+        return ` --agent ${agent}`;
+    return '';
+}
+/**
+ * The tool a guidance `respond` must name, or undefined when a bare one already
+ * reaches the waiting session.
+ *
+ * Only a request that named a tool explicitly and no instance gets one, and
+ * only when that tool is not what an unqualified request resolves to (the
+ * worktree default): `--agent claude` on a claude worktree, and a request that
+ * named nothing, keep the sentence they had (#4031's "primary and default are
+ * unchanged").
+ *
+ * @param requestedCliTool - The tool the request named explicitly, if any
+ * @param instanceId - The instance the request named, if any
+ * @param unqualifiedCliTool - The tool a request naming nothing resolves to
+ */
+function respondAgentFor(requestedCliTool, instanceId, unqualifiedCliTool) {
+    if (instanceId || !requestedCliTool)
+        return undefined;
+    return requestedCliTool === unqualifiedCliTool ? undefined : requestedCliTool;
+}
+/**
+ * Why `send` stops at the plan review overlay (Issue #3125).
+ *
+ * The overlay replaces the composer until a human decides, so waiting for the
+ * composer only ran out the clock (`prompt not ready` after the full timeout).
+ * Its comments, Submit review, approval and cancel go through `respond`.
+ *
+ * Issue #4049: a function, not a constant. The constant named a
+ * `<worktree-id>` placeholder and no instance, so on `command-code-2` the
+ * `respond` it showed went to the primary instance. The primary instance
+ * (no id, or the tool's own id — #868) gets no `--instance`.
+ *
+ * Issue #4063: and the tool, by {@link respondTargetFlags}' rule, when the
+ * request named Command Code on a worktree whose default is another tool
+ * ({@link respondAgentFor}). `CommandCodeTool.sendMessage` does not know the
+ * request, so the routes (send, terminal) rebuild the sentence with the `agent`
+ * they resolved; the tool's own throw leaves it out. Kept here, with no import
+ * beyond types, so those routes do not load the tool module.
+ *
+ * @param worktreeId - The worktree whose session is showing the review
+ * @param instanceId - The instance the send was for, if any
+ * @param agent - The tool the `respond` must name when no instance is (see `respondAgentFor`)
+ */
+function commandCodePlanReviewSendMessage(worktreeId, instanceId, agent) {
+    const target = respondTargetFlags(instanceId && instanceId !== 'command-code' ? instanceId : undefined, agent);
+    return ('Command Code is showing a plan review (REVIEW), which takes review comments, not messages. ' +
+        `Comment with \`commandmate respond ${worktreeId} "<text>"${target}\`, then \`--plan-review submit\` (ctrl+r), ` +
+        '`--plan-review approve` (ctrl+a) or `--plan-review cancel` (esc).');
+}

package/dist/server/src/lib/session/send-attempt-state.js

@@ -22,11 +22,46 @@
  * Recording must never change a send's outcome: {@link recordSendAttempt}
  * swallows its own failures.
  *
+ * Issue #4065: which attempt is "the last" is decided by the input lock's
+ * grant order, not by which attempt finished last. Three kinds of record:
+ *
+ * - **granted** — the attempt held the body's input lock (`inputGeneration`,
+ *   the ticket's generation g). Includes one refused after the grant before
+ *   any key (g does not mean "typed"). Kept when g ≥ the instance's highest
+ *   granted generation so far (maxG), dropped when g < maxG: a send granted
+ *   later has already said how it went.
+ * - **refused** — `not-sent` before any lock was granted to it
+ *   (`observedGeneration`, the generation counter o read once at the request's
+ *   outermost entry). Kept when maxG ≤ o, dropped when maxG > o: a send granted
+ *   after this request began has already said how it went. o is only ever
+ *   compared with maxG — never with another o, nor with another instance's
+ *   grants; o = 0 is a value like any other.
+ * - **excluded / unknown** — neither (copilot's selection-list commands and
+ *   `/model`, opencode's HTTP delivery including its keyboard fallback after an
+ *   `unknown` dispatch, a tool path that reports nothing). Kept in the order
+ *   they finish, as before #4065, and they never move maxG.
+ *
+ * maxG is held beside the published record and only ever grows: a refused or
+ * excluded record, or a demotion ({@link markLastSendDiscarded}), never lowers
+ * it, so an older grant's late outcome cannot come back after them. Within one
+ * process the generation never goes back (a recreated session keeps counting);
+ * a restart forgets the records and maxG together. A worktree ID migration
+ * does not move them (the old ID's records are dropped). When more than
+ * {@link MAX_TRACKED_INSTANCES} instances are tracked the least recently sent
+ * to loses its record and its maxG together — a late outcome for it is then
+ * recorded as if it were the first.
+ *
+ * The published `lastSend` is still the three fields `at` / `state` /
+ * `reason`; neither g nor o is published, and `at` is not an order. It is the
+ * instance's last attempt by the rules above — not necessarily the reading
+ * request's own (that is `onAttempt` / `sendOutcome`).
+ *
  * @module lib/session/send-attempt-state
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sendMessageDigest = sendMessageDigest;
 exports.recordSendAttempt = recordSendAttempt;
+exports.forgetSendAttemptsForWorktree = forgetSendAttemptsForWorktree;
 exports.getLastSendAttempt = getLastSendAttempt;
 exports.markLastSendDiscarded = markLastSendDiscarded;
 exports.clearSendAttempts = clearSendAttempts;
@@ -42,6 +77,13 @@ const logger = (0, logger_1.createLogger)('session/send-attempt-state');
 /** How many instances are tracked at once; the least recently sent to is forgotten first. */
 const MAX_TRACKED_INSTANCES = 1024;
 const records = (0, global_state_1.getOrInitGlobal)('__sendAttemptRecords', () => new Map());
+/**
+ * Issue #4065: per instance, the highest input generation a granted record
+ * carried (maxG). Kept apart from the published record so that a refused or
+ * excluded record — or a demotion — that replaces it does not forget it.
+ * Evicted with the instance's record.
+ */
+const maxGenerations = (0, global_state_1.getOrInitGlobal)('__sendAttemptMaxGeneration', () => new Map());
 function keyOf(instance) {
     return JSON.stringify([instance.worktreeId, instance.cliToolId, instance.instanceId]);
 }
@@ -52,27 +94,90 @@ function sendMessageDigest(content) {
 /**
  * Record how a send attempt ended. Never throws: a record that cannot be made
  * leaves the send exactly as it was.
+ *
+ * Issue #4048: `typedContent` is the body the sender actually typed when it
+ * differs from `content`; `inputGeneration` is the input lock generation the
+ * attempt ran under.
+ *
+ * Issue #4065: `observedGeneration` is the generation counter the request read
+ * at its outermost entry (`instanceInputGenerationMark` in `instance-input-lock`), given for a
+ * `not-sent` refusal made before any lock was granted to it. Which record is
+ * kept is decided against the instance's maxG (see the module comment):
+ * granted g ≥ maxG is kept (and raises maxG), g < maxG dropped; a refusal is
+ * kept when maxG ≤ o; a record with neither is kept, in the order recorded.
+ * `inputGeneration` wins when both are given.
+ *
+ * @returns Whether the attempt became the instance's record. The request's own
+ *   outcome is the caller's to report whatever this says (`onAttempt`).
  */
 function recordSendAttempt(instance, attempt, now = Date.now()) {
     try {
         const key = keyOf(instance);
+        const maxGeneration = maxGenerations.get(key);
+        if (attempt.inputGeneration !== undefined) {
+            if (maxGeneration !== undefined && maxGeneration > attempt.inputGeneration) {
+                logger.info('send-attempt-record-skipped-stale-generation', {
+                    generation: attempt.inputGeneration,
+                    heldGeneration: maxGeneration,
+                });
+                return false;
+            }
+        }
+        else if (attempt.observedGeneration !== undefined) {
+            if (maxGeneration !== undefined && maxGeneration > attempt.observedGeneration) {
+                logger.info('send-attempt-record-skipped-refusal-before-newer-grant', {
+                    observedGeneration: attempt.observedGeneration,
+                    heldGeneration: maxGeneration,
+                });
+                return false;
+            }
+        }
+        const messageDigest = sendMessageDigest(attempt.content);
+        const typedDigest = attempt.typedContent === undefined ? undefined : sendMessageDigest(attempt.typedContent);
         // Re-inserted, so the map's order is least recently sent to first.
         records.delete(key);
         records.set(key, {
             at: Math.floor(now),
             state: attempt.state,
             reason: attempt.reason,
-            messageDigest: sendMessageDigest(attempt.content),
+            messageDigest,
+            ...(typedDigest !== undefined && typedDigest !== messageDigest ? { typedDigest } : {}),
+            ...(attempt.inputGeneration !== undefined ? { inputGeneration: attempt.inputGeneration } : {}),
         });
+        if (attempt.inputGeneration !== undefined) {
+            maxGenerations.set(key, Math.max(maxGeneration ?? attempt.inputGeneration, attempt.inputGeneration));
+        }
         while (records.size > MAX_TRACKED_INSTANCES) {
             const oldest = records.keys().next().value;
             if (oldest === undefined)
                 break;
             records.delete(oldest);
+            maxGenerations.delete(oldest);
         }
+        return true;
     }
     catch (error) {
         logger.warn('send-attempt-record-failed', { error: error instanceof Error ? error.message : String(error) });
+        return false;
+    }
+}
+/**
+ * Forget the records — and their maxG — of every instance of `worktreeId`
+ * (Issue #4065): a worktree ID migration drops them rather than moving them,
+ * so the new ID starts with no record. Never throws.
+ */
+function forgetSendAttemptsForWorktree(worktreeId) {
+    try {
+        for (const key of [...records.keys(), ...maxGenerations.keys()]) {
+            const parsed = JSON.parse(key);
+            if (Array.isArray(parsed) && parsed[0] === worktreeId) {
+                records.delete(key);
+                maxGenerations.delete(key);
+            }
+        }
+    }
+    catch (error) {
+        logger.warn('send-attempt-forget-failed', { error: error instanceof Error ? error.message : String(error) });
     }
 }
 /** The instance's last recorded attempt, or null when none is held. */
@@ -83,22 +188,35 @@ function getLastSendAttempt(instance) {
  * Turn the instance's last `sent` record `indeterminate` (Issue #4035): the
  * next send found that body still in the composer, so it never reached the
  * agent. Any other record is left as it is. Never throws.
+ *
+ * `messageDigest` (Issue #4048) is the digest of the body that was found (the
+ * body typed, so it is matched against the record's `typedDigest` too): a
+ * record of another attempt — a later send, or one whose body differs — is
+ * left as it is. Omitted, the last `sent` record is demoted as before.
  */
-function markLastSendDiscarded(instance, now = Date.now()) {
+function markLastSendDiscarded(instance, now = Date.now(), messageDigest) {
     try {
         const key = keyOf(instance);
         const record = records.get(key);
         if (record === undefined || record.state !== 'sent')
             return;
+        if (messageDigest !== undefined &&
+            record.messageDigest !== messageDigest &&
+            record.typedDigest !== messageDigest) {
+            return;
+        }
+        // Issue #4065: the spread keeps the record's generation, and maxG is not
+        // touched — a demotion is not a newer attempt.
         records.set(key, { ...record, at: Math.floor(now), state: 'indeterminate', reason: 'found-in-composer' });
     }
     catch (error) {
         logger.warn('send-attempt-record-failed', { error: error instanceof Error ? error.message : String(error) });
     }
 }
-/** Forget every record (tests). */
+/** Forget every record and every maxG (tests). */
 function clearSendAttempts() {
     records.clear();
+    maxGenerations.clear();
 }
 /**
  * The wordings of a failed tmux call that can carry the message body: `tmux.ts`
@@ -134,6 +252,15 @@ function carriesCode(error, code) {
  * (`Failed to send message to <tool>: …`), so they are matched anywhere in it.
  */
 function classifySendFailure(error) {
+    // #4040: opencode's keyboard fallback refused before any key (its cause says
+    // why — a code like `paste-not-started` included), but the server dispatch
+    // before it ended `unknown`: the message may already be there, so the attempt
+    // as a whole stays unknown, never "safe to resend". Read FIRST, before any
+    // code the cause carries.
+    if (error instanceof Error &&
+        /an earlier server dispatch may have delivered the message \(Issue #4040\)/.test(error.message)) {
+        return { state: 'indeterminate', reason: 'send-error' };
+    }
     if (typeof error === 'object' &&
         error !== null &&
         error.code === session_start_error_1.SESSION_STARTING_CODE) {