@gkorepanov/ccodex 0.3.0

package/dist/claude/sessionRuntime.js

@@ -0,0 +1,1361 @@
+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