@gkorepanov/ccodex 0.4.2 → 0.4.4

package/dist/claude/session/session.js

@@ -9,7 +9,7 @@ import { ClaudeMailbox, createDeferred, } from "./mailbox.js";
 import { remapBoundaries } from "./repository.js";
 import { isImageRead, planSteps, projectToolCompletion, startTool, updateToolInput, } from "../toolMapper.js";
 import { isFileMutationTool, toolPolicy } from "../permissionPolicy.js";
-import { newChildScope, newMainStreamState, scopeProjection, streamItem, toolAt, } from "./scopeState.js";
+import { newChildScope, newMainStreamState, scopeProjection, streamItem, taskUsesProvider, toolAt, } from "./scopeState.js";
 import { systemNoticeText } from "../../gateway/transientNotice.js";
 import { isClaudeStatusCommand } from "../statusCommand.js";
 import { isCCodexStateCommand } from "../../state/stateCommand.js";
@@ -23,7 +23,9 @@ import { mapUserInput } from "../inputMapper.js";
 import { bashCommandActions } from "../commandActions.js";
 import { safeSessionPermissionUpdates } from "./permissionUpdates.js";
 import { StaleClaudeRuntimeSettingsError, createProviderRuntime, providerPermissionMode, providerRuntimeSettings, runtimeTransportSettings, } from "./providerRuntimeFactory.js";
+import { isRetryableClaudeRuntimeStartupError, } from "./providerRuntime.js";
 import { assistantHasTools, backgroundOutputFile, backgroundTaskId, isNoQueryAcknowledgement, serverToolResult, toolResults, } from "./providerFacts.js";
+import { normalizeClaudeModelIdentifier } from "../modelSelection.js";
 const nullSource = { providerEventId: null, providerEventType: null };
 const providerJournalMaxEvents = 20_000;
 const providerJournalMaxBytes = 256 * 1_024 * 1_024;
@@ -193,10 +195,26 @@ export class ClaudeSession {
     }
     async ensureRuntime(reinitialize = false) {
         const owner = await this.requireRuntimeOwner();
-        await owner.ready;
+        try {
+            await owner.ready;
+        }
+        catch (error) {
+            await owner.activation.promise;
+            throw error;
+        }
         if (reinitialize)
             await owner.runtime.reinitialize();
     }
+    async ensureEphemeralRuntime() {
+        try {
+            await this.ensureRuntime();
+        }
+        catch (error) {
+            if (!isRetryableClaudeRuntimeStartupError(error))
+                throw error;
+            await this.ensureRuntime();
+        }
+    }
     async materializeRuntime() {
         for (;;) {
             const claim = await this.submitLineage({
@@ -558,6 +576,7 @@ export class ClaudeSession {
             reasoningSummary: record.reasoningSummary,
             collaborationMode: record.collaborationMode,
             outputSchema: record.outputSchema,
+            interactiveQuestions: this.runtimeDependencies.interactiveQuestions ?? true,
         };
     }
     async createRuntimeGeneration(startup) {
@@ -592,7 +611,8 @@ export class ClaudeSession {
             const ready = this.waitForProviderRuntime(runtime);
             await Promise.resolve();
             if (runtime.hasExited) {
-                throw new Error(`Claude runtime '${this.threadId}' became unavailable during initialization.`);
+                await ready;
+                throw runtime.initializationFailure(new Error(`Claude runtime '${this.threadId}' became unavailable during initialization.`));
             }
             const transportSettings = runtimeTransportSettings(startup);
             const rateLimitGeneration = dependencies.rateLimits.register({
@@ -650,6 +670,9 @@ export class ClaudeSession {
                 }),
             ]);
         }
+        catch (error) {
+            throw runtime.initializationFailure(error);
+        }
         finally {
             if (timer)
                 clearTimeout(timer);
@@ -1152,7 +1175,6 @@ export class ClaudeSession {
             }
             catch (error) {
                 failure = error instanceof Error ? error.message : String(error);
-                throw error;
             }
             finally {
                 await this.submitProviderProjection(fact.runtimeGeneration, {
@@ -1164,6 +1186,15 @@ export class ClaudeSession {
                     ...(failure ? { error: failure } : {}),
                 });
             }
+            if (failure) {
+                await this.submitProviderProjection(fact.runtimeGeneration, {
+                    type: "runtimeExited",
+                    runtimeGeneration: fact.runtimeGeneration,
+                    message: `Claude provider projection failed: ${failure}`,
+                    codexErrorInfo: null,
+                });
+                runtime.beginClose();
+            }
         });
     }
     async projectProviderMessage(projection, runtime, runtimeGeneration, message) {
@@ -1265,7 +1296,9 @@ export class ClaudeSession {
                 description: message.summary,
                 outputFile: message.output_file,
             }, owner);
-            await this.providerSubmitLifecycle(projection, runtimeGeneration, { type: "taskNotification" });
+            if (owner === this.threadId) {
+                await this.providerSubmitLifecycle(projection, runtimeGeneration, { type: "taskNotification" });
+            }
             await this.applyProviderMainStream(projection, runtimeGeneration, {
                 kind: "taskComplete",
                 taskId: message.task_id,
@@ -1321,9 +1354,12 @@ export class ClaudeSession {
             return "stateOnly";
         }
         if (message.type === "stream_event") {
-            const childThreadId = await this.providerChildThreadFor(runtimeGeneration, message.parent_tool_use_id);
-            if (childThreadId) {
-                await this.providerChildStreamEvent(projection, runtimeGeneration, childThreadId, message);
+            const child = await this.providerChildThreadFor(runtimeGeneration, message.parent_tool_use_id);
+            if (child?.active) {
+                await this.providerChildStreamEvent(projection, runtimeGeneration, child.threadId, message);
+            }
+            else if (child) {
+                return "retainedOnly";
             }
             else {
                 await this.providerMainStreamEvent(projection, runtimeGeneration, message);
@@ -1346,12 +1382,14 @@ export class ClaudeSession {
             if (message.supersedes?.length) {
                 await this.providerEvictMessages(projection, runtimeGeneration, message.supersedes);
             }
-            const childThreadId = await this.providerChildThreadFor(runtimeGeneration, message.parent_tool_use_id);
-            if (childThreadId) {
-                const itemIds = await this.providerProjectAssistant(projection, runtimeGeneration, message, childThreadId);
-                await this.providerLinkItems(runtimeGeneration, message.uuid, childThreadId, itemIds);
+            const child = await this.providerChildThreadFor(runtimeGeneration, message.parent_tool_use_id);
+            if (child?.active) {
+                const itemIds = await this.providerProjectAssistant(projection, runtimeGeneration, message, child.threadId);
+                await this.providerLinkItems(runtimeGeneration, message.uuid, child.threadId, itemIds);
                 return "projected";
             }
+            if (child)
+                return "retainedOnly";
             if (activeTurnId) {
                 if (message.error) {
                     await this.submitProviderProjection(runtimeGeneration, {
@@ -1387,14 +1425,16 @@ export class ClaudeSession {
             if ("uuid" in message && typeof message.uuid === "string") {
                 runtime.releaseMessage(message.uuid);
             }
-            const childThreadId = await this.providerChildThreadFor(runtimeGeneration, message.parent_tool_use_id);
-            if (childThreadId) {
-                const itemIds = await this.providerProjectToolResults(projection, runtimeGeneration, message, childThreadId);
+            const child = await this.providerChildThreadFor(runtimeGeneration, message.parent_tool_use_id);
+            if (child?.active) {
+                const itemIds = await this.providerProjectToolResults(projection, runtimeGeneration, message, child.threadId);
                 if ("uuid" in message && typeof message.uuid === "string") {
-                    await this.providerLinkItems(runtimeGeneration, message.uuid, childThreadId, itemIds);
+                    await this.providerLinkItems(runtimeGeneration, message.uuid, child.threadId, itemIds);
                 }
                 return "projected";
             }
+            if (child)
+                return "retainedOnly";
             if (activeTurnId && "uuid" in message && typeof message.uuid === "string") {
                 await this.submitProviderProjection(runtimeGeneration, {
                     type: "providerBoundary",
@@ -1717,6 +1757,12 @@ export class ClaudeSession {
         if (name === "AskUserQuestion") {
             return this.askProviderUser(projection, runtimeGeneration, input, options);
         }
+        if (providerPermissionMode(settings) === "auto") {
+            return {
+                behavior: "deny",
+                message: options.decisionReason ?? options.description ?? `Claude Auto did not allow tool '${name}'.`,
+            };
+        }
         if (name === "ExitPlanMode") {
             return {
                 behavior: "deny",
@@ -2024,11 +2070,14 @@ export class ClaudeSession {
     async providerChildThreadFor(runtimeGeneration, providerId) {
         if (!providerId)
             return undefined;
-        return (await this.submitProviderProjection(runtimeGeneration, {
+        const inspection = await this.submitProviderProjection(runtimeGeneration, {
             type: "inspectRuntime",
             runtimeGeneration,
             providerId,
-        })).childThreadId ?? undefined;
+        });
+        return inspection.childThreadId
+            ? { threadId: inspection.childThreadId, active: inspection.interruptible }
+            : undefined;
     }
     async providerLinkItems(runtimeGeneration, providerMessageId, ownerThreadId, itemIds) {
         await this.submitProviderProjection(runtimeGeneration, {
@@ -4106,8 +4155,22 @@ export class ClaudeSession {
                 if (command.runtimeGeneration !== this.runtimeGeneration
                     || this.interruptFence || this.dropLateFacts)
                     return undefined;
-                if (command.fact.kind === "inspect" && !this.scopes.has(command.ownerThreadId ?? this.threadId))
-                    return undefined;
+                {
+                    const ownerThreadId = command.ownerThreadId ?? this.threadId;
+                    if (!this.scopes.has(ownerThreadId)) {
+                        if (command.fact.kind === "inspect")
+                            return undefined;
+                        switch (command.fact.kind) {
+                            case "taskStart":
+                            case "taskProgress":
+                            case "taskMembership":
+                            case "taskOutput":
+                            case "taskComplete":
+                            case "taskStop":
+                                return this.projectDetachedTaskFact(command.fact, command.source);
+                        }
+                    }
+                }
                 {
                     if (command.fact.kind === "taskComplete" && !command.fact.outputDrained) {
                         const task = this.tasks.get(command.fact.taskId);
@@ -4331,27 +4394,14 @@ export class ClaudeSession {
                 if (this.dropLateFacts || this.adminOperation && this.adminOperation.kind !== "rename"
                     || this.repository.archived(command.threadId))
                     return false;
-                const record = this.repository.read(command.threadId, false);
-                if (!record)
+                const state = this.scopes.get(command.threadId);
+                if (!state || command.requestedTurnId && command.requestedTurnId !== state.turnId
+                    || this.repository.readTurn(command.threadId, state.turnId)?.status !== "inProgress")
                     return false;
-                const turnId = command.requestedTurnId
-                    ?? (command.threadId === this.threadId ? this.shell?.turnId : undefined)
-                    ?? this.scopes.get(command.threadId)?.turnId
-                    ?? record.lastCompletedTurnId
-                    ?? uuidv7();
-                const params = {
-                    error: {
-                        message: command.message,
-                        codexErrorInfo: command.codexErrorInfo,
-                        additionalDetails: null,
-                    },
-                    willRetry: false,
-                    threadId: command.threadId,
-                    turnId,
-                };
-                if (this.repository.appendEvent(command.threadId, turnId, "error", params)) {
-                    this.output.emit(command.threadId, "error", params);
-                }
+                this.projectMainStream(command.threadId, {
+                    kind: "instantAgent",
+                    text: systemNoticeText(command.message, "error"),
+                }, nullSource);
                 return true;
             }
             case "startCompact": {
@@ -5188,8 +5238,13 @@ export class ClaudeSession {
             this.pendingNoQuery = this.pendingInputs = 0;
             this.preparedRuntimeInputs.clear();
             this.disposeRuntimeOperations();
-            if (active)
+            if (active) {
                 active.commandCompleted = true;
+                active.acknowledged = active.notifications;
+                active.goals = 0;
+                active.goalInFlight = false;
+                delete active.request;
+            }
             this.settleForcedScopes(source);
             if (fact.type === "runtimeExit" && generation !== undefined) {
                 this.runtimeGeneration = undefined;
@@ -5199,8 +5254,10 @@ export class ClaudeSession {
         else if (fact.type === "timer" && active?.result && this.hasNotifications()
             && fact.generation === active.notifications && fact.generation > active.diagnosed) {
             active.diagnosed = fact.generation;
-            this.projectMainStream(this.threadId, { kind: "instantAgent", text: systemNoticeText("Claude did not emit a request, result, or idle lifecycle signal after a background-task notification. "
-                    + "The turn remains active; use Stop if needed.", "error") }, source);
+            this.runtimeDependencies?.logger.warn("claude.lifecycle.notification-unacknowledged", {
+                threadId: this.threadId,
+                generation: fact.generation,
+            });
         }
         this.maybeFinish(source, fact.type === "sync");
     }
@@ -5759,7 +5816,7 @@ export class ClaudeSession {
         let owner = this.toolOwner(command.providerId);
         if (!owner && command.ownerProviderId) {
             owner = this.toolOwner(command.ownerProviderId);
-            const task = [...this.tasks.values()].find((candidate) => candidate.providerId === command.ownerProviderId || candidate.taskId === command.ownerProviderId);
+            const task = [...this.tasks.values()].find((candidate) => taskUsesProvider(candidate, command.ownerProviderId) || candidate.taskId === command.ownerProviderId);
             if (task?.childThreadId)
                 owner = this.scopes.get(task.childThreadId);
         }
@@ -5892,11 +5949,12 @@ export class ClaudeSession {
         }
         let ownerThreadId = command.ownerThreadId ?? this.threadId;
         let targetThreadId = ownerThreadId;
+        let providerTask;
         if (command.providerId) {
             const scope = [...this.scopes.values()].find((candidate) => candidate.tools.has(command.providerId));
-            const task = [...this.tasks.values()].find((candidate) => candidate.providerId === command.providerId || candidate.taskId === command.providerId);
-            ownerThreadId = task?.ownerThreadId ?? scope?.ownerThreadId ?? ownerThreadId;
-            targetThreadId = ownerThreadId;
+            providerTask = [...this.tasks.values()].find((candidate) => taskUsesProvider(candidate, command.providerId) || candidate.taskId === command.providerId);
+            ownerThreadId = providerTask?.ownerThreadId ?? scope?.ownerThreadId ?? ownerThreadId;
+            targetThreadId = providerTask?.childThreadId ?? ownerThreadId;
         }
         const childTask = command.childThreadId
             ? [...this.tasks.values()].find((candidate) => candidate.childThreadId === command.childThreadId)
@@ -5923,12 +5981,14 @@ export class ClaudeSession {
             modelContextWindow: this.requireRecord(false).modelContextWindow,
             interruptible: command.expectedTurnId
                 ? targetState?.turnId === command.expectedTurnId
-                : childTask ? !childTask.terminal && Boolean(targetState) : Boolean(targetState),
+                : childTask ? !childTask.terminal && Boolean(targetState)
+                    : providerTask?.childThreadId ? !providerTask.terminal && Boolean(targetState)
+                        : Boolean(targetState),
             ownerThreadId,
             ownerTurnId: ownerState?.turnId ?? null,
             taskIds,
             childThreadId: command.providerId
-                ? [...this.tasks.values()].find((task) => task.providerId === command.providerId || task.taskId === command.providerId)?.childThreadId ?? null
+                ? [...this.tasks.values()].find((task) => taskUsesProvider(task, command.providerId) || task.taskId === command.providerId)?.childThreadId ?? null
                 : null,
             taskId: childTask?.taskId ?? null,
             quiescent: this.isQuiescent(),
@@ -6346,8 +6406,9 @@ export class ClaudeSession {
             const existing = tool && turn.items.find((item) => item.id === tool.itemId);
             const subagent = Boolean(fact.subagentType) || fact.taskType === "agent" || fact.taskType === "subagent";
             if (!task && !existing && !subagent) {
+                const providerId = fact.providerId ?? fact.taskId;
                 task = { taskId: fact.taskId, ownerThreadId: state.ownerThreadId,
-                    itemId: `claude-task:${fact.taskId}`, providerId: fact.providerId ?? fact.taskId,
+                    itemId: `claude-task:${fact.taskId}`, providerId, providerIds: new Set([providerId]),
                     turnId: turn.id, childThreadId: undefined, outputFile: fact.outputFile, terminal: false };
                 this.tasks.set(task.taskId, task);
             }
@@ -6357,8 +6418,9 @@ export class ClaudeSession {
                     status: "inProgress", senderThreadId: state.ownerThreadId, receiverThreadIds: [],
                     prompt: fact.prompt ?? fact.description, model: null, reasoningEffort: null, agentsStates: {},
                 };
+                const providerId = fact.providerId ?? item.id;
                 const createdTask = { taskId: fact.taskId, ownerThreadId: state.ownerThreadId, itemId: item.id,
-                    providerId: fact.providerId ?? item.id, turnId: turn.id, childThreadId: undefined,
+                    providerId, providerIds: new Set([providerId]), turnId: turn.id, childThreadId: undefined,
                     outputFile: fact.outputFile, terminal: false };
                 task = createdTask;
                 this.tasks.set(createdTask.taskId, createdTask);
@@ -6369,12 +6431,32 @@ export class ClaudeSession {
                     }, source);
                 }
                 if (subagent && item.type === "collabAgentToolCall") {
-                    childThread = this.createChildScope(state.ownerThreadId, fact, source);
+                    const requestedModel = typeof tool?.input.model === "string" ? tool.input.model : undefined;
+                    childThread = this.createChildScope(state.ownerThreadId, fact, source, requestedModel);
                     task.childThreadId = childThread.id;
                     item.receiverThreadIds = [childThread.id];
                     item.agentsStates = { [childThread.id]: { status: "running", message: fact.description } };
                 }
             }
+            const resumed = task?.terminal && subagent && task.childThreadId && fact.providerId
+                && !taskUsesProvider(task, fact.providerId);
+            if (resumed && task?.childThreadId) {
+                childThread = this.resumeChildScope(task.childThreadId, fact, source);
+                task.terminal = false;
+                task.providerId = fact.providerId;
+                task.providerIds.add(fact.providerId);
+                task.itemId = existing?.id ?? task.itemId;
+                task.turnId = turn.id;
+                task.outputFile = fact.outputFile;
+                if (existing?.type === "collabAgentToolCall") {
+                    existing.receiverThreadIds = [task.childThreadId];
+                    existing.agentsStates = {
+                        [task.childThreadId]: { status: "running", message: fact.description },
+                    };
+                    if (tool)
+                        this.beginTool(turn, state, tool, true, source);
+                }
+            }
             if (task && tool) {
                 tool.backgroundTaskId = task.taskId;
                 if (task.outputFile)
@@ -6402,8 +6484,24 @@ export class ClaudeSession {
             handled = taskIds.length > 0;
         }
         else if (task) {
-            const ownerState = this.requireMainStreamState(task.ownerThreadId);
+            const ownerState = this.scopes.get(task.ownerThreadId);
             const ownerTurn = this.repository.readTurn(task.ownerThreadId, task.turnId);
+            if (!ownerState || !ownerTurn || ownerTurn.status !== "inProgress") {
+                if (fact.kind === "taskComplete" && !task.terminal) {
+                    this.stopBackgroundTailer(task);
+                    task.outputFile = fact.outputFile ?? task.outputFile;
+                    task.terminal = true;
+                    if (task.childThreadId)
+                        this.finishChildScope(task.childThreadId, fact.status, fact.summary, source);
+                }
+                return scopeProjection(turn, {
+                    handled: fact.kind === "taskComplete",
+                    taskIds: [task.taskId],
+                    outputFile: task.outputFile,
+                    childThreadId: task.childThreadId,
+                    terminal: task.terminal,
+                });
+            }
             const item = ownerTurn.items.find((candidate) => candidate.id === task.itemId);
             if (fact.kind === "taskProgress") {
                 if (item?.type === "collabAgentToolCall")
@@ -6444,10 +6542,12 @@ export class ClaudeSession {
                         status: fact.status === "completed" ? "completed" : fact.status === "stopped" ? "interrupted" : "errored",
                         message: fact.summary,
                     };
-                    ownerState.completedItems.add(item.id);
-                    this.publishTurn(ownerTurn, "item/completed", {
-                        item, threadId: task.ownerThreadId, turnId: ownerTurn.id, completedAtMs: Date.now(),
-                    }, source);
+                    if (item.tool !== "sendInput" || !ownerState.completedItems.has(item.id)) {
+                        ownerState.completedItems.add(item.id);
+                        this.publishTurn(ownerTurn, "item/completed", {
+                            item, threadId: task.ownerThreadId, turnId: ownerTurn.id, completedAtMs: Date.now(),
+                        }, source);
+                    }
                 }
                 if (task.childThreadId)
                     this.finishChildScope(task.childThreadId, fact.status, fact.summary, source);
@@ -6488,11 +6588,49 @@ export class ClaudeSession {
             tool: task ? this.scopes.get(task.ownerThreadId)?.tools.get(task.providerId) : undefined,
         });
     }
+    projectDetachedTaskFact(fact, source) {
+        if (!("taskId" in fact))
+            return undefined;
+        const task = this.tasks.get(fact.taskId);
+        if (!task)
+            return undefined;
+        const turn = this.repository.readTurn(task.ownerThreadId, task.turnId);
+        if (!turn)
+            return undefined;
+        if (fact.kind === "taskStart") {
+            task.outputFile = fact.outputFile ?? task.outputFile;
+        }
+        else if (fact.kind === "taskComplete" && !task.terminal) {
+            this.stopBackgroundTailer(task);
+            task.outputFile = fact.outputFile ?? task.outputFile;
+            task.terminal = true;
+            if (task.childThreadId)
+                this.finishChildScope(task.childThreadId, fact.status, fact.summary, source);
+        }
+        return scopeProjection(turn, {
+            handled: true,
+            taskIds: [task.taskId],
+            outputFile: task.outputFile,
+            childThreadId: task.childThreadId,
+            terminal: task.terminal,
+        });
+    }
     updateTool(turn, state, tool, input, source) {
         const item = turn.items.find((candidate) => candidate.id === tool.itemId);
         if (!item)
             return;
         updateToolInput(item, tool, input, state.record.thread.cwd);
+        if (item.type === "collabAgentToolCall" && item.tool === "sendInput") {
+            const target = typeof input.to === "string" ? input.to
+                : typeof input.recipient === "string" ? input.recipient : undefined;
+            const task = target ? this.tasks.get(target) : undefined;
+            if (task?.childThreadId) {
+                item.receiverThreadIds = [task.childThreadId];
+                item.agentsStates = {
+                    [task.childThreadId]: { status: task.terminal ? "completed" : "running", message: null },
+                };
+            }
+        }
         if (tool.name === "TaskOutput") {
             const id = typeof input.task_id === "string" ? input.task_id
                 : typeof input.taskId === "string" ? input.taskId : undefined;
@@ -6511,6 +6649,9 @@ export class ClaudeSession {
         if (!item || tool.started || tool.foldedTaskId || isImageRead(tool, record.thread.cwd)
             || item.type === "commandExecution" && !item.command)
             return;
+        if (item.type === "collabAgentToolCall" && item.tool === "sendInput"
+            && (!item.prompt || item.receiverThreadIds.length === 0))
+            return;
         if (tool.name === "Bash" && tool.input.run_in_background === true && !tool.backgroundTaskId)
             return;
         if (!force
@@ -6536,6 +6677,16 @@ export class ClaudeSession {
         const projection = projectToolCompletion(item, tool, output, isError, result, state.record.thread.cwd);
         turn.items[index] = projection.completed;
         state.completedItems.add(item.id);
+        if (projection.completed.type === "collabAgentToolCall"
+            && projection.completed.tool === "spawnAgent" && projection.completed.model) {
+            const childThreadId = projection.completed.receiverThreadIds[0];
+            const child = childThreadId ? this.repository.read(childThreadId, false) : undefined;
+            if (child)
+                this.repository.update({
+                    ...child,
+                    resolvedModel: normalizeClaudeModelIdentifier(projection.completed.model),
+                });
+        }
         if (!tool.started) {
             tool.started = true;
             this.publishTurn(turn, "item/started", {
@@ -6548,9 +6699,17 @@ export class ClaudeSession {
             item: projection.completed, threadId: state.ownerThreadId, turnId: turn.id, completedAtMs: Date.now(),
         }, source);
     }
-    createChildScope(parentThreadId, fact, source) {
+    createChildScope(parentThreadId, fact, source, requestedModel) {
         const parent = this.repository.read(parentThreadId, false);
-        const { record, turn, item } = newChildScope(parent, parentThreadId, fact);
+        const normalized = requestedModel && requestedModel !== "inherit"
+            ? normalizeClaudeModelIdentifier(requestedModel) : undefined;
+        const model = normalized
+            ? this.runtimeDependencies?.resolveChildModel?.(normalized) ?? {
+                modelPickerId: `claude:${normalized}`,
+                claudeModelValue: normalized,
+            }
+            : undefined;
+        const { record, turn, item } = newChildScope(parent, parentThreadId, fact, model);
         const { thread } = record;
         const childThreadId = thread.id;
         this.repository.create(record);
@@ -6565,6 +6724,50 @@ export class ClaudeSession {
         this.publishAt(childThreadId, turn.id, "item/completed", { item, threadId: childThreadId, turnId: turn.id, completedAtMs: Date.now() }, source);
         return thread;
     }
+    resumeChildScope(childThreadId, fact, source) {
+        const record = this.repository.read(childThreadId, false);
+        if (!record)
+            throw new Error(`Unknown Claude child thread '${childThreadId}'.`);
+        const startedAt = Math.floor(Date.now() / 1_000);
+        const text = fact.prompt ?? fact.description;
+        const item = {
+            type: "userMessage", id: uuidv7(), clientId: null,
+            content: [{ type: "text", text, text_elements: [] }],
+        };
+        const turn = {
+            id: uuidv7(), items: [item], itemsView: "full", status: "inProgress", error: null,
+            startedAt, completedAt: null, durationMs: null,
+        };
+        const updated = {
+            ...record,
+            thread: {
+                ...record.thread,
+                preview: text,
+                status: { type: "active", activeFlags: [] },
+                updatedAt: startedAt,
+                recencyAt: startedAt,
+            },
+        };
+        const status = { threadId: childThreadId, status: updated.thread.status };
+        this.commitState(updated, [{
+                turnId: turn.id,
+                method: "thread/status/changed",
+                params: status,
+                providerEventId: source.providerEventId,
+                providerEventType: source.providerEventType,
+            }], turn, true);
+        const state = newMainStreamState(childThreadId, turn.id, updated);
+        state.completedItems.add(item.id);
+        this.scopes.set(childThreadId, state);
+        this.publishAt(childThreadId, turn.id, "turn/started", { threadId: childThreadId, turn }, source);
+        this.publishAt(childThreadId, turn.id, "item/started", {
+            item, threadId: childThreadId, turnId: turn.id, startedAtMs: Date.now(),
+        }, source);
+        this.publishAt(childThreadId, turn.id, "item/completed", {
+            item, threadId: childThreadId, turnId: turn.id, completedAtMs: Date.now(),
+        }, source);
+        return updated.thread;
+    }
     finishChildScope(childThreadId, status, summary, source) {
         const state = this.scopes.get(childThreadId);
         const record = this.repository.read(childThreadId, false);