commandmate 0.44.2 → 0.45.0

package/dist/server/src/lib/hooks/sources/claude/self-resume.js

@@ -0,0 +1,213 @@
+"use strict";
+/**
+ * Whether a Claude Code `Stop` leaves background work behind that will wake the
+ * agent again (Issue #3430) — the Claude half of #2614.
+ *
+ * Claude Code ends a turn with work still running in two measured ways: a
+ * `Bash` call that outlived its timeout (or was started with
+ * `run_in_background`) and a `Monitor`. When that work finishes Claude queues a
+ * `<task-notification>` and, if the session is idle, opens a new turn on it by
+ * itself. Measured on 2026-10-08 (worktree commandmate-issue-3423): a worker
+ * ended its turn at 23:37:53 "waiting for the related-tests run to finish",
+ * `wait --verify` read that `Stop` as the end and verified an uncommitted
+ * worktree, and the notification opened the turn that committed at 23:38:32.
+ *
+ * ## What is read, and why not the `Stop` payload
+ *
+ * The payload carries `background_tasks`, but only its empty form has ever been
+ * captured (`tests/fixtures/hooks/claude/stop.json`), so its shape is a guess.
+ * The transcript names the same work in structured fields, measured on the
+ * transcripts under `~/.claude/projects` written in the four days to 2026-10-08:
+ *
+ *  - a background `Bash`: `toolUseResult.backgroundTaskId` (1,008 results);
+ *  - a `Monitor`: `toolUseResult.taskId` beside a boolean `persistent`
+ *    (115 results);
+ *  - a background subagent: `toolUseResult.isAsync: true` and `agentId`
+ *    (30 results);
+ *  - a `TaskStop`: `toolUseResult.task_id` (39 results). A stopped task is never
+ *    notified, so this is what retires it.
+ *
+ * and each finished task is retired by the notification Claude delivers for it:
+ * a `type: "user"` prompt or a `queued_command` attachment whose text begins
+ * with `<task-notification>` and carries `<task-id>…</task-id>` — the id above.
+ * A notice that is only enqueued is not yet delivered, and the session will open
+ * a turn on it, so its task still counts as pending.
+ *
+ * ## Erring towards "finished"
+ *
+ * Every doubt answers "nothing pending", which is what every Claude `Stop` meant
+ * before this Issue: no transcript path, a path outside `~/.claude/projects`, a
+ * file that cannot be read, a line that does not parse. A persistent `Monitor`
+ * (a watch for the whole session, never notified on its own) is not counted
+ * either. A task that really is never notified — a process that died with its
+ * session — is bounded by `commandmate wait`'s `SELF_RESUME_HOLD_MS`.
+ *
+ * @module lib/hooks/sources/claude/self-resume
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLAUDE_SELF_RESUME_TAIL_BYTES = exports.CLAUDE_TRANSCRIPT_PATH_FIELD = void 0;
+exports.pendingClaudeBackgroundTasks = pendingClaudeBackgroundTasks;
+exports.claudeStopLeavesBackgroundWork = claudeStopLeavesBackgroundWork;
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+const transcript_history_1 = require("../transcript-history");
+const queued_notice_1 = require("./queued-notice");
+const transcript_1 = require("./transcript");
+/** The `Stop` payload field naming the session's transcript. */
+exports.CLAUDE_TRANSCRIPT_PATH_FIELD = 'transcript_path';
+/**
+ * How much of the transcript's tail is read on a `Stop`.
+ *
+ * A task is started before it is notified, so a window that holds the start
+ * holds the notification too; a start older than the window is simply not seen
+ * (the "finished" direction). 4 MiB is `CLAUDE_TRANSCRIPT_TAIL_BYTES`, the first
+ * read of `./history`, which holds 99% of turns whole (#2470).
+ */
+exports.CLAUDE_SELF_RESUME_TAIL_BYTES = 4 * 1024 * 1024;
+const TASK_ID_PATTERN = /<task-id>([^<]+)<\/task-id>/;
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function nonEmptyString(value) {
+    return typeof value === 'string' && value.length > 0 ? value : null;
+}
+/** The background task a tool result started, or null. */
+function startedTaskId(result) {
+    const bash = nonEmptyString(result.backgroundTaskId);
+    if (bash)
+        return bash;
+    // Monitor. `persistent: true` watches for the life of the session and is not
+    // work the turn is waiting on.
+    const monitor = nonEmptyString(result.taskId);
+    if (monitor && result.persistent === false)
+        return monitor;
+    const agent = nonEmptyString(result.agentId);
+    if (agent && result.isAsync === true)
+        return agent;
+    return null;
+}
+/** The task a `<task-notification>` text retires, or null. */
+function notifiedTaskId(text) {
+    if (typeof text !== 'string')
+        return null;
+    if (!text.trimStart().startsWith(queued_notice_1.CLAUDE_TASK_NOTIFICATION_PREFIX))
+        return null;
+    return TASK_ID_PATTERN.exec(text)?.[1] ?? null;
+}
+/** Every text a delivered `type: "user"` record carries. */
+function userTexts(record) {
+    const message = record.message;
+    if (!isRecord(message))
+        return [];
+    const content = message.content;
+    if (typeof content === 'string')
+        return [content];
+    if (!Array.isArray(content))
+        return [];
+    return content.filter(isRecord).filter((b) => b.type === 'text').map((b) => b.text);
+}
+/**
+ * The ids of background tasks started in `text` (transcript JSONL) and not yet
+ * delivered a notification or stopped, in the order they were started.
+ *
+ * Pure. Lines that do not parse are skipped, as is everything a subagent wrote
+ * into the parent's file (`isSidechain: true`).
+ */
+function pendingClaudeBackgroundTasks(text) {
+    const started = [];
+    const retired = new Set();
+    for (const line of text.split('\n')) {
+        if (line.trim() === '')
+            continue;
+        let record;
+        try {
+            record = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (!isRecord(record) || record.isSidechain === true)
+            continue;
+        if (record.type === 'user') {
+            const result = record.toolUseResult;
+            if (isRecord(result)) {
+                const id = startedTaskId(result);
+                if (id)
+                    started.push(id);
+                const stopped = nonEmptyString(result.task_id);
+                if (stopped)
+                    retired.add(stopped);
+            }
+            for (const t of userTexts(record)) {
+                const id = notifiedTaskId(t);
+                if (id)
+                    retired.add(id);
+            }
+        }
+        else if (record.type === 'attachment' && isRecord(record.attachment)) {
+            if (record.attachment.type !== 'queued_command')
+                continue;
+            const id = notifiedTaskId(record.attachment.prompt);
+            if (id)
+                retired.add(id);
+        }
+    }
+    return [...new Set(started)].filter((id) => !retired.has(id));
+}
+/**
+ * The last `maxBytes` of a file, starting at a line boundary; null when it
+ * cannot be read.
+ */
+function readTail(path, maxBytes) {
+    let fd = null;
+    try {
+        fd = (0, fs_1.openSync)(path, 'r');
+        const size = (0, fs_1.fstatSync)(fd).size;
+        const start = Math.max(0, size - maxBytes);
+        const buffer = Buffer.alloc(size - start);
+        let read = 0;
+        while (read < buffer.length) {
+            const n = (0, fs_1.readSync)(fd, buffer, read, buffer.length - read, start + read);
+            if (n === 0)
+                break;
+            read += n;
+        }
+        const text = buffer.subarray(0, read).toString('utf8');
+        // A window opened mid-file starts mid-line; that line is dropped.
+        return start === 0 ? text : text.slice(text.indexOf('\n') + 1);
+    }
+    catch {
+        return null;
+    }
+    finally {
+        if (fd !== null) {
+            try {
+                (0, fs_1.closeSync)(fd);
+            }
+            catch {
+                // Nothing to do: the answer is already decided.
+            }
+        }
+    }
+}
+/**
+ * Whether this `Stop` payload's session still has background work that has not
+ * been notified — i.e. whether Claude will open another turn by itself.
+ *
+ * Synchronous: it runs inside event normalization. `false` for every case it
+ * cannot vouch for (see the module comment).
+ */
+function claudeStopLeavesBackgroundWork(payload, options = {}) {
+    const hint = nonEmptyString(payload[exports.CLAUDE_TRANSCRIPT_PATH_FIELD]);
+    if (!hint)
+        return false;
+    const root = (0, path_1.join)(options.homeDir ?? (0, os_1.homedir)(), ...transcript_1.CLAUDE_PROJECTS_DIR_SEGMENTS);
+    const path = (0, transcript_history_1.acceptPathUnderRoot)(root, '.jsonl', hint);
+    if (!path)
+        return false;
+    const text = readTail(path, options.tailBytes ?? exports.CLAUDE_SELF_RESUME_TAIL_BYTES);
+    if (text === null)
+        return false;
+    return pendingClaudeBackgroundTasks(text).length > 0;
+}

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

@@ -34,6 +34,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.claudeAgentEventSource = void 0;
 exports.encodeClaudeVerdict = encodeClaudeVerdict;
+exports.extractClaudeEventDetail = extractClaudeEventDetail;
+const uat_isolation_1 = require("../../../../config/uat-isolation");
 const agent_event_types_1 = require("../../../../lib/hooks/agent-event-types");
 const ask_user_question_payload_1 = require("../../../../lib/hooks/ask-user-question-payload");
 const hook_settings_generator_1 = require("../../../../lib/hooks/hook-settings-generator");
@@ -42,6 +44,8 @@ const define_source_1 = require("../define-source");
 const event_mapper_1 = require("../event-mapper");
 const hook_event_vocabulary_1 = require("../hook-event-vocabulary");
 const model_switch_1 = require("./model-switch");
+const queued_notice_1 = require("./queued-notice");
+const self_resume_1 = require("./self-resume");
 const tool_id_1 = require("./tool-id");
 /**
  * The no-decision body, byte for byte what the #1721 spike returned for D5.
@@ -83,6 +87,20 @@ function encodeClaudeVerdict(verdict) {
         },
     };
 }
+/**
+ * The subtype of one Claude event.
+ *
+ * Every event but `stop` is the shared snake_case reading (S2). A `stop` is
+ * {@link SELF_RESUME_PENDING_DETAIL} when the session's transcript shows
+ * background work that has not been notified yet (Issue #3430), and has no
+ * subtype otherwise — which is what every Claude `stop` had before.
+ */
+function extractClaudeEventDetail(event, payload) {
+    if (event === 'stop' && (0, self_resume_1.claudeStopLeavesBackgroundWork)(payload)) {
+        return agent_event_types_1.SELF_RESUME_PENDING_DETAIL;
+    }
+    return (0, hook_event_vocabulary_1.extractSnakeCaseEventDetail)(event, payload);
+}
 /**
  * Claude Code as an event source.
  *
@@ -125,11 +143,12 @@ exports.claudeAgentEventSource = (0, define_source_1.definePushHookSource)({
         // JSONL when the poller asks (#2121); the gate dispatches on this word
         // rather than on the tool id.
         transcriptHistory: 'pull',
-        // Issue #2614. Claude Code does resume itself (background tasks, session
-        // crons), and its `Stop` payload carries `background_tasks` /
-        // `session_crons` — but only the empty form has been captured, so nothing
-        // reads them yet and this stays false until a non-empty one is measured.
-        stopReportsSelfResume: false,
+        // Issue #3430 (#2614 for Claude). A `Stop` whose transcript shows a
+        // background `Bash` / `Monitor` / subagent not yet notified carries
+        // `SELF_RESUME_PENDING_DETAIL`: the notification opens the next turn by
+        // itself. The payload's `background_tasks` is still unread — only its empty
+        // form has been captured. See `./self-resume` and `extractDetail` below.
+        stopReportsSelfResume: true,
     },
     // S1. A plain name table is enough *for this tool* — one native name, one
     // word, no predicates — so it is expressed as rules built from the table
@@ -158,8 +177,11 @@ exports.claudeAgentEventSource = (0, define_source_1.definePushHookSource)({
     // the latch. `extractModel` runs before `modelFields`, and answers null for
     // every other event so the flat lookup above is unchanged for them.
     extractModel: model_switch_1.extractClaudeSwitchedModel,
-    // S2.
-    extractDetail: hook_event_vocabulary_1.extractSnakeCaseEventDetail,
+    // Issue #3330. A background-task notice attached to the running turn fires
+    // `UserPromptSubmit` too, and continues that turn rather than opening one.
+    promptJoinsOpenTurn: queued_notice_1.isClaudeQueuedNoticePrompt,
+    // S2, plus the `Stop` that leaves background work behind (Issue #3430).
+    extractDetail: extractClaudeEventDetail,
     // S7. Both parsers are strict and answer null for anything they cannot vouch
     // for; the callers turn null into "no structured data", which degrades to the
     // behaviour of a machine without hooks rather than into a guess.
@@ -171,22 +193,47 @@ exports.claudeAgentEventSource = (0, define_source_1.definePushHookSource)({
     // writes the settings file, falls back to the bare path on any failure, and is
     // covered byte-for-byte by `tests/unit/hooks/hook-settings-generator.test.ts`.
     prepareLaunch: ({ target, executablePath }) => {
-        const command = (0, hook_settings_generator_1.buildClaudeLaunchCommand)(executablePath, {
+        // Issue #3312: under `own-home` the settings file goes in only once its
+        // directory and the file itself check out inside the dedicated user's
+        // HOME; else the launch is refused.
+        const ownHome = (0, uat_isolation_1.getUatIsolationMode)() === 'own-home';
+        const hookTarget = {
             worktreeId: target.worktreeId,
             instanceId: target.instanceId,
             cliToolId: target.cliToolId,
-        });
+        };
+        if ((0, hook_settings_generator_1.isHookInjectionEnabled)()) {
+            (0, uat_isolation_1.assertUatOwnHomeWriteTargets)(tool_id_1.CLAUDE_CLI_TOOL_ID, [
+                (0, hook_settings_generator_1.getHookSettingsDirectory)(),
+                (0, hook_settings_generator_1.getHookSettingsPath)(hookTarget),
+            ]);
+        }
+        const baseCommand = (0, hook_settings_generator_1.buildClaudeLaunchCommand)(executablePath, hookTarget);
+        // Issue #3312: under `own-home` a claude without its settings file is a
+        // check that cannot see `hook_stop`, so injection switched off or a file
+        // that could not be written refuses the launch. `1` and normal mode keep
+        // starting the bare executable.
+        if (ownHome && baseCommand === executablePath) {
+            throw new uat_isolation_1.UatIsolationLaunchRefusedError(tool_id_1.CLAUDE_CLI_TOOL_ID, (0, hook_settings_generator_1.isHookInjectionEnabled)() ? 'the hook settings file could not be written' : 'CM_AGENT_HOOKS_INJECT=0', (0, hook_settings_generator_1.isHookInjectionEnabled)()
+                ? 'Make CM_AGENT_HOOKS_DIR writable by the dedicated user.'
+                : 'Do not combine CM_AGENT_HOOKS_INJECT=0 with own-home.');
+        }
         // The path is reported only when the command actually names it. Injection
         // can be switched off (`CM_AGENT_HOOKS_INJECT=0`) or fail to write, and both
         // return the bare executable — claiming a settings file in that case would
         // be telling the caller about a file that is not there.
-        const settingsPath = (0, hook_settings_generator_1.isHookInjectionEnabled)() && command !== executablePath
+        const settingsPath = (0, hook_settings_generator_1.isHookInjectionEnabled)() && baseCommand !== executablePath
             ? (0, hook_settings_generator_1.getHookSettingsPath)({
                 worktreeId: target.worktreeId,
                 instanceId: target.instanceId,
                 cliToolId: target.cliToolId,
             })
             : null;
+        // Issue #3360: in UAT isolation the user's own `~/.claude/settings.json`
+        // (whose hooks post to production) is not loaded; `--settings` still is.
+        const command = (0, uat_isolation_1.isUatIsolationEnabled)()
+            ? `${baseCommand} --setting-sources ${uat_isolation_1.CLAUDE_UAT_SETTING_SOURCES}`
+            : baseCommand;
         // Empty, and the only source for which that is uninteresting: `--settings`
         // carries the correlation keys inside the file, so Claude never needed the
         // environment prefix the other four sources reached for (#1846).

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

@@ -297,18 +297,12 @@ function readToolDetail(input) {
     for (const field of CLAUDE_TOOL_DETAIL_FIELDS) {
         const value = (0, event_mapper_1.readStringField)(input, field);
         if (value)
-            return boundToolDetail(collapseToLine(value));
+            return boundToolDetail((0, turn_body_1.collapseToLine)(value));
     }
     return null;
 }
-/** A tool detail on one line. A heredoc `command` puts newlines in it. */
-function collapseToLine(value) {
-    return value.replace(/\s+/g, ' ').trim();
-}
 function boundToolDetail(value) {
-    return value.length <= exports.MAX_CLAUDE_TOOL_DETAIL_LENGTH
-        ? value
-        : `${value.slice(0, exports.MAX_CLAUDE_TOOL_DETAIL_LENGTH - 1)}…`;
+    return (0, turn_body_1.boundDetail)(value, exports.MAX_CLAUDE_TOOL_DETAIL_LENGTH);
 }
 /**
  * Read one parsed transcript line.
@@ -787,11 +781,7 @@ function renderClaudeTurn(turn) {
             unknown.add(block.type);
     }
     let body = (0, turn_body_1.separateTurnBody)(rendered).body;
-    if (body.length > exports.MAX_CLAUDE_TURN_BODY_LENGTH) {
-        body =
-            body.slice(0, exports.MAX_CLAUDE_TURN_BODY_LENGTH - exports.CLAUDE_TURN_TRUNCATION_MARKER.length) +
-                exports.CLAUDE_TURN_TRUNCATION_MARKER;
-    }
+    body = (0, turn_body_1.truncateTurnBody)(body, exports.MAX_CLAUDE_TURN_BODY_LENGTH, exports.CLAUDE_TURN_TRUNCATION_MARKER);
     return {
         sessionId: turn.sessionId,
         promptUuid: turn.promptUuid,

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

@@ -95,6 +95,7 @@ exports.isCodexRolloutFileFor = isCodexRolloutFileFor;
 exports.findCodexRolloutPath = findCodexRolloutPath;
 exports.captureCodexTranscriptTurn = captureCodexTranscriptTurn;
 exports.resolveCodexTranscriptPath = resolveCodexTranscriptPath;
+const global_state_1 = require("../../../../lib/global-state");
 const promises_1 = require("fs/promises");
 const os_1 = require("os");
 const path_1 = require("path");
@@ -104,6 +105,7 @@ const user_turn_recorder_1 = require("../../../../lib/history/user-turn-recorder
 const assistant_response_saver_1 = require("../../../../lib/assistant-response-saver");
 const logger_1 = require("../../../../lib/logger");
 const agent_transcript_1 = require("../../../../types/agent-transcript");
+const transcript_history_1 = require("../transcript-history");
 const transcript_1 = require("./transcript");
 const logger = (0, logger_1.createLogger)('lib/hooks/sources/codex/history');
 /**
@@ -151,7 +153,7 @@ const CODEX_SESSION_ID_PATTERN = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-
  * codex sends `session_id` on every event it delivers — but a future one that
  * did not would otherwise blank the pointer mid-session.
  */
-const sessionPointers = (globalThis.__codexTranscriptSessions ??= new Map());
+const sessionPointers = (0, global_state_1.getOrInitGlobal)('__codexTranscriptSessions', () => new Map());
 /**
  * Where each session id's rollout file was found.
  *
@@ -161,7 +163,7 @@ const sessionPointers = (globalThis.__codexTranscriptSessions ??= new Map());
  * session started, which is not derivable from the id — and a scan of 1,791
  * files on every finished turn is not something to do twice.
  */
-const rolloutPaths = (globalThis.__codexTranscriptPaths ??= new Map());
+const rolloutPaths = (0, global_state_1.getOrInitGlobal)('__codexTranscriptPaths', () => new Map());
 function keyOf(target) {
     return (0, auto_yes_state_1.buildCompositeKey)(target.worktreeId, target.cliToolId, target.instanceId);
 }
@@ -185,24 +187,7 @@ function resetCodexTranscriptSessions() {
  * keeps being the only record, which is merely the status quo.
  */
 async function resolveCodexSessionId(target) {
-    const key = keyOf(target);
-    try {
-        const { getLastAgentEvent } = await Promise.resolve().then(() => __importStar(require('../../../../lib/session/agent-event-state')));
-        const sessionId = getLastAgentEvent(target.worktreeId, target.cliToolId, target.instanceId)?.sessionId;
-        if (typeof sessionId === 'string' && sessionId.length > 0) {
-            sessionPointers.set(key, sessionId);
-            return sessionId;
-        }
-    }
-    catch (error) {
-        // A state module that cannot be reached is one that knows no session id.
-        logger.debug('codex-transcript-session-lookup-failed', {
-            worktreeId: target.worktreeId,
-            instanceId: target.instanceId ?? target.cliToolId,
-            error: error instanceof Error ? error.message : String(error),
-        });
-    }
-    return sessionPointers.get(key) ?? null;
+    return (0, transcript_history_1.resolveSessionIdFromEvents)(target, sessionPointers, keyOf(target), logger, 'codex-transcript-session-lookup-failed');
 }
 /**
  * `$CODEX_HOME`, or `~/.codex`.
@@ -234,15 +219,7 @@ function codexSessionsRoot(codexHome) {
  * @returns The resolved path, or null when it is not acceptable
  */
 function acceptCodexRolloutPath(codexHome, candidate) {
-    if (!candidate.endsWith(transcript_1.CODEX_ROLLOUT_EXTENSION))
-        return null;
-    if (candidate.includes('\0'))
-        return null;
-    const root = (0, path_1.resolve)(codexSessionsRoot(codexHome));
-    const resolved = (0, path_1.resolve)(candidate);
-    if (resolved !== root && !resolved.startsWith(root + path_1.sep))
-        return null;
-    return resolved;
+    return (0, transcript_history_1.acceptPathUnderRoot)(codexSessionsRoot(codexHome), transcript_1.CODEX_ROLLOUT_EXTENSION, candidate);
 }
 /** Whether a file name is the rollout of this session. */
 function isCodexRolloutFileFor(name, sessionId) {
@@ -440,7 +417,7 @@ async function captureCodexTranscriptTurn(target, capture = {}, report) {
         let captured = false;
         for (let index = 0; index < pending.turns.length; index += 1) {
             const turn = pending.turns[index];
-            captured = await writeCodexTurn(target, turn, (0, transcript_1.renderCodexTurn)(turn), resolveAssistantTimestampMs(turn, userRows[index], lastRecordAt.get(turn.turnId) ?? 0, nextTurnOpensAt(pending.turns, userRows, index)), windowFacts, report);
+            captured = await writeCodexTurn(target, turn, (0, transcript_1.renderCodexTurn)(turn), (0, transcript_history_1.resolveAssistantTimestampMs)(turn, userRows[index], lastRecordAt.get(turn.turnId) ?? 0, (0, transcript_history_1.nextTurnOpensAt)(pending.turns, userRows, index)), windowFacts, report);
         }
         if (captured) {
             // Issue #2437: History now holds this turn as the agent's own Markdown.
@@ -506,26 +483,7 @@ function firstCodexRecordAt(records) {
  * @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,
-    };
+    return (0, transcript_history_1.selectUnwrittenTurns)(target, turns, (turn) => (0, agent_transcript_1.codexTurnRequestId)(turn.turnId));
 }
 /**
  * The rollout file for this session, or null.
@@ -537,7 +495,7 @@ async function selectUnwrittenCodexTurns(target, turns) {
 async function locateCodexRollout(codexHome, sessionId) {
     const memoKey = `${codexHome}\0${sessionId}`;
     const memoised = rolloutPaths.get(memoKey);
-    if (memoised && (await isReadableFile(memoised)))
+    if (memoised && (await (0, transcript_history_1.isReadableFile)(memoised)))
         return memoised;
     if (memoised)
         rolloutPaths.delete(memoKey);
@@ -550,14 +508,6 @@ async function locateCodexRollout(codexHome, sessionId) {
     rolloutPaths.set(memoKey, accepted);
     return accepted;
 }
-async function isReadableFile(path) {
-    try {
-        return (await (0, promises_1.stat)(path)).isFile();
-    }
-    catch {
-        return false;
-    }
-}
 /**
  * Record every prompt this turn answers, before the reply is written (#2196).
  *
@@ -598,7 +548,7 @@ async function recordCodexUserTurns(target, turn, previousStartedAt = 0) {
     }
     return last;
 }
-/**
+/*
  * When the assistant row for this turn is dated.
  *
  * **The turn's LAST record, not its first (Issue #2273).** #2197 dated the reply
@@ -626,13 +576,6 @@ async function recordCodexUserTurns(target, turn, previousStartedAt = 0) {
  * @param nextTurnOpensAt - Epoch ms of the next turn's user row, or null when
  *   this is the newest turn in the window
  */
-function resolveAssistantTimestampMs(turn, userRow, lastRecordAt = 0, nextTurnOpensAt = null) {
-    const earliest = userRow.timestampMs === null
-        ? turn.startedAt
-        : Math.max(turn.startedAt, userRow.timestampMs + 1);
-    const latest = nextTurnOpensAt === null ? Number.POSITIVE_INFINITY : nextTurnOpensAt - 1;
-    return Math.max(earliest, Math.min(lastRecordAt, latest));
-}
 /**
  * When each turn's last record was written (Issue #2273).
  *
@@ -660,7 +603,7 @@ function lastCodexRecordAt(records) {
     }
     return at;
 }
-/**
+/*
  * The instant the next pending turn's prompt row carries, or null (Issue #2273).
  *
  * The user row's own timestamp when there is one, because that is what History
@@ -669,12 +612,6 @@ function lastCodexRecordAt(records) {
  * prompt is while the previous turn was still running. The turn's start is the
  * fallback for a turn that produced no row at all.
  */
-function nextTurnOpensAt(turns, userRows, index) {
-    const next = turns[index + 1];
-    if (!next)
-        return null;
-    return userRows[index + 1]?.timestampMs ?? next.startedAt;
-}
 /**
  * Write one rendered turn, unless it is already there.
  *