@gkorepanov/ccodex 0.3.0

package/dist/claude/service.js

@@ -0,0 +1,1008 @@
+import { join, resolve } from "node:path";
+import { statSync } from "node:fs";
+import { spawn } from "node:child_process";
+import { deleteSession, forkSession, getSessionMessages, renameSession } from "@anthropic-ai/claude-agent-sdk";
+import { v7 as uuidv7 } from "uuid";
+import { SqliteHybridStore } from "../store/sqliteStore.js";
+import { LayeredHybridStore } from "../store/memoryStore.js";
+import { ClaudeSessionRuntime } from "./sessionRuntime.js";
+import { createClaudeQuery } from "./queryFactory.js";
+import { InteractionBridge } from "./interactions.js";
+import { invalidParams } from "../protocol/errors.js";
+import { MetricsRegistry } from "../observability/metrics.js";
+import { claudeCatalogId, normalizeClaudeServiceTier, resolveClaudeModel, } from "./modelSelection.js";
+function nowSeconds() {
+    return Math.floor(Date.now() / 1_000);
+}
+function existingThreadCwd(value) {
+    const cwd = resolve(value);
+    try {
+        if (statSync(cwd).isDirectory())
+            return cwd;
+    }
+    catch {
+        // Project moves should surface as a precise protocol error, not the Claude
+        // SDK's misleading native-binary/libc spawn diagnostic.
+    }
+    throw invalidParams(`Claude thread cwd '${cwd}' does not exist or is not a directory.`);
+}
+function sandboxPolicy(mode, cwd) {
+    if (mode === "read-only")
+        return { type: "readOnly", networkAccess: false };
+    if (mode === "danger-full-access")
+        return { type: "dangerFullAccess" };
+    return {
+        type: "workspaceWrite",
+        writableRoots: [cwd],
+        networkAccess: false,
+        excludeTmpdirEnvVar: false,
+        excludeSlashTmp: false,
+    };
+}
+function permissionProfileSandboxPolicy(profile, cwd) {
+    if (profile === ":read-only")
+        return sandboxPolicy("read-only", cwd);
+    if (profile === ":workspace")
+        return sandboxPolicy("workspace-write", cwd);
+    if (profile === ":danger-full-access")
+        return sandboxPolicy("danger-full-access", cwd);
+    throw invalidParams(`Claude threads do not support Codex permission profile '${profile}'.`);
+}
+function approvalsReviewer(value, fallback = "user") {
+    return value ?? fallback;
+}
+function threadResponse(record, includeTurns) {
+    return {
+        thread: { ...record.thread, turns: includeTurns ? record.thread.turns : [] },
+        model: record.modelPickerId,
+        modelProvider: "claude",
+        serviceTier: record.serviceTier,
+        cwd: record.thread.cwd,
+        runtimeWorkspaceRoots: [record.thread.cwd],
+        instructionSources: [],
+        approvalPolicy: record.approvalPolicy,
+        approvalsReviewer: record.approvalsReviewer,
+        sandbox: record.sandboxPolicy,
+        activePermissionProfile: null,
+        reasoningEffort: record.reasoningEffort,
+        multiAgentMode: "explicitRequestOnly",
+    };
+}
+function clonedTurn(turn) {
+    return structuredClone(turn);
+}
+function failedAfterCrash(turn) {
+    const completedAt = nowSeconds();
+    return {
+        ...turn,
+        items: turn.items.map((item) => "status" in item && item.status === "inProgress" ? { ...item, status: "failed" } : item),
+        status: "failed",
+        completedAt,
+        durationMs: turn.startedAt === null ? null : Math.max(0, (completedAt - turn.startedAt) * 1_000),
+        error: {
+            message: "Gateway restarted while the Claude turn was active.",
+            codexErrorInfo: { responseStreamDisconnected: { httpStatusCode: null } },
+            additionalDetails: null,
+        },
+    };
+}
+export class ClaudeService {
+    config;
+    hub;
+    logger;
+    queryFactory;
+    modelCatalog;
+    metrics;
+    runtimes = new Map();
+    idleTimer;
+    store;
+    interactions;
+    idleSweep = Promise.resolve();
+    constructor(config, hub, logger, durableStore = new SqliteHybridStore(join(config.dataDir, "state.sqlite")), queryFactory = createClaudeQuery, modelCatalog, metrics = new MetricsRegistry()) {
+        this.config = config;
+        this.hub = hub;
+        this.logger = logger;
+        this.queryFactory = queryFactory;
+        this.modelCatalog = modelCatalog;
+        this.metrics = metrics;
+        this.store = new LayeredHybridStore(durableStore);
+        this.interactions = new InteractionBridge(this.store, hub, metrics);
+        this.reconcileAfterRestart();
+        for (const record of this.store.allThreadRecords()) {
+            for (const request of this.store.listPendingRequests(record.thread.id)) {
+                this.metrics.pendingOpened(request.requestId, request.createdAt);
+            }
+        }
+        const intervalMs = Math.max(1_000, Math.min(config.idleTimeoutSeconds * 500, 60_000));
+        this.idleTimer = setInterval(() => {
+            this.idleSweep = this.idleSweep.then(() => this.unloadIdleRuntimes());
+        }, intervalMs);
+        this.idleTimer.unref();
+    }
+    ownsThread(threadId) {
+        return this.store.hasThread(threadId);
+    }
+    ownsModel(modelId) {
+        return resolveClaudeModel(this.config, modelId) !== undefined;
+    }
+    handoffSource(threadId, lastTurnId) {
+        const record = this.requireRecord(threadId, true);
+        const through = lastTurnId
+            ? record.thread.turns.findIndex((turn) => turn.id === lastTurnId)
+            : record.thread.turns.length - 1;
+        if (lastTurnId && through < 0)
+            throw invalidParams(`Unknown Claude turn '${lastTurnId}'.`);
+        return {
+            thread: record.thread,
+            turns: record.thread.turns.slice(0, through + 1),
+            settings: this.threadSettings(record),
+        };
+    }
+    currentThreadSettings(threadId) {
+        return this.threadSettings(this.requireRecord(threadId, false));
+    }
+    loadedThreadIds() {
+        return [...this.runtimes.keys()].filter((threadId) => !this.hub.isSuppressed(threadId));
+    }
+    reportError(threadId, requestedTurnId, message, codexErrorInfo) {
+        const record = this.requireRecord(threadId, false);
+        const turnId = requestedTurnId
+            ?? this.runtimes.get(threadId)?.activeTurnId
+            ?? record.lastCompletedTurnId
+            ?? uuidv7();
+        const params = {
+            error: { message, codexErrorInfo, additionalDetails: null },
+            willRetry: false,
+            threadId,
+            turnId,
+        };
+        this.emit(threadId, turnId, "error", params);
+    }
+    async startThread(params) {
+        const modelPickerId = params.model;
+        const claudeModelValue = modelPickerId && resolveClaudeModel(this.config, modelPickerId);
+        if (!modelPickerId || !claudeModelValue) {
+            throw invalidParams("Claude thread requires a configured Claude model or alias.");
+        }
+        if (params.permissions && params.sandbox) {
+            throw invalidParams("Claude thread start cannot combine permissions with sandbox.");
+        }
+        const serviceTier = normalizeClaudeServiceTier(this.config, modelPickerId, params.serviceTier);
+        if (serviceTier !== null && serviceTier !== "default" && serviceTier !== "fast") {
+            throw invalidParams(`Unsupported Claude service tier '${serviceTier}'.`);
+        }
+        await this.validateModelSettings(modelPickerId, null, serviceTier);
+        const createdAt = nowSeconds();
+        const cwd = existingThreadCwd(params.cwd ?? process.cwd());
+        const thread = {
+            id: uuidv7(),
+            extra: null,
+            sessionId: uuidv7(),
+            forkedFromId: null,
+            parentThreadId: null,
+            preview: "",
+            ephemeral: params.ephemeral ?? false,
+            historyMode: params.historyMode ?? "legacy",
+            modelProvider: "claude",
+            createdAt,
+            updatedAt: createdAt,
+            recencyAt: createdAt,
+            status: { type: "notLoaded" },
+            path: null,
+            cwd,
+            cliVersion: "claude-code",
+            source: "appServer",
+            threadSource: params.threadSource ?? null,
+            agentNickname: null,
+            agentRole: null,
+            gitInfo: null,
+            name: null,
+            turns: [],
+        };
+        let record = {
+            thread,
+            claudeSessionId: uuidv7(),
+            modelPickerId,
+            claudeModelValue,
+            serviceTier,
+            approvalPolicy: params.approvalPolicy ?? "on-request",
+            approvalsReviewer: approvalsReviewer(params.approvalsReviewer),
+            sandboxPolicy: params.permissions
+                ? permissionProfileSandboxPolicy(params.permissions, cwd)
+                : sandboxPolicy(params.sandbox, cwd),
+            baseInstructions: params.baseInstructions ?? null,
+            developerInstructions: params.developerInstructions ?? null,
+            personality: params.personality ?? null,
+            resolvedModel: null,
+            lastClaudeMessageUuid: null,
+            lastCompletedTurnId: null,
+            claudeCodeVersion: null,
+            reasoningEffort: null,
+            reasoningSummary: null,
+            collaborationMode: null,
+            outputSchema: null,
+            tokenUsageTotal: { totalTokens: 0, inputTokens: 0, cachedInputTokens: 0, outputTokens: 0, reasoningOutputTokens: 0 },
+        };
+        this.store.createThread(record);
+        try {
+            const runtime = await ClaudeSessionRuntime.create(record, this.store, this.hub, this.logger, this.config, false, this.queryFactory, this.interactions, () => this.modelCatalog?.invalidate?.(), this.metrics);
+            this.runtimes.set(thread.id, runtime);
+            this.metrics.runtimeLoaded(false);
+            record = { ...record, thread: { ...thread, status: { type: "idle" } } };
+            this.store.updateThread(record);
+            return threadResponse(record, false);
+        }
+        catch (error) {
+            if (/auth|oauth|model.?not.?found/i.test(String(error)))
+                this.modelCatalog?.invalidate?.();
+            this.store.deleteThread(thread.id);
+            throw error;
+        }
+    }
+    announceThread(thread) {
+        this.store.appendEvent(thread.id, null, "thread/started", { thread });
+        this.hub.emit(thread.id, "thread/started", { thread });
+    }
+    async resumeThread(params) {
+        const resume = typeof params === "string" ? { threadId: params } : params;
+        const { threadId } = resume;
+        let record = this.store.getThreadRecord(threadId, true);
+        if (!record)
+            throw invalidParams(`Unknown Claude thread '${threadId}'.`);
+        const loaded = this.runtimes.get(threadId);
+        if (loaded) {
+            await loaded.reinitialize();
+        }
+        else {
+            if (record.thread.ephemeral)
+                throw invalidParams(`Ephemeral Claude thread '${threadId}' is no longer loaded.`);
+            const shouldResume = record.lastClaudeMessageUuid !== null;
+            const runtime = await ClaudeSessionRuntime.create(record, this.store, this.hub, this.logger, this.config, shouldResume, this.queryFactory, this.interactions, () => this.modelCatalog?.invalidate?.(), this.metrics);
+            this.runtimes.set(threadId, runtime);
+            this.metrics.runtimeLoaded(shouldResume);
+            record = { ...record, thread: { ...record.thread, status: { type: "idle" } } };
+            this.store.updateThread(record);
+        }
+        return {
+            ...threadResponse(record, !resume.excludeTurns),
+            initialTurnsPage: resume.initialTurnsPage
+                ? this.turnsPage({
+                    threadId,
+                    ...(resume.initialTurnsPage.limit !== undefined ? { limit: resume.initialTurnsPage.limit } : {}),
+                    ...(resume.initialTurnsPage.sortDirection !== undefined ? { sortDirection: resume.initialTurnsPage.sortDirection } : {}),
+                    ...(resume.initialTurnsPage.itemsView !== undefined ? { itemsView: resume.initialTurnsPage.itemsView } : {}),
+                })
+                : null,
+        };
+    }
+    readThread(threadId, includeTurns) {
+        const record = this.store.getThreadRecord(threadId, includeTurns);
+        if (!record)
+            throw invalidParams(`Unknown Claude thread '${threadId}'.`);
+        return { thread: record.thread };
+    }
+    async prepareTurn(params) {
+        await this.applyTurnOverrides(params);
+        const runtime = await this.requireRuntime(params.threadId);
+        const prepared = await runtime.prepareTurn(params);
+        return { response: { turn: prepared.turn }, announce: prepared.announce, start: prepared.start };
+    }
+    async interruptTurn(threadId) {
+        await (await this.requireRuntime(threadId)).interrupt();
+    }
+    async steerTurn(params) {
+        return { turnId: await (await this.requireRuntime(params.threadId)).steer(params) };
+    }
+    async compactThread(threadId) {
+        await (await this.requireRuntime(threadId)).compact();
+        return {};
+    }
+    async updateThreadSettings(params) {
+        await this.applySettings(params, false);
+        return {};
+    }
+    async injectItems(params) {
+        await (await this.requireRuntime(params.threadId)).injectItems(params.items);
+        return {};
+    }
+    async summarizeHandoff(threadId, prompt) {
+        const source = this.requireRecord(threadId, false);
+        const started = await this.startThread({
+            model: source.modelPickerId,
+            serviceTier: source.serviceTier,
+            cwd: source.thread.cwd,
+            approvalPolicy: "never",
+            sandbox: "read-only",
+            developerInstructions: "Create a portable conversation handoff. Do not call tools or mutate the workspace.",
+            ephemeral: true,
+            threadSource: "subAgent",
+        });
+        const temporaryId = started.thread.id;
+        this.hub.suppress(temporaryId);
+        try {
+            const prepared = await this.prepareTurn({
+                threadId: temporaryId,
+                input: [{ type: "text", text: prompt, text_elements: [] }],
+            });
+            prepared.announce();
+            prepared.start();
+            const completed = await new Promise((resolve, reject) => {
+                const timeout = setTimeout(() => {
+                    clearInterval(poll);
+                    reject(new Error("Claude compact handoff timed out."));
+                }, 120_000);
+                const poll = setInterval(() => {
+                    const turn = this.store.listTurns(temporaryId).at(-1);
+                    if (!turn || turn.status === "inProgress")
+                        return;
+                    clearTimeout(timeout);
+                    clearInterval(poll);
+                    if (turn.status !== "completed")
+                        reject(new Error(turn.error?.message ?? "Claude compact handoff failed."));
+                    else
+                        resolve(turn);
+                }, 25);
+            });
+            const text = completed.items.flatMap((item) => item.type === "agentMessage" ? [item.text] : []).join("\n").trim();
+            if (!text)
+                throw new Error("Claude compact handoff returned no text.");
+            return text;
+        }
+        finally {
+            await this.discardThreadSilently(temporaryId);
+            this.hub.unsuppress(temporaryId);
+        }
+    }
+    async createHandoffFork(params, sourceThread, inheritedTurns, settings, developerInstructions, targetName) {
+        if (!params.model || !this.ownsModel(params.model))
+            throw invalidParams("Claude handoff fork requires a Claude target model.");
+        const started = await this.startThread({
+            model: params.model,
+            modelProvider: "claude",
+            cwd: params.cwd ?? sourceThread.cwd,
+            developerInstructions,
+            ...(params.serviceTier !== undefined ? { serviceTier: params.serviceTier } : {}),
+            ...(params.approvalPolicy !== undefined ? { approvalPolicy: params.approvalPolicy } : {}),
+            ...(params.approvalsReviewer !== undefined ? { approvalsReviewer: params.approvalsReviewer } : {}),
+            ...(params.sandbox !== undefined ? { sandbox: params.sandbox } : {}),
+            ...(params.permissions !== undefined ? { permissions: params.permissions } : {}),
+            ...(params.config !== undefined ? { config: params.config } : {}),
+            ...(params.baseInstructions !== undefined ? { baseInstructions: params.baseInstructions } : {}),
+            ...(settings.personality !== undefined ? { personality: settings.personality } : {}),
+            ...(params.ephemeral !== undefined ? { ephemeral: params.ephemeral } : {}),
+            ...(params.threadSource !== undefined ? { threadSource: params.threadSource } : {}),
+        });
+        let current = this.requireRecord(started.thread.id, false);
+        const configured = {
+            ...current,
+            reasoningEffort: settings.effort === undefined ? current.reasoningEffort : settings.effort,
+            reasoningSummary: settings.summary === undefined ? current.reasoningSummary : settings.summary,
+            collaborationMode: settings.collaborationMode === undefined ? current.collaborationMode : settings.collaborationMode,
+        };
+        await this.validateModelSettings(configured.modelPickerId, configured.reasoningEffort, configured.serviceTier);
+        if (["reasoningEffort", "reasoningSummary", "collaborationMode"].some((key) => JSON.stringify(configured[key]) !== JSON.stringify(current[key]))) {
+            await this.unloadRuntime(started.thread.id, "Fresh handoff target settings applied.");
+            this.store.updateThread(configured);
+            const runtime = await ClaudeSessionRuntime.create(configured, this.store, this.hub, this.logger, this.config, false, this.queryFactory, this.interactions, () => this.modelCatalog?.invalidate?.(), this.metrics);
+            this.runtimes.set(started.thread.id, runtime);
+            this.metrics.runtimeLoaded(false);
+            current = { ...configured, thread: { ...configured.thread, status: { type: "idle" } } };
+            this.store.updateThread(current);
+        }
+        const now = nowSeconds();
+        const updated = {
+            ...current,
+            lastCompletedTurnId: inheritedTurns.at(-1)?.id ?? null,
+            thread: {
+                ...current.thread,
+                forkedFromId: sourceThread.id,
+                preview: sourceThread.preview,
+                name: targetName,
+                updatedAt: now,
+                recencyAt: now,
+            },
+        };
+        this.store.updateThread(updated);
+        for (const turn of inheritedTurns)
+            this.store.createTurn(updated.thread.id, clonedTurn(turn));
+        this.runtimes.get(updated.thread.id)?.synchronizeRecord(updated);
+        return threadResponse({ ...updated, thread: { ...updated.thread, turns: inheritedTurns } }, !params.excludeTurns);
+    }
+    async shellCommand(params) {
+        const runtime = this.runtimes.get(params.threadId);
+        if (runtime?.isActive)
+            throw invalidParams("Cannot run a thread shell command during an active Claude turn.");
+        const record = this.requireRecord(params.threadId, false);
+        const now = nowSeconds();
+        let item = {
+            type: "commandExecution", id: uuidv7(), command: params.command, cwd: record.thread.cwd,
+            processId: null, source: "userShell", status: "inProgress", commandActions: [],
+            aggregatedOutput: "", exitCode: null, durationMs: null,
+        };
+        let turn = {
+            id: uuidv7(), items: [item], itemsView: "full", status: "inProgress", error: null,
+            startedAt: now, completedAt: null, durationMs: null,
+        };
+        this.store.createTurn(params.threadId, turn);
+        this.store.updateThread({ ...record, thread: { ...record.thread, status: { type: "active", activeFlags: [] }, updatedAt: now } });
+        this.emit(params.threadId, turn.id, "turn/started", { threadId: params.threadId, turn });
+        this.emit(params.threadId, turn.id, "item/started", { item, threadId: params.threadId, turnId: turn.id, startedAtMs: Date.now() });
+        const startedAt = Date.now();
+        const child = spawn(process.env.SHELL ?? "/bin/sh", ["-lc", params.command], { cwd: record.thread.cwd, env: process.env });
+        const append = (bytes) => {
+            const delta = bytes.toString();
+            if (item.type !== "commandExecution")
+                return;
+            item = { ...item, aggregatedOutput: `${item.aggregatedOutput ?? ""}${delta}` };
+            turn = { ...turn, items: [item] };
+            this.store.updateTurn(params.threadId, turn);
+            this.emit(params.threadId, turn.id, "item/commandExecution/outputDelta", { threadId: params.threadId, turnId: turn.id, itemId: item.id, delta });
+        };
+        child.stdout.on("data", append);
+        child.stderr.on("data", append);
+        const exitCode = await new Promise((done, reject) => {
+            child.once("error", reject);
+            child.once("close", (code) => done(code ?? 1));
+        });
+        const completedAt = nowSeconds();
+        item = { ...item, status: exitCode === 0 ? "completed" : "failed", exitCode, durationMs: Date.now() - startedAt };
+        turn = {
+            ...turn, items: [item], status: exitCode === 0 ? "completed" : "failed",
+            completedAt, durationMs: Date.now() - startedAt,
+            error: exitCode === 0 ? null : { message: `Shell command exited with code ${exitCode}.`, codexErrorInfo: null, additionalDetails: null },
+        };
+        this.store.updateTurn(params.threadId, turn);
+        const current = this.requireRecord(params.threadId, false);
+        const updatedRecord = {
+            ...current,
+            lastCompletedTurnId: turn.id,
+            thread: { ...current.thread, status: { type: "idle" }, updatedAt: completedAt, recencyAt: completedAt },
+        };
+        this.store.updateThread(updatedRecord);
+        runtime?.synchronizeRecord(updatedRecord);
+        this.emit(params.threadId, turn.id, "item/completed", { item, threadId: params.threadId, turnId: turn.id, completedAtMs: Date.now() });
+        this.emit(params.threadId, turn.id, "turn/completed", { threadId: params.threadId, turn });
+        return {};
+    }
+    async prepareReview(params) {
+        let reviewThreadId = params.threadId;
+        let forkedThread;
+        if (params.delivery === "detached") {
+            const fork = await this.forkThread({ threadId: params.threadId, excludeTurns: false });
+            reviewThreadId = fork.thread.id;
+            forkedThread = fork.thread;
+        }
+        const review = params.target.type === "uncommittedChanges"
+            ? "uncommitted changes"
+            : params.target.type === "baseBranch"
+                ? `changes against base branch ${params.target.branch}`
+                : params.target.type === "commit"
+                    ? `commit ${params.target.sha}${params.target.title ? ` (${params.target.title})` : ""}`
+                    : "custom review";
+        const prompt = params.target.type === "custom"
+            ? params.target.instructions
+            : `Review ${review}. Inspect the repository and report concrete bugs, regressions, and risks with file and line references. Do not modify files.`;
+        await this.applySettings({
+            threadId: reviewThreadId,
+            sandboxPolicy: { type: "readOnly", networkAccess: false },
+            approvalsReviewer: "user",
+        }, true);
+        const runtime = await this.requireRuntime(reviewThreadId);
+        const prepared = await runtime.prepareTurn({
+            threadId: reviewThreadId,
+            input: [{ type: "text", text: prompt, text_elements: [] }],
+        }, review);
+        return {
+            response: { turn: prepared.turn, reviewThreadId },
+            announce: prepared.announce,
+            start: prepared.start,
+            ...(forkedThread ? { forkedThread } : {}),
+        };
+    }
+    listTurns(threadId) {
+        return this.store.listTurns(threadId);
+    }
+    turnsPage(params) {
+        const turns = this.listTurns(params.threadId);
+        const ordered = params.sortDirection === "asc" ? turns : [...turns].reverse();
+        if (params.cursor && !params.cursor.startsWith("hyb-turn:"))
+            throw invalidParams("Invalid Claude turn cursor.");
+        const offset = params.cursor?.startsWith("hyb-turn:") ? Number(params.cursor.slice("hyb-turn:".length)) : 0;
+        if (!Number.isInteger(offset) || offset < 0)
+            throw invalidParams("Invalid Claude turn cursor.");
+        const limit = Math.max(1, Math.min(params.limit ?? 50, 100));
+        const itemsView = params.itemsView ?? "summary";
+        const data = ordered.slice(offset, offset + limit).map((turn) => ({
+            ...turn,
+            itemsView,
+            ...(itemsView === "notLoaded" ? { items: [] } : {}),
+        }));
+        return {
+            data,
+            nextCursor: offset + data.length < ordered.length ? `hyb-turn:${offset + data.length}` : null,
+            backwardsCursor: data.length > 0 ? `hyb-turn:${Math.max(0, offset - limit)}` : null,
+        };
+    }
+    listThreads(params) {
+        return this.store.listThreads(params).filter((thread) => !this.hub.isSuppressed(thread.id));
+    }
+    async setThreadName(params) {
+        const record = this.requireRecord(params.threadId, false);
+        if (!record.thread.ephemeral && record.lastCompletedTurnId) {
+            await renameSession(record.claudeSessionId, params.name, { dir: record.thread.cwd });
+        }
+        const updated = { ...record, thread: { ...record.thread, name: params.name, updatedAt: nowSeconds() } };
+        this.store.updateThread(updated);
+        this.runtimes.get(params.threadId)?.synchronizeRecord(updated);
+        this.hub.emit(params.threadId, "thread/name/updated", { threadId: params.threadId, threadName: params.name });
+        return {};
+    }
+    updateThreadMetadata(params) {
+        const record = this.requireRecord(params.threadId, false);
+        const previous = record.thread.gitInfo ?? { sha: null, branch: null, originUrl: null };
+        const patch = params.gitInfo;
+        const gitInfo = patch === null ? null : patch === undefined ? record.thread.gitInfo : {
+            sha: patch.sha === undefined ? previous.sha : patch.sha,
+            branch: patch.branch === undefined ? previous.branch : patch.branch,
+            originUrl: patch.originUrl === undefined ? previous.originUrl : patch.originUrl,
+        };
+        const updated = { ...record, thread: { ...record.thread, gitInfo, updatedAt: nowSeconds() } };
+        this.store.updateThread(updated);
+        this.runtimes.get(params.threadId)?.synchronizeRecord(updated);
+        return { thread: updated.thread };
+    }
+    async archiveThread(threadId) {
+        const record = this.requireRecord(threadId, false);
+        if (!record.thread.ephemeral)
+            await this.unloadRuntime(threadId, "Claude thread archived during an active turn.");
+        this.store.setThreadArchived(threadId, true);
+        this.hub.emit(threadId, "thread/archived", { threadId });
+        return {};
+    }
+    unarchiveThread(threadId) {
+        this.requireRecord(threadId, false);
+        this.store.setThreadArchived(threadId, false);
+        const thread = this.requireRecord(threadId, false).thread;
+        this.hub.emit(threadId, "thread/unarchived", { threadId });
+        return { thread };
+    }
+    async deleteThread(threadId) {
+        const record = this.requireRecord(threadId, false);
+        this.interactions.cancelThread(threadId);
+        await this.unloadRuntime(threadId, "Claude thread deleted during an active turn.");
+        await deleteSession(record.claudeSessionId, { dir: record.thread.cwd }).catch((error) => {
+            if (!String(error).toLocaleLowerCase().includes("not found"))
+                throw error;
+        });
+        this.store.deleteThread(threadId);
+        this.hub.emit(threadId, "thread/deleted", { threadId });
+        return {};
+    }
+    listItems(params) {
+        const items = this.store.listTurns(params.threadId)
+            .flatMap((turn) => params.turnId && turn.id !== params.turnId ? [] : turn.items);
+        const ordered = params.sortDirection === "desc" ? [...items].reverse() : items;
+        if (params.cursor && !params.cursor.startsWith("hyb-item:"))
+            throw invalidParams("Invalid Claude item cursor.");
+        const offset = params.cursor?.startsWith("hyb-item:") ? Number(params.cursor.slice("hyb-item:".length)) : 0;
+        if (!Number.isInteger(offset) || offset < 0)
+            throw invalidParams("Invalid Claude item cursor.");
+        const limit = Math.max(1, Math.min(params.limit ?? 50, 100));
+        const data = ordered.slice(offset, offset + limit);
+        return {
+            data,
+            nextCursor: offset + data.length < ordered.length ? `hyb-item:${offset + data.length}` : null,
+            backwardsCursor: data.length > 0 ? `hyb-item:${Math.max(0, offset - limit)}` : null,
+        };
+    }
+    async forkThread(params) {
+        if (params.path)
+            throw invalidParams("Claude thread forks must use threadId, not a Codex rollout path.");
+        const source = this.requireRecord(params.threadId, true);
+        if (source.thread.ephemeral)
+            throw invalidParams("Forking an ephemeral Claude source thread is not supported.");
+        if (this.runtimes.get(params.threadId)?.isActive)
+            throw invalidParams("Cannot fork a Claude thread with an active turn.");
+        const modelPickerId = params.model ?? source.modelPickerId;
+        const claudeModelValue = resolveClaudeModel(this.config, modelPickerId);
+        if (!claudeModelValue)
+            throw invalidParams("Cannot fork a Claude thread to a Codex model.");
+        if (params.permissions && params.sandbox)
+            throw invalidParams("Claude thread fork cannot combine permissions with sandbox.");
+        const serviceTier = normalizeClaudeServiceTier(this.config, modelPickerId, params.serviceTier === undefined ? source.serviceTier : params.serviceTier);
+        await this.validateModelSettings(modelPickerId, source.reasoningEffort, serviceTier);
+        const through = params.lastTurnId
+            ? source.thread.turns.findIndex((turn) => turn.id === params.lastTurnId)
+            : source.thread.turns.length - 1;
+        if (params.lastTurnId && through < 0)
+            throw invalidParams(`Unknown Claude turn '${params.lastTurnId}'.`);
+        if (through >= 0 && source.thread.turns[through]?.status === "inProgress")
+            throw invalidParams("Cannot fork through an active turn.");
+        const sourceTurns = source.thread.turns.slice(0, through + 1);
+        const boundary = this.lastProviderBoundary(source.thread.id, sourceTurns);
+        const branch = await this.forkTranscript(source, boundary);
+        const createdAt = nowSeconds();
+        const cwd = existingThreadCwd(params.cwd ?? source.thread.cwd);
+        const thread = {
+            ...source.thread,
+            id: uuidv7(),
+            ephemeral: params.ephemeral ?? false,
+            sessionId: source.thread.sessionId,
+            forkedFromId: source.thread.id,
+            cwd,
+            modelProvider: "claude",
+            createdAt,
+            updatedAt: createdAt,
+            recencyAt: createdAt,
+            status: { type: "notLoaded" },
+            name: source.thread.name ? `${source.thread.name} (fork)` : null,
+            threadSource: params.threadSource ?? source.thread.threadSource,
+            turns: [],
+        };
+        const copiedTurns = sourceTurns.map(clonedTurn);
+        const record = {
+            ...source,
+            thread,
+            claudeSessionId: branch.sessionId,
+            modelPickerId,
+            claudeModelValue,
+            serviceTier,
+            approvalPolicy: params.approvalPolicy ?? source.approvalPolicy,
+            approvalsReviewer: approvalsReviewer(params.approvalsReviewer, source.approvalsReviewer),
+            sandboxPolicy: params.permissions
+                ? permissionProfileSandboxPolicy(params.permissions, cwd)
+                : params.sandbox
+                    ? sandboxPolicy(params.sandbox, cwd)
+                    : source.sandboxPolicy,
+            baseInstructions: params.baseInstructions === undefined ? source.baseInstructions : params.baseInstructions,
+            developerInstructions: params.developerInstructions === undefined ? source.developerInstructions : params.developerInstructions,
+            lastClaudeMessageUuid: boundary ? branch.uuidMap.get(boundary) ?? null : null,
+            lastCompletedTurnId: copiedTurns.at(-1)?.id ?? null,
+        };
+        this.store.createThread(record);
+        for (let index = 0; index < copiedTurns.length; index += 1) {
+            const turn = copiedTurns[index];
+            this.store.createTurn(thread.id, turn);
+            const oldUuid = this.store.getTurnClaudeMessageUuid(source.thread.id, sourceTurns[index].id);
+            const newUuid = oldUuid && branch.uuidMap.get(oldUuid);
+            if (newUuid)
+                this.store.setTurnClaudeMessageUuid(thread.id, turn.id, newUuid);
+        }
+        let responseRecord = { ...record, thread: { ...thread, turns: copiedTurns } };
+        if (thread.ephemeral) {
+            try {
+                const runtime = await ClaudeSessionRuntime.create(responseRecord, this.store, this.hub, this.logger, this.config, boundary !== undefined, this.queryFactory, this.interactions, () => this.modelCatalog?.invalidate?.(), this.metrics);
+                this.runtimes.set(thread.id, runtime);
+                this.metrics.runtimeLoaded(boundary !== undefined);
+                responseRecord = { ...responseRecord, thread: { ...responseRecord.thread, status: { type: "idle" } } };
+                this.store.updateThread(responseRecord);
+            }
+            catch (error) {
+                this.store.deleteThread(thread.id);
+                await deleteSession(branch.sessionId, { dir: cwd }).catch(() => undefined);
+                throw error;
+            }
+        }
+        const response = threadResponse(responseRecord, !params.excludeTurns);
+        return response;
+    }
+    async rollbackThread(params) {
+        if (!Number.isInteger(params.numTurns) || params.numTurns < 1)
+            throw invalidParams("numTurns must be at least 1.");
+        const source = this.requireRecord(params.threadId, true);
+        if (source.thread.ephemeral)
+            throw invalidParams("Rolling back an ephemeral Claude thread is not supported.");
+        if (params.numTurns > source.thread.turns.length)
+            throw invalidParams("Cannot remove more turns than the Claude thread contains.");
+        if (this.runtimes.get(params.threadId)?.isActive)
+            throw invalidParams("Cannot roll back a Claude thread with an active turn.");
+        const keepCount = source.thread.turns.length - params.numTurns;
+        const retained = source.thread.turns.slice(0, keepCount);
+        const boundary = this.lastProviderBoundary(params.threadId, retained);
+        const branch = await this.forkTranscript(source, boundary);
+        await this.unloadRuntime(params.threadId, "Claude thread rolled back.");
+        this.store.truncateTurns(params.threadId, keepCount);
+        for (const turn of retained) {
+            const oldUuid = this.store.getTurnClaudeMessageUuid(params.threadId, turn.id);
+            const newUuid = oldUuid && branch.uuidMap.get(oldUuid);
+            if (newUuid)
+                this.store.setTurnClaudeMessageUuid(params.threadId, turn.id, newUuid);
+        }
+        const current = this.requireRecord(params.threadId, false);
+        const updated = {
+            ...current,
+            claudeSessionId: branch.sessionId,
+            lastClaudeMessageUuid: boundary ? branch.uuidMap.get(boundary) ?? null : null,
+            lastCompletedTurnId: retained.at(-1)?.id ?? null,
+            thread: { ...current.thread, status: { type: "notLoaded" }, updatedAt: nowSeconds(), recencyAt: nowSeconds() },
+        };
+        this.store.updateThread(updated);
+        await deleteSession(source.claudeSessionId, { dir: source.thread.cwd }).catch((error) => {
+            this.logger.warn("claude.rollback.old-session-delete-failed", { threadId: params.threadId, error: String(error) });
+        });
+        return { thread: { ...updated.thread, turns: retained } };
+    }
+    setGoal(params) {
+        this.requireRecord(params.threadId, false);
+        const now = nowSeconds();
+        const previous = this.currentGoal(params.threadId, now);
+        const goal = {
+            threadId: params.threadId,
+            objective: params.objective ?? previous?.objective ?? "",
+            status: params.status ?? previous?.status ?? "active",
+            tokenBudget: params.tokenBudget === undefined ? previous?.tokenBudget ?? null : params.tokenBudget,
+            tokensUsed: previous?.tokensUsed ?? 0,
+            timeUsedSeconds: previous?.timeUsedSeconds ?? 0,
+            createdAt: previous?.createdAt ?? now,
+            updatedAt: now,
+        };
+        this.store.setGoal(goal);
+        this.hub.emit(params.threadId, "thread/goal/updated", { threadId: params.threadId, turnId: null, goal });
+        return { goal };
+    }
+    getGoal(threadId) {
+        this.requireRecord(threadId, false);
+        return { goal: this.currentGoal(threadId, nowSeconds()) ?? null };
+    }
+    clearGoal(threadId) {
+        this.requireRecord(threadId, false);
+        const cleared = this.store.clearGoal(threadId);
+        if (cleared)
+            this.hub.emit(threadId, "thread/goal/cleared", { threadId });
+        return { cleared };
+    }
+    resolveServerRequest(requestId, response) {
+        return this.interactions.resolve(requestId, response);
+    }
+    replayPendingRequests(threadId) {
+        this.interactions.replay(threadId);
+    }
+    async close() {
+        clearInterval(this.idleTimer);
+        await this.idleSweep;
+        const runtimes = [...this.runtimes.values()];
+        await Promise.all(runtimes.map((runtime) => runtime.stop("Gateway shut down during an active Claude turn.")));
+        for (const _runtime of runtimes)
+            this.metrics.runtimeUnloaded();
+        this.runtimes.clear();
+        this.store.close();
+    }
+    async discardThreadSilently(threadId) {
+        const record = this.store.getThreadRecord(threadId, false);
+        if (!record)
+            return;
+        await this.unloadRuntime(threadId, "Internal compact handoff completed.");
+        this.store.deleteThread(threadId);
+        await deleteSession(record.claudeSessionId, { dir: record.thread.cwd }).catch(() => undefined);
+    }
+    reconcileAfterRestart() {
+        for (const record of this.store.allThreadRecords()) {
+            const crashed = record.thread.turns.filter((turn) => turn.status === "inProgress").map(failedAfterCrash);
+            if (crashed.length > 0)
+                this.interactions.cancelThread(record.thread.id);
+            for (const turn of crashed) {
+                this.store.appendEvent(record.thread.id, turn.id, "turn/completed", { threadId: record.thread.id, turn }, {
+                    turn, dedupKey: `turn/completed:${turn.id}`,
+                });
+                this.metrics.turnCompleted("failed");
+            }
+            const status = record.thread.status.type === "active" || crashed.length > 0
+                ? { type: "systemError" }
+                : { type: "notLoaded" };
+            this.store.updateThread({
+                ...record,
+                ...(crashed.length > 0 ? { lastCompletedTurnId: crashed.at(-1).id } : {}),
+                thread: { ...record.thread, status },
+            });
+        }
+    }
+    async unloadIdleRuntimes() {
+        const idleMs = this.config.idleTimeoutSeconds * 1_000;
+        for (const [threadId, runtime] of this.runtimes) {
+            if (runtime.isEphemeral || !runtime.isIdleFor(idleMs))
+                continue;
+            this.runtimes.delete(threadId);
+            await runtime.stop();
+            this.metrics.runtimeUnloaded();
+            this.logger.info("claude.runtime.unloaded", { threadId });
+        }
+    }
+    async requireRuntime(threadId) {
+        const loaded = this.runtimes.get(threadId);
+        if (loaded)
+            return loaded;
+        await this.resumeThread(threadId);
+        const runtime = this.runtimes.get(threadId);
+        if (!runtime)
+            throw new Error(`Failed to load Claude thread '${threadId}'.`);
+        return runtime;
+    }
+    requireRecord(threadId, includeTurns) {
+        const record = this.store.getThreadRecord(threadId, includeTurns);
+        if (!record)
+            throw invalidParams(`Unknown Claude thread '${threadId}'.`);
+        return record;
+    }
+    lastProviderBoundary(threadId, turns) {
+        for (let index = turns.length - 1; index >= 0; index -= 1) {
+            const boundary = this.store.getTurnClaudeMessageUuid(threadId, turns[index].id);
+            if (boundary)
+                return boundary;
+        }
+        return undefined;
+    }
+    async unloadRuntime(threadId, reason) {
+        const runtime = this.runtimes.get(threadId);
+        if (!runtime)
+            return;
+        this.runtimes.delete(threadId);
+        await runtime.stop(reason);
+        this.metrics.runtimeUnloaded();
+    }
+    async applyTurnOverrides(params) {
+        const record = this.requireRecord(params.threadId, false);
+        const nextOutputSchema = params.outputSchema ?? null;
+        const outputSchema = JSON.stringify(record.outputSchema) === JSON.stringify(nextOutputSchema)
+            ? undefined
+            : nextOutputSchema;
+        await this.applySettings({
+            threadId: params.threadId,
+            ...(params.cwd !== undefined ? { cwd: params.cwd } : {}),
+            ...(params.approvalPolicy !== undefined ? { approvalPolicy: params.approvalPolicy } : {}),
+            ...(params.approvalsReviewer !== undefined ? { approvalsReviewer: params.approvalsReviewer } : {}),
+            ...(params.sandboxPolicy !== undefined ? { sandboxPolicy: params.sandboxPolicy } : {}),
+            ...(params.permissions !== undefined ? { permissions: params.permissions } : {}),
+            ...(params.model !== undefined ? { model: params.model } : {}),
+            ...(params.serviceTier !== undefined ? { serviceTier: params.serviceTier } : {}),
+            ...(params.effort !== undefined ? { effort: params.effort } : {}),
+            ...(params.summary !== undefined ? { summary: params.summary } : {}),
+            ...(params.collaborationMode !== undefined ? { collaborationMode: params.collaborationMode } : {}),
+            ...(params.personality !== undefined ? { personality: params.personality } : {}),
+        }, true, outputSchema);
+    }
+    async applySettings(params, turnOverride, outputSchema) {
+        const before = this.requireRecord(params.threadId, false);
+        if (params.permissions && params.sandboxPolicy) {
+            throw invalidParams("Claude thread settings cannot combine permissions with sandboxPolicy.");
+        }
+        if (params.model && !resolveClaudeModel(this.config, params.model))
+            throw invalidParams("Cannot switch a Claude thread to a Codex model.");
+        if (params.effort && !["low", "medium", "high", "xhigh", "max"].includes(params.effort)) {
+            throw invalidParams(`Unsupported Claude effort '${params.effort}'.`);
+        }
+        const modelPickerId = params.model ?? before.modelPickerId;
+        const claudeModelValue = resolveClaudeModel(this.config, modelPickerId);
+        if (!claudeModelValue)
+            throw invalidParams("Cannot switch a Claude thread to a Codex model.");
+        const serviceTier = normalizeClaudeServiceTier(this.config, modelPickerId, params.serviceTier === undefined ? before.serviceTier : params.serviceTier);
+        if (serviceTier !== null && serviceTier !== "default" && serviceTier !== "fast") {
+            throw invalidParams(`Unsupported Claude service tier '${serviceTier}'.`);
+        }
+        const cwd = existingThreadCwd(params.cwd ?? before.thread.cwd);
+        const selectedSandboxPolicy = params.permissions
+            ? permissionProfileSandboxPolicy(params.permissions, cwd)
+            : params.sandboxPolicy ?? before.sandboxPolicy;
+        const candidate = {
+            ...before,
+            thread: { ...before.thread, cwd },
+            modelPickerId,
+            claudeModelValue,
+            approvalPolicy: params.approvalPolicy ?? before.approvalPolicy,
+            approvalsReviewer: approvalsReviewer(params.approvalsReviewer, before.approvalsReviewer),
+            sandboxPolicy: selectedSandboxPolicy,
+            serviceTier,
+            reasoningEffort: params.effort === undefined ? before.reasoningEffort : params.effort,
+            reasoningSummary: params.summary === undefined ? before.reasoningSummary : params.summary,
+            collaborationMode: params.collaborationMode === undefined ? before.collaborationMode : params.collaborationMode,
+            personality: params.personality === undefined ? before.personality : params.personality,
+            outputSchema: outputSchema === undefined ? before.outputSchema : outputSchema,
+        };
+        await this.validateModelSettings(candidate.modelPickerId, candidate.reasoningEffort, candidate.serviceTier);
+        const changed = cwd !== before.thread.cwd || [
+            "modelPickerId", "claudeModelValue", "approvalPolicy", "approvalsReviewer", "sandboxPolicy", "serviceTier",
+            "reasoningEffort", "reasoningSummary", "collaborationMode", "personality", "outputSchema",
+        ].some((key) => JSON.stringify(candidate[key]) !== JSON.stringify(before[key]));
+        if (!changed)
+            return;
+        const runtime = this.runtimes.get(params.threadId);
+        if (runtime?.isActive)
+            throw invalidParams("Cannot change Claude settings during an active turn.");
+        if (before.thread.ephemeral && runtime && !runtime.canRestartEphemeral) {
+            throw invalidParams("Cannot reconfigure an ephemeral Claude thread after model-visible input was submitted.");
+        }
+        await this.unloadRuntime(params.threadId, "Claude runtime reconfigured.");
+        const record = this.requireRecord(params.threadId, false);
+        const updated = {
+            ...candidate,
+            thread: { ...candidate.thread, status: record.thread.status, updatedAt: nowSeconds() },
+        };
+        this.store.updateThread(updated);
+        let finalUpdated = updated;
+        if (updated.thread.ephemeral) {
+            const shouldResume = updated.lastClaudeMessageUuid !== null;
+            let replacement;
+            try {
+                replacement = await ClaudeSessionRuntime.create(updated, this.store, this.hub, this.logger, this.config, shouldResume, this.queryFactory, this.interactions, () => this.modelCatalog?.invalidate?.(), this.metrics);
+            }
+            catch (error) {
+                this.store.deleteThread(params.threadId);
+                await deleteSession(updated.claudeSessionId, { dir: updated.thread.cwd }).catch(() => undefined);
+                throw error;
+            }
+            this.runtimes.set(params.threadId, replacement);
+            this.metrics.runtimeLoaded(shouldResume);
+            finalUpdated = { ...updated, thread: { ...updated.thread, status: { type: "idle" } } };
+            this.store.updateThread(finalUpdated);
+        }
+        const threadSettings = this.threadSettings(finalUpdated);
+        this.hub.emit(params.threadId, "thread/settings/updated", { threadId: params.threadId, threadSettings });
+        if (!turnOverride)
+            this.logger.info("claude.thread.settings-updated", { threadId: params.threadId });
+    }
+    async validateModelSettings(modelId, effort, serviceTier) {
+        if (!this.modelCatalog)
+            return;
+        const catalogId = claudeCatalogId(this.config, modelId);
+        const model = (await this.modelCatalog.list()).find((candidate) => candidate.id === catalogId);
+        if (!model)
+            throw invalidParams(`Claude model '${modelId}' is not present in the current account catalog.`);
+        if (effort && !model.supportedReasoningEfforts.some((level) => level.reasoningEffort === effort)) {
+            throw invalidParams(`Claude model '${modelId}' does not support effort '${effort}'.`);
+        }
+        if (serviceTier === "fast" && !model.serviceTiers.some((tier) => tier.id === "fast")) {
+            throw invalidParams(`Claude model '${modelId}' does not support the fast service tier.`);
+        }
+    }
+    threadSettings(record) {
+        return {
+            cwd: record.thread.cwd,
+            approvalPolicy: record.approvalPolicy,
+            approvalsReviewer: record.approvalsReviewer,
+            sandboxPolicy: record.sandboxPolicy,
+            activePermissionProfile: null,
+            model: record.modelPickerId,
+            modelProvider: "claude",
+            serviceTier: record.serviceTier,
+            effort: record.reasoningEffort,
+            summary: record.reasoningSummary,
+            collaborationMode: record.collaborationMode ?? {
+                mode: "default",
+                settings: { model: record.modelPickerId, reasoning_effort: record.reasoningEffort, developer_instructions: null },
+            },
+            multiAgentMode: "explicitRequestOnly",
+            personality: record.personality,
+        };
+    }
+    emit(threadId, turnId, method, params) {
+        this.store.appendEvent(threadId, turnId, method, params);
+        if (method === "turn/completed" && params && typeof params === "object" && "turn" in params) {
+            const turn = params.turn;
+            if (turn.status !== "inProgress")
+                this.metrics.turnCompleted(turn.status);
+        }
+        this.hub.emit(threadId, method, params);
+    }
+    currentGoal(threadId, now) {
+        const goal = this.store.getGoal(threadId);
+        if (!goal || goal.status !== "active")
+            return goal;
+        return { ...goal, timeUsedSeconds: goal.timeUsedSeconds + Math.max(0, now - goal.updatedAt), updatedAt: now };
+    }
+    async forkTranscript(source, boundary) {
+        if (!boundary)
+            return { sessionId: uuidv7(), uuidMap: new Map() };
+        const original = await getSessionMessages(source.claudeSessionId, { dir: source.thread.cwd });
+        const boundaryIndex = original.findIndex((message) => message.uuid === boundary);
+        if (boundaryIndex < 0)
+            throw new Error(`Claude transcript does not contain fork boundary '${boundary}'.`);
+        const fork = await forkSession(source.claudeSessionId, { dir: source.thread.cwd, upToMessageId: boundary });
+        const copied = await getSessionMessages(fork.sessionId, { dir: source.thread.cwd });
+        const prefix = original.slice(0, boundaryIndex + 1);
+        if (copied.length !== prefix.length || copied.some((message, index) => message.type !== prefix[index]?.type)) {
+            await deleteSession(fork.sessionId, { dir: source.thread.cwd }).catch(() => undefined);
+            throw new Error("Claude fork transcript could not be correlated with the source branch.");
+        }
+        return { sessionId: fork.sessionId, uuidMap: new Map(prefix.map((message, index) => [message.uuid, copied[index].uuid])) };
+    }
+}
+//# sourceMappingURL=service.js.map