praxis-agent 0.32.0 → 0.34.0

package/dist/cli/interactive.d.ts

@@ -58,6 +58,7 @@ interface InteractiveSessionCommands {
     workflows?(): readonly Record<string, unknown>[];
     taskSnapshots?(sessionId: string): Promise<BackgroundTaskSnapshot>;
     stopTask?(sessionId: string, taskId: string): Promise<void>;
+    backgroundForegroundTask?(sessionId: string): void | Promise<void>;
     mcpInspect?(): Promise<readonly ClaudeMcpServerStatus[]>;
     mcpReconnect?(name: string): Promise<void>;
     mcpAuthenticate?(name: string): Promise<void>;

package/dist/cli/interactive.js

@@ -2947,7 +2947,9 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
                     ? ['Confirmation']
                     : selectingSession
                         ? ['Select']
-                        : ['Chat'];
+                        : busy
+                            ? ['Task', 'Chat']
+                            : ['Chat'];
         const inputChord = tuiKeyChord(value, key);
         const pendingSequence = keySequenceRef.current;
         let keybindingAction;
@@ -5140,6 +5142,29 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
             return;
         }
         if (busy) {
+            if (isKeybinding('task:background')) {
+                const backgrounding = (async () => {
+                    try {
+                        const activeSessionId = sessionIdRef.current;
+                        if (!activeSessionId)
+                            throw new Error('No active session');
+                        const commands = await service();
+                        if (!commands.backgroundForegroundTask) {
+                            throw new Error('Foreground Agent backgrounding is unavailable.');
+                        }
+                        await commands.backgroundForegroundTask(activeSessionId);
+                        append({
+                            kind: 'notice',
+                            text: 'Agent moved to background · continuing this turn',
+                        });
+                    }
+                    catch (error) {
+                        warn(error);
+                    }
+                })();
+                void backgrounding;
+                return;
+            }
             if (isKeybinding('chat:cancel'))
                 turnControllerRef.current?.abort();
             return;

package/dist/cli/tui/task-panel.d.ts

@@ -2,7 +2,7 @@ import type { BackgroundAgentSnapshot } from '../../application/background-agent
 import type { BackgroundBashSnapshot } from '../../application/background-bash-manager.js';
 import type { WorkflowTaskSnapshot } from '../../application/workflow-manager.js';
 export type TuiTaskKind = 'shell' | 'agent' | 'workflow';
-export type TuiTaskStatus = 'running' | 'completed' | 'failed' | 'stopped';
+export type TuiTaskStatus = 'running' | 'completed' | 'failed' | 'stopped' | 'interrupted';
 export interface TuiTaskEntry {
     id: string;
     kind: TuiTaskKind;

package/dist/cli/tui/task-panel.js

@@ -21,7 +21,8 @@ function taskStatus(record) {
     if (status === 'running' ||
         status === 'completed' ||
         status === 'failed' ||
-        status === 'stopped') {
+        status === 'stopped' ||
+        status === 'interrupted') {
         return status;
     }
     if (status === 'error')

package/dist/cli-runtime.d.ts

@@ -57,6 +57,7 @@ interface SessionCommands {
         sessionId?: string;
     }): Promise<void>;
     sessions(): Promise<SessionSummary[]>;
+    registerResumePath?(path: string): Promise<SessionSummary>;
     inspect(sessionId: string): Promise<SessionInspection>;
     export(sessionId: string): Promise<Buffer>;
     transcript?(sessionId: string): Promise<ClaudeDisplayTranscriptItem[]>;

package/dist/cli-runtime.js

@@ -3,7 +3,7 @@ import { realpathSync } from 'node:fs';
 import { access, copyFile, mkdir, readFile } from 'node:fs/promises';
 import { createRequire } from 'node:module';
 import { homedir } from 'node:os';
-import { dirname, join, resolve } from 'node:path';
+import { basename, dirname, extname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { randomUUID } from 'node:crypto';
 import { ClaudeSessionService, } from './application/session-service.js';
@@ -882,6 +882,7 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
         claudeVersion,
         eventSink: runtimeEventSink,
         sessionPersistence: cli.sessionPersistence,
+        resumeInterruptedTurn: /^(?:1|true|yes|on)$/iu.test((runtimeEnvironment.CLAUDE_CODE_RESUME_INTERRUPTED_TURN ?? '').trim()),
         costStateStore,
         simpleMode,
         explicitModel: interactiveModel !== undefined || controls.model !== undefined,
@@ -1693,6 +1694,7 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
                 }
             },
             sessions: () => service.sessions(),
+            registerResumePath: (path) => service.registerResumePath(path),
             costSnapshot: (sessionId) => service.costSnapshot(sessionId),
             slashCommands: () => extensions.slashCommandDefinitions().map((definition) => ({
                 name: definition.name,
@@ -1998,22 +2000,40 @@ export function createDefaultDependencies(entrypoint = fileURLToPath(import.meta
                     statePath: interactiveStatePath,
                 });
             const effectiveModel = resolveRuntimeModel(interactiveControls.model, process.env, interactiveRuntimeSettings);
+            const resumePath = typeof resume?.sessionSelector === 'string' &&
+                isResumePathSelector(resume.sessionSelector)
+                ? resume.sessionSelector
+                : undefined;
+            let continueSessionFilter;
+            if (interactiveControls.continueSession &&
+                resume?.fromPr === undefined &&
+                resume?.sessionSelector === undefined) {
+                continueSessionFilter = await createContinueSessionFilter(liveTopLevelSessions(dependencies, interactiveDataPlane));
+            }
+            const createInteractiveService = async (options) => {
+                const commands = await createDefaultService({
+                    ...options,
+                    ...(options.cwd === undefined ? {} : { cwd: options.cwd }),
+                    sandboxOriginalCwd: process.cwd(),
+                    ...(agent === undefined ? {} : { agent }),
+                    controls: {
+                        ...interactiveControls,
+                        addDirectories: options.additionalDirectories ??
+                            interactiveControls.addDirectories,
+                    },
+                    interactive: true,
+                });
+                if (resumePath !== undefined) {
+                    await commands.registerResumePath?.(resumePath);
+                }
+                return commands;
+            };
             return runInteractive({
                 dataPlane: interactiveDataPlane,
                 configRoot: interactiveConfigRoot,
                 statePath: interactiveStatePath,
                 factory: {
-                    createService: ({ additionalDirectories, cwd, ...options }) => createDefaultService({
-                        ...options,
-                        ...(cwd === undefined ? {} : { cwd }),
-                        sandboxOriginalCwd: process.cwd(),
-                        ...(agent === undefined ? {} : { agent }),
-                        controls: {
-                            ...interactiveControls,
-                            addDirectories: additionalDirectories ?? interactiveControls.addDirectories,
-                        },
-                        interactive: true,
-                    }),
+                    createService: createInteractiveService,
                     scheduledPrompts: Boolean(process.env.PRAXIS_API_KEY && effectiveModel),
                 },
                 ...(signal ? { signal } : {}),
@@ -2056,15 +2076,22 @@ export function createDefaultDependencies(entrypoint = fileURLToPath(import.meta
                         sessionFilter: createClaudePrSessionFilter(resume.fromPr),
                         requireSession: true,
                     }
-                    : resume?.sessionSelector === undefined
-                        ? {}
-                        : {
-                            sessionFilter: createResumeSessionFilter(resume.sessionSelector),
+                    : resume?.sessionSelector !== undefined
+                        ? {
+                            sessionFilter: createResumeSessionFilter(resumePathSessionId(resume.sessionSelector) ??
+                                resume.sessionSelector),
                             requireSession: true,
                             missingSessionMessage: isClaudeSessionId(resume.sessionSelector)
                                 ? `No conversation found with session ID: ${resume.sessionSelector}`
                                 : `No conversation found matching: ${resume.sessionSelector}`,
-                        }),
+                        }
+                        : continueSessionFilter === undefined
+                            ? {}
+                            : {
+                                sessionFilter: continueSessionFilter,
+                                requireSession: true,
+                                missingSessionMessage: 'No conversation found to continue',
+                            }),
                 ...(resume?.requireSession ? { requireSession: true } : {}),
             });
         },
@@ -2116,7 +2143,7 @@ function writeJson(io, value) {
 }
 function formatSessionIssue(issue) {
     return issue
-        ? `line ${issue.lineNumber}, byte ${issue.byteOffset}: ${issue.message}`
+        ? `${issue.lineNumber === null ? '' : `line ${issue.lineNumber}, `}byte ${issue.byteOffset}: ${issue.message}`
         : '';
 }
 function selectPrLinkedSession(sessions, selector) {
@@ -2132,14 +2159,45 @@ function selectPrLinkedSession(sessions, selector) {
     }
     return matches[0];
 }
-function selectImplicitResumeSession(sessions, fromPr) {
+async function selectImplicitResumeSession(sessions, fromPr, liveSessions) {
     if (fromPr !== undefined)
         return selectPrLinkedSession(sessions, fromPr);
-    const latest = sessions[0];
+    const filter = await createContinueSessionFilter(liveSessions);
+    const eligible = filter === undefined ? sessions : sessions.filter(filter);
+    const latest = eligible[0];
     if (!latest)
         throw new Error('No conversation found to continue');
     return latest;
 }
+async function createContinueSessionFilter(liveSessions) {
+    if (liveSessions === undefined)
+        return undefined;
+    try {
+        const liveBackgroundIds = new Set((await liveSessions())
+            .filter((agent) => ['background', 'bg', 'daemon', 'daemon-worker'].includes(agent.kind))
+            .filter((agent) => agent.state === 'working' || agent.status !== undefined)
+            .map((agent) => agent.sessionId));
+        return (session) => !liveBackgroundIds.has(session.sessionId);
+    }
+    catch {
+        // Deterministic local ordering remains the fallback when the optional
+        // liveness registry is unavailable or unreadable.
+        return undefined;
+    }
+}
+function liveTopLevelSessions(dependencies, dataPlane) {
+    let manager;
+    try {
+        manager = dependencies.createTopLevelAgents?.(dataPlane);
+        manager ??= dependencies.topLevelAgents;
+    }
+    catch {
+        return undefined;
+    }
+    return manager === undefined
+        ? undefined
+        : () => manager.list({ cwd: process.cwd(), all: false });
+}
 function missingResumeSelectorMessage(invocation) {
     if (invocation.print) {
         return '--resume requires a valid session ID or session title when used with --print. Usage: praxis -p --resume <session-id|title>';
@@ -2167,6 +2225,24 @@ function selectResumeSession(sessions, selector, invocation) {
     }
     throw new Error(`${missingResumeSelectorMessage(invocation)}. Provided value "${selector}" is not a UUID and does not match any session title.`);
 }
+function isResumePathSelector(selector) {
+    return extname(selector).toLowerCase() === '.jsonl';
+}
+function resumePathSessionId(selector) {
+    if (!isResumePathSelector(selector))
+        return undefined;
+    const sessionId = basename(selector, extname(selector));
+    return isClaudeSessionId(sessionId) ? sessionId : undefined;
+}
+async function resolveExplicitResumeSession(service, selector, invocation) {
+    if (isResumePathSelector(selector)) {
+        if (!service.registerResumePath) {
+            throw new Error('Explicit Claude transcript path resume is unavailable');
+        }
+        return service.registerResumePath(selector);
+    }
+    return selectResumeSession(await service.sessions(), selector, invocation);
+}
 function createResumeSessionFilter(selector) {
     const normalized = selector.toLowerCase();
     if (isClaudeSessionId(selector)) {
@@ -4268,8 +4344,12 @@ async function execute(argv, io, dependencies, signal) {
                 ...(typeof invocation.resumeSelector === 'string'
                     ? {
                         sessionSelector: invocation.resumeSelector,
-                        ...(isClaudeSessionId(invocation.resumeSelector)
-                            ? { sessionId: invocation.resumeSelector }
+                        ...(isClaudeSessionId(invocation.resumeSelector) ||
+                            resumePathSessionId(invocation.resumeSelector) !== undefined
+                            ? {
+                                sessionId: resumePathSessionId(invocation.resumeSelector) ??
+                                    invocation.resumeSelector,
+                            }
                             : {}),
                     }
                     : {}),
@@ -4480,12 +4560,12 @@ async function execute(argv, io, dependencies, signal) {
                 controls: invocation,
             });
             try {
-                const sessions = await sessionService.sessions();
                 if (explicitResumeSelector !== undefined) {
-                    resumeSessionId = selectResumeSession(sessions, explicitResumeSelector, invocation).sessionId;
+                    resumeSessionId = (await resolveExplicitResumeSession(sessionService, explicitResumeSelector, invocation)).sessionId;
                 }
                 else {
-                    resumeSessionId = selectImplicitResumeSession(sessions, invocation.fromPr).sessionId;
+                    const sessions = await sessionService.sessions();
+                    resumeSessionId = (await selectImplicitResumeSession(sessions, invocation.fromPr, liveTopLevelSessions(dependencies, invocation.dataPlane ?? resolveDataPlane()))).sessionId;
                 }
                 if (invocation.forkSession) {
                     resumeSessionId = (await sessionService.fork(resumeSessionId, invocation.sessionId)).sessionId;
@@ -4872,12 +4952,12 @@ async function execute(argv, io, dependencies, signal) {
         if (explicitResumeSelector !== undefined ||
             invocation.continueSession ||
             invocation.fromPr !== undefined) {
-            const sessions = await service.sessions();
-            existingSessionId =
-                explicitResumeSelector === undefined
-                    ? selectImplicitResumeSession(sessions, invocation.fromPr).sessionId
-                    : selectResumeSession(sessions, explicitResumeSelector, invocation)
-                        .sessionId;
+            if (explicitResumeSelector === undefined) {
+                existingSessionId = (await selectImplicitResumeSession(await service.sessions(), invocation.fromPr, liveTopLevelSessions(dependencies, dataPlane))).sessionId;
+            }
+            else {
+                existingSessionId = (await resolveExplicitResumeSession(service, explicitResumeSelector, invocation)).sessionId;
+            }
         }
         if (existingSessionId && invocation.forkSession) {
             existingSessionId = (await service.fork(existingSessionId, invocation.sessionId)).sessionId;

package/dist/compatibility/claude/history.d.ts

@@ -1,4 +1,12 @@
 import type { ClaudeTranscriptEntry } from './schema.js';
+export declare function isClaudeDurableLastPromptSnapshot(entries: readonly ClaudeTranscriptEntry[], index: number): boolean;
 export declare function selectClaudeActiveTranscript(entries: readonly ClaudeTranscriptEntry[]): ClaudeTranscriptEntry[];
+/** Validates and selects ancestry from the newest structural non-sidechain
+ * entry. Explicit path resume uses this instead of potentially stale
+ * last-prompt metadata. */
+export declare function selectClaudeTranscriptFromNewestLeaf(entries: readonly ClaudeTranscriptEntry[]): {
+    entries: ClaudeTranscriptEntry[];
+    leafUuid: string;
+};
 export declare function selectClaudeTranscriptAtMessage(entries: readonly ClaudeTranscriptEntry[], messageUuid: string): ClaudeTranscriptEntry[];
 //# sourceMappingURL=history.d.ts.map

package/dist/compatibility/claude/history.js

@@ -1,7 +1,37 @@
 import { getClaudePreservedMessageUuids } from './compaction.js';
+import { isClaudeDurableMetadataType } from './session-metadata.js';
 function entryUuid(entry) {
     return typeof entry.uuid === 'string' ? entry.uuid : null;
 }
+const ADDITIONAL_NON_STRUCTURAL_ENTRY_TYPES = new Set([
+    'queue-operation',
+    'relocated',
+]);
+function isNonStructuralEntryType(type) {
+    return (isClaudeDurableMetadataType(type) ||
+        ADDITIONAL_NON_STRUCTURAL_ENTRY_TYPES.has(type));
+}
+export function isClaudeDurableLastPromptSnapshot(entries, index) {
+    const entry = entries[index];
+    if (entry?.type !== 'last-prompt')
+        return false;
+    for (let prior = index - 1; prior >= 0; prior -= 1) {
+        const candidate = entries[prior];
+        if (candidate?.type !== 'last-prompt' ||
+            candidate.sessionId !== entry.sessionId ||
+            candidate.leafUuid !== entry.leafUuid ||
+            candidate.lastPrompt !== entry.lastPrompt) {
+            continue;
+        }
+        const structuralEntries = entries
+            .slice(prior + 1, index)
+            .filter((between) => between.isSidechain !== true &&
+            typeof between.uuid === 'string' &&
+            !isNonStructuralEntryType(between.type));
+        return structuralEntries.length > 0;
+    }
+    return false;
+}
 function latestLeafUuid(entries) {
     for (let index = entries.length - 1; index >= 0; index -= 1) {
         const summary = entries[index];
@@ -29,6 +59,8 @@ function latestLeafUuid(entries) {
         if (!entry || entry.isSidechain === true)
             continue;
         if (entry.type === 'last-prompt' && typeof entry.leafUuid === 'string') {
+            if (isClaudeDurableLastPromptSnapshot(entries, index))
+                continue;
             return entry.leafUuid;
         }
         const uuid = entryUuid(entry);
@@ -155,6 +187,28 @@ export function selectClaudeActiveTranscript(entries) {
     }
     return expandPreservedMessages(entries, selectAncestry(entries, leafUuid));
 }
+/** Validates and selects ancestry from the newest structural non-sidechain
+ * entry. Explicit path resume uses this instead of potentially stale
+ * last-prompt metadata. */
+export function selectClaudeTranscriptFromNewestLeaf(entries) {
+    let leafUuid;
+    for (let index = entries.length - 1; index >= 0; index -= 1) {
+        const entry = entries[index];
+        if (entry?.isSidechain !== true &&
+            !isNonStructuralEntryType(entry?.type ?? '') &&
+            typeof entry?.uuid === 'string') {
+            leafUuid = entry.uuid;
+            break;
+        }
+    }
+    if (leafUuid === undefined) {
+        throw new Error('Claude transcript has no resumable non-sidechain leaf');
+    }
+    return {
+        entries: expandPreservedMessages(entries, selectAncestry(entries, leafUuid)),
+        leafUuid,
+    };
+}
 export function selectClaudeTranscriptAtMessage(entries, messageUuid) {
     const active = selectClaudeActiveTranscript(entries);
     const target = active.find((entry) => entry.uuid === messageUuid &&

package/dist/compatibility/claude/interruption.d.ts

@@ -0,0 +1,16 @@
+import type { ClaudeTranscriptEntry } from './schema.js';
+export type ClaudeInterruptionClassification = {
+    kind: 'complete';
+} | {
+    kind: 'none';
+} | {
+    kind: 'interrupted-prompt' | 'interrupted-turn';
+    prompt?: string;
+    replayEntries?: ClaudeTranscriptEntry[];
+    replayParentUuid?: string | null;
+};
+export declare const CLAUDE_INTERRUPTED_TURN_CONTINUATION = "Continue the interrupted turn using the available tool results and context.";
+/** Classifies only model-visible active-tail state; passive metadata never
+ * creates a phantom continuation. */
+export declare function classifyClaudeInterruption(source: readonly ClaudeTranscriptEntry[]): ClaudeInterruptionClassification;
+//# sourceMappingURL=interruption.d.ts.map

package/dist/compatibility/claude/interruption.js

@@ -0,0 +1,147 @@
+import { selectClaudeActiveTranscript } from './history.js';
+export const CLAUDE_INTERRUPTED_TURN_CONTINUATION = 'Continue the interrupted turn using the available tool results and context.';
+const PASSIVE_METADATA_TYPES = new Set([
+    'agent-color',
+    'agent-name',
+    'agent-setting',
+    'ai-title',
+    'custom-title',
+    'file-history-delta',
+    'file-history-snapshot',
+    'last-prompt',
+    'mode',
+    'permission-mode',
+    'pr-link',
+    'queue-operation',
+    'relocated',
+    'tag',
+    'worktree-state',
+]);
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function contentBlocks(entry) {
+    if (!isRecord(entry.message) || !Array.isArray(entry.message.content)) {
+        return [];
+    }
+    return entry.message.content.filter(isRecord);
+}
+function plainUserPrompt(entry) {
+    if (entry.type !== 'user' ||
+        entry.isMeta === true ||
+        entry.isCompactSummary === true ||
+        !isRecord(entry.message) ||
+        entry.message.role !== 'user') {
+        return undefined;
+    }
+    if (typeof entry.message.content === 'string') {
+        const prompt = entry.message.content.trim();
+        if (prompt.length === 0 ||
+            /^<(?:command-name|local-command-caveat|local-command-stdout)>/u.test(prompt)) {
+            return undefined;
+        }
+        return entry.message.content;
+    }
+    if (!Array.isArray(entry.message.content))
+        return undefined;
+    const blocks = entry.message.content.filter(isRecord);
+    if (blocks.some((block) => block.type === 'tool_result'))
+        return undefined;
+    const text = blocks
+        .filter((block) => block.type === 'text' && typeof block.text === 'string')
+        .map((block) => String(block.text))
+        .join('');
+    return text.trim().length === 0 ? undefined : text;
+}
+function continuationState(entries, throughIndex) {
+    const replayEntries = entries.slice(0, throughIndex + 1);
+    const replayParentUuid = [...replayEntries]
+        .reverse()
+        .find((entry) => typeof entry.uuid === 'string')?.uuid;
+    return {
+        prompt: CLAUDE_INTERRUPTED_TURN_CONTINUATION,
+        replayEntries,
+        replayParentUuid: typeof replayParentUuid === 'string' ? replayParentUuid : null,
+    };
+}
+function assistantHasVisibleText(entry) {
+    if (!isRecord(entry.message) || entry.message.role !== 'assistant') {
+        return false;
+    }
+    if (typeof entry.message.content === 'string') {
+        return entry.message.content.trim().length > 0;
+    }
+    return contentBlocks(entry).some((block) => block.type === 'text' &&
+        typeof block.text === 'string' &&
+        block.text.trim().length > 0);
+}
+function terminalToolResult(entry) {
+    if (entry.toolDenialKind !== undefined)
+        return true;
+    const blocks = contentBlocks(entry).filter((block) => block.type === 'tool_result');
+    return (blocks.length > 0 &&
+        blocks.every((block) => block.is_error === true &&
+            typeof block.content === 'string' &&
+            /(?:user (?:rejected|declined)|doesn't want to proceed|interrupted)/iu.test(block.content)));
+}
+/** Classifies only model-visible active-tail state; passive metadata never
+ * creates a phantom continuation. */
+export function classifyClaudeInterruption(source) {
+    const entries = selectClaudeActiveTranscript(source);
+    for (let index = entries.length - 1; index >= 0; index -= 1) {
+        const entry = entries[index];
+        if (!entry || entry.isSidechain === true)
+            continue;
+        if (PASSIVE_METADATA_TYPES.has(entry.type))
+            continue;
+        if (entry.type === 'assistant') {
+            if (entry.isApiErrorMessage === true ||
+                entry.synthetic === true ||
+                entry.error === true) {
+                return { kind: 'none' };
+            }
+            if (assistantHasVisibleText(entry))
+                return { kind: 'complete' };
+            // Thinking-only, whitespace, and unresolved tool-use-only assistants do
+            // not hide the user prompt that was interrupted before a valid answer.
+            continue;
+        }
+        if (entry.type === 'user') {
+            if (entry.isCompactSummary === true)
+                return { kind: 'none' };
+            const blocks = contentBlocks(entry);
+            if (blocks.some((block) => block.type === 'tool_result')) {
+                if (terminalToolResult(entry))
+                    return { kind: 'none' };
+                return {
+                    kind: 'interrupted-turn',
+                    ...continuationState(entries, index),
+                };
+            }
+            const prompt = plainUserPrompt(entry);
+            if (prompt !== undefined) {
+                return {
+                    kind: 'interrupted-prompt',
+                    prompt,
+                    replayEntries: entries.slice(0, index),
+                    replayParentUuid: typeof entry.parentUuid === 'string' ? entry.parentUuid : null,
+                };
+            }
+            return { kind: 'none' };
+        }
+        if (entry.type === 'attachment') {
+            return {
+                kind: 'interrupted-turn',
+                ...continuationState(entries, index),
+            };
+        }
+        if (entry.type === 'system' &&
+            (entry.subtype === 'compact_boundary' ||
+                entry.subtype === 'api_error' ||
+                entry.subtype === 'local_command')) {
+            return { kind: 'none' };
+        }
+    }
+    return { kind: 'none' };
+}
+//# sourceMappingURL=interruption.js.map

package/dist/compatibility/claude/projection.d.ts

@@ -34,6 +34,10 @@ export type ClaudeDisplayTranscriptItem = {
 export declare function projectClaudeDisplayTranscript(entries: readonly ClaudeTranscriptEntry[]): ClaudeDisplayTranscriptItem[];
 export declare function projectClaudeTextMessages(entries: readonly ClaudeTranscriptEntry[]): ClaudeTextMessage[];
 export declare function projectClaudeModelMessages(entries: readonly ClaudeTranscriptEntry[]): ModelMessage[];
+/** Builds restart/SendMessage context without mutating the retained sidechain.
+ * Only complete tool call/result pairs survive. Ambiguous duplicate IDs fail
+ * locally because silently choosing one could resume the wrong operation. */
+export declare function projectClaudeSidechainContinuationMessages(entries: readonly ClaudeTranscriptEntry[]): ModelMessage[];
 export declare function getClaudeLastPrompt(entries: readonly ClaudeTranscriptEntry[]): string | null;
 export declare function getClaudeAgentSetting(entries: readonly ClaudeTranscriptEntry[]): string | null;
 //# sourceMappingURL=projection.d.ts.map

package/dist/compatibility/claude/projection.js

@@ -432,6 +432,88 @@ export function projectClaudeModelMessages(entries) {
     }
     return messages;
 }
+function sidechainToolResultReplacements(entries) {
+    const replacements = new Map();
+    for (const entry of entries) {
+        if (entry.type !== 'content-replacement' ||
+            !Array.isArray(entry.replacements)) {
+            continue;
+        }
+        for (const replacement of entry.replacements) {
+            if (isRecord(replacement) &&
+                replacement.kind === 'tool-result' &&
+                typeof replacement.toolUseId === 'string' &&
+                typeof replacement.replacement === 'string') {
+                replacements.set(replacement.toolUseId, replacement.replacement);
+            }
+        }
+    }
+    return replacements;
+}
+/** Builds restart/SendMessage context without mutating the retained sidechain.
+ * Only complete tool call/result pairs survive. Ambiguous duplicate IDs fail
+ * locally because silently choosing one could resume the wrong operation. */
+export function projectClaudeSidechainContinuationMessages(entries) {
+    const messages = projectClaudeModelMessages(entries);
+    const callCounts = new Map();
+    const resultCounts = new Map();
+    for (const message of messages) {
+        if (message.role === 'assistant') {
+            for (const call of message.toolCalls ?? []) {
+                callCounts.set(call.id, (callCounts.get(call.id) ?? 0) + 1);
+            }
+        }
+        else if (message.role === 'tool') {
+            resultCounts.set(message.toolCallId, (resultCounts.get(message.toolCallId) ?? 0) + 1);
+        }
+    }
+    for (const [toolUseId, count] of callCounts) {
+        if (count > 1) {
+            throw new Error(`Claude sidechain continuation has duplicate tool ID ${toolUseId}`);
+        }
+    }
+    for (const [toolUseId, count] of resultCounts) {
+        if (count > 1) {
+            throw new Error(`Claude sidechain continuation has duplicate tool result ${toolUseId}`);
+        }
+    }
+    const pairedToolIds = new Set([...callCounts.keys()].filter((toolUseId) => resultCounts.get(toolUseId) === 1));
+    const replacements = sidechainToolResultReplacements(entries);
+    return messages.flatMap((message) => {
+        if (message.role === 'assistant') {
+            const toolCalls = (message.toolCalls ?? []).filter((call) => pairedToolIds.has(call.id));
+            if (message.content.trim().length === 0 && toolCalls.length === 0) {
+                return [];
+            }
+            return [
+                {
+                    role: 'assistant',
+                    content: message.content,
+                    ...(message.thinkingBlocks
+                        ? { thinkingBlocks: message.thinkingBlocks }
+                        : {}),
+                    ...(toolCalls.length === 0 ? {} : { toolCalls }),
+                },
+            ];
+        }
+        if (message.role === 'tool') {
+            if (!pairedToolIds.has(message.toolCallId))
+                return [];
+            const replacement = replacements.get(message.toolCallId);
+            return [
+                replacement === undefined
+                    ? message
+                    : {
+                        role: 'tool',
+                        toolCallId: message.toolCallId,
+                        content: replacement,
+                        isError: message.isError,
+                    },
+            ];
+        }
+        return [message];
+    });
+}
 export function getClaudeLastPrompt(entries) {
     for (let index = entries.length - 1; index >= 0; index -= 1) {
         const entry = entries[index];