@cjhyy/code-shell-core 0.8.1 → 0.8.3

package/dist/session/session-manager.js

@@ -142,6 +142,12 @@ function adoptCompatibilityGoalMutation(state) {
         state.goalLifecycle = terminateGoalLifecycle(lifecycle, lifecycleTerminalReason(matchingTerminal.reason), matchingTerminal.terminatedAtMs ?? Date.now());
     }
 }
+// Quick Chat sessions are intentionally process-local. SessionManager
+// instances are created per Engine, so this registry lives at module scope to
+// let a fork created by one Engine be resumed by another without touching
+// disk. The storage root remains part of the key to preserve identity/data-root
+// isolation.
+const processLocalSessionBundles = new Map();
 const FORK_COPY_EVENT_TYPES = new Set([
     "message",
     "tool_use",
@@ -292,6 +298,26 @@ export class SessionManager {
         mkdirSync(this.sessionsDir, { recursive: true });
         this.cleanupStaleForkStaging();
     }
+    processLocalKey(sessionId) {
+        return `${this.sessionsDir}\0${sessionId}`;
+    }
+    processLocalBundle(sessionId) {
+        return processLocalSessionBundles.get(this.processLocalKey(sessionId));
+    }
+    storeProcessLocalBundle(bundle) {
+        processLocalSessionBundles.set(this.processLocalKey(bundle.state.sessionId), {
+            state: structuredClone(bundle.state),
+            transcript: bundle.transcript,
+        });
+    }
+    /** Forget a Quick Chat/side-chat bundle immediately; nothing remains on disk. */
+    forgetEphemeralSession(sessionId) {
+        assertSafeSessionId(sessionId);
+        const bundle = this.processLocalBundle(sessionId);
+        if (!bundle || !isEphemeralSessionState(bundle.state))
+            return false;
+        return processLocalSessionBundles.delete(this.processLocalKey(sessionId));
+    }
     cleanupStaleForkStaging() {
         let removed = 0;
         let entries;
@@ -336,11 +362,8 @@ export class SessionManager {
         return next;
     }
     /**
-     * Create a new on-disk session. If `explicitSessionId` is passed, use
-     * it verbatim (ChatSessionManager-driven hosts choose a logical sid like
-     * "tui-main" and expect us to honor it). Otherwise generate one with
-     * nanoid. Either way the on-disk directory is materialized and the
-     * state.json + transcript.jsonl files are written before return.
+     * Create a session. `qchat-` sessions stay process-local; ordinary sessions
+     * materialize state.json + transcript.jsonl before return.
      */
     create(cwd, model, provider, explicitSessionId, parentSessionId, origin, kind = "work") {
         // External callers may pass any string; nanoid output is trusted. Either
@@ -349,16 +372,6 @@ export class SessionManager {
         if (explicitSessionId !== undefined)
             assertSafeSessionId(explicitSessionId);
         const sessionId = explicitSessionId ?? nanoid(16);
-        const sessionDir = join(this.sessionsDir, sessionId);
-        try {
-            mkdirSync(sessionDir);
-        }
-        catch (err) {
-            if (err.code === "EEXIST") {
-                throw new SessionError(`Session already exists: ${sessionId}`);
-            }
-            throw err;
-        }
         const state = {
             sessionId,
             kind,
@@ -383,6 +396,33 @@ export class SessionManager {
             ...(sessionId.startsWith("qchat-") ? { ephemeral: true } : {}),
             ...(origin ? { origin } : {}),
         };
+        if (isEphemeralSessionState(state)) {
+            if (this.processLocalBundle(sessionId)) {
+                throw new SessionError(`Session already exists: ${sessionId}`);
+            }
+            const transcript = Transcript.inMemory(sessionId);
+            transcript.append("session_meta", {
+                sessionId,
+                cwd,
+                model,
+                provider,
+                startedAt: state.startedAt,
+                kind,
+            });
+            const bundle = { state, transcript };
+            this.storeProcessLocalBundle(bundle);
+            return bundle;
+        }
+        const sessionDir = join(this.sessionsDir, sessionId);
+        try {
+            mkdirSync(sessionDir);
+        }
+        catch (err) {
+            if (err.code === "EEXIST") {
+                throw new SessionError(`Session already exists: ${sessionId}`);
+            }
+            throw err;
+        }
         // Atomic write (tmp+rename) like saveState, so a crash during this one-time
         // create can't leave a torn state.json that resume() then fails to parse.
         const stateTarget = join(sessionDir, "state.json");
@@ -400,11 +440,7 @@ export class SessionManager {
         });
         return { state, transcript };
     }
-    /**
-     * Whether a session directory exists on disk. Used by ChatSession-driven
-     * cold starts to decide between resume vs create-with-explicit-sid
-     * without catching SessionError.
-     */
+    /** Whether a persisted or process-local session exists. */
     exists(sessionId) {
         // exists() is a probe — callers use it to decide between resume and
         // create-with-explicit-sid. Treat an invalid id as "not present"
@@ -415,6 +451,12 @@ export class SessionManager {
         catch {
             return false;
         }
+        if (this.processLocalBundle(sessionId))
+            return true;
+        // Never resurrect a legacy Quick Chat directory after the process-local
+        // record has expired.
+        if (sessionId.startsWith("qchat-"))
+            return false;
         return existsSync(join(this.sessionsDir, sessionId));
     }
     /**
@@ -430,6 +472,11 @@ export class SessionManager {
         catch {
             return undefined;
         }
+        const processLocal = this.processLocalBundle(sessionId);
+        if (processLocal)
+            return sessionMainRoot(processLocal.state);
+        if (sessionId.startsWith("qchat-"))
+            return undefined;
         const stateFile = join(this.sessionsDir, sessionId, "state.json");
         if (!existsSync(stateFile))
             return undefined;
@@ -449,6 +496,11 @@ export class SessionManager {
         catch {
             return undefined;
         }
+        const processLocal = this.processLocalBundle(sessionId);
+        if (processLocal)
+            return normalizedSessionKind(processLocal.state.kind);
+        if (sessionId.startsWith("qchat-"))
+            return undefined;
         const stateFile = join(this.sessionsDir, sessionId, "state.json");
         if (!existsSync(stateFile))
             return undefined;
@@ -464,6 +516,13 @@ export class SessionManager {
     readSessionWorkspaceProfile(sessionId) {
         try {
             assertSafeSessionId(sessionId);
+            const processLocal = this.processLocalBundle(sessionId);
+            if (processLocal) {
+                const profile = processLocal.state.workspaceProfile;
+                return typeof profile === "string" && profile ? profile : undefined;
+            }
+            if (sessionId.startsWith("qchat-"))
+                return undefined;
             const stateFile = join(this.sessionsDir, sessionId, "state.json");
             if (!existsSync(stateFile))
                 return undefined;
@@ -534,7 +593,7 @@ export class SessionManager {
     readCwd(sessionId) {
         return this.readSessionMainRoot(sessionId);
     }
-    /** Disk-only direct-parent ACL metadata. Undefined means unprovable/corrupt. */
+    /** Direct-parent ACL metadata. Undefined means unprovable/corrupt. */
     readParentSessionId(sessionId) {
         try {
             assertSafeSessionId(sessionId);
@@ -542,6 +601,13 @@ export class SessionManager {
         catch {
             return undefined;
         }
+        const processLocal = this.processLocalBundle(sessionId);
+        if (processLocal) {
+            const parent = processLocal.state.parentSessionId;
+            return parent === null || typeof parent === "string" ? parent : undefined;
+        }
+        if (sessionId.startsWith("qchat-"))
+            return undefined;
         const stateFile = join(this.sessionsDir, sessionId, "state.json");
         if (!existsSync(stateFile))
             return undefined;
@@ -556,7 +622,7 @@ export class SessionManager {
         }
     }
     /**
-     * Disk-only workspace pointer reader. Legacy sessions written before
+     * Workspace pointer reader. Legacy sessions written before
      * `workspace` existed are treated as main-workspace sessions rooted at
      * `state.cwd`; the read is intentionally non-mutating.
      */
@@ -567,6 +633,16 @@ export class SessionManager {
         catch {
             return undefined;
         }
+        const processLocal = this.processLocalBundle(sessionId);
+        if (processLocal) {
+            const state = processLocal.state;
+            if (isSessionWorkspace(state.workspace))
+                return structuredClone(state.workspace);
+            const mainRoot = sessionMainRoot(state);
+            return mainRoot ? { root: mainRoot, kind: "main" } : undefined;
+        }
+        if (sessionId.startsWith("qchat-"))
+            return undefined;
         const stateFile = join(this.sessionsDir, sessionId, "state.json");
         if (!existsSync(stateFile))
             return undefined;
@@ -601,6 +677,11 @@ export class SessionManager {
         catch {
             return undefined;
         }
+        const processLocal = this.processLocalBundle(sessionId);
+        if (processLocal)
+            return processLocal.state.archivedAt;
+        if (sessionId.startsWith("qchat-"))
+            return undefined;
         const stateFile = join(this.sessionsDir, sessionId, "state.json");
         if (!existsSync(stateFile))
             return undefined;
@@ -618,6 +699,19 @@ export class SessionManager {
     }
     recordWorkspaceHandoff(sessionId, from, to) {
         assertSafeSessionId(sessionId);
+        const processLocal = this.processLocalBundle(sessionId);
+        if (processLocal) {
+            processLocal.transcript.append("session_meta", {
+                sessionId,
+                cwd: to.root,
+                workspace: to,
+                handoffFrom: from?.root,
+                handoffAt: Date.now(),
+            });
+            return;
+        }
+        if (sessionId.startsWith("qchat-"))
+            return;
         const transcriptFile = join(this.sessionsDir, sessionId, "transcript.jsonl");
         if (!existsSync(transcriptFile))
             return;
@@ -645,15 +739,13 @@ export class SessionManager {
      */
     async resolveSessionWorkspaceForResume(sessionId) {
         assertSafeSessionId(sessionId);
-        const stateFile = join(this.sessionsDir, sessionId, "state.json");
-        if (!existsSync(stateFile)) {
-            throw new SessionError(`Session state file not found: ${sessionId}`);
-        }
         let state;
         try {
-            state = JSON.parse(readFileSync(stateFile, "utf-8"));
+            state = this.readPersistedState(sessionId);
         }
         catch (err) {
+            if (err instanceof SessionError)
+                throw err;
             throw new SessionError(`Session state is corrupt for ${sessionId}: ${err instanceof Error ? err.message : String(err)}`);
         }
         const mainRoot = sessionMainRoot(state);
@@ -731,6 +823,26 @@ export class SessionManager {
         catch {
             return undefined;
         }
+        const processLocal = this.processLocalBundle(sessionId);
+        if (processLocal) {
+            try {
+                const state = hydrateGoalLifecycle(structuredClone(processLocal.state));
+                const lifecycle = state.goalLifecycle;
+                if (!lifecycle || lifecycle.phase === "terminal")
+                    return undefined;
+                const goal = goalConfigFromLifecycle(lifecycle);
+                return {
+                    ...goal,
+                    goalId: goal.goalId ?? deriveLegacyGoalId(sessionId, goal),
+                    revision: goal.revision ?? 1,
+                };
+            }
+            catch {
+                return undefined;
+            }
+        }
+        if (sessionId.startsWith("qchat-"))
+            return undefined;
         const stateFile = join(this.sessionsDir, sessionId, "state.json");
         if (!existsSync(stateFile))
             return undefined;
@@ -873,6 +985,18 @@ export class SessionManager {
     }
     resume(sessionId) {
         assertSafeSessionId(sessionId);
+        const processLocal = this.processLocalBundle(sessionId);
+        if (processLocal) {
+            const state = hydrateGoalLifecycle(structuredClone(processLocal.state));
+            state.kind = normalizedSessionKind(state.kind);
+            state.status = "active";
+            delete state.lastCompletionKind;
+            Object.assign(state, normalizeCumulativeUsageCounters(state, state.tokenUsage));
+            return { state, transcript: processLocal.transcript };
+        }
+        if (sessionId.startsWith("qchat-")) {
+            throw new SessionError(`Session not found: ${sessionId}`);
+        }
         const sessionDir = join(this.sessionsDir, sessionId);
         if (!existsSync(sessionDir)) {
             throw new SessionError(`Session not found: ${sessionId}`);
@@ -1166,6 +1290,34 @@ export class SessionManager {
             (currentSessionCloseEpochs.get(this.generationKey(state.sessionId)) ?? 0) !== writerGeneration) {
             return { ok: false, reason: "generation_conflict" };
         }
+        const processLocal = this.processLocalBundle(state.sessionId);
+        if (processLocal) {
+            const persisted = structuredClone(processLocal.state);
+            const incomingKind = normalizedSessionKind(state.kind);
+            const persistedKind = normalizedSessionKind(persisted.kind);
+            if (incomingKind !== persistedKind)
+                return { ok: false, reason: "kind_conflict" };
+            state.kind = persistedKind;
+            const persistedRevision = persisted.stateRevision;
+            const incomingRevision = state.stateRevision;
+            const revisionsMatch = (persistedRevision === undefined && incomingRevision === undefined) ||
+                (typeof persistedRevision === "number" && incomingRevision === persistedRevision);
+            if (!revisionsMatch)
+                return { ok: false, reason: "revision_conflict" };
+            if (persisted.title !== undefined && !("title" in state))
+                state.title = persisted.title;
+            state.stateRevision = (persistedRevision ?? incomingRevision ?? 0) + 1;
+            const next = hydrateGoalLifecycle(structuredClone(stateForPersistence(state)));
+            this.rebaseLiveState(processLocal.state, next);
+            if (state !== processLocal.state)
+                this.rebaseLiveState(state, next);
+            return { ok: true };
+        }
+        // A closed process-local session must stay gone even if a late writer
+        // races the close fence.
+        if (isEphemeralSessionState(state)) {
+            return { ok: false, reason: "revision_conflict" };
+        }
         const sessionDir = join(this.sessionsDir, state.sessionId);
         mkdirSync(sessionDir, { recursive: true });
         const target = join(sessionDir, "state.json");
@@ -1272,6 +1424,12 @@ export class SessionManager {
         }
     }
     readPersistedState(sessionId) {
+        const processLocal = this.processLocalBundle(sessionId);
+        if (processLocal)
+            return hydrateGoalLifecycle(structuredClone(processLocal.state));
+        if (sessionId.startsWith("qchat-")) {
+            throw new SessionError(`Session state file not found: ${sessionId}`);
+        }
         const stateFile = join(this.sessionsDir, sessionId, "state.json");
         if (!existsSync(stateFile)) {
             throw new SessionError(`Session state file not found: ${sessionId}`);
@@ -1322,6 +1480,13 @@ export class SessionManager {
     /** Freeze and validate an inclusive source range before any model call. */
     selectContextPackage(sourceSessionId, range) {
         assertSafeSessionId(sourceSessionId);
+        const processLocal = this.processLocalBundle(sourceSessionId);
+        if (processLocal) {
+            return Transcript.selectContextRange(processLocal.transcript.getEvents(), range);
+        }
+        if (sourceSessionId.startsWith("qchat-")) {
+            throw new SessionError(`Session not found: ${sourceSessionId}`);
+        }
         const transcriptFile = join(this.sessionsDir, sourceSessionId, "transcript.jsonl");
         const stateFile = join(this.sessionsDir, sourceSessionId, "state.json");
         if (!existsSync(stateFile))
@@ -1377,6 +1542,13 @@ export class SessionManager {
         return { bundle, lineage, copiedEventCount: 0 };
     }
     readForkSnapshot(sourceSessionId, throughEventId, snapshotMode) {
+        const processLocal = this.processLocalBundle(sourceSessionId);
+        if (processLocal) {
+            return this.freezeForkSnapshot(sourceSessionId, structuredClone(processLocal.state), processLocal.transcript.getEvents(), throughEventId, snapshotMode);
+        }
+        if (sourceSessionId.startsWith("qchat-")) {
+            throw new SessionError(`Session not found: ${sourceSessionId}`);
+        }
         const sessionDir = join(this.sessionsDir, sourceSessionId);
         const stateFile = join(sessionDir, "state.json");
         const transcriptFile = join(sessionDir, "transcript.jsonl");
@@ -1393,7 +1565,10 @@ export class SessionManager {
         if (parsed.malformedLineCount > 0) {
             throw new SessionError(`Session transcript is malformed for ${sourceSessionId}: ${parsed.malformedLineCount} invalid line(s)`);
         }
-        const sourceEvents = structuredClone(parsed.events);
+        return this.freezeForkSnapshot(sourceSessionId, sourceState, parsed.events, throughEventId, snapshotMode);
+    }
+    freezeForkSnapshot(sourceSessionId, sourceState, events, throughEventId, snapshotMode) {
+        const sourceEvents = structuredClone([...events]);
         let frozen = sourceEvents;
         const effectiveCursor = snapshotMode === "completed" ? sourceState.completedThroughEventId : throughEventId;
         if (snapshotMode === "completed" && effectiveCursor === undefined) {
@@ -1436,6 +1611,17 @@ export class SessionManager {
     }
     publishSessionAtomically(targetSessionId, state, events) {
         const targetDir = join(this.sessionsDir, targetSessionId);
+        if (isEphemeralSessionState(state)) {
+            if (this.processLocalBundle(targetSessionId) || existsSync(targetDir)) {
+                throw new SessionError(`Session already exists: ${targetSessionId}`);
+            }
+            const bundle = {
+                state: hydrateGoalLifecycle(structuredClone(state)),
+                transcript: Transcript.fromMemoryEvents(targetSessionId, events),
+            };
+            this.storeProcessLocalBundle(bundle);
+            return bundle;
+        }
         if (existsSync(targetDir))
             throw new SessionError(`Session already exists: ${targetSessionId}`);
         const stagingDir = join(this.sessionsDir, `.pending-fork-${targetSessionId}-${nanoid(8)}`);

package/dist/session/transcript.d.ts

@@ -48,10 +48,18 @@ export declare class Transcript {
     private filePath;
     private currentTurn;
     private readonly writer;
+    private readonly persistent;
     private dirty;
     private lastFlushFailure;
     getFilePath(): string;
-    constructor(filePath: string, writer?: TranscriptWriter);
+    constructor(filePath: string, writer?: TranscriptWriter, options?: {
+        persistent?: boolean;
+    });
+    /** A process-local transcript that never creates or appends a file. */
+    static inMemory(label: string): Transcript;
+    /** Rehydrate a process-local fork without serializing its copied history. */
+    static fromMemoryEvents(label: string, events: readonly TranscriptEvent[]): Transcript;
+    isPersistent(): boolean;
     append(type: TranscriptEventType, data: Record<string, unknown>): TranscriptEvent;
     /**
      * Append a chat message to the transcript.
@@ -116,9 +124,16 @@ export declare class Transcript {
     private errorErrno;
     private errorMessage;
     /**
-     * Repair tool_result pairing issues:
-     * - Orphaned tool_results (no matching tool_use) get removed
-     * - Missing tool_results (tool_use with no result) get synthetic error results
+     * Normalize tool_result pairing in this detached in-memory snapshot:
+     * - orphaned results are removed;
+     * - duplicate results collapse to one, preferring a real result over the
+     *   legacy synthetic interrupted placeholder;
+     * - missing results remain missing. The run-resume boundary patches those
+     *   in its request-local Message[] after it has established ownership.
+     *
+     * This method must never append to the JSONL file. loadFromFile is used by
+     * read-only/background consumers while another run may be waiting for tool
+     * approval; persisting a synthetic result there races the real executor.
      */
     repairToolResultPairs(): void;
     static readEvents(filePath: string): ParsedEvents;
@@ -133,5 +148,6 @@ export declare class Transcript {
      */
     static selectContextRange(events: readonly TranscriptEvent[], range: ContextEventRange): SelectedContextRange;
     static loadFromFile(filePath: string): Transcript;
+    private loadEvents;
 }
 export {};

package/dist/session/transcript.js

@@ -13,24 +13,84 @@ const CONTEXT_EVENT_TYPES = new Set([
     "summary",
     "context_transfer",
 ]);
+const INTERRUPTED_TOOL_RESULT_ERROR = "[Tool result missing due to interrupted session]";
+function isSyntheticInterruptedToolResult(event) {
+    return (event.type === "tool_result" &&
+        event.data.toolName === "unknown" &&
+        event.data.error === INTERRUPTED_TOOL_RESULT_ERROR);
+}
+/**
+ * Choose at most one result for every declared tool call. A real late result
+ * wins over the legacy synthetic "interrupted" placeholder that an older
+ * reader could persist while the tool was merely waiting for approval.
+ */
+function preferredToolResults(events) {
+    const toolUseIds = new Set();
+    for (const event of events) {
+        if (event.type === "tool_use" && typeof event.data.toolCallId === "string") {
+            toolUseIds.add(event.data.toolCallId);
+        }
+        if (event.type === "message" &&
+            event.data.role === "assistant" &&
+            Array.isArray(event.data.content)) {
+            for (const block of event.data.content) {
+                if (block.type === "tool_use" && typeof block.id === "string") {
+                    toolUseIds.add(block.id);
+                }
+            }
+        }
+    }
+    const preferred = new Map();
+    for (const event of events) {
+        if (event.type !== "tool_result")
+            continue;
+        const toolCallId = event.data.toolCallId;
+        if (typeof toolCallId !== "string" || !toolUseIds.has(toolCallId))
+            continue;
+        const current = preferred.get(toolCallId);
+        if (!current ||
+            isSyntheticInterruptedToolResult(current) ||
+            !isSyntheticInterruptedToolResult(event)) {
+            preferred.set(toolCallId, event);
+        }
+    }
+    return preferred;
+}
 export class Transcript {
     events = [];
     filePath;
     currentTurn = 0;
     writer;
+    persistent;
     dirty = false;
     lastFlushFailure;
     getFilePath() {
         return this.filePath;
     }
-    constructor(filePath, writer = appendFileSync) {
+    constructor(filePath, writer = appendFileSync, options = {}) {
         this.filePath = filePath;
         this.writer = writer;
+        this.persistent = options.persistent !== false;
+        if (!this.persistent)
+            return;
         mkdirSync(dirname(filePath), { recursive: true });
         if (!existsSync(filePath)) {
             writeFileSync(filePath, "", "utf-8");
         }
     }
+    /** A process-local transcript that never creates or appends a file. */
+    static inMemory(label) {
+        return new Transcript(`<memory:${label}>`, () => undefined, { persistent: false });
+    }
+    /** Rehydrate a process-local fork without serializing its copied history. */
+    static fromMemoryEvents(label, events) {
+        const transcript = Transcript.inMemory(label);
+        transcript.loadEvents(events);
+        return transcript;
+    }
+    isPersistent() {
+        return this.persistent;
+    }
     append(type, data) {
         const event = {
             id: nanoid(12),
@@ -161,6 +221,7 @@ export class Transcript {
      */
     toMessages() {
         const messages = [];
+        const selectedToolResults = preferredToolResults(this.events);
         for (const event of this.events) {
             switch (event.type) {
                 case "message": {
@@ -174,6 +235,11 @@ export class Transcript {
                     break;
                 }
                 case "tool_result": {
+                    const eventToolCallId = event.data.toolCallId;
+                    if (typeof eventToolCallId !== "string" ||
+                        selectedToolResults.get(eventToolCallId) !== event) {
+                        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];
@@ -243,6 +309,8 @@ export class Transcript {
             event.data.clientMessageId === clientMessageId);
     }
     flush(event) {
+        if (!this.persistent)
+            return true;
         const line = JSON.stringify(event) + "\n";
         try {
             this.writer(this.filePath, line, "utf-8");
@@ -290,39 +358,24 @@ export class Transcript {
         return error instanceof Error ? error.message : String(error);
     }
     /**
-     * Repair tool_result pairing issues:
-     * - Orphaned tool_results (no matching tool_use) get removed
-     * - Missing tool_results (tool_use with no result) get synthetic error results
+     * Normalize tool_result pairing in this detached in-memory snapshot:
+     * - orphaned results are removed;
+     * - duplicate results collapse to one, preferring a real result over the
+     *   legacy synthetic interrupted placeholder;
+     * - missing results remain missing. The run-resume boundary patches those
+     *   in its request-local Message[] after it has established ownership.
+     *
+     * This method must never append to the JSONL file. loadFromFile is used by
+     * read-only/background consumers while another run may be waiting for tool
+     * approval; persisting a synthetic result there races the real executor.
      */
     repairToolResultPairs() {
-        const toolUseIds = new Set();
-        const toolResultIds = new Set();
-        for (const event of this.events) {
-            if (event.type === "tool_use") {
-                toolUseIds.add(event.data.toolCallId);
-            }
-            else if (event.type === "tool_result") {
-                toolResultIds.add(event.data.toolCallId);
-            }
-        }
-        // Find tool_use events without matching tool_result
-        for (const id of toolUseIds) {
-            if (!toolResultIds.has(id)) {
-                // Synthesize an error result
-                this.append("tool_result", {
-                    toolCallId: id,
-                    toolName: "unknown",
-                    error: "[Tool result missing due to interrupted session]",
-                });
-            }
-        }
-        // Remove orphaned tool_results (result without matching use)
+        const selectedToolResults = preferredToolResults(this.events);
         this.events = this.events.filter((event) => {
-            if (event.type === "tool_result") {
-                const id = event.data.toolCallId;
-                return toolUseIds.has(id);
-            }
-            return true;
+            if (event.type !== "tool_result")
+                return true;
+            const toolCallId = event.data.toolCallId;
+            return typeof toolCallId === "string" && selectedToolResults.get(toolCallId) === event;
         });
     }
     static readEvents(filePath) {
@@ -436,22 +489,30 @@ export class Transcript {
             return transcript;
         const content = readFileSync(filePath, "utf-8");
         const lines = content.split("\n").filter((l) => l.trim());
+        const events = [];
         for (const line of lines) {
             try {
-                const event = JSON.parse(line);
-                transcript.events.push(event);
-                if (event.type === "turn_boundary") {
-                    transcript.currentTurn = event.data.turnNumber ?? transcript.currentTurn + 1;
-                }
+                events.push(JSON.parse(line));
             }
             catch {
                 // Skip malformed lines
             }
         }
+        transcript.loadEvents(events);
         // Repair pairing on load
         transcript.repairToolResultPairs();
         return transcript;
     }
+    loadEvents(events) {
+        this.events = structuredClone([...events]);
+        this.currentTurn = 0;
+        for (const event of this.events) {
+            if (event.type === "turn_boundary") {
+                this.currentTurn =
+                    typeof event.data.turnNumber === "number" ? event.data.turnNumber : this.currentTurn + 1;
+            }
+        }
+    }
 }
 function isEngineResultReceipt(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))