commandmate 0.30.0 → 0.30.1

package/dist/server/src/lib/history/user-turn-recorder.js

@@ -148,8 +148,9 @@ function describe(target) {
  *   re-read of the log and a `/clear`.
  * @param content - The prompt, as the agent recorded it
  * @param timestampMs - When the agent says it was prompted, epoch ms
+ * @param options - See {@link RecordUserTurnOptions}; the defaults are #2196's
  */
-async function recordUserTurn(target, key, content, timestampMs) {
+async function recordUserTurn(target, key, content, timestampMs, options = {}) {
     const instanceId = target.instanceId ?? target.cliToolId;
     const normalized = normalizeUserTurnContent(content);
     if (key.length === 0 || normalized.length === 0) {
@@ -171,7 +172,7 @@ async function recordUserTurn(target, key, content, timestampMs) {
             };
         }
         const at = timestampMs > 0 ? timestampMs : Date.now();
-        const adopted = adoptExistingRow(chatDb, db, target, instanceId, key, normalized, at);
+        const adopted = adoptExistingRow(chatDb, db, target, instanceId, key, normalized, at, options);
         if (adopted)
             return adopted;
         const message = chatDb.createMessage(db, {
@@ -217,13 +218,17 @@ async function recordUserTurn(target, key, content, timestampMs) {
  *
  * @returns The claimed row, or null when nothing here belongs to this prompt
  */
-function adoptExistingRow(chatDb, db, target, instanceId, key, normalized, at) {
+function adoptExistingRow(chatDb, db, target, instanceId, key, normalized, at, options) {
+    // `Math.min` and not a replacement: {@link RecordUserTurnOptions} may widen
+    // the search backwards and may never narrow it, so a caller that supplies a
+    // bound *inside* the standard window changes nothing.
+    const fromMs = Math.min(at - exports.USER_TURN_ADOPTION_WINDOW_MS, options.adoptionFromMs ?? Number.POSITIVE_INFINITY);
     const candidates = chatDb
         .findUnkeyedUserMessages(db, {
         worktreeId: target.worktreeId,
         cliToolId: target.cliToolId,
         instanceId,
-        fromMs: at - exports.USER_TURN_ADOPTION_WINDOW_MS,
+        fromMs,
         toMs: at + exports.USER_TURN_ADOPTION_WINDOW_MS,
     })
         .filter((row) => normalizeUserTurnContent(row.content) === normalized)

package/dist/server/src/lib/hooks/agent-event-service.js

@@ -30,6 +30,7 @@ const path_validator_1 = require("../../lib/security/path-validator");
 const task_transition_service_1 = require("../../lib/tasks/task-transition-service");
 const gate_runner_1 = require("../../lib/verification/gate-runner");
 const agent_event_state_1 = require("../../lib/session/agent-event-state");
+const stop_history_capture_1 = require("../../lib/hooks/stop-history-capture");
 const logger_1 = require("../../lib/logger");
 const logger = (0, logger_1.createLogger)('lib/hooks/agent-event-service');
 /**
@@ -144,14 +145,32 @@ function safeRealpath(target) {
  * Apply a `stop` event to whatever the worktree is currently doing.
  *
  * The no-op is the load-bearing case. Sessions with no contract, and therefore
- * no task, are the overwhelming majority; for them this records the timestamp
- * and returns. Nothing about the existing completion path changes.
+ * no task, are the overwhelming majority; for them this records the timestamp,
+ * asks the transcript reader for the turn, and returns.
+ *
+ * ## Why the history read is here (Issue #2246)
+ *
+ * Because it must happen for *every* stop event and not only for the ones that
+ * govern a task — the majority case above is exactly the session whose replies
+ * this is trying not to lose — and because both callers of this function are
+ * stop receivers (`/api/hooks/agent-event` and the compatibility
+ * `/api/hooks/claude-done`). Putting it in one of the routes would have left the
+ * other one on the old behaviour.
+ *
+ * It runs **before** the task lookup so that the two early returns below cannot
+ * skip it, and after `recordAgentStopEvent` because the reader resolves its
+ * transcript through the session pointer that call refreshes.
+ *
+ * It is awaited rather than detached. The turn has already ended, so the cost is
+ * paid by nobody who is waiting for an answer, and a detached promise here would
+ * be one whose failures nothing observes.
  *
  * Never throws. A hook is fire-and-forget from a CLI's stop handler, and a
  * failure here must not become the agent's problem.
  */
 async function applyAgentStopEvent(db, worktree, cliToolId, instanceId) {
     (0, agent_event_state_1.recordAgentStopEvent)(worktree.id, cliToolId, instanceId);
+    const structuredHistoryCaptured = await (0, stop_history_capture_1.captureTranscriptTurnOnStop)(worktree, cliToolId, instanceId);
     let task;
     try {
         task = (0, tasks_db_1.getActiveTaskForInstance)(db, worktree.id, cliToolId, instanceId);
@@ -161,10 +180,20 @@ async function applyAgentStopEvent(db, worktree, cliToolId, instanceId) {
             worktreeId: worktree.id,
             error: error instanceof Error ? error.message : String(error),
         });
-        return { taskId: null, taskEventApplied: false, verificationRunId: null };
+        return {
+            taskId: null,
+            taskEventApplied: false,
+            verificationRunId: null,
+            structuredHistoryCaptured,
+        };
     }
     if (!task) {
-        return { taskId: null, taskEventApplied: false, verificationRunId: null };
+        return {
+            taskId: null,
+            taskEventApplied: false,
+            verificationRunId: null,
+            structuredHistoryCaptured,
+        };
     }
     let taskEventApplied = false;
     try {
@@ -178,7 +207,12 @@ async function applyAgentStopEvent(db, worktree, cliToolId, instanceId) {
         });
     }
     if (!task.contract.success.autoVerifyOnStop) {
-        return { taskId: task.id, taskEventApplied, verificationRunId: null };
+        return {
+            taskId: task.id,
+            taskEventApplied,
+            verificationRunId: null,
+            structuredHistoryCaptured,
+        };
     }
     let verificationRunId = null;
     try {
@@ -201,5 +235,5 @@ async function applyAgentStopEvent(db, worktree, cliToolId, instanceId) {
             });
         }
     }
-    return { taskId: task.id, taskEventApplied, verificationRunId };
+    return { taskId: task.id, taskEventApplied, verificationRunId, structuredHistoryCaptured };
 }

package/dist/server/src/lib/hooks/sources/antigravity/history.js

@@ -99,6 +99,7 @@ exports.antigravityBrainRoot = antigravityBrainRoot;
 exports.antigravityTranscriptPath = antigravityTranscriptPath;
 exports.acceptAntigravityTranscriptPath = acceptAntigravityTranscriptPath;
 exports.captureAntigravityTranscriptTurn = captureAntigravityTranscriptTurn;
+exports.resolveAntigravityTranscriptPath = resolveAntigravityTranscriptPath;
 const promises_1 = require("fs/promises");
 const os_1 = require("os");
 const path_1 = require("path");
@@ -256,15 +257,21 @@ function acceptAntigravityTranscriptPath(agyHome, candidate) {
     return resolved;
 }
 /**
- * Read the newest turn out of this instance's transcript and write it.
+ * Read this instance's unwritten turns out of its transcript and write them.
  *
- * **Only the newest turn**, and that is the same deliberate difference from
- * opencode's backfill that #2121 documents: every earlier turn already has a
- * `chat_messages` row the *scraper* wrote, and writing a Markdown row for it too
- * would put the same reply in History twice. One row per turn from the scraper,
- * one row per turn from here, so the swap is one-for-one.
+ * **Every turn in the window that is not already a row**, oldest first, which is
+ * the shape Issue #2246 gave all three pull readers and the reasoning for it is
+ * written out once on `../claude/history`'s
+ * {@link captureClaudeTranscriptTurn}. The short version: this reader only runs
+ * when the poller judges a turn finished, so a missed judgement used to lose a
+ * turn permanently — by the next judgement "the newest turn" had moved on.
  *
- * The return value is the poller's instruction. **True** means History holds
+ * #2121's one-row-per-turn argument is preserved by the **anchor**: the newest
+ * turn in the window this reader has already written is where the backfill
+ * starts, and a window with no anchor falls back to the newest turn alone.
+ *
+ * The return value is the poller's instruction, and it is about the **newest**
+ * turn whatever else was written on the way. **True** means History holds
  * this turn as the agent's own Markdown and the scrape must be dropped. **False**
  * means it does not, for any reason at all — no conversation pointer, no file, an
  * unreadable file, a window with no prompt in it — and the scrape must be saved.
@@ -313,8 +320,7 @@ async function captureAntigravityTranscriptTurn(target, capture = {}) {
             return false;
         const parsed = (0, transcript_1.parseAntigravityTranscript)(text);
         const built = (0, transcript_1.buildAntigravityTurns)(parsed.records, conversationId);
-        const turn = built.turns.at(-1);
-        if (!turn) {
+        if (built.turns.length === 0) {
             // No `USER_INPUT` in the window. Two ordinary causes, both fail-open: the
             // 4 MiB window cut mid-conversation, and `transcript_full.jsonl` can hold
             // less than the whole history — one of the 41 files in the corpus held a
@@ -341,8 +347,33 @@ async function captureAntigravityTranscriptTurn(target, capture = {}) {
                 preludeRecords: built.preludeRecords,
             });
         }
-        const userRow = await recordAntigravityUserTurn(target, turn);
-        return await writeAntigravityTurn(target, turn, (0, transcript_1.renderAntigravityTurn)(turn), resolveAssistantTimestampMs(turn, userRow), path);
+        const pending = await selectUnwrittenAntigravityTurns(target, built.turns);
+        if (pending.turns.length === 0) {
+            logger.debug('antigravity-transcript-turns-already-saved', {
+                worktreeId: target.worktreeId,
+                instanceId,
+                turnsInWindow: built.turns.length,
+            });
+            return true;
+        }
+        if (pending.turns.length > 1) {
+            logger.info('antigravity-transcript-backfilling-turns', {
+                worktreeId: target.worktreeId,
+                instanceId,
+                path,
+                pendingTurns: pending.turns.length,
+                turnsInWindow: built.turns.length,
+                anchored: pending.anchored,
+            });
+        }
+        let captured = false;
+        for (let index = 0; index < pending.turns.length; index += 1) {
+            const turn = pending.turns[index];
+            const previousStartedAt = index === 0 ? pending.previousStartedAt : pending.turns[index - 1].startedAt;
+            const userRow = await recordAntigravityUserTurn(target, turn, previousStartedAt);
+            captured = await writeAntigravityTurn(target, turn, (0, transcript_1.renderAntigravityTurn)(turn), resolveAssistantTimestampMs(turn, userRow), path);
+        }
+        return captured;
     }
     catch (error) {
         logger.error('antigravity-transcript-capture-failed', {
@@ -353,6 +384,59 @@ async function captureAntigravityTranscriptTurn(target, capture = {}) {
         return false;
     }
 }
+/**
+ * The transcript file this instance would be read from, or null (Issue #2246).
+ *
+ * The same two steps {@link captureAntigravityTranscriptTurn} opens with, asked
+ * without reading or writing anything; see `../claude/history`'s
+ * {@link resolveClaudeTranscriptPath} for what the Stop receiver does with it.
+ *
+ * Never throws.
+ */
+async function resolveAntigravityTranscriptPath(target, capture = {}) {
+    try {
+        const conversationId = await resolveAntigravityConversationId(target);
+        if (!conversationId)
+            return null;
+        return await locateAntigravityTranscript(capture.antigravityHome ?? resolveAntigravityHome(), conversationId);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The turns {@link captureAntigravityTranscriptTurn} still has to write (#2246).
+ *
+ * The same rule as `../claude/history`'s, on agy's own key: search backwards
+ * from the newest turn for one that is already a row, and take everything after
+ * it. Record order and never a timestamp — agy stamps `created_at` at
+ * second resolution, so a turn and its own reply routinely share an instant.
+ *
+ * @param turns - Every turn in the window, oldest first
+ */
+async function selectUnwrittenAntigravityTurns(target, turns) {
+    const [{ getDbInstance }, { findMessageByRequestId }] = await Promise.all([
+        Promise.resolve().then(() => __importStar(require('../../../../lib/db/db-instance'))),
+        Promise.resolve().then(() => __importStar(require('../../../../lib/db'))),
+    ]);
+    const db = getDbInstance();
+    for (let index = turns.length - 1; index >= 0; index -= 1) {
+        const turn = turns[index];
+        const requestId = (0, agent_transcript_1.antigravityTurnRequestId)(turn.conversationId, turn.stepIndex);
+        if (!findMessageByRequestId(db, target.worktreeId, requestId))
+            continue;
+        return {
+            turns: turns.slice(index + 1),
+            previousStartedAt: turn.startedAt,
+            anchored: true,
+        };
+    }
+    return {
+        turns: turns.slice(-1),
+        previousStartedAt: turns.length > 1 ? turns[turns.length - 2].startedAt : 0,
+        anchored: false,
+    };
+}
 /**
  * The transcript file for this conversation, or null.
  *
@@ -392,12 +476,16 @@ async function isReadableFile(path) {
  *
  * Never throws; `recordUserTurn` reports its failures in the return value.
  */
-async function recordAntigravityUserTurn(target, turn) {
+async function recordAntigravityUserTurn(target, turn, previousStartedAt = 0) {
     const skipped = { outcome: 'skipped', messageId: null, timestampMs: null };
     const prompt = turn.prompt;
     if (!prompt)
         return skipped;
-    const recorded = await (0, user_turn_recorder_1.recordUserTurn)(target, (0, agent_transcript_1.antigravityPromptRequestId)(turn.conversationId, prompt.stepIndex), prompt.text, prompt.timestampMs);
+    // Issue #2246: a turn read late is a turn whose `/send` row may be older than
+    // #2196's symmetric window reaches. The previous turn's start is the tightest
+    // honest bound, and it only ever widens the search.
+    const adoption = previousStartedAt > 0 ? { adoptionFromMs: previousStartedAt } : {};
+    const recorded = await (0, user_turn_recorder_1.recordUserTurn)(target, (0, agent_transcript_1.antigravityPromptRequestId)(turn.conversationId, prompt.stepIndex), prompt.text, prompt.timestampMs, adoption);
     if (recorded.outcome === 'failed') {
         logger.warn('antigravity-transcript-user-turn-failed', {
             worktreeId: target.worktreeId,

package/dist/server/src/lib/hooks/sources/claude/history.js

@@ -97,6 +97,7 @@ exports.claudeProjectsRoot = claudeProjectsRoot;
 exports.claudeTranscriptPath = claudeTranscriptPath;
 exports.acceptClaudeTranscriptHint = acceptClaudeTranscriptHint;
 exports.captureClaudeTranscriptTurn = captureClaudeTranscriptTurn;
+exports.resolveClaudeTranscriptPath = resolveClaudeTranscriptPath;
 exports.readClaudeTurnProgress = readClaudeTurnProgress;
 const promises_1 = require("fs/promises");
 const os_1 = require("os");
@@ -113,8 +114,9 @@ const logger = (0, logger_1.createLogger)('lib/hooks/sources/claude/history');
  * The file grows for the life of the session and a long one is tens of
  * megabytes — the largest on this machine on 2026-08-31 was 23 MB — so reading
  * it whole on every finished turn would be the most expensive thing the poller
- * does. Only the newest turn is ever written (see {@link captureClaudeTranscriptTurn}),
- * so only the newest turn has to be in the window.
+ * does. Only turns whose prompt record is inside the window are ever written
+ * (see {@link captureClaudeTranscriptTurn}), which is also what stops a turn the
+ * window opened halfway through being written from its middle.
  *
  * 4 MiB is roughly two orders of magnitude above the measured size of a single
  * turn and still small enough to read and parse in one tick. A turn that
@@ -216,15 +218,38 @@ function acceptClaudeTranscriptHint(homeDir, hint) {
     return resolved;
 }
 /**
- * Read the newest turn out of this instance's transcript and write it.
- *
- * **Only the newest turn**, and that is the deliberate difference from
- * opencode's backfill. Every earlier turn of this session already has a
- * `chat_messages` row that the *scraper* wrote, and writing a Markdown row for
- * it as well would put the same reply in History twice — once as prose and once
- * as the pane drew it. The scraper wrote exactly one row per turn and this
- * writes exactly one row per turn, so the swap is one-for-one and history is
- * neither duplicated nor rewritten.
+ * Read this instance's unwritten turns out of its transcript and write them.
+ *
+ * ## Why this is no longer "only the newest turn" (Issue #2246)
+ *
+ * #2121 wrote `built.turns.at(-1)` and nothing else, for a reason that was
+ * sound and is still half true: every earlier turn of this session already has
+ * a `chat_messages` row that the *scraper* wrote, and writing a Markdown row
+ * for it as well would put the same reply in History twice — once as prose and
+ * once as the pane drew it.
+ *
+ * What that argument did not cover is a turn **no writer recorded at all**. The
+ * trigger for this reader is the poller deciding a turn finished, so a poll that
+ * misjudges one completion (#2247's launch-banner heuristic, measured on
+ * 2026-09-02) does not merely delay the turn: by the time the next completion is
+ * judged, "the newest turn" is the *next* one, and the missed turn is nobody's.
+ * One dropped completion cost one turn permanently.
+ *
+ * So the unit of work is now "every turn in the window that is not already a
+ * row", written oldest first, and what preserves #2121's argument is the
+ * **anchor**: the newest turn in the window that this reader has already written
+ * is where the backfill starts. Turns after it are turns this reader was live
+ * for, so a scraper row for them exists only in the case the anchor cannot see
+ * — the reader answering false once for a transient reason (an empty body) and
+ * the scraper saving that turn's pane copy. That trade is deliberate and in the
+ * direction every Issue in this subsystem picks: two writers duplicate a reply,
+ * no writer loses one.
+ *
+ * When the window holds **no** anchor — a session the reader has never written
+ * for, and equally the first read after a `/clear` — this falls back to #2121's
+ * behaviour exactly: the newest turn, and nothing before it. That is the case
+ * where the earlier turns really are the scraper's, and there is no evidence in
+ * the window that says otherwise.
  *
  * The return value is the poller's instruction, so the two failure directions
  * are worth stating plainly. **True** means this path has recorded the turn and
@@ -234,10 +259,15 @@ function acceptClaudeTranscriptHint(homeDir, hint) {
  * false, which is the fail-open the acceptance criteria require: two writers
  * duplicate a reply, no writer loses one.
  *
+ * **It is the newest turn the answer is about**, backfill or not. A run that
+ * wrote three missed turns and then found the newest one still empty answers
+ * false, because the scrape the poller is holding is the pane's copy of *that*
+ * turn and dropping it would lose it.
+ *
  * Never throws.
  *
  * @param target - The instance whose turn just ended
- * @returns Whether History now holds this turn as the agent's own Markdown
+ * @returns Whether History now holds this instance's newest turn as Markdown
  */
 async function captureClaudeTranscriptTurn(target, capture) {
     const instanceId = target.instanceId ?? target.cliToolId;
@@ -262,8 +292,7 @@ async function captureClaudeTranscriptTurn(target, capture) {
             return false;
         const parsed = (0, transcript_1.parseClaudeTranscript)(text);
         const built = (0, transcript_1.buildClaudeTurns)(parsed.records, sessionId ?? '');
-        const turn = built.turns.at(-1);
-        if (!turn) {
+        if (built.turns.length === 0) {
             logger.info('claude-transcript-no-turn', {
                 worktreeId: target.worktreeId,
                 instanceId,
@@ -294,8 +323,43 @@ async function captureClaudeTranscriptTurn(target, capture) {
                 sidechainRecords: built.sidechainRecords,
             });
         }
-        const userRow = await recordClaudeUserTurn(target, turn);
-        return await writeClaudeTurn(target, (0, transcript_1.renderClaudeTurn)(turn), resolveAssistantTimestampMs(turn, userRow), path);
+        const pending = await selectUnwrittenClaudeTurns(target, built.turns);
+        if (pending.turns.length === 0) {
+            // The anchor is the newest turn in the window, so there is nothing to
+            // write and the newest turn is a row. True, for the reason
+            // {@link writeClaudeTurn} answers true to an already-saved turn: a second
+            // poll of one finished turn must not put the pane's copy on top of it.
+            logger.debug('claude-transcript-turns-already-saved', {
+                worktreeId: target.worktreeId,
+                instanceId,
+                turnsInWindow: built.turns.length,
+            });
+            return true;
+        }
+        if (pending.turns.length > 1) {
+            // The #2246 case, and the one worth a line in the log: more than one turn
+            // was unwritten, so a completion went unnoticed at the time.
+            logger.info('claude-transcript-backfilling-turns', {
+                worktreeId: target.worktreeId,
+                instanceId,
+                path,
+                pendingTurns: pending.turns.length,
+                turnsInWindow: built.turns.length,
+                anchored: pending.anchored,
+            });
+        }
+        // Oldest first, and the ordering is load-bearing twice over: History sorts
+        // by timestamp, and each turn's `/send` row is adopted against the previous
+        // turn's start, so a later turn must not get to claim a row an earlier one
+        // is about to ask for.
+        let captured = false;
+        for (let index = 0; index < pending.turns.length; index += 1) {
+            const turn = pending.turns[index];
+            const previousStartedAt = index === 0 ? pending.previousStartedAt : pending.turns[index - 1].startedAt;
+            const userRow = await recordClaudeUserTurn(target, turn, previousStartedAt);
+            captured = await writeClaudeTurn(target, (0, transcript_1.renderClaudeTurn)(turn), resolveAssistantTimestampMs(turn, userRow), path);
+        }
+        return captured;
     }
     catch (error) {
         logger.error('claude-transcript-capture-failed', {
@@ -306,6 +370,78 @@ async function captureClaudeTranscriptTurn(target, capture) {
         return false;
     }
 }
+/**
+ * The turns {@link captureClaudeTranscriptTurn} still has to write (Issue #2246).
+ *
+ * The search runs **backwards from the newest turn** and stops at the first one
+ * that is already a row. That turn is the *anchor*, and everything after it is
+ * pending — by construction, since the anchor is the newest written turn in the
+ * window.
+ *
+ * Two properties of that rule are worth stating because both were required:
+ *
+ *  - **Order, not time.** The comparison is the transcript's own record order
+ *    and never a timestamp. A turn's assistant row is dated one millisecond
+ *    after its user row (`resolveAssistantTimestampMs`), so the rows do not
+ *    carry an ordering that could be trusted for this.
+ *  - **The window bounds it.** `buildClaudeTurns` only opens a turn on a prompt
+ *    record, so a turn whose prompt fell outside
+ *    {@link CLAUDE_TRANSCRIPT_TAIL_BYTES} is not in `turns` at all and cannot be
+ *    backfilled from its middle. Its records are counted as
+ *    `orphanedAssistantRecords` instead, which is what the caller reports.
+ *
+ * A window with no anchor answers with the newest turn alone. See
+ * {@link captureClaudeTranscriptTurn} for why that is #2121's behaviour rather
+ * than a degraded one.
+ *
+ * @param turns - Every turn in the window, oldest first
+ */
+async function selectUnwrittenClaudeTurns(target, turns) {
+    const [{ getDbInstance }, { findMessageByRequestId }] = await Promise.all([
+        Promise.resolve().then(() => __importStar(require('../../../../lib/db/db-instance'))),
+        Promise.resolve().then(() => __importStar(require('../../../../lib/db'))),
+    ]);
+    const db = getDbInstance();
+    for (let index = turns.length - 1; index >= 0; index -= 1) {
+        const requestId = (0, agent_transcript_1.claudeTurnRequestId)(turns[index].promptUuid);
+        if (!findMessageByRequestId(db, target.worktreeId, requestId))
+            continue;
+        return {
+            turns: turns.slice(index + 1),
+            previousStartedAt: turns[index].startedAt,
+            anchored: true,
+        };
+    }
+    return {
+        turns: turns.slice(-1),
+        previousStartedAt: turns.length > 1 ? turns[turns.length - 2].startedAt : 0,
+        anchored: false,
+    };
+}
+/**
+ * The transcript file this instance would be read from, or null (Issue #2246).
+ *
+ * The same two steps {@link captureClaudeTranscriptTurn} opens with — resolve
+ * the session pointer, then check the filesystem — asked without reading or
+ * writing anything. The Stop receiver uses it to decide whether waiting half a
+ * second and asking again could possibly help: a session with no transcript to
+ * name will not have grown one by then, and a hook handler that sleeps for
+ * nothing is a hook handler that slows every turn of every tool.
+ *
+ * Never throws.
+ */
+async function resolveClaudeTranscriptPath(target, capture) {
+    try {
+        const homeDir = capture.homeDir ?? (0, os_1.homedir)();
+        if (typeof capture.worktreePath !== 'string' || capture.worktreePath.length === 0) {
+            return null;
+        }
+        return await locateClaudeTranscript(homeDir, capture, await resolveClaudeSessionId(target));
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * The key for a body read with no prompt record in the window.
  *
@@ -463,8 +599,14 @@ async function readClaudeTurnProgress(target, capture) {
  * agent really did reply, and #2121's behaviour for those turns is unchanged.
  *
  * Never throws; `recordUserTurn` reports its failures in the return value.
+ *
+ * @param previousStartedAt - When the turn before this one opened, or 0. Widens
+ *   `/send` adoption backwards to that instant (Issue #2246): a prompt the agent
+ *   queued for eleven minutes is still the row CommandMate wrote when it sent
+ *   the text, and #2196's symmetric two-minute window cannot reach it. Never
+ *   narrows — see {@link RecordUserTurnOptions}.
  */
-async function recordClaudeUserTurn(target, turn) {
+async function recordClaudeUserTurn(target, turn, previousStartedAt = 0) {
     const instanceId = target.instanceId ?? target.cliToolId;
     if (!turn.promptIsOperatorInput) {
         logger.debug('claude-transcript-user-turn-skipped', {
@@ -475,7 +617,8 @@ async function recordClaudeUserTurn(target, turn) {
         });
         return { outcome: 'skipped', messageId: null, timestampMs: null };
     }
-    const recorded = await (0, user_turn_recorder_1.recordUserTurn)(target, (0, agent_transcript_1.claudePromptRequestId)(turn.promptUuid), turn.promptText, turn.startedAt);
+    const adoption = previousStartedAt > 0 ? { adoptionFromMs: previousStartedAt } : {};
+    const recorded = await (0, user_turn_recorder_1.recordUserTurn)(target, (0, agent_transcript_1.claudePromptRequestId)(turn.promptUuid), turn.promptText, turn.startedAt, adoption);
     if (recorded.outcome === 'failed') {
         logger.warn('claude-transcript-user-turn-failed', {
             worktreeId: target.worktreeId,