commandmate 0.30.0 → 0.30.1

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

@@ -94,6 +94,7 @@ exports.acceptCodexRolloutPath = acceptCodexRolloutPath;
 exports.isCodexRolloutFileFor = isCodexRolloutFileFor;
 exports.findCodexRolloutPath = findCodexRolloutPath;
 exports.captureCodexTranscriptTurn = captureCodexTranscriptTurn;
+exports.resolveCodexTranscriptPath = resolveCodexTranscriptPath;
 const promises_1 = require("fs/promises");
 const os_1 = require("os");
 const path_1 = require("path");
@@ -296,15 +297,21 @@ async function scanForRollout(dir, sessionId, depth) {
     return null;
 }
 /**
- * Read the newest turn out of this instance's rollout and write it.
+ * Read this instance's unwritten turns out of its rollout 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 session pointer, no file, an
  * unreadable file, a turn codex has not closed yet — and the scrape must be
@@ -350,8 +357,7 @@ async function captureCodexTranscriptTurn(target, capture = {}) {
             return false;
         const parsed = (0, transcript_1.parseCodexRollout)(text);
         const built = (0, transcript_1.buildCodexTurns)(parsed.records, sessionId);
-        const turn = built.turns.at(-1);
-        if (!turn) {
+        if (built.turns.length === 0) {
             logger.info('codex-transcript-no-turn', {
                 worktreeId: target.worktreeId,
                 instanceId,
@@ -375,8 +381,33 @@ async function captureCodexTranscriptTurn(target, capture = {}) {
                 duplicateStreamRecords: built.duplicateStreamRecords,
             });
         }
-        const lastUserRow = await recordCodexUserTurns(target, turn);
-        return await writeCodexTurn(target, turn, (0, transcript_1.renderCodexTurn)(turn), resolveAssistantTimestampMs(turn, lastUserRow), path);
+        const pending = await selectUnwrittenCodexTurns(target, built.turns);
+        if (pending.turns.length === 0) {
+            logger.debug('codex-transcript-turns-already-saved', {
+                worktreeId: target.worktreeId,
+                instanceId,
+                turnsInWindow: built.turns.length,
+            });
+            return true;
+        }
+        if (pending.turns.length > 1) {
+            logger.info('codex-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 lastUserRow = await recordCodexUserTurns(target, turn, previousStartedAt);
+            captured = await writeCodexTurn(target, turn, (0, transcript_1.renderCodexTurn)(turn), resolveAssistantTimestampMs(turn, lastUserRow), path);
+        }
+        return captured;
     }
     catch (error) {
         logger.error('codex-transcript-capture-failed', {
@@ -387,6 +418,58 @@ async function captureCodexTranscriptTurn(target, capture = {}) {
         return false;
     }
 }
+/**
+ * The rollout file this instance would be read from, or null (Issue #2246).
+ *
+ * The same two steps {@link captureCodexTranscriptTurn} 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 resolveCodexTranscriptPath(target, capture = {}) {
+    try {
+        const sessionId = await resolveCodexSessionId(target);
+        if (!sessionId)
+            return null;
+        return await locateCodexRollout(capture.codexHome ?? resolveCodexHome(), sessionId);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The turns {@link captureCodexTranscriptTurn} still has to write (Issue #2246).
+ *
+ * The same rule as `../claude/history`'s, on codex'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, and bounded by the window — a turn
+ * whose records fell outside {@link CODEX_TRANSCRIPT_TAIL_BYTES} is not in `turns`.
+ *
+ * @param turns - Every turn in the window, oldest first
+ */
+async function selectUnwrittenCodexTurns(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.codexTurnRequestId)(turns[index].turnId);
+        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 rollout file for this session, or null.
  *
@@ -435,11 +518,15 @@ async function isReadableFile(path) {
  *
  * @returns The last row written or found, for the timestamp
  */
-async function recordCodexUserTurns(target, turn) {
+async function recordCodexUserTurns(target, turn, previousStartedAt = 0) {
     const instanceId = target.instanceId ?? target.cliToolId;
     let last = { outcome: 'skipped', messageId: null, timestampMs: null };
+    // 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 } : {};
     for (const prompt of turn.prompts) {
-        const recorded = await (0, user_turn_recorder_1.recordUserTurn)(target, (0, agent_transcript_1.codexPromptRequestId)(prompt.itemId), prompt.text, prompt.timestampMs);
+        const recorded = await (0, user_turn_recorder_1.recordUserTurn)(target, (0, agent_transcript_1.codexPromptRequestId)(prompt.itemId), prompt.text, prompt.timestampMs, adoption);
         if (recorded.outcome === 'failed') {
             logger.warn('codex-transcript-user-turn-failed', {
                 worktreeId: target.worktreeId,

package/dist/server/src/lib/hooks/stop-history-capture.js

@@ -0,0 +1,161 @@
+"use strict";
+/**
+ * Reading the transcript when the agent says it stopped (Issue #2246).
+ *
+ * ## Why the poller was not enough
+ *
+ * `lib/polling/structured-history-gate` is asked to record a turn at exactly one
+ * moment: the poll on which the scraper decided the turn had finished and was
+ * about to save its own copy. That is the right moment — doing the handover at
+ * the point of the write is what makes it impossible for both writers to run —
+ * but it is the *only* moment, and the decision behind it is a string analysis
+ * of a terminal frame.
+ *
+ * When that analysis misses one completion the cost is not a delay. By the time
+ * the next completion is judged, the newest turn is the next one; before #2246
+ * the reader wrote only that, so the missed turn belonged to nobody and stayed
+ * missing. One misjudged frame, one turn gone (measured 2026-09-02: a reply the
+ * transcript held in full and History never showed).
+ *
+ * The agent itself knows the boundary exactly, and has been telling us: the
+ * `stop` hook. This module is that second trigger.
+ *
+ * ## What it does not do
+ *
+ * **It does not replace the poller's call.** A session with no hooks — or with
+ * hooks the operator never wired up — sends no `stop`, and for it the poller is
+ * still the only trigger there is. Two triggers for one turn cost nothing
+ * because the readers are idempotent and the gate serialises them per instance;
+ * one trigger that is sometimes absent costs a reply.
+ *
+ * **It does not decide anything about the turn.** The whole judgement stays in
+ * the gate and the readers, so the two entry points cannot drift.
+ *
+ * Never throws: a hook post is fire-and-forget from a CLI's stop handler, and a
+ * failure here must not become the agent's problem.
+ *
+ * @module lib/hooks/stop-history-capture
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STOP_TRANSCRIPT_RETRY_DELAY_MS = void 0;
+exports.captureTranscriptTurnOnStop = captureTranscriptTurnOnStop;
+const logger_1 = require("../../lib/logger");
+const logger = (0, logger_1.createLogger)('lib/hooks/stop-history-capture');
+/**
+ * How long to wait before asking a second time.
+ *
+ * The `stop` hook fires when the agent considers the turn over, and the last
+ * assistant record is appended to the transcript around — not necessarily
+ * before — that instant. A reader that arrives in the gap sees the prompt
+ * record and no body, answers false (correctly: an empty row would be a blank
+ * reply forever) and, without a retry, hands a turn the agent has definitely
+ * finished back to the scraper.
+ *
+ * Half a second is chosen against what the gap actually is — a file append that
+ * has already been issued — rather than against a timeout. One retry and not a
+ * loop, because the poller's own trigger is still behind this: if the file is
+ * still empty after the retry, the next poll is the right place to notice, and
+ * a hook handler that waits on a file is a hook handler that can hang a turn.
+ */
+exports.STOP_TRANSCRIPT_RETRY_DELAY_MS = 500;
+function sleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+/**
+ * Ask the pull-mode reader to record this instance's turn, now.
+ *
+ * The tool question is asked first and without doing any work
+ * (`isPullTranscriptHistory`), so a `stop` from gemini, copilot or opencode
+ * costs one map lookup and returns — in particular it never waits out the
+ * retry delay. opencode has a second writer too, but a *push* one: its
+ * subscription has already received the reply and there is nothing to pull.
+ *
+ * The import is dynamic so that the poller's module graph — which reaches every
+ * transcript reader and the whole opencode client — does not become a static
+ * dependency of the hook receiver.
+ *
+ * @param worktree - The worktree the event resolved to
+ * @param cliToolId - The tool that sent the event
+ * @param instanceId - The already-resolved instance id
+ * @returns Whether History now holds this instance's newest turn as Markdown
+ */
+async function captureTranscriptTurnOnStop(worktree, cliToolId, instanceId, options = {}) {
+    try {
+        const { captureStructuredHistoryTurn, hasStructuredHistoryTranscript, isPullTranscriptHistory } = await Promise.resolve().then(() => __importStar(require('../../lib/polling/structured-history-gate')));
+        if (!isPullTranscriptHistory(cliToolId))
+            return false;
+        // No `transcriptPathHint`: that value is a line the *pane* printed, and the
+        // hook receiver has not read the pane. A tool whose transcript can only be
+        // found that way has no session pointer either, and therefore sends no stop
+        // event this path could act on.
+        const capture = { worktreePath: worktree.path, transcriptPathHint: null };
+        if (await captureStructuredHistoryTurn(worktree.id, cliToolId, instanceId, capture)) {
+            return true;
+        }
+        const retryDelayMs = options.retryDelayMs ?? exports.STOP_TRANSCRIPT_RETRY_DELAY_MS;
+        if (retryDelayMs <= 0)
+            return false;
+        // The retry is for one failure and one only: the turn's last assistant
+        // record had not been appended yet. Every other reason the capture answers
+        // false — no session pointer, no transcript, the operator never wired hooks
+        // for this tool — is a reason waiting cannot fix, and this handler is on the
+        // agent's own stop path, so half a second spent for nothing is half a second
+        // added to every turn it is spent on.
+        if (!(await hasStructuredHistoryTranscript(worktree.id, cliToolId, instanceId, capture))) {
+            return false;
+        }
+        await sleep(retryDelayMs);
+        const captured = await captureStructuredHistoryTurn(worktree.id, cliToolId, instanceId, capture);
+        logger.debug('stop-history-capture-retried', {
+            worktreeId: worktree.id,
+            cliToolId,
+            instanceId,
+            captured,
+        });
+        return captured;
+    }
+    catch (error) {
+        logger.warn('stop-history-capture-failed', {
+            worktreeId: worktree.id,
+            cliToolId,
+            instanceId,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return false;
+    }
+}

package/dist/server/src/lib/polling/response-checker.js

@@ -434,10 +434,36 @@ function extractResponse(output, lastCapturedLine, cliToolId, captureWindowLines
         // CRITICAL FIX: Detect and skip Claude Code startup banner/screen
         if (cliToolId === 'claude') {
             const cleanResponse = (0, cli_patterns_1.stripAnsi)(response);
-            const hasBannerArt = /[╭╮╰╯│]/.test(cleanResponse) || /░{3,}/.test(cleanResponse) || /▓{3,}/.test(cleanResponse);
-            const hasVersionInfo = /Claude Code|claude\/|v\d+\.\d+/.test(cleanResponse);
+            // Issue #2247: `│` is what Claude Code draws markdown TABLES with -- the
+            // live frame in `tests/fixtures/claude-live-2247/turn-table.txt` is a
+            // two-row table and nothing else -- so it identified a reply, not a banner.
+            // The banner's own frame glyphs are the rounded corners and the block
+            // shading; those stay.
+            const hasBannerArt = /[╭╮╰╯]/.test(cleanResponse) || /░{3,}/.test(cleanResponse) || /▓{3,}/.test(cleanResponse);
+            // Issue #2247: the bare `v\d+\.\d+` alternative matched any version string a
+            // reply happens to mention. The frame that lost a turn on 2026-09-02 was
+            // "GitHub Release v0.30.0 を公開しました" (148 chars, well under the 2000
+            // below). What the banner actually prints is the tool's own name and
+            // version on one row -- `Claude Code v2.1.258` -- so that is what is
+            // matched now, plus the `claude/` form older banners used.
+            const hasVersionInfo = /Claude Code v\d+\.\d+|claude\//.test(cleanResponse);
             const hasStartupTips = /Tip:|for shortcuts|\?\s*for help/.test(cleanResponse);
             const hasProjectInit = /^\s*\/Users\/.*$/m.test(cleanResponse) && cleanResponse.split('\n').length < 30;
+            // Issue #2247: the anchors above are only evidence of a banner on a pane
+            // that has not had a single turn yet -- the same shape as the #1897 copilot
+            // fix below. Claude echoes every prompt into the transcript as `❯ <text>`,
+            // and the startup screen has none, so an echo anywhere in the transcript
+            // rules the banner out no matter what the reply quotes.
+            //
+            // The search is `findRecentUserPromptIndex`, deliberately: it is the same
+            // `/^[>❯]\s+\S/` this file already anchors extraction on, and it stops at
+            // `contentEnd`. That bound is load-bearing rather than incidental -- the
+            // footer's composer draws a DIM ghost suggestion (`❯ Try "write a test for
+            // <filepath>"`, see `boot-banner.txt`) whose stripped bytes are identical
+            // to a real echo (#1879), so a scan over the whole pane would read the
+            // startup screen as "already had a turn" and put the banner back in
+            // History.
+            const hasTurnEcho = findRecentUserPromptIndex(totalLines) >= 0;
             const userPromptMatch = cleanResponse.match(/^[>❯]\s+(\S.*)$/m);
             if (userPromptMatch) {
                 const userPromptIndex = cleanResponse.indexOf(userPromptMatch[0]);
@@ -452,7 +478,21 @@ function extractResponse(output, lastCapturedLine, cliToolId, captureWindowLines
                     return incompleteResult(totalLines);
                 }
             }
-            else if ((hasBannerArt || hasVersionInfo || hasStartupTips || hasProjectInit) && response.length < 2000) {
+            else if (!hasTurnEcho &&
+                (hasBannerArt || hasVersionInfo || hasStartupTips || hasProjectInit) &&
+                response.length < 2000) {
+                // Issue #2247: this branch used to swallow the turn in silence -- the
+                // poller kept ticking every 2s and `response-poller` logged nothing at
+                // all, so the only way to tell a lost turn from an idle session was to
+                // re-run `extractResponse` on a saved pane by hand. It is reached only
+                // before the first echo lands, so it cannot become a per-tick flood.
+                logger.info('Claude startup banner suppressed, response not saved', {
+                    responseLength: response.length,
+                    hasBannerArt,
+                    hasVersionInfo,
+                    hasStartupTips,
+                    hasProjectInit,
+                });
                 return incompleteResult(totalLines);
             }
         }

package/dist/server/src/lib/polling/structured-history-gate.js

@@ -64,8 +64,11 @@
  * @module lib/polling/structured-history-gate
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetStructuredHistoryCaptureQueue = resetStructuredHistoryCaptureQueue;
+exports.isPullTranscriptHistory = isPullTranscriptHistory;
 exports.isStructuredHistoryWriterLive = isStructuredHistoryWriterLive;
 exports.captureStructuredHistoryTurn = captureStructuredHistoryTurn;
+exports.hasStructuredHistoryTranscript = hasStructuredHistoryTranscript;
 const logger_1 = require("../../lib/logger");
 const subscription_1 = require("../../lib/hooks/sources/opencode/subscription");
 const history_1 = require("../../lib/hooks/sources/claude/history");
@@ -76,6 +79,68 @@ const tool_id_2 = require("../../lib/hooks/sources/codex/tool-id");
 const tool_id_3 = require("../../lib/hooks/sources/antigravity/tool-id");
 const registry_1 = require("../../lib/hooks/sources/registry");
 const logger = (0, logger_1.createLogger)('lib/polling/structured-history-gate');
+/**
+ * One in-flight capture per instance (Issue #2246).
+ *
+ * Until this Issue there was one caller — the poller's save path, whose ticks do
+ * not overlap — and the Stop hook receiver is now a second one, arriving at
+ * exactly the moment the poller is most likely to be inside the same turn. Two
+ * things follow, and it is worth separating them because #2246's own text runs
+ * them together.
+ *
+ * **The duplicate-row race it describes is not open today, and this is what
+ * keeps it shut.** The readers are idempotent through `findMessageByRequestId`,
+ * which is a check-then-write over a *non-unique* index — but the check and the
+ * write are adjacent and synchronous (`better-sqlite3` is), and the only `await`
+ * in that stretch is the dynamic import *before* the check. So there is no point
+ * for a second caller to interleave at, and two concurrent captures of one turn
+ * already end in one row. That is a property of two adjacent statements, which
+ * is exactly the kind of property a later refactor removes without noticing: an
+ * `await` inserted between them re-opens the window silently, and the row it
+ * costs is a duplicated reply nobody sees until an operator reports it.
+ *
+ * **What it saves today is the work.** Both triggers otherwise read, parse and
+ * render the same 4 MiB tail at the same time, and the second one throws all of
+ * it away.
+ *
+ * A queue rather than a shared result: the second caller runs the read again
+ * after the first finishes, because it may be asking about a newer turn and
+ * because the answer it needs is about the file as it is *now*. Re-running is
+ * cheap and, after the first call, finds the row and answers true.
+ *
+ * On `globalThis` for the reason every shared map in this subsystem is (#1736):
+ * under `next dev` the poller's bundle and the hook receiver's bundle would each
+ * get a private copy of a module-scoped map, and a lock only one of two bundles
+ * can see is not a lock.
+ */
+const captureQueue = (globalThis.__structuredHistoryCaptureQueue ??= new Map());
+/** Forget every instance's in-flight capture. Test seam. */
+function resetStructuredHistoryCaptureQueue() {
+    captureQueue.clear();
+}
+/** The queue key; the same triple `buildCompositeKey` spells everywhere else. */
+function captureKeyOf(worktreeId, cliToolId, instanceId) {
+    return `${worktreeId}\u0000${cliToolId}\u0000${instanceId}`;
+}
+/**
+ * Run `work` after whatever is already running for this instance.
+ *
+ * The stored promise is a settled-only shadow of the real one, so a caller that
+ * throws cannot reject the next caller's chain, and the entry is removed only by
+ * whoever put it there — a later call that has already replaced it must not have
+ * its own lock deleted underneath it.
+ */
+function serializePerInstance(key, work) {
+    const previous = captureQueue.get(key) ?? Promise.resolve();
+    const result = previous.then(work, work);
+    const settled = result.then(() => undefined, () => undefined);
+    captureQueue.set(key, settled);
+    void settled.then(() => {
+        if (captureQueue.get(key) === settled)
+            captureQueue.delete(key);
+    });
+    return result;
+}
 /**
  * Which reader answers for which tool.
  *
@@ -91,9 +156,18 @@ const logger = (0, logger_1.createLogger)('lib/polling/structured-history-gate')
  * {@link captureStructuredHistoryTurn} logs it and falls back to the scraper.
  */
 const PULL_TRANSCRIPT_READERS = {
-    [tool_id_1.CLAUDE_CLI_TOOL_ID]: (target, capture) => (0, history_1.captureClaudeTranscriptTurn)(target, capture),
-    [tool_id_2.CODEX_CLI_TOOL_ID]: (target, capture) => (0, history_2.captureCodexTranscriptTurn)(target, capture),
-    [tool_id_3.ANTIGRAVITY_CLI_TOOL_ID]: (target, capture) => (0, history_3.captureAntigravityTranscriptTurn)(target, capture),
+    [tool_id_1.CLAUDE_CLI_TOOL_ID]: {
+        capture: (target, capture) => (0, history_1.captureClaudeTranscriptTurn)(target, capture),
+        locate: (target, capture) => (0, history_1.resolveClaudeTranscriptPath)(target, capture),
+    },
+    [tool_id_2.CODEX_CLI_TOOL_ID]: {
+        capture: (target, capture) => (0, history_2.captureCodexTranscriptTurn)(target, capture),
+        locate: (target, capture) => (0, history_2.resolveCodexTranscriptPath)(target, capture),
+    },
+    [tool_id_3.ANTIGRAVITY_CLI_TOOL_ID]: {
+        capture: (target, capture) => (0, history_3.captureAntigravityTranscriptTurn)(target, capture),
+        locate: (target, capture) => (0, history_3.resolveAntigravityTranscriptPath)(target, capture),
+    },
 };
 /**
  * What this tool's source says about who records its replies.
@@ -114,6 +188,17 @@ function transcriptHistoryModeOf(cliToolId) {
         return null;
     }
 }
+/**
+ * Whether this tool keeps a transcript a reader can be asked to pull from.
+ *
+ * Exported for the Stop receiver (Issue #2246), which has to decide whether the
+ * *retry* below is worth waiting for before it answers the agent's hook. It is
+ * the same question {@link captureStructuredHistoryTurn} opens with, asked
+ * without doing the read — never a tool id comparison, here or there.
+ */
+function isPullTranscriptHistory(cliToolId) {
+    return transcriptHistoryModeOf(cliToolId) === 'pull';
+}
 /**
  * Whether the agent's own server is recording this instance's replies.
  *
@@ -180,7 +265,7 @@ function isStructuredHistoryWriterLive(worktreeId, cliToolId, instanceId) {
  * @param capture - Where to look; see {@link StructuredHistoryCapture}
  */
 async function captureStructuredHistoryTurn(worktreeId, cliToolId, instanceId, capture) {
-    if (transcriptHistoryModeOf(cliToolId) !== 'pull')
+    if (!isPullTranscriptHistory(cliToolId))
         return false;
     const reader = PULL_TRANSCRIPT_READERS[cliToolId];
     if (!reader) {
@@ -191,11 +276,51 @@ async function captureStructuredHistoryTurn(worktreeId, cliToolId, instanceId, c
         });
         return false;
     }
+    const resolvedInstanceId = instanceId ?? cliToolId;
+    return serializePerInstance(captureKeyOf(worktreeId, cliToolId, resolvedInstanceId), async () => {
+        try {
+            return await reader.capture({ worktreeId, cliToolId, instanceId: resolvedInstanceId }, capture);
+        }
+        catch (error) {
+            logger.warn('structured-history-capture-unavailable', {
+                worktreeId,
+                cliToolId,
+                instanceId: resolvedInstanceId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return false;
+        }
+    });
+}
+/**
+ * Whether a pull reader can name a transcript for this instance (Issue #2246).
+ *
+ * Not "is there a turn to write" and not "did anything get written" — only
+ * whether the file the reader would open exists right now. The one caller is
+ * `lib/hooks/stop-history-capture`, which asks it after a capture answered
+ * false, to decide whether waiting half a second and asking again could help.
+ * An instance with no transcript will not have one in half a second, and the
+ * delay would be paid on every `stop` of every session without hooks.
+ *
+ * False for every tool that does not declare `transcriptHistory: 'pull'`, and
+ * never throws — an unanswerable question is one whose answer is "no file",
+ * which costs the retry and nothing else.
+ *
+ * @param worktreeId - The worktree
+ * @param cliToolId - The tool driving the pane
+ * @param instanceId - The agent instance; defaults to the primary
+ * @param capture - Where to look; see {@link StructuredHistoryCapture}
+ */
+async function hasStructuredHistoryTranscript(worktreeId, cliToolId, instanceId, capture) {
+    const reader = isPullTranscriptHistory(cliToolId) ? PULL_TRANSCRIPT_READERS[cliToolId] : undefined;
+    if (!reader)
+        return false;
     try {
-        return await reader({ worktreeId, cliToolId, instanceId: instanceId ?? cliToolId }, capture);
+        const path = await reader.locate({ worktreeId, cliToolId, instanceId: instanceId ?? cliToolId }, capture);
+        return path !== null;
     }
     catch (error) {
-        logger.warn('structured-history-capture-unavailable', {
+        logger.warn('structured-history-locate-unavailable', {
             worktreeId,
             cliToolId,
             instanceId: instanceId ?? cliToolId,