@gkorepanov/ccodex 0.3.0 → 0.4.1

package/dist/claude/sessionRuntime.js

@@ -1,1361 +0,0 @@
-import { v7 as uuidv7 } from "uuid";
-import { AsyncQueue } from "./asyncQueue.js";
-import { mapUserInput } from "./inputMapper.js";
-import { completeTool, planSteps, startTool, updateToolInput } from "./toolMapper.js";
-import { diffFile, snapshotFile } from "./fileSnapshots.js";
-import { appendHookProgress, completeHookRun, startHookRun } from "./hookMapper.js";
-import { isFileMutationTool, toolPolicy } from "./permissionPolicy.js";
-import { interruptAndCancelOwned } from "./interruptCompat.js";
-import { classifyClaudeResult, classifyClaudeRuntimeError } from "./resultClassifier.js";
-import { invalidParams } from "../protocol/errors.js";
-import { MetricsRegistry } from "../observability/metrics.js";
-import { normalizeClaudeModelIdentifier } from "./modelSelection.js";
-function nowSeconds() {
-    return Math.floor(Date.now() / 1_000);
-}
-function eventDedupKey(method, params) {
-    if (!params || typeof params !== "object")
-        return null;
-    const value = params;
-    const item = value.item && typeof value.item === "object" ? value.item : undefined;
-    const run = value.run && typeof value.run === "object" ? value.run : undefined;
-    const turn = value.turn && typeof value.turn === "object" ? value.turn : undefined;
-    const turnId = typeof value.turnId === "string" ? value.turnId : typeof turn?.id === "string" ? turn.id : null;
-    if (["turn/started", "turn/completed", "thread/compacted"].includes(method) && turnId) {
-        return `${method}:${turnId}`;
-    }
-    if (["item/started", "item/completed"].includes(method) && typeof item?.id === "string") {
-        return `${method}:${item.id}`;
-    }
-    if (["hook/started", "hook/completed"].includes(method) && typeof run?.id === "string") {
-        return `${method}:${run.id}`;
-    }
-    return null;
-}
-function appendInstructions(record) {
-    const parts = [record.baseInstructions, record.developerInstructions];
-    if (record.personality === "friendly")
-        parts.push("Use a friendly, collaborative communication style.");
-    if (record.personality === "pragmatic")
-        parts.push("Be direct, pragmatic, and focused on concrete outcomes.");
-    const value = parts.filter((part) => Boolean(part)).join("\n\n");
-    return value || undefined;
-}
-function effort(value) {
-    return value === "low" || value === "medium" || value === "high" || value === "xhigh" || value === "max"
-        ? value
-        : undefined;
-}
-function permissionMode(record) {
-    if (record.approvalsReviewer !== "user")
-        return "auto";
-    const sandbox = record.sandboxPolicy && typeof record.sandboxPolicy === "object" && "type" in record.sandboxPolicy
-        ? record.sandboxPolicy
-        : undefined;
-    if (record.approvalPolicy === "never" && sandbox?.type === "dangerFullAccess")
-        return "bypassPermissions";
-    if (record.approvalPolicy === "never")
-        return "dontAsk";
-    return "default";
-}
-function claudeOutputSchema(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        return undefined;
-    const { $schema: _dialect, ...schema } = value;
-    return schema;
-}
-function textFromAssistant(message) {
-    if (message.type !== "assistant" || !Array.isArray(message.message.content))
-        return [];
-    return message.message.content.flatMap((block) => block.type === "text" && typeof block.text === "string" ? [block.text] : []);
-}
-function outputText(value) {
-    if (typeof value === "string")
-        return value;
-    if (!Array.isArray(value))
-        return "";
-    return value.flatMap((block) => {
-        if (!block || typeof block !== "object")
-            return [];
-        const candidate = block;
-        return typeof candidate.text === "string" ? [candidate.text] : [];
-    }).join("\n");
-}
-function toolResults(message) {
-    if (message.type !== "user" || !Array.isArray(message.message.content))
-        return [];
-    return message.message.content.flatMap((block) => {
-        if (!block || typeof block !== "object" || block.type !== "tool_result")
-            return [];
-        return [{ toolUseId: block.tool_use_id, output: outputText(block.content), isError: block.is_error === true }];
-    });
-}
-function serverToolResult(value) {
-    if (!value || typeof value !== "object")
-        return undefined;
-    const block = value;
-    if (typeof block.type !== "string" || !block.type.endsWith("_tool_result") || typeof block.tool_use_id !== "string")
-        return undefined;
-    const content = block.content;
-    const errorType = content && typeof content === "object" && !Array.isArray(content)
-        ? content.type
-        : undefined;
-    return {
-        toolUseId: block.tool_use_id,
-        output: typeof content === "string" ? content : content === undefined ? "" : JSON.stringify(content),
-        isError: typeof errorType === "string" && errorType.endsWith("_error"),
-    };
-}
-export class ClaudeSessionRuntime {
-    record;
-    store;
-    hub;
-    logger;
-    interactions;
-    invalidateModelCatalog;
-    metrics;
-    promptQueue = new AsyncQueue();
-    abort = new AbortController();
-    sdkQuery;
-    active;
-    consumePromise;
-    stopped = false;
-    lastActivityMs = Date.now();
-    pendingCompaction;
-    fileSnapshots = new Map();
-    hookRuns = new Map();
-    hookDisplayOrder = 0;
-    tasks = new Map();
-    hiddenTaskIds = new Set();
-    backgroundTaskIds = new Set();
-    backgroundTurn;
-    capabilities = new Set();
-    ownedMessageIds = new Set();
-    sessionApprovedTools = new Set();
-    hasSubmittedInput = false;
-    providerEventId = null;
-    providerEventType = null;
-    constructor(record, store, hub, logger, config, resume, queryFactory, interactions, invalidateModelCatalog, metrics) {
-        this.record = record;
-        this.store = store;
-        this.hub = hub;
-        this.logger = logger;
-        this.interactions = interactions;
-        this.invalidateModelCatalog = invalidateModelCatalog;
-        this.metrics = metrics;
-        const append = appendInstructions(record);
-        const selectedPermissionMode = permissionMode(record);
-        const selectedEffort = effort(record.reasoningEffort);
-        if (record.reasoningEffort && !selectedEffort)
-            throw new Error(`Unsupported Claude effort '${record.reasoningEffort}'.`);
-        const outputSchema = claudeOutputSchema(record.outputSchema);
-        this.sdkQuery = queryFactory({
-            prompt: this.promptQueue,
-            options: {
-                cwd: record.thread.cwd,
-                model: normalizeClaudeModelIdentifier(record.claudeModelValue),
-                ...(resume ? { resume: record.claudeSessionId } : { sessionId: record.claudeSessionId }),
-                pathToClaudeCodeExecutable: config.claudeBinary,
-                persistSession: !record.thread.ephemeral,
-                abortController: this.abort,
-                includePartialMessages: true,
-                includeHookEvents: true,
-                forwardSubagentText: true,
-                settingSources: ["user", "project", "local"],
-                systemPrompt: { type: "preset", preset: "claude_code", ...(append ? { append } : {}) },
-                permissionMode: selectedPermissionMode,
-                ...(selectedPermissionMode === "bypassPermissions" ? { allowDangerouslySkipPermissions: true } : {}),
-                ...(selectedPermissionMode === "auto"
-                    ? {}
-                    : { canUseTool: (name, input, options) => this.canUseTool(name, input, options) }),
-                onElicitation: (request, options) => this.onElicitation(request, options.signal),
-                hooks: {
-                    PreToolUse: [{ hooks: [(input, toolUseId) => this.beforeToolUse(input, toolUseId)] }],
-                    PostToolUse: [{ matcher: "Edit|Write|NotebookEdit", hooks: [(input, toolUseId) => this.captureFileAfter(input, toolUseId)] }],
-                    PostToolUseFailure: [{ matcher: "Edit|Write|NotebookEdit", hooks: [(input, toolUseId) => this.captureFileAfter(input, toolUseId)] }],
-                },
-                ...(record.serviceTier === "fast" ? { settings: { fastMode: true } } : {}),
-                ...(selectedEffort ? { effort: selectedEffort } : {}),
-                ...(record.reasoningSummary === "none"
-                    ? { thinking: { type: "adaptive", display: "omitted" } }
-                    : record.reasoningSummary
-                        ? { thinking: { type: "adaptive", display: "summarized" } }
-                        : {}),
-                ...(outputSchema
-                    ? { outputFormat: { type: "json_schema", schema: outputSchema } }
-                    : {}),
-                env: process.env,
-                stderr: (line) => logger.debug("claude.stderr", { threadId: record.thread.id, output: line }),
-            },
-        });
-        this.consumePromise = this.consume();
-    }
-    static async create(record, store, hub, logger, config, resume, queryFactory, interactions, invalidateModelCatalog = () => undefined, metrics = new MetricsRegistry()) {
-        const runtime = new ClaudeSessionRuntime(record, store, hub, logger, config, resume, queryFactory, interactions, invalidateModelCatalog, metrics);
-        let timer;
-        try {
-            await Promise.race([
-                runtime.sdkQuery.initializationResult(),
-                new Promise((_, reject) => { timer = setTimeout(() => reject(new Error("Claude session initialization timed out.")), 15_000); }),
-            ]);
-            return runtime;
-        }
-        catch (error) {
-            await runtime.stop("Claude session initialization failed.");
-            throw error;
-        }
-        finally {
-            if (timer)
-                clearTimeout(timer);
-        }
-    }
-    get threadId() {
-        return this.record.thread.id;
-    }
-    get isActive() {
-        return this.active !== undefined;
-    }
-    get activeTurnId() {
-        return this.active?.turn.id;
-    }
-    get isEphemeral() {
-        return this.record.thread.ephemeral;
-    }
-    get canRestartEphemeral() {
-        return this.record.thread.ephemeral && !this.hasSubmittedInput && !this.active;
-    }
-    synchronizeRecord(record) {
-        if (record.thread.id !== this.threadId)
-            throw new Error("Cannot synchronize a different Claude thread.");
-        this.record = record;
-    }
-    isIdleFor(milliseconds) {
-        return !this.active && Date.now() - this.lastActivityMs >= milliseconds;
-    }
-    async prepareTurn(params, review) {
-        if (this.active)
-            throw invalidParams(`Thread '${this.threadId}' already has an active turn.`);
-        this.completeBackgroundTurn();
-        this.lastActivityMs = Date.now();
-        if (params.model && params.model !== this.record.modelPickerId) {
-            if (!params.model.startsWith("claude:"))
-                throw invalidParams("Cannot switch a Claude thread to a Codex model.");
-            await this.sdkQuery.setModel(params.model.slice("claude:".length));
-            this.record = {
-                ...this.record,
-                modelPickerId: params.model,
-                claudeModelValue: params.model.slice("claude:".length),
-            };
-        }
-        const userItem = {
-            type: "userMessage",
-            id: uuidv7(),
-            clientId: params.clientUserMessageId ?? null,
-            content: params.input,
-        };
-        const reviewItem = review ? { type: "enteredReviewMode", id: uuidv7(), review } : undefined;
-        const turn = {
-            id: uuidv7(),
-            items: [...(reviewItem ? [reviewItem] : []), userItem],
-            itemsView: "full",
-            status: "inProgress",
-            error: null,
-            startedAt: nowSeconds(),
-            completedAt: null,
-            durationMs: null,
-        };
-        const messageUuid = uuidv7();
-        const message = await mapUserInput(params.input, messageUuid, { cwd: this.record.thread.cwd, sandboxPolicy: this.record.sandboxPolicy });
-        this.ownedMessageIds.add(messageUuid);
-        this.active = {
-            turn,
-            blockItems: new Map(),
-            tools: new Map(),
-            completedItems: new Set([userItem.id, ...(reviewItem ? [reviewItem.id] : [])]),
-            ...(review ? { review } : {}),
-        };
-        this.store.createTurn(this.threadId, turn);
-        const preview = this.record.thread.preview || params.input.flatMap((item) => item.type === "text" ? [item.text] : []).join(" ").slice(0, 200);
-        this.updateThread({
-            ...this.record.thread,
-            preview,
-            status: { type: "active", activeFlags: [] },
-            updatedAt: nowSeconds(),
-            recencyAt: nowSeconds(),
-        });
-        return {
-            turn,
-            announce: () => {
-                this.emit("turn/started", { threadId: this.threadId, turn });
-                if (reviewItem) {
-                    this.emit("item/started", { item: reviewItem, threadId: this.threadId, turnId: turn.id, startedAtMs: Date.now() });
-                    this.emit("item/completed", { item: reviewItem, threadId: this.threadId, turnId: turn.id, completedAtMs: Date.now() });
-                }
-                this.emit("item/started", { item: userItem, threadId: this.threadId, turnId: turn.id, startedAtMs: Date.now() });
-                this.emit("item/completed", { item: userItem, threadId: this.threadId, turnId: turn.id, completedAtMs: Date.now() });
-            },
-            start: () => {
-                this.hasSubmittedInput = true;
-                this.promptQueue.push(message);
-            },
-        };
-    }
-    async interrupt() {
-        if (!this.active)
-            return;
-        this.interactions.cancelThread(this.threadId);
-        const cancellation = await interruptAndCancelOwned(this.sdkQuery, this.ownedMessageIds, this.capabilities);
-        for (const id of [...cancellation.cancelled, ...cancellation.raced])
-            this.ownedMessageIds.delete(id);
-        if (cancellation.raced.length > 0) {
-            this.logger.warn("claude.interrupt.queued-message-race", { threadId: this.threadId, count: cancellation.raced.length });
-        }
-    }
-    async steer(params) {
-        if (!this.active || this.active.turn.id !== params.expectedTurnId) {
-            throw invalidParams(`Expected active turn '${params.expectedTurnId}' does not match the Claude thread.`);
-        }
-        const item = {
-            type: "userMessage",
-            id: uuidv7(),
-            clientId: params.clientUserMessageId ?? null,
-            content: params.input,
-        };
-        const messageUuid = uuidv7();
-        const message = await mapUserInput(params.input, messageUuid, { cwd: this.record.thread.cwd, sandboxPolicy: this.record.sandboxPolicy });
-        this.ownedMessageIds.add(messageUuid);
-        this.active.turn.items.push(item);
-        this.active.completedItems.add(item.id);
-        this.persistActive();
-        this.emit("item/started", { item, threadId: this.threadId, turnId: this.active.turn.id, startedAtMs: Date.now() });
-        this.emit("item/completed", { item, threadId: this.threadId, turnId: this.active.turn.id, completedAtMs: Date.now() });
-        this.promptQueue.push(message);
-        return this.active.turn.id;
-    }
-    async reinitialize() {
-        await this.sdkQuery.reinitialize();
-    }
-    async compact() {
-        if (this.active)
-            throw invalidParams("Cannot compact a Claude thread during an active turn.");
-        if (this.pendingCompaction)
-            throw invalidParams("Claude compaction is already in progress.");
-        const completion = new Promise((resolve, reject) => {
-            const timer = setTimeout(() => {
-                this.pendingCompaction = undefined;
-                reject(new Error("Installed Claude CLI did not confirm compaction; this version may not support SDK-driven /compact."));
-            }, 60_000);
-            this.pendingCompaction = { resolve, reject, timer };
-        });
-        this.hasSubmittedInput = true;
-        this.promptQueue.push(await mapUserInput([{ type: "text", text: "/compact", text_elements: [] }], uuidv7()));
-        await completion;
-    }
-    async injectItems(items) {
-        if (this.active)
-            throw invalidParams("Cannot inject history during an active Claude turn.");
-        const visible = items.map((item) => JSON.stringify(item)).join("\n");
-        const input = [{ type: "text", text: `[Injected model-visible history]\n${visible}`, text_elements: [] }];
-        const messageUuid = uuidv7();
-        const message = await mapUserInput(input, messageUuid);
-        this.hasSubmittedInput = true;
-        this.promptQueue.push({ ...message, shouldQuery: false });
-        const now = nowSeconds();
-        const userItem = { type: "userMessage", id: uuidv7(), clientId: null, content: input };
-        const turn = {
-            id: uuidv7(), items: [userItem], itemsView: "full", status: "completed", error: null,
-            startedAt: now, completedAt: now, durationMs: 0,
-        };
-        this.store.createTurn(this.threadId, turn);
-        this.store.setTurnClaudeMessageUuid(this.threadId, turn.id, messageUuid);
-        this.record = { ...this.record, lastClaudeMessageUuid: messageUuid };
-        this.record = { ...this.record, lastCompletedTurnId: turn.id };
-        this.updateThread({ ...this.record.thread, updatedAt: now, recencyAt: now });
-        this.emit("item/completed", { item: userItem, threadId: this.threadId, turnId: turn.id, completedAtMs: Date.now() });
-    }
-    async stop(reason = "Claude runtime unloaded.") {
-        if (this.stopped)
-            return;
-        if (this.pendingCompaction) {
-            const pending = this.pendingCompaction;
-            this.pendingCompaction = undefined;
-            clearTimeout(pending.timer);
-            pending.reject(new Error(reason));
-        }
-        if (this.active)
-            await this.failActive(reason);
-        this.completeBackgroundTurn("failed", reason);
-        this.stopped = true;
-        this.promptQueue.close();
-        this.abort.abort();
-        await this.sdkQuery.return(undefined).catch(() => undefined);
-        await this.consumePromise.catch(() => undefined);
-        if (this.record.thread.status.type !== "notLoaded") {
-            this.updateThread({ ...this.record.thread, status: { type: "notLoaded" }, updatedAt: nowSeconds() });
-        }
-    }
-    async consume() {
-        try {
-            for await (const message of this.sdkQuery)
-                await this.handleMessage(message);
-            if (!this.stopped) {
-                if (this.active)
-                    await this.failActive("Claude runtime exited before the turn completed.");
-                this.updateThread({ ...this.record.thread, status: { type: "systemError" }, updatedAt: nowSeconds() });
-            }
-        }
-        catch (error) {
-            if (!this.stopped) {
-                await this.failActive(error instanceof Error ? error.message : String(error));
-                this.updateThread({ ...this.record.thread, status: { type: "systemError" }, updatedAt: nowSeconds() });
-            }
-        }
-    }
-    async canUseTool(name, input, options) {
-        if (!this.active)
-            return { behavior: "deny", message: "No active Claude turn." };
-        if (name === "AskUserQuestion")
-            return this.askUser(input, options);
-        if (name === "ExitPlanMode") {
-            return { behavior: "deny", message: "The plan is visible in the client. Wait for the user's next instruction before executing it." };
-        }
-        if (permissionMode(this.record) === "bypassPermissions")
-            return { behavior: "allow", updatedInput: input };
-        const policy = toolPolicy(name, input, this.record.thread.cwd, this.record.approvalPolicy, this.record.sandboxPolicy);
-        if (policy.decision === "deny")
-            return { behavior: "deny", message: policy.reason ?? `Tool '${name}' is denied by the Codex thread policy.` };
-        if (policy.decision === "defer" && isFileMutationTool(name))
-            return { behavior: "allow", updatedInput: input };
-        if (this.sessionApprovedTools.has(name))
-            return { behavior: "allow", updatedInput: input };
-        if (this.record.approvalPolicy === "never") {
-            return { behavior: "deny", message: `Tool '${name}' requires permission, but approvalPolicy is never.` };
-        }
-        const itemId = options.toolUseID;
-        const tool = this.active.tools.get(itemId);
-        const item = tool && this.active.turn.items.find((candidate) => candidate.id === tool.itemId);
-        if (tool && item) {
-            updateToolInput(item, tool, input);
-            this.persistActive();
-        }
-        const common = {
-            threadId: this.threadId,
-            turnId: this.active.turn.id,
-            itemId,
-            startedAtMs: Date.now(),
-        };
-        let method;
-        let params;
-        if (name === "Bash") {
-            method = "item/commandExecution/requestApproval";
-            params = {
-                ...common, environmentId: null, reason: options.decisionReason ?? options.description ?? null,
-                command: typeof input.command === "string" ? input.command : null, cwd: this.record.thread.cwd,
-                commandActions: typeof input.command === "string" ? [{ type: "unknown", command: input.command }] : null,
-                additionalPermissions: null, proposedExecpolicyAmendment: null,
-                proposedNetworkPolicyAmendments: null, availableDecisions: ["accept", "acceptForSession", "decline", "cancel"],
-            };
-        }
-        else if (name === "Edit" || name === "Write" || name === "NotebookEdit") {
-            method = "item/fileChange/requestApproval";
-            params = { ...common, reason: options.decisionReason ?? options.description ?? null, grantRoot: options.blockedPath ?? null };
-        }
-        else {
-            method = "item/permissions/requestApproval";
-            const path = options.blockedPath ? [options.blockedPath] : null;
-            params = {
-                ...common, environmentId: null, cwd: this.record.thread.cwd,
-                reason: options.title ?? options.decisionReason ?? `Claude requests permission for ${name}.`,
-                permissions: { network: null, fileSystem: path ? { read: path, write: path } : null },
-            };
-        }
-        this.updateThread({ ...this.record.thread, status: { type: "active", activeFlags: ["waitingOnApproval"] } });
-        if (tool && item)
-            this.startToolItem(tool, item, true);
-        let response;
-        try {
-            response = await this.interactions.open({
-                threadId: this.threadId,
-                turnId: this.active.turn.id,
-                claudeRequestId: options.requestId,
-                method,
-                params,
-                signal: options.signal,
-            });
-        }
-        finally {
-            if (this.active)
-                this.updateThread({ ...this.record.thread, status: { type: "active", activeFlags: [] } });
-        }
-        if (response && typeof response === "object" && "cancelled" in response) {
-            return { behavior: "deny", message: "User cancelled tool execution." };
-        }
-        const decision = response && typeof response === "object" && "decision" in response
-            ? response.decision
-            : response && typeof response === "object" && "scope" in response
-                ? "accept"
-                : "decline";
-        if (decision === "accept" || decision === "acceptForSession") {
-            if (decision === "acceptForSession")
-                this.sessionApprovedTools.add(name);
-            return {
-                behavior: "allow",
-                updatedInput: input,
-                ...(decision === "acceptForSession" && options.suggestions ? { updatedPermissions: options.suggestions } : {}),
-            };
-        }
-        return { behavior: "deny", message: decision === "cancel" ? "User cancelled tool execution." : "User declined tool execution." };
-    }
-    async askUser(input, options) {
-        if (!this.active)
-            return { behavior: "deny", message: "No active Claude turn." };
-        const rawQuestions = Array.isArray(input.questions) ? input.questions : [];
-        const questions = rawQuestions.map((value, index) => {
-            const question = value && typeof value === "object" ? value : {};
-            const prompt = typeof question.question === "string" ? question.question : `Question ${index + 1}`;
-            const choices = Array.isArray(question.options) ? question.options : [];
-            return {
-                id: prompt,
-                header: typeof question.header === "string" ? question.header : `Question ${index + 1}`,
-                question: prompt,
-                isOther: true,
-                isSecret: false,
-                options: choices.map((choice) => {
-                    const option = choice && typeof choice === "object" ? choice : {};
-                    return { label: String(option.label ?? ""), description: String(option.description ?? "") };
-                }),
-            };
-        });
-        const response = await this.interactions.open({
-            threadId: this.threadId,
-            turnId: this.active.turn.id,
-            claudeRequestId: options.requestId,
-            method: "item/tool/requestUserInput",
-            params: { threadId: this.threadId, turnId: this.active.turn.id, itemId: options.toolUseID, questions, autoResolutionMs: null },
-            signal: options.signal,
-        });
-        if (!response || typeof response !== "object" || "cancelled" in response) {
-            return { behavior: "deny", message: "User cancelled the question." };
-        }
-        const rawAnswers = "answers" in response ? response.answers : undefined;
-        const answers = {};
-        if (rawAnswers && typeof rawAnswers === "object") {
-            for (const [id, value] of Object.entries(rawAnswers)) {
-                const values = value && typeof value === "object" && "answers" in value
-                    ? value.answers
-                    : undefined;
-                if (Array.isArray(values))
-                    answers[id] = values.map(String).join(", ");
-            }
-        }
-        return { behavior: "allow", updatedInput: { ...input, answers } };
-    }
-    async onElicitation(request, signal) {
-        const response = await this.interactions.open({
-            threadId: this.threadId,
-            turnId: this.active?.turn.id ?? null,
-            claudeRequestId: request.elicitationId ?? null,
-            method: "mcpServer/elicitation/request",
-            params: request.mode === "url"
-                ? { threadId: this.threadId, turnId: this.active?.turn.id ?? null, serverName: request.serverName, mode: "url", _meta: null, message: request.message, url: request.url ?? "", elicitationId: request.elicitationId ?? "" }
-                : { threadId: this.threadId, turnId: this.active?.turn.id ?? null, serverName: request.serverName, mode: "form", _meta: null, message: request.message, requestedSchema: request.requestedSchema ?? {} },
-            signal,
-        });
-        if (!response || typeof response !== "object" || "cancelled" in response)
-            return { action: "cancel" };
-        const result = response;
-        return {
-            action: result.action ?? "cancel",
-            ...(result.content ? { content: result.content } : {}),
-        };
-    }
-    async beforeToolUse(input, toolUseId) {
-        if (input.hook_event_name !== "PreToolUse" || !toolUseId || !this.active)
-            return { continue: true };
-        const toolInput = input.tool_input && typeof input.tool_input === "object"
-            ? input.tool_input
-            : {};
-        const selected = toolPolicy(input.tool_name, toolInput, this.record.thread.cwd, this.record.approvalPolicy, this.record.sandboxPolicy);
-        const policy = permissionMode(this.record) === "auto" && selected.decision === "ask"
-            ? { decision: "defer" }
-            : selected;
-        if (policy.decision !== "deny") {
-            const snapshot = await snapshotFile(input.tool_name, toolInput, this.record.thread.cwd);
-            if (snapshot)
-                this.fileSnapshots.set(toolUseId, snapshot);
-        }
-        if (policy.decision !== "deny" && this.sessionApprovedTools.has(input.tool_name))
-            return { continue: true };
-        if (policy.decision === "defer")
-            return { continue: true };
-        return {
-            continue: true,
-            hookSpecificOutput: {
-                hookEventName: "PreToolUse",
-                permissionDecision: policy.decision,
-                ...(policy.reason ? { permissionDecisionReason: policy.reason } : {}),
-            },
-        };
-    }
-    async captureFileAfter(input, toolUseId) {
-        if ((input.hook_event_name !== "PostToolUse" && input.hook_event_name !== "PostToolUseFailure") || !toolUseId) {
-            return { continue: true };
-        }
-        const snapshot = this.fileSnapshots.get(toolUseId);
-        this.fileSnapshots.delete(toolUseId);
-        if (!snapshot || !this.active)
-            return { continue: true };
-        const change = await diffFile(snapshot);
-        const tool = this.active.tools.get(toolUseId);
-        const index = tool && this.active.turn.items.findIndex((item) => item.id === tool.itemId);
-        const item = index !== undefined && index >= 0 ? this.active.turn.items[index] : undefined;
-        if (!change || !item || item.type !== "fileChange")
-            return { continue: true };
-        item.changes = [change];
-        this.persistActive();
-        this.emitFileDiff(item);
-        return { continue: true };
-    }
-    async handleMessage(message) {
-        const previousId = this.providerEventId;
-        const previousType = this.providerEventType;
-        this.providerEventId = "uuid" in message && typeof message.uuid === "string" ? message.uuid : null;
-        this.providerEventType = message.type === "system" && "subtype" in message ? `system/${message.subtype}` : message.type;
-        if (this.providerEventId && this.store.hasProcessedProviderEvent(this.threadId, this.providerEventId)) {
-            this.metrics.eventDeduplicated();
-            this.providerEventId = previousId;
-            this.providerEventType = previousType;
-            return;
-        }
-        try {
-            await this.handleProviderMessage(message);
-            if (this.providerEventId && this.providerEventType) {
-                this.store.markProviderEventProcessed(this.threadId, this.providerEventType, this.providerEventId);
-            }
-        }
-        finally {
-            this.providerEventId = previousId;
-            this.providerEventType = previousType;
-        }
-    }
-    async handleProviderMessage(message) {
-        if (message.type === "system" && message.subtype === "hook_started") {
-            const run = startHookRun(message, this.record.thread.cwd, Boolean(this.active), this.hookDisplayOrder++);
-            if (run) {
-                this.hookRuns.set(message.hook_id, run);
-                this.emit("hook/started", { threadId: this.threadId, turnId: this.active?.turn.id ?? null, run });
-            }
-            return;
-        }
-        if (message.type === "system" && message.subtype === "hook_progress") {
-            const run = this.hookRuns.get(message.hook_id);
-            if (run)
-                appendHookProgress(run, message);
-            return;
-        }
-        if (message.type === "system" && message.subtype === "hook_response") {
-            const run = this.hookRuns.get(message.hook_id);
-            if (run) {
-                completeHookRun(run, message);
-                this.hookRuns.delete(message.hook_id);
-                this.emit("hook/completed", { threadId: this.threadId, turnId: this.active?.turn.id ?? null, run });
-            }
-            return;
-        }
-        if (message.type === "system" && message.subtype === "task_started") {
-            this.startTask(message);
-            return;
-        }
-        if (message.type === "system" && message.subtype === "task_progress") {
-            this.progressTask(message);
-            return;
-        }
-        if (message.type === "system" && message.subtype === "task_updated") {
-            this.updateTask(message);
-            return;
-        }
-        if (message.type === "system" && message.subtype === "task_notification") {
-            this.completeTask(message);
-            return;
-        }
-        if (message.type === "system" && message.subtype === "background_tasks_changed") {
-            this.backgroundTaskIds = new Set(message.tasks.map((task) => task.task_id));
-            if (!this.active) {
-                if (this.backgroundTaskIds.size === 0)
-                    this.completeBackgroundTurn();
-                else
-                    this.updateThread({ ...this.record.thread, status: { type: "active", activeFlags: [] }, updatedAt: nowSeconds() });
-            }
-            return;
-        }
-        if (message.type === "system" && message.subtype === "status" && this.pendingCompaction && message.compact_result === "failed") {
-            const pending = this.pendingCompaction;
-            this.pendingCompaction = undefined;
-            clearTimeout(pending.timer);
-            pending.reject(new Error(message.compact_error ?? "Claude compaction failed."));
-            return;
-        }
-        if (message.type === "system" && message.subtype === "compact_boundary") {
-            await this.handleCompaction(message.compact_metadata);
-            return;
-        }
-        if (message.type === "system" && message.subtype === "init") {
-            if (message.session_id !== this.record.claudeSessionId) {
-                throw new Error(`Claude initialized session '${message.session_id}', expected '${this.record.claudeSessionId}'.`);
-            }
-            this.record = {
-                ...this.record,
-                resolvedModel: message.model,
-                claudeCodeVersion: message.claude_code_version,
-                thread: { ...this.record.thread, cliVersion: message.claude_code_version },
-            };
-            this.capabilities.clear();
-            for (const capability of message.capabilities ?? [])
-                this.capabilities.add(capability);
-            this.store.updateThread(this.record);
-            return;
-        }
-        if (message.type === "stream_event") {
-            await this.handleStreamEvent(message);
-            return;
-        }
-        if (message.type === "assistant") {
-            if (this.active) {
-                if (message.error) {
-                    this.active.providerError = message.error;
-                    if (message.error === "authentication_failed" || message.error === "oauth_org_not_allowed" || message.error === "model_not_found") {
-                        this.invalidateModelCatalog();
-                    }
-                }
-                this.store.setTurnClaudeMessageUuid(this.threadId, this.active.turn.id, message.uuid);
-                this.record = { ...this.record, lastClaudeMessageUuid: message.uuid };
-                this.store.updateThread(this.record);
-                if (Array.isArray(message.message.content)) {
-                    for (const block of message.message.content)
-                        this.completeServerToolResult(serverToolResult(block));
-                }
-            }
-            await this.backfillAssistant(message);
-            return;
-        }
-        if (message.type === "user") {
-            if ("uuid" in message && typeof message.uuid === "string")
-                this.ownedMessageIds.delete(message.uuid);
-            this.handleToolResults(message);
-            return;
-        }
-        if (message.type === "result") {
-            if (!this.active && this.pendingCompaction && message.subtype !== "success") {
-                const pending = this.pendingCompaction;
-                this.pendingCompaction = undefined;
-                clearTimeout(pending.timer);
-                pending.reject(new Error(message.errors[0] ?? "Claude compaction failed."));
-                return;
-            }
-            const result = classifyClaudeResult(message, this.active?.providerError);
-            if (result.codexErrorInfo === "unauthorized" || result.codexErrorInfo === "badRequest")
-                this.invalidateModelCatalog();
-            if (result.status === "completed" && message.subtype === "success") {
-                if (message.structured_output !== undefined)
-                    this.appendStructuredOutput(message.structured_output);
-                this.emitUsage(message);
-                await this.completeActive("completed");
-            }
-            else {
-                await this.completeActive(result.status === "completed" ? "failed" : result.status, result.error, result.codexErrorInfo);
-            }
-        }
-    }
-    appendStructuredOutput(value) {
-        if (!this.active)
-            return;
-        const text = JSON.stringify(value, null, 2);
-        const item = { type: "agentMessage", id: uuidv7(), text, phase: null, memoryCitation: null };
-        this.active.turn.items.push(item);
-        this.active.completedItems.add(item.id);
-        this.persistActive();
-        this.emit("item/started", { item, threadId: this.threadId, turnId: this.active.turn.id, startedAtMs: Date.now() });
-        this.emit("item/agentMessage/delta", { threadId: this.threadId, turnId: this.active.turn.id, itemId: item.id, delta: text });
-        this.emit("item/completed", { item, threadId: this.threadId, turnId: this.active.turn.id, completedAtMs: Date.now() });
-    }
-    startTask(message) {
-        if (message.skip_transcript) {
-            this.hiddenTaskIds.add(message.task_id);
-            return;
-        }
-        const turn = this.taskTurn();
-        const existing = message.tool_use_id ? this.active?.tools.get(message.tool_use_id) : undefined;
-        const existingItem = existing && turn.items.find((item) => item.id === existing.itemId);
-        const subagent = Boolean(message.subagent_type) || message.task_type === "agent" || message.task_type === "subagent";
-        const item = existingItem ?? (subagent
-            ? {
-                type: "collabAgentToolCall", id: message.tool_use_id ?? `claude-task:${uuidv7()}`, tool: "spawnAgent",
-                status: "inProgress", senderThreadId: this.threadId, receiverThreadIds: [message.task_id],
-                prompt: message.prompt ?? message.description, model: null, reasoningEffort: null,
-                agentsStates: { [message.task_id]: { status: "running", message: message.description } },
-            }
-            : {
-                type: "dynamicToolCall", id: message.tool_use_id ?? `claude-task:${uuidv7()}`, namespace: "claude",
-                tool: message.task_type ?? "backgroundTask", arguments: { taskId: message.task_id, description: message.description },
-                status: "inProgress", contentItems: null, success: null, durationMs: null,
-            });
-        if (item.type === "collabAgentToolCall") {
-            item.receiverThreadIds = [message.task_id];
-            item.agentsStates[message.task_id] = { status: "running", message: message.description };
-        }
-        if (!existingItem) {
-            turn.items.push(item);
-            this.persistTaskTurn(turn);
-            this.emit("item/started", { item, threadId: this.threadId, turnId: turn.id, startedAtMs: Date.now() }, turn.id);
-        }
-        this.tasks.set(message.task_id, {
-            taskId: message.task_id, itemId: item.id, turnId: turn.id, subagent, description: message.description, terminal: false,
-        });
-    }
-    progressTask(message) {
-        if (this.hiddenTaskIds.has(message.task_id))
-            return;
-        const task = this.taskForEvent(message.task_id, message.description, Boolean(message.subagent_type));
-        if (!task)
-            return;
-        task.description = message.summary ?? message.description;
-        const { turn, item } = this.taskItem(task);
-        if (!turn || !item)
-            return;
-        if (item.type === "collabAgentToolCall") {
-            item.agentsStates[message.task_id] = { status: "running", message: task.description };
-        }
-        else if (item.type === "dynamicToolCall") {
-            item.contentItems = [{ type: "inputText", text: task.description }];
-        }
-        this.persistTaskTurn(turn);
-    }
-    updateTask(message) {
-        if (this.hiddenTaskIds.has(message.task_id))
-            return;
-        const task = this.tasks.get(message.task_id);
-        if (!task)
-            return;
-        if (message.patch.description)
-            task.description = message.patch.description;
-        const { turn, item } = this.taskItem(task);
-        if (!turn || !item || item.type !== "collabAgentToolCall")
-            return;
-        const status = message.patch.status;
-        item.agentsStates[message.task_id] = {
-            status: status === "failed" ? "errored" : status === "killed" ? "interrupted" : status === "completed" ? "completed" : "running",
-            message: message.patch.error ?? task.description,
-        };
-        this.persistTaskTurn(turn);
-    }
-    completeTask(message) {
-        if (this.hiddenTaskIds.delete(message.task_id))
-            return;
-        const task = this.taskForEvent(message.task_id, message.summary, false);
-        if (!task)
-            return;
-        const { turn, item } = this.taskItem(task);
-        if (!turn || !item)
-            return;
-        task.terminal = true;
-        if (item.type === "collabAgentToolCall") {
-            item.status = message.status === "completed" ? "completed" : "failed";
-            item.agentsStates[message.task_id] = {
-                status: message.status === "completed" ? "completed" : message.status === "stopped" ? "interrupted" : "errored",
-                message: message.summary,
-            };
-        }
-        else if (item.type === "dynamicToolCall") {
-            item.status = message.status === "completed" ? "completed" : "failed";
-            item.success = message.status === "completed";
-            item.durationMs = message.usage?.duration_ms ?? null;
-            item.contentItems = message.summary ? [{ type: "inputText", text: message.summary }] : [];
-        }
-        this.persistTaskTurn(turn);
-        if (this.active?.turn.id === turn.id)
-            this.active.completedItems.add(item.id);
-        this.emit("item/completed", { item, threadId: this.threadId, turnId: turn.id, completedAtMs: Date.now() }, turn.id);
-        if (!this.active && !this.backgroundTaskIds.has(message.task_id))
-            this.completeBackgroundTurn();
-    }
-    taskForEvent(taskId, description, subagent) {
-        if (this.hiddenTaskIds.has(taskId))
-            return undefined;
-        const existing = this.tasks.get(taskId);
-        if (existing && this.taskItem(existing).turn)
-            return existing;
-        const projectedSubagent = existing?.subagent ?? subagent;
-        this.startTask({
-            type: "system", subtype: "task_started", task_id: taskId, description,
-            ...(projectedSubagent ? { subagent_type: "agent" } : {}),
-            uuid: "00000000-0000-4000-8000-000000000001", session_id: this.record.claudeSessionId,
-        });
-        return this.tasks.get(taskId);
-    }
-    taskTurn() {
-        if (this.active)
-            return this.active.turn;
-        if (this.backgroundTurn)
-            return this.backgroundTurn;
-        const turn = {
-            id: uuidv7(), items: [], itemsView: "full", status: "inProgress", error: null,
-            startedAt: nowSeconds(), completedAt: null, durationMs: null,
-        };
-        this.backgroundTurn = turn;
-        this.store.createTurn(this.threadId, turn);
-        this.updateThread({ ...this.record.thread, status: { type: "active", activeFlags: [] }, updatedAt: nowSeconds(), recencyAt: nowSeconds() });
-        this.emit("turn/started", { threadId: this.threadId, turn }, turn.id);
-        return turn;
-    }
-    taskItem(task) {
-        const turn = this.active?.turn.id === task.turnId
-            ? this.active.turn
-            : this.backgroundTurn?.id === task.turnId
-                ? this.backgroundTurn
-                : undefined;
-        return { turn, item: turn?.items.find((item) => item.id === task.itemId) };
-    }
-    persistTaskTurn(turn) {
-        if (this.active?.turn.id === turn.id)
-            this.persistActive();
-        else
-            this.store.updateTurn(this.threadId, turn);
-    }
-    completeBackgroundTurn(status = "completed", errorMessage) {
-        const turn = this.backgroundTurn;
-        if (!turn)
-            return;
-        const completedAt = nowSeconds();
-        for (const item of turn.items) {
-            if (item.type === "collabAgentToolCall" && item.status === "inProgress")
-                item.status = "completed";
-            else if (item.type === "dynamicToolCall" && item.status === "inProgress")
-                item.status = "completed";
-        }
-        turn.status = status;
-        turn.completedAt = completedAt;
-        turn.durationMs = Math.max(0, (completedAt - (turn.startedAt ?? completedAt)) * 1_000);
-        turn.error = status === "failed" ? { message: errorMessage ?? "Background Claude work failed.", codexErrorInfo: null, additionalDetails: null } : null;
-        this.store.updateTurn(this.threadId, turn);
-        this.backgroundTurn = undefined;
-        for (const task of this.tasks.values())
-            if (task.turnId === turn.id)
-                task.turnId = null;
-        this.record = { ...this.record, lastCompletedTurnId: turn.id };
-        this.updateThread({
-            ...this.record.thread,
-            status: this.backgroundTaskIds.size > 0 ? { type: "active", activeFlags: [] } : { type: "idle" },
-            updatedAt: completedAt, recencyAt: completedAt,
-        });
-        if (turn.error) {
-            this.emit("error", { error: turn.error, willRetry: false, threadId: this.threadId, turnId: turn.id }, turn.id);
-        }
-        this.emit("turn/completed", { threadId: this.threadId, turn }, turn.id);
-    }
-    async handleCompaction(metadata) {
-        const item = { type: "contextCompaction", id: uuidv7() };
-        let turnId;
-        if (this.active) {
-            this.active.turn.items.push(item);
-            this.active.completedItems.add(item.id);
-            this.persistActive();
-            turnId = this.active.turn.id;
-        }
-        else {
-            const now = nowSeconds();
-            const turn = {
-                id: uuidv7(), items: [item], itemsView: "full", status: "completed", error: null,
-                startedAt: now, completedAt: now, durationMs: 0,
-            };
-            this.store.createTurn(this.threadId, turn);
-            turnId = turn.id;
-            this.record = { ...this.record, lastCompletedTurnId: turn.id };
-            this.updateThread({ ...this.record.thread, updatedAt: now, recencyAt: now, status: { type: "idle" } });
-        }
-        const timestamp = Date.now();
-        this.emit("item/started", { item, threadId: this.threadId, turnId, startedAtMs: timestamp });
-        this.emit("item/completed", { item, threadId: this.threadId, turnId, completedAtMs: timestamp });
-        this.emit("thread/compacted", { threadId: this.threadId, turnId });
-        let context;
-        try {
-            context = await this.sdkQuery.getContextUsage();
-        }
-        catch (error) {
-            this.logger.debug("claude.context-usage.failed", { threadId: this.threadId, error: String(error) });
-        }
-        const contextTokens = context?.totalTokens ?? metadata.post_tokens;
-        if (contextTokens !== undefined) {
-            const last = {
-                totalTokens: contextTokens, inputTokens: contextTokens,
-                cachedInputTokens: 0, outputTokens: 0, reasoningOutputTokens: 0,
-            };
-            this.emit("thread/tokenUsage/updated", {
-                threadId: this.threadId, turnId,
-                tokenUsage: { total: this.record.tokenUsageTotal, last, modelContextWindow: context?.maxTokens ?? null },
-            });
-        }
-        const pending = this.pendingCompaction;
-        if (pending) {
-            this.pendingCompaction = undefined;
-            clearTimeout(pending.timer);
-            pending.resolve();
-        }
-    }
-    emitUsage(message) {
-        if (!this.active)
-            return;
-        const inputTokens = message.usage.input_tokens + message.usage.cache_creation_input_tokens + message.usage.cache_read_input_tokens;
-        const last = {
-            totalTokens: inputTokens + message.usage.output_tokens,
-            inputTokens,
-            cachedInputTokens: message.usage.cache_read_input_tokens,
-            outputTokens: message.usage.output_tokens,
-            reasoningOutputTokens: 0,
-        };
-        const total = {
-            totalTokens: this.record.tokenUsageTotal.totalTokens + last.totalTokens,
-            inputTokens: this.record.tokenUsageTotal.inputTokens + last.inputTokens,
-            cachedInputTokens: this.record.tokenUsageTotal.cachedInputTokens + last.cachedInputTokens,
-            outputTokens: this.record.tokenUsageTotal.outputTokens + last.outputTokens,
-            reasoningOutputTokens: this.record.tokenUsageTotal.reasoningOutputTokens + last.reasoningOutputTokens,
-        };
-        this.record = { ...this.record, tokenUsageTotal: total };
-        this.store.updateThread(this.record);
-        const contextWindows = Object.values(message.modelUsage).map((usage) => usage.contextWindow);
-        this.emit("thread/tokenUsage/updated", {
-            threadId: this.threadId,
-            turnId: this.active.turn.id,
-            tokenUsage: {
-                total,
-                last,
-                modelContextWindow: contextWindows.length > 0 ? Math.max(...contextWindows) : null,
-            },
-        });
-    }
-    async handleStreamEvent(message) {
-        const event = message.event;
-        if (!this.active)
-            return;
-        if (event.type === "message_start") {
-            this.active.blockItems.clear();
-            return;
-        }
-        if (event.type === "content_block_start") {
-            const block = event.content_block;
-            if (block.type === "text")
-                this.createAgentItem(event.index);
-            else if (block.type === "thinking")
-                this.createReasoningItem(event.index);
-            else if (block.type === "tool_use" || block.type === "server_tool_use" || block.type === "mcp_tool_use") {
-                this.createToolItem(event.index, block);
-            }
-            else
-                this.completeServerToolResult(serverToolResult(block));
-            return;
-        }
-        if (event.type === "content_block_delta") {
-            if (event.delta.type === "text_delta")
-                this.appendAgentText(event.index, event.delta.text);
-            else if (event.delta.type === "thinking_delta")
-                this.appendReasoning(event.index, event.delta.thinking);
-            else if (event.delta.type === "input_json_delta")
-                this.appendToolInput(event.index, event.delta.partial_json);
-            return;
-        }
-        if (event.type === "content_block_stop" && !this.toolAt(event.index))
-            this.completeItem(event.index);
-    }
-    createToolItem(index, block) {
-        if (!this.active)
-            throw new Error("No active turn.");
-        const existing = this.itemAt(index);
-        if (existing)
-            return existing;
-        const { state, item } = startTool(index, block, this.record.thread.cwd, this.threadId);
-        this.active.blockItems.set(index, item.id);
-        this.active.tools.set(state.providerId, state);
-        this.active.turn.items.push(item);
-        this.persistActive();
-        this.startToolItem(state, item);
-        return item;
-    }
-    appendToolInput(index, delta) {
-        const tool = this.toolAt(index);
-        const item = this.itemAt(index);
-        if (!tool || !item)
-            return;
-        tool.partialInput += delta;
-        try {
-            const input = JSON.parse(tool.partialInput);
-            updateToolInput(item, tool, input);
-            this.persistActive();
-            this.startToolItem(tool, item);
-            this.emitPlan(item, input);
-        }
-        catch {
-            // Partial JSON is expected until the final input_json_delta.
-        }
-    }
-    handleToolResults(message) {
-        if (!this.active)
-            return;
-        const structured = message.tool_use_result;
-        const result = structured && typeof structured === "object" ? structured : undefined;
-        for (const toolResult of toolResults(message)) {
-            const tool = this.active.tools.get(toolResult.toolUseId);
-            if (!tool || this.active.completedItems.has(tool.itemId))
-                continue;
-            const index = this.active.turn.items.findIndex((item) => item.id === tool.itemId);
-            const item = this.active.turn.items[index];
-            if (!item)
-                continue;
-            this.startToolItem(tool, item, true);
-            const previousChanges = item.type === "fileChange" ? JSON.stringify(item.changes) : undefined;
-            const completed = completeTool(item, toolResult.output, toolResult.isError, result, tool.startedAtMs);
-            this.active.turn.items[index] = completed;
-            this.active.completedItems.add(completed.id);
-            this.persistActive();
-            if (completed.type === "commandExecution" && toolResult.output) {
-                this.emit("item/commandExecution/outputDelta", { threadId: this.threadId, turnId: this.active.turn.id, itemId: completed.id, delta: toolResult.output });
-            }
-            if (completed.type === "fileChange" && completed.changes.length > 0 && JSON.stringify(completed.changes) !== previousChanges)
-                this.emitFileDiff(completed);
-            this.emit("item/completed", { item: completed, threadId: this.threadId, turnId: this.active.turn.id, completedAtMs: Date.now() });
-        }
-    }
-    completeServerToolResult(result) {
-        if (!this.active || !result)
-            return;
-        const tool = this.active.tools.get(result.toolUseId);
-        if (!tool || this.active.completedItems.has(tool.itemId))
-            return;
-        const index = this.active.turn.items.findIndex((item) => item.id === tool.itemId);
-        const item = this.active.turn.items[index];
-        if (!item)
-            return;
-        this.startToolItem(tool, item, true);
-        const completed = completeTool(item, result.output, result.isError, undefined, tool.startedAtMs);
-        this.active.turn.items[index] = completed;
-        this.active.completedItems.add(completed.id);
-        this.persistActive();
-        this.emit("item/completed", {
-            item: completed, threadId: this.threadId, turnId: this.active.turn.id, completedAtMs: Date.now(),
-        });
-    }
-    emitFileDiff(item) {
-        if (!this.active)
-            return;
-        this.emit("item/fileChange/patchUpdated", {
-            threadId: this.threadId, turnId: this.active.turn.id, itemId: item.id, changes: item.changes,
-        });
-        const diff = this.active.turn.items.flatMap((candidate) => candidate.type === "fileChange" ? candidate.changes.map((change) => change.diff) : []).join("\n");
-        this.emit("turn/diff/updated", { threadId: this.threadId, turnId: this.active.turn.id, diff });
-    }
-    emitPlan(item, input) {
-        if (!this.active || item.type !== "plan")
-            return;
-        const plan = planSteps(input);
-        if (plan.length > 0)
-            this.emit("turn/plan/updated", { threadId: this.threadId, turnId: this.active.turn.id, explanation: null, plan });
-    }
-    startToolItem(tool, item, force = false) {
-        if (!this.active || tool.started || (item.type === "commandExecution" && !item.command))
-            return;
-        if (!force && !this.sessionApprovedTools.has(tool.name)) {
-            const policy = toolPolicy(tool.name, tool.input, this.record.thread.cwd, this.record.approvalPolicy, this.record.sandboxPolicy);
-            if (policy.decision === "ask")
-                return;
-        }
-        tool.started = true;
-        this.emit("item/started", {
-            item, threadId: this.threadId, turnId: this.active.turn.id, startedAtMs: tool.startedAtMs,
-        });
-        this.emitPlan(item, tool.input);
-    }
-    itemAt(index) {
-        if (!this.active)
-            return undefined;
-        const itemId = this.active.blockItems.get(index);
-        return itemId ? this.active.turn.items.find((item) => item.id === itemId) : undefined;
-    }
-    toolAt(index) {
-        if (!this.active)
-            return undefined;
-        const itemId = this.active.blockItems.get(index);
-        return itemId ? [...this.active.tools.values()].find((tool) => tool.itemId === itemId) : undefined;
-    }
-    createAgentItem(index) {
-        if (!this.active)
-            throw new Error("No active turn.");
-        const existingId = this.active.blockItems.get(index);
-        const existing = existingId && this.active.turn.items.find((item) => item.id === existingId);
-        if (existing)
-            return existing;
-        const item = { type: "agentMessage", id: uuidv7(), text: "", phase: null, memoryCitation: null };
-        this.active.blockItems.set(index, item.id);
-        this.active.turn.items.push(item);
-        this.persistActive();
-        this.emit("item/started", { item, threadId: this.threadId, turnId: this.active.turn.id, startedAtMs: Date.now() });
-        return item;
-    }
-    createReasoningItem(index) {
-        if (!this.active)
-            throw new Error("No active turn.");
-        const existingId = this.active.blockItems.get(index);
-        const existing = existingId && this.active.turn.items.find((item) => item.id === existingId);
-        if (existing)
-            return existing;
-        const item = { type: "reasoning", id: uuidv7(), summary: [], content: [] };
-        this.active.blockItems.set(index, item.id);
-        this.active.turn.items.push(item);
-        this.persistActive();
-        this.emit("item/started", { item, threadId: this.threadId, turnId: this.active.turn.id, startedAtMs: Date.now() });
-        return item;
-    }
-    appendAgentText(index, delta) {
-        if (!this.active)
-            return;
-        const item = this.createAgentItem(index);
-        if (item.type !== "agentMessage")
-            return;
-        item.text += delta;
-        this.persistActive();
-        this.emit("item/agentMessage/delta", { threadId: this.threadId, turnId: this.active.turn.id, itemId: item.id, delta });
-    }
-    appendReasoning(index, delta) {
-        if (!this.active)
-            return;
-        const item = this.createReasoningItem(index);
-        if (item.type !== "reasoning")
-            return;
-        item.content[0] = `${item.content[0] ?? ""}${delta}`;
-        this.persistActive();
-        this.emit("item/reasoning/textDelta", { threadId: this.threadId, turnId: this.active.turn.id, itemId: item.id, delta, contentIndex: 0 });
-    }
-    completeItem(index) {
-        if (!this.active)
-            return;
-        const itemId = this.active.blockItems.get(index);
-        const item = itemId && this.active.turn.items.find((candidate) => candidate.id === itemId);
-        if (!item || this.active.completedItems.has(item.id))
-            return;
-        this.active.completedItems.add(item.id);
-        this.persistActive();
-        this.emit("item/completed", { item, threadId: this.threadId, turnId: this.active.turn.id, completedAtMs: Date.now() });
-    }
-    async backfillAssistant(message) {
-        if (!this.active)
-            return;
-        for (const text of textFromAssistant(message)) {
-            const alreadyPresent = this.active.turn.items.some((item) => item.type === "agentMessage" && item.text === text);
-            if (alreadyPresent)
-                continue;
-            const item = { type: "agentMessage", id: uuidv7(), text, phase: null, memoryCitation: null };
-            this.active.turn.items.push(item);
-            this.active.completedItems.add(item.id);
-            this.persistActive();
-            this.emit("item/started", { item, threadId: this.threadId, turnId: this.active.turn.id, startedAtMs: Date.now() });
-            this.emit("item/agentMessage/delta", { threadId: this.threadId, turnId: this.active.turn.id, itemId: item.id, delta: text });
-            this.emit("item/completed", { item, threadId: this.threadId, turnId: this.active.turn.id, completedAtMs: Date.now() });
-        }
-    }
-    async failActive(message) {
-        await this.completeActive("failed", message, classifyClaudeRuntimeError(message));
-    }
-    async completeActive(status, errorMessage, codexErrorInfo = null) {
-        if (!this.active)
-            return;
-        for (const tool of this.active.tools.values()) {
-            if (this.active.completedItems.has(tool.itemId))
-                continue;
-            const index = this.active.turn.items.findIndex((item) => item.id === tool.itemId);
-            const item = this.active.turn.items[index];
-            if (!item)
-                continue;
-            this.active.turn.items[index] = completeTool(item, "Claude turn ended before the tool returned a result.", true, undefined, tool.startedAtMs);
-        }
-        for (const index of this.active.blockItems.keys())
-            this.completeItem(index);
-        if (this.active.review) {
-            const item = { type: "exitedReviewMode", id: uuidv7(), review: this.active.review };
-            this.active.turn.items.push(item);
-            this.active.completedItems.add(item.id);
-            this.persistActive();
-            this.emit("item/started", { item, threadId: this.threadId, turnId: this.active.turn.id, startedAtMs: Date.now() });
-            this.emit("item/completed", { item, threadId: this.threadId, turnId: this.active.turn.id, completedAtMs: Date.now() });
-        }
-        for (const task of this.tasks.values()) {
-            if (task.turnId !== this.active.turn.id || task.terminal)
-                continue;
-            const item = this.active.turn.items.find((candidate) => candidate.id === task.itemId);
-            if (item?.type === "collabAgentToolCall")
-                item.status = "completed";
-            else if (item?.type === "dynamicToolCall")
-                item.status = "completed";
-            if (item) {
-                this.active.completedItems.add(item.id);
-                this.emit("item/completed", { item, threadId: this.threadId, turnId: this.active.turn.id, completedAtMs: Date.now() });
-            }
-            task.turnId = null;
-        }
-        const completedAt = nowSeconds();
-        const startedAt = this.active.turn.startedAt ?? completedAt;
-        this.active.turn = {
-            ...this.active.turn,
-            status,
-            completedAt,
-            durationMs: Math.max(0, (completedAt - startedAt) * 1_000),
-            error: status === "failed"
-                ? { message: errorMessage ?? "Claude turn failed.", codexErrorInfo, additionalDetails: null }
-                : null,
-        };
-        this.persistActive();
-        const turn = this.active.turn;
-        this.active = undefined;
-        this.lastActivityMs = Date.now();
-        this.record = { ...this.record, lastCompletedTurnId: turn.id };
-        this.updateThread({
-            ...this.record.thread,
-            status: this.backgroundTaskIds.size > 0 ? { type: "active", activeFlags: [] } : { type: "idle" },
-            updatedAt: completedAt, recencyAt: completedAt,
-        });
-        if (turn.error) {
-            this.emit("error", { error: turn.error, willRetry: false, threadId: this.threadId, turnId: turn.id }, turn.id);
-        }
-        this.emit("turn/completed", { threadId: this.threadId, turn });
-    }
-    persistActive() {
-        if (this.active)
-            this.store.updateTurn(this.threadId, this.active.turn);
-    }
-    updateThread(thread) {
-        this.record = { ...this.record, thread };
-        this.store.updateThread(this.record);
-        this.emit("thread/status/changed", { threadId: this.threadId, status: thread.status });
-    }
-    emit(method, params, turnId = this.active?.turn.id ?? null) {
-        const value = params && typeof params === "object" ? params : undefined;
-        const parameterTurn = value?.turn && typeof value.turn === "object" && "items" in value.turn
-            ? value.turn
-            : undefined;
-        const runtimeTurn = this.active?.turn.id === turnId
-            ? this.active.turn
-            : this.backgroundTurn?.id === turnId
-                ? this.backgroundTurn
-                : undefined;
-        const persistedTurn = parameterTurn ?? runtimeTurn;
-        const sequence = this.store.appendEvent(this.threadId, turnId, method, params, {
-            ...(persistedTurn ? { turn: persistedTurn } : {}),
-            providerEventId: this.providerEventId,
-            providerEventType: this.providerEventType,
-            dedupKey: eventDedupKey(method, params),
-        });
-        if (sequence === 0)
-            return;
-        if (method === "turn/completed" && parameterTurn && parameterTurn.status !== "inProgress") {
-            this.metrics.turnCompleted(parameterTurn.status);
-        }
-        this.hub.emit(this.threadId, method, params);
-    }
-}
-//# sourceMappingURL=sessionRuntime.js.map