@cjhyy/code-shell-core 0.9.5 → 0.9.7

package/dist/protocol/session-message-result.d.ts

@@ -0,0 +1,12 @@
+import type { EngineResult } from "../engine/types.js";
+import type { RouteSessionMessageInput } from "../session/session-message.js";
+import type { ResultEnvelopeDraft } from "../tool-system/builtin/agent-notifications.js";
+export interface SessionMessageOutcome {
+    status: "completed" | "failed" | "cancelled";
+    text: string;
+    error?: string;
+}
+export declare function sessionMessageFailure(error: unknown): SessionMessageOutcome;
+/** A resolved Engine promise can still represent a refusal or failed run. */
+export declare function sessionMessageOutcome(result: EngineResult): SessionMessageOutcome;
+export declare function sessionMessageResultNotification(input: RouteSessionMessageInput, messageId: string, outcome: SessionMessageOutcome): ResultEnvelopeDraft;

package/dist/protocol/session-message-result.js

@@ -0,0 +1,42 @@
+export function sessionMessageFailure(error) {
+    return {
+        status: error instanceof Error && error.name === "AbortError" ? "cancelled" : "failed",
+        text: "",
+        error: error instanceof Error ? error.message : String(error),
+    };
+}
+/** A resolved Engine promise can still represent a refusal or failed run. */
+export function sessionMessageOutcome(result) {
+    if (result.reason === "aborted_streaming" || result.reason === "aborted_tools") {
+        return {
+            status: "cancelled",
+            text: result.text,
+            error: result.text || "Target turn was cancelled.",
+        };
+    }
+    if (result.reason === "completed" && result.turnCount > 0) {
+        return { status: "completed", text: result.text };
+    }
+    const detail = result.text ||
+        (result.turnCount === 0 ? "Target turn did not start." : "Target turn did not complete.");
+    return { status: "failed", text: result.text, error: `${detail} (reason: ${result.reason})` };
+}
+export function sessionMessageResultNotification(input, messageId, outcome) {
+    return {
+        kind: "result",
+        from: { sessionId: input.target.sessionId, authority: "agent" },
+        to: { sessionId: input.sourceSessionId, authority: "system" },
+        correlationId: messageId,
+        delivery: "idle-drain",
+        payload: {
+            workId: messageId,
+            name: input.target.title,
+            description: `Reply to message ${messageId} from Session ${input.target.sessionId}: ${input.message.slice(0, 240)}`,
+            workKind: "agent",
+            status: outcome.status,
+            finalText: outcome.text,
+            ...(outcome.error ? { error: outcome.error } : {}),
+            finishedAt: Date.now(),
+        },
+    };
+}

package/dist/protocol/session-message-workspace.d.ts

@@ -0,0 +1,21 @@
+import type { SessionManager } from "../session/session-manager.js";
+import { type WorkspaceContext } from "../workspace/workspace-context.js";
+export interface SessionMessageWorkspace {
+    cwd: string;
+    workspaceContext?: WorkspaceContext;
+    projectTrusted?: boolean;
+}
+/**
+ * Protocol-only hosts can reuse already trusted mounted roots. Desktop should
+ * ask its project registry for fresh authority instead. Persisted Session ids,
+ * bindings and runtime roots always take precedence over a caller's catalog.
+ */
+export declare function resolveSessionMessageWorkspace(input: {
+    sessionManager: Pick<SessionManager, "readSessionMainRoot" | "readSessionProjectBinding" | "getSessionWorkspace">;
+    sourceSessionId: string;
+    targetSessionId: string;
+    sourceWorkspace: SessionMessageWorkspace;
+    targetWorkspace?: SessionMessageWorkspace;
+}): SessionMessageWorkspace & {
+    projectTrusted: boolean;
+};

package/dist/protocol/session-message-workspace.js

@@ -0,0 +1,57 @@
+import { canonicalKey } from "../workspace/canonical-key.js";
+import { createWorkspaceContext, validateWorkspaceContext, } from "../workspace/workspace-context.js";
+/**
+ * Protocol-only hosts can reuse already trusted mounted roots. Desktop should
+ * ask its project registry for fresh authority instead. Persisted Session ids,
+ * bindings and runtime roots always take precedence over a caller's catalog.
+ */
+export function resolveSessionMessageWorkspace(input) {
+    const { sessionManager, sourceSessionId, targetSessionId, sourceWorkspace, targetWorkspace } = input;
+    const sourceMain = sessionManager.readSessionMainRoot(sourceSessionId) ?? sourceWorkspace.cwd;
+    const targetMain = sessionManager.readSessionMainRoot(targetSessionId);
+    const sourceBinding = sessionManager.readSessionProjectBinding(sourceSessionId);
+    const targetBinding = sessionManager.readSessionProjectBinding(targetSessionId);
+    const cwd = sessionManager.getSessionWorkspace(targetSessionId)?.root ?? targetMain ?? sourceMain;
+    const sameMainRoot = !targetMain || canonicalKey(sourceMain) === canonicalKey(targetMain);
+    const projectTrusted = targetWorkspace?.projectTrusted ?? (sameMainRoot && sourceWorkspace.projectTrusted === true);
+    if (targetMain && !targetBinding) {
+        if (!sameMainRoot)
+            throw new Error("target Session does not share the source's authorized main root");
+        return { cwd, projectTrusted };
+    }
+    if (!targetBinding && !sourceBinding)
+        return { cwd, projectTrusted };
+    if (targetBinding && (!sourceBinding || targetBinding.projectId !== sourceBinding.projectId)) {
+        throw new Error("target Session project binding is not authorized by the source Session");
+    }
+    const binding = targetBinding ?? sourceBinding;
+    if (!sourceWorkspace.workspaceContext) {
+        throw new Error("cross-Session run requires an authoritative WorkspaceContext from the host");
+    }
+    const context = validateWorkspaceContext(sourceWorkspace.workspaceContext);
+    if (context.projectId !== sourceBinding?.projectId ||
+        context.sessionMainRootId !== sourceBinding.mainRootId) {
+        throw new Error("source WorkspaceContext does not match its persisted project binding");
+    }
+    // A source worktree is a runtime substitution, not a project mount that may
+    // be propagated into another Session's secondary roots.
+    const mountedRoots = context.roots.map((root) => root.id === sourceBinding.mainRootId ? { ...root, path: sourceMain } : { ...root });
+    const targetRoot = mountedRoots.find((root) => root.id === binding.mainRootId);
+    if (!targetRoot || (targetMain && canonicalKey(targetRoot.path) !== canonicalKey(targetMain))) {
+        throw new Error("target Session main root is not present in the host-authorized project roots");
+    }
+    return {
+        cwd,
+        projectTrusted,
+        workspaceContext: createWorkspaceContext({
+            projectId: context.projectId,
+            projectRevision: context.projectRevision,
+            sessionMainRootId: binding.mainRootId,
+            roots: mountedRoots.map((root) => ({
+                ...root,
+                path: root.id === binding.mainRootId ? cwd : root.path,
+                role: root.id === binding.mainRootId ? "primary" : "secondary",
+            })),
+        }),
+    };
+}

package/dist/protocol/types.d.ts

@@ -13,6 +13,8 @@ import type { SessionMessageTarget } from "../session/session-message.js";
 export type PendingApprovalKind = "tool_approval" | "ask_user" | "internal";
 /** Resolver-free metadata retained beside a pending approval callback. */
 export interface PendingApprovalMetadata {
+    /** Child task that originated this request; sessionId remains its parent UI route. */
+    sourceSessionId?: string;
     sessionId: string;
     requestId: string;
     routeGeneration?: number;
@@ -198,6 +200,8 @@ export interface RunParams {
      * optional token/time budgets). Normalized at the engine run boundary.
      */
     goal?: string | import("../goal/lifecycle.js").GoalConfig;
+    /** Disable explicit, persisted, and configured Goal mode for this standalone turn. */
+    disableGoal?: boolean;
 }
 export interface RunResult {
     text: string;

package/dist/session/session-manager.js

@@ -160,6 +160,8 @@ const FORK_EVENT_POLICY = {
     tool_result: "copy",
     summary: "copy",
     context_transfer: "copy",
+    context_note: "copy",
+    context_checkpoint: "copy",
     range_archive: "copy",
     content_replace: "copy",
     file_history: "skip",
@@ -1922,13 +1924,12 @@ export function buildForkTranscript(sourceEvents, state) {
             forkedFrom: structuredClone(state.forkedFrom),
         },
     };
-    return [
-        meta,
-        ...sourceEvents.map((source) => ({
-            ...structuredClone(source),
-            id: nanoid(12),
-        })),
-    ];
+    const copied = sourceEvents.map((source) => ({
+        ...structuredClone(source),
+        id: nanoid(12),
+    }));
+    Transcript.remapContextForkReferences(sourceEvents, copied);
+    return [meta, ...copied];
 }
 function validateForkToolPairs(events) {
     const projectedUses = [];

package/dist/session/session-message.d.ts

@@ -9,14 +9,29 @@ export interface RouteSessionMessageInput {
     sourceSessionId: string;
     target: SessionMessageTarget;
     message: string;
+    /** Sender tool cancellation; never serialized or supplied by the model. */
+    signal?: AbortSignal;
     /** Full same-project catalog so the target can send a later message onward. */
     catalog: readonly SessionMessageTarget[];
 }
-export type SessionMessageRouter = (input: RouteSessionMessageInput) => Promise<void>;
+/** One dispatch acknowledgement, not a subscription to future target turns. */
+export interface SessionMessageReceipt {
+    messageId: string;
+    status: "queued" | "started" | "completed";
+    /** Present when the target finished before the dispatch returned. */
+    result?: {
+        text: string;
+        reason: import("../types.js").TerminalReason;
+    };
+}
+export type SessionMessageRouter = (input: RouteSessionMessageInput) => Promise<SessionMessageReceipt | void>;
 export interface SessionMessageToolService {
     targets: readonly SessionMessageTarget[];
     send(input: {
         targetSessionId: string;
         message: string;
-    }): Promise<SessionMessageTarget>;
+        signal?: AbortSignal;
+    }): Promise<SessionMessageTarget & {
+        receipt?: SessionMessageReceipt;
+    }>;
 }

package/dist/session/transcript.d.ts

@@ -27,6 +27,16 @@ export interface SelectedContextRange {
     messages: Message[];
     sourceEventCount: number;
 }
+/** Host-generated replay state. Models supply the note text, never this snapshot. */
+export interface ContextCheckpointSnapshot {
+    version: 1;
+    noteId: string;
+    coveredThroughEventId: string;
+    messages: Message[];
+    clientMessageIds: Array<[string, number]>;
+}
+/** Complete, ordered provider pairs are required before a checkpoint can commit. */
+export declare function hasCompleteContextToolPairs(messages: readonly Message[]): boolean;
 export type SummaryAppendMetadata = {
     fromTurn: number;
     toTurn: number;
@@ -59,8 +69,14 @@ export declare class Transcript {
     static inMemory(label: string): Transcript;
     /** Rehydrate a process-local fork without serializing its copied history. */
     static fromMemoryEvents(label: string, events: readonly TranscriptEvent[]): Transcript;
+    /** Preserve checkpoint provenance when a fork assigns fresh event ids. */
+    static remapContextForkReferences(sourceEvents: readonly TranscriptEvent[], copiedEvents: TranscriptEvent[]): void;
     isPersistent(): boolean;
     append(type: TranscriptEventType, data: Record<string, unknown>): TranscriptEvent;
+    /** Failed note/checkpoint writes must never change the active replay. */
+    appendContextNote(text: string, coveredThroughEventId: string): TranscriptEvent | undefined;
+    appendContextCheckpoint(snapshot: ContextCheckpointSnapshot): TranscriptEvent | undefined;
+    private appendDurableContextEvent;
     /**
      * Append a chat message to the transcript.
      *
@@ -148,6 +164,7 @@ export declare class Transcript {
         messages: Message[];
         liveIndexByClientMessageId: Map<string, number>;
     };
+    private contextReplayEvents;
     getEvents(type?: TranscriptEventType): TranscriptEvent[];
     get turnNumber(): number;
     get eventCount(): number;

package/dist/session/transcript.js

@@ -4,6 +4,7 @@
  */
 import { appendFileSync, chmodSync, closeSync, existsSync, fchmodSync, fstatSync, mkdirSync, openSync, readFileSync, readSync, writeFileSync, } from "node:fs";
 import { dirname } from "node:path";
+import { createHash } from "node:crypto";
 import { nanoid } from "nanoid";
 import { logger } from "../logging/logger.js";
 const DEFAULT_CONTEXT_TAIL_SCAN_BYTES = 32 * 1024 * 1024;
@@ -33,6 +34,131 @@ function appendTranscriptLine(filePath, data) {
 const defaultTranscriptWriter = (filePath, data) => {
     appendTranscriptLine(filePath, data);
 };
+function checkpointHash(snapshot) {
+    return createHash("sha256").update(JSON.stringify(snapshot)).digest("hex");
+}
+/** Complete, ordered provider pairs are required before a checkpoint can commit. */
+export function hasCompleteContextToolPairs(messages) {
+    const pending = new Set();
+    const used = new Set();
+    for (const message of messages) {
+        if (pending.size > 0 &&
+            (message.role !== "user" ||
+                !Array.isArray(message.content) ||
+                message.content.length === 0 ||
+                message.content.some((block) => block.type !== "tool_result")))
+            return false;
+        if (!Array.isArray(message.content))
+            continue;
+        for (const block of message.content) {
+            if (block.type === "tool_use") {
+                if (message.role !== "assistant" || !block.id || used.has(block.id))
+                    return false;
+                used.add(block.id);
+                pending.add(block.id);
+            }
+            else if (block.type === "tool_result") {
+                if (message.role !== "user" || !block.tool_use_id || !pending.delete(block.tool_use_id)) {
+                    return false;
+                }
+            }
+        }
+    }
+    return pending.size === 0;
+}
+function readCheckpoint(event, precedingEvents) {
+    if (event.type !== "context_checkpoint")
+        return undefined;
+    const data = event.data;
+    if (!data ||
+        typeof data !== "object" ||
+        data.version !== 1 ||
+        typeof data.noteId !== "string" ||
+        typeof data.coveredThroughEventId !== "string" ||
+        !Array.isArray(data.messages) ||
+        data.messages.length === 0 ||
+        !Array.isArray(data.clientMessageIds))
+        return undefined;
+    const noteIndex = precedingEvents.findIndex((candidate) => candidate.id === data.noteId);
+    const cursorIndex = precedingEvents.findIndex((candidate) => candidate.id === data.coveredThroughEventId);
+    const note = precedingEvents[noteIndex];
+    if (cursorIndex < 0 ||
+        noteIndex <= cursorIndex ||
+        note?.type !== "context_note" ||
+        !note.data ||
+        typeof note.data.text !== "string" ||
+        note.data.text.trim().length === 0 ||
+        note.data.coveredThroughEventId !== data.coveredThroughEventId)
+        return undefined;
+    for (const value of data.messages) {
+        if (!value || typeof value !== "object")
+            return undefined;
+        const message = value;
+        if (!["user", "assistant", "system", "tool"].includes(message.role))
+            return undefined;
+        if (!validCheckpointContent(message.content))
+            return undefined;
+    }
+    const seen = new Set();
+    for (const pair of data.clientMessageIds) {
+        if (!Array.isArray(pair) ||
+            pair.length !== 2 ||
+            typeof pair[0] !== "string" ||
+            seen.has(pair[0]) ||
+            !Number.isSafeInteger(pair[1]) ||
+            pair[1] < 0 ||
+            pair[1] >= data.messages.length)
+            return undefined;
+        seen.add(pair[0]);
+    }
+    const snapshot = {
+        version: 1,
+        noteId: data.noteId,
+        coveredThroughEventId: data.coveredThroughEventId,
+        messages: data.messages,
+        clientMessageIds: data.clientMessageIds,
+    };
+    if (data.checksum !== checkpointHash(snapshot) ||
+        !hasCompleteContextToolPairs(snapshot.messages)) {
+        return undefined;
+    }
+    return snapshot;
+}
+function validCheckpointContent(content, depth = 0) {
+    if (typeof content === "string")
+        return true;
+    if (!Array.isArray(content) || depth > 8)
+        return false;
+    return content.every((value) => {
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            return false;
+        const block = value;
+        switch (block.type) {
+            case "text":
+            case "reasoning":
+                return ((block.text === undefined || typeof block.text === "string") &&
+                    (block.reasoningContent === undefined || typeof block.reasoningContent === "string"));
+            case "image":
+                return (block.source?.type === "base64" &&
+                    typeof block.source.media_type === "string" &&
+                    typeof block.source.data === "string");
+            case "tool_use":
+                return (depth === 0 &&
+                    typeof block.id === "string" &&
+                    (block.name === undefined || typeof block.name === "string") &&
+                    (block.input === undefined ||
+                        (block.input !== null &&
+                            typeof block.input === "object" &&
+                            !Array.isArray(block.input))));
+            case "tool_result":
+                return (depth === 0 &&
+                    typeof block.tool_use_id === "string" &&
+                    (block.content === undefined || validCheckpointContent(block.content, depth + 1)));
+            default:
+                return false;
+        }
+    });
+}
 const CONTEXT_EVENT_TYPES = new Set([
     "message",
     "tool_use",
@@ -47,6 +173,18 @@ function isSyntheticInterruptedToolResult(event) {
         event.data.toolName === "unknown" &&
         event.data.error === INTERRUPTED_TOOL_RESULT_ERROR);
 }
+function toolResultContentBlock(event) {
+    const { toolCallId, result, error, contentBlocks } = event.data;
+    return {
+        type: "tool_result",
+        tool_use_id: toolCallId,
+        content: error
+            ? `Error: ${error}`
+            : Array.isArray(contentBlocks) && contentBlocks.length > 0
+                ? structuredClone(contentBlocks)
+                : (result ?? "(no output)"),
+    };
+}
 /**
  * Choose at most one result for every declared tool call. A real late result
  * wins over the legacy synthetic "interrupted" placeholder that an older
@@ -120,6 +258,40 @@ export class Transcript {
         transcript.loadEvents(events);
         return transcript;
     }
+    /** Preserve checkpoint provenance when a fork assigns fresh event ids. */
+    static remapContextForkReferences(sourceEvents, copiedEvents) {
+        if (!sourceEvents.some((event) => event.type === "context_note"))
+            return;
+        const eventIds = new Map(sourceEvents.map((event, index) => [event.id, copiedEvents[index].id]));
+        for (const [index, source] of sourceEvents.entries()) {
+            const copied = copiedEvents[index];
+            // An inherited note can cite old event ids. Resolve those aliases only
+            // against the copied prefix, never by reaching into the parent session.
+            copied.data.contextHistorySourceIds = [
+                ...(Array.isArray(source.data.contextHistorySourceIds)
+                    ? source.data.contextHistorySourceIds.filter((id) => typeof id === "string")
+                    : []),
+                source.id,
+            ];
+            if (source.type === "context_note") {
+                const cursor = source.data.coveredThroughEventId;
+                if (typeof cursor === "string" && eventIds.has(cursor)) {
+                    copied.data.coveredThroughEventId = eventIds.get(cursor);
+                }
+            }
+            if (source.type !== "context_checkpoint")
+                continue;
+            const snapshot = readCheckpoint(source, sourceEvents.slice(0, index));
+            if (!snapshot)
+                continue; // Never turn a corrupt source checkpoint into a valid one.
+            const noteId = eventIds.get(snapshot.noteId);
+            const coveredThroughEventId = eventIds.get(snapshot.coveredThroughEventId);
+            if (!noteId || !coveredThroughEventId)
+                continue;
+            const remapped = { ...snapshot, noteId, coveredThroughEventId };
+            Object.assign(copied.data, remapped, { checksum: checkpointHash(remapped) });
+        }
+    }
     isPersistent() {
         return this.persistent;
     }
@@ -135,6 +307,41 @@ export class Transcript {
         this.flush(event);
         return event;
     }
+    /** Failed note/checkpoint writes must never change the active replay. */
+    appendContextNote(text, coveredThroughEventId) {
+        return this.appendDurableContextEvent("context_note", { text, coveredThroughEventId });
+    }
+    appendContextCheckpoint(snapshot) {
+        const frozen = structuredClone(snapshot);
+        const data = { ...frozen, checksum: checkpointHash(frozen) };
+        const candidate = {
+            id: "validation",
+            type: "context_checkpoint",
+            timestamp: Date.now(),
+            turnNumber: this.currentTurn,
+            data,
+        };
+        if (!readCheckpoint(candidate, this.events))
+            return undefined;
+        return this.appendDurableContextEvent("context_checkpoint", data);
+    }
+    appendDurableContextEvent(type, data) {
+        // A missing earlier event makes a durable cursor unreliable, even when
+        // this particular append would succeed.
+        if (this.dirty)
+            return undefined;
+        const event = {
+            id: nanoid(12),
+            type,
+            timestamp: Date.now(),
+            turnNumber: this.currentTurn,
+            data,
+        };
+        if (!this.flush(event))
+            return undefined;
+        this.events.push(event);
+        return event;
+    }
     /**
      * Append a chat message to the transcript.
      *
@@ -288,10 +495,11 @@ export class Transcript {
      *   payloads, and transport metadata must not leak into them.
      */
     toMessagesWithIndex() {
+        const events = this.contextReplayEvents();
         const messages = [];
         const liveIndexByClientMessageId = new Map();
-        const selectedToolResults = preferredToolResults(this.events);
-        const hasRangeArchive = this.events.some((e) => e.type === "range_archive");
+        const selectedToolResults = preferredToolResults(events);
+        const hasRangeArchive = events.some((e) => e.type === "range_archive");
         const spansByFromId = new Map();
         let openingSpan;
         if (hasRangeArchive) {
@@ -302,7 +510,7 @@ export class Transcript {
             // while scanning forward, so it would never close — silently swallowing
             // the rest of the conversation. Fail open instead: ignore the marker.
             const firstIndexByClientId = new Map();
-            for (const [index, event] of this.events.entries()) {
+            for (const [index, event] of events.entries()) {
                 if (event.type === "message" && typeof event.data.clientMessageId === "string") {
                     if (!firstIndexByClientId.has(event.data.clientMessageId)) {
                         firstIndexByClientId.set(event.data.clientMessageId, index);
@@ -310,7 +518,7 @@ export class Transcript {
                 }
             }
             const presentClientIds = new Set(firstIndexByClientId.keys());
-            for (const event of this.events) {
+            for (const event of events) {
                 if (event.type !== "range_archive")
                     continue;
                 const { summary, toClientMessageId, fromClientMessageId } = event.data;
@@ -351,7 +559,7 @@ export class Transcript {
         // preferred) real result landed outside it — would be an orphaned block
         // that breaks provider validation; skip it instead of emitting it.
         const emittedToolUseIds = new Set();
-        for (const event of this.events) {
+        for (const event of events) {
             // Span bookkeeping runs on message events only: exit before entry so
             // adjacent spans (A.to === B.from) hand over on the boundary message.
             if (event.type === "message") {
@@ -387,7 +595,9 @@ export class Transcript {
                             }
                         }
                     }
-                    messages.push({ role: role, content });
+                    // Tool results can be merged into this array below. Never mutate
+                    // the source event (or a checkpoint) during a read-only replay.
+                    messages.push({ role: role, content: structuredClone(content) });
                     break;
                 }
                 case "tool_use": {
@@ -402,18 +612,9 @@ export class Transcript {
                         !emittedToolUseIds.has(eventToolCallId)) {
                         break;
                     }
-                    const { toolCallId, result, error, contentBlocks } = event.data;
                     // Find if there's already a user message with tool_results to append to
                     const lastMsg = messages[messages.length - 1];
-                    const block = {
-                        type: "tool_result",
-                        tool_use_id: toolCallId,
-                        content: error
-                            ? `Error: ${error}`
-                            : Array.isArray(contentBlocks) && contentBlocks.length > 0
-                                ? contentBlocks
-                                : (result ?? "(no output)"),
-                    };
+                    const block = toolResultContentBlock(event);
                     if (lastMsg?.role === "user" && Array.isArray(lastMsg.content)) {
                         lastMsg.content.push(block);
                     }
@@ -449,6 +650,55 @@ export class Transcript {
         }
         return { messages, liveIndexByClientMessageId };
     }
+    contextReplayEvents() {
+        for (let index = this.events.length - 1; index >= 0; index -= 1) {
+            const event = this.events[index];
+            if (event.type !== "context_checkpoint")
+                continue;
+            const snapshot = readCheckpoint(event, this.events.slice(0, index));
+            if (!snapshot)
+                continue; // Corrupt or truncated checkpoints fail open.
+            const clientIdByIndex = new Map(snapshot.clientMessageIds.map(([id, i]) => [i, id]));
+            const snapshotEvents = snapshot.messages.map((message, messageIndex) => ({
+                id: `${event.id}:${messageIndex}`,
+                type: "message",
+                timestamp: event.timestamp,
+                turnNumber: event.turnNumber,
+                data: {
+                    role: message.role,
+                    content: structuredClone(message.content),
+                    ...(clientIdByIndex.has(messageIndex)
+                        ? { clientMessageId: clientIdByIndex.get(messageIndex) }
+                        : {}),
+                },
+            }));
+            const tail = this.events.slice(index + 1);
+            const lateResults = preferredToolResults([...snapshotEvents, ...tail]);
+            const completedIds = new Set();
+            for (const snapshotEvent of snapshotEvents) {
+                const content = snapshotEvent.data.content;
+                if (!Array.isArray(content))
+                    continue;
+                snapshotEvent.data.content = content.map((block) => {
+                    if (block.type !== "tool_result" || !block.tool_use_id)
+                        return block;
+                    completedIds.add(block.tool_use_id);
+                    const late = lateResults.get(block.tool_use_id);
+                    // Reconcile late duplicates in the original result position, so a
+                    // result cannot become orphaned or split an unrelated later batch.
+                    return late && !isSyntheticInterruptedToolResult(late)
+                        ? toolResultContentBlock(late)
+                        : block;
+                });
+            }
+            return [
+                ...snapshotEvents,
+                ...tail.filter((candidate) => candidate.type !== "tool_result" ||
+                    !completedIds.has(candidate.data.toolCallId)),
+            ];
+        }
+        return this.events;
+    }
     getEvents(type) {
         if (!type)
             return [...this.events];
@@ -727,6 +977,11 @@ export class Transcript {
                 return Transcript.loadFromFile(filePath);
             }
         }
+        // Checkpoint validity references its note and covered cursor. A bounded
+        // range-archive tail may omit either, so use the full loader here.
+        if (events.some((event) => event.type === "context_checkpoint")) {
+            return Transcript.loadFromFile(filePath);
+        }
         let markerIndex = -1;
         let toClientMessageId;
         for (const [index, event] of events.entries()) {