@gkorepanov/ccodex 0.4.25 → 0.5.0-rc.2

package/dist/claude/service.js

@@ -1,2138 +0,0 @@
-import { isAbsolute, join, resolve } from "node:path";
-import { statSync } from "node:fs";
-import { deleteSession, listSessions, renameSession, } from "@anthropic-ai/claude-agent-sdk";
-import { v7 as uuidv7 } from "uuid";
-import { runtimeWorkspaceRoots as storedWorkspaceRoots, settingsGeneration } from "../store/HybridStore.js";
-import { SqliteHybridStore } from "../store/sqliteStore.js";
-import { LayeredHybridStore } from "../store/memoryStore.js";
-import { createClaudeQuery } from "./queryFactory.js";
-import { claudeEnvironment } from "./environment.js";
-import { invalidParams, invalidRequest } from "../protocol/errors.js";
-import { historyCursors, paginateItems, paginateTurns, startedTurn } from "../protocol/turnPagination.js";
-import { searchTurnOccurrences, threadSearchSnippet } from "../protocol/search.js";
-import { MetricsRegistry } from "../observability/metrics.js";
-import { SdkTranscriptBrancher, } from "./transcriptBrancher.js";
-import { ClaudeRateLimitCoordinator, } from "./rateLimits.js";
-import { isClaudeStatusCommand } from "./statusCommand.js";
-import { systemNoticeText } from "../gateway/transientNotice.js";
-import { claudeCatalogId, normalizeClaudeModelIdentifier, normalizeClaudeServiceTier, pickClaudeModelReplacement, resolveClaudeModel, } from "./modelSelection.js";
-import { ClaudeOutputAdapter } from "./session/outputAdapter.js";
-import { branchRevision, ClaudeSessionRepository } from "./session/repository.js";
-import { ActiveClaudeTurnError, ClaudeSession } from "./session/session.js";
-import { ShellRunner } from "./session/shellRunner.js";
-import { ClaudeSessionRegistry } from "./sessionRegistry.js";
-import { validateResponseItems } from "./responseItemValidation.js";
-import { providerUnavailableMessage, } from "../runtime/providerAvailability.js";
-import { isCCodexStateCommand, stateModelName, } from "../state/stateCommand.js";
-import { syncedCollaborationMode, threadSettings } from "./threadSettings.js";
-import { claudeDeveloperInstructions } from "./developerInstructions.js";
-function recordValue(value) {
-    return value && typeof value === "object" ? value : undefined;
-}
-function boundaryCorrelations(store, source, boundaries) {
-    let owner = source;
-    const seen = new Set();
-    while (owner.thread.parentThreadId && !seen.has(owner.thread.id)) {
-        seen.add(owner.thread.id);
-        const parent = store.getThreadRecord(owner.thread.parentThreadId, false);
-        if (!parent)
-            break;
-        owner = parent;
-    }
-    const wanted = new Set(boundaries.map((boundary) => boundary.messageUuid));
-    const correlations = new Map();
-    for (const event of store.listProviderEvents(owner.thread.id)) {
-        if (!event.providerEventId || !wanted.has(event.providerEventId))
-            continue;
-        const payload = recordValue(event.payload);
-        const message = recordValue(payload?.message);
-        const requestId = typeof payload?.request_id === "string" ? payload.request_id : undefined;
-        const messageId = typeof message?.id === "string" ? message.id : undefined;
-        if (requestId)
-            correlations.set(event.providerEventId, { requestId, ...(messageId ? { messageId } : {}) });
-    }
-    return correlations;
-}
-async function* idleUsagePrompt(signal) {
-    if (signal.aborted)
-        return;
-    await new Promise((resolve) => signal.addEventListener("abort", () => resolve(), { once: true }));
-}
-const sdkThreadAdminEffects = {
-    rename: async (sessionId, name, cwd) => renameSession(sessionId, name, { dir: cwd }),
-    delete: async (sessionId, cwd) => deleteSession(sessionId, { dir: cwd }),
-};
-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 turnReasoningEffort(params) {
-    return params.collaborationMode?.settings.reasoning_effort ?? params.effort ?? undefined;
-}
-function workspaceRoots(value) {
-    const roots = [];
-    const seen = new Set();
-    for (const root of value) {
-        if (!isAbsolute(root))
-            throw invalidParams(`Claude runtime workspace root '${root}' must be absolute.`);
-        if (!seen.has(root)) {
-            seen.add(root);
-            roots.push(root);
-        }
-    }
-    return roots;
-}
-function workspaceSelection(params, previous) {
-    const environments = params.environments;
-    if (environments?.some((environment) => environment.environmentId !== "local")) {
-        throw invalidParams("Claude threads only support the local Codex environment.");
-    }
-    if (environments && environments.length > 1) {
-        throw invalidParams("Claude threads support at most one local Codex environment.");
-    }
-    const environment = environments?.[0];
-    const requestedCwd = environment?.cwd ?? params.cwd ?? previous?.cwd ?? process.cwd();
-    const cwd = existingThreadCwd(requestedCwd);
-    const explicitRoots = environment
-        ? environment.runtimeWorkspaceRoots
-        : params.runtimeWorkspaceRoots;
-    if (explicitRoots !== undefined && explicitRoots !== null) {
-        return { cwd, runtimeWorkspaceRoots: workspaceRoots(explicitRoots) };
-    }
-    if (!previous)
-        return { cwd, runtimeWorkspaceRoots: [cwd] };
-    if (cwd === previous.cwd)
-        return { cwd, runtimeWorkspaceRoots: [...previous.runtimeWorkspaceRoots] };
-    return {
-        cwd,
-        runtimeWorkspaceRoots: workspaceRoots(previous.runtimeWorkspaceRoots.map((root) => root === previous.cwd ? cwd : root)),
-    };
-}
-function writableRoots(cwd, runtimeWorkspaceRoots) {
-    return workspaceRoots([cwd, ...runtimeWorkspaceRoots]);
-}
-function sandboxPolicy(mode, cwd, runtimeWorkspaceRoots = [cwd]) {
-    if (mode === "read-only")
-        return { type: "readOnly", networkAccess: false };
-    if (mode === "danger-full-access")
-        return { type: "dangerFullAccess" };
-    return {
-        type: "workspaceWrite",
-        writableRoots: writableRoots(cwd, runtimeWorkspaceRoots),
-        networkAccess: false,
-        excludeTmpdirEnvVar: false,
-        excludeSlashTmp: false,
-    };
-}
-function permissionProfileSandboxPolicy(profile, cwd, runtimeWorkspaceRoots = [cwd]) {
-    if (profile === ":read-only")
-        return sandboxPolicy("read-only", cwd, runtimeWorkspaceRoots);
-    if (profile === ":workspace")
-        return sandboxPolicy("workspace-write", cwd, runtimeWorkspaceRoots);
-    if (profile === ":danger-full-access")
-        return sandboxPolicy("danger-full-access", cwd, runtimeWorkspaceRoots);
-    throw invalidParams(`Claude threads do not support Codex permission profile '${profile}'.`);
-}
-function inheritedSandboxPolicy(policy, cwd, runtimeWorkspaceRoots) {
-    if (policy && typeof policy === "object" && "type" in policy
-        && policy.type === "workspaceWrite") {
-        return { ...policy, writableRoots: writableRoots(cwd, runtimeWorkspaceRoots) };
-    }
-    return policy;
-}
-function approvalsReviewer(value, fallback = "user") {
-    return value ?? fallback;
-}
-function threadResponse(record, includeTurns) {
-    const { sandboxPolicy: sandbox, effort: reasoningEffort, summary: _summary, collaborationMode: _collaborationMode, personality: _personality, ...settings } = threadSettings(record);
-    return {
-        ...settings,
-        thread: {
-            ...record.thread,
-            section: record.thread.section ?? null,
-            sectionEnteredAt: record.thread.sectionEnteredAt ?? null,
-            projectId: record.thread.projectId ?? null,
-            canAcceptDirectInput: record.thread.parentThreadId ? false : true,
-            turns: includeTurns ? record.thread.turns : [],
-        },
-        runtimeWorkspaceRoots: [...storedWorkspaceRoots(record)],
-        instructionSources: [],
-        sandbox,
-        reasoningEffort,
-    };
-}
-function clonedTurn(turn) {
-    return structuredClone(turn);
-}
-function forkProjection(turn, targetThreadId) {
-    const cloned = clonedTurn(turn);
-    if (cloned.status === "inProgress") {
-        const completedAt = nowSeconds();
-        cloned.status = "interrupted";
-        cloned.completedAt = completedAt;
-        cloned.durationMs = cloned.startedAt === null
-            ? null
-            : Math.max(0, (completedAt - cloned.startedAt) * 1_000);
-    }
-    const items = [];
-    for (const item of cloned.items) {
-        if (item.type === "subAgentActivity")
-            continue;
-        items.push(item.type === "collabAgentToolCall" ? {
-            ...item,
-            senderThreadId: targetThreadId,
-            receiverThreadIds: [],
-            agentsStates: {},
-        } : item);
-    }
-    cloned.items = items;
-    return cloned;
-}
-function sideReferenceItem(item) {
-    const reference = { type: item.type };
-    if (item.type === "userMessage")
-        reference.content = item.content;
-    if (item.type === "agentMessage") {
-        reference.text = item.text;
-        reference.phase = item.phase;
-    }
-    if (item.type === "reasoning")
-        reference.summary = item.summary;
-    if (item.type === "commandExecution") {
-        reference.command = item.command;
-        reference.cwd = item.cwd;
-    }
-    if (item.type === "fileChange")
-        reference.changes = item.changes;
-    if (item.type === "collabAgentToolCall")
-        reference.prompt = item.prompt;
-    if (item.type === "dynamicToolCall")
-        reference.tool = item.tool;
-    if (item.type === "mcpToolCall") {
-        reference.server = item.server;
-        reference.tool = item.tool;
-    }
-    if (item.type === "webSearch")
-        reference.query = item.query;
-    if ("status" in item)
-        reference.status = item.status;
-    return reference;
-}
-function sideReferenceSnapshot(sourceThreadId, turn) {
-    return {
-        type: "ccodex_side_parent_snapshot",
-        sourceThreadId,
-        note: "Reference-only snapshot of the parent turn at fork time. Do not continue or control its live tools.",
-        turn: {
-            status: turn.status,
-            items: turn.items.map(sideReferenceItem),
-        },
-    };
-}
-function selectedBoundaryIsStable(turn) {
-    return turn?.status === "completed";
-}
-export const EPHEMERAL_DISCONNECT_GRACE_MS = 60 * 60_000;
-export class ClaudeService {
-    config;
-    hub;
-    logger;
-    queryFactory;
-    modelCatalog;
-    metrics;
-    transcripts;
-    threadAdminEffects;
-    availabilityProbe;
-    skillsChanged;
-    nativeSessionCatalog;
-    ephemeralReleases = new Map();
-    ephemeralReleaseTimers = new Map();
-    /** Root threads whose last turn completed or failed and whose queue drains once the session is quiescent. */
-    queueDrainPending = new Set();
-    removalRetries = new Map();
-    terminalAdmins = new Map();
-    settingsUpdates = new Map();
-    idleTimer;
-    store;
-    sessionOutput;
-    sessions;
-    rateLimits;
-    idleSweep = Promise.resolve();
-    restartRecovery;
-    closing = false;
-    closePromise;
-    standaloneStatusRead;
-    nativeMetadata = new Map();
-    nativeMetadataRead;
-    nativeMetadataReadAt = 0;
-    constructor(config, hub, logger, durableStore = new SqliteHybridStore(join(config.dataDir, "state.sqlite")), queryFactory = createClaudeQuery, modelCatalog, metrics = new MetricsRegistry(), transcripts = new SdkTranscriptBrancher(), threadAdminEffects = sdkThreadAdminEffects, shellRunner = new ShellRunner(), availabilityProbe = async () => ({
-        provider: "claude",
-        state: "ready",
-    }), skillsChanged, nativeSessionCatalog = () => listSessions()) {
-        this.config = config;
-        this.hub = hub;
-        this.logger = logger;
-        this.queryFactory = queryFactory;
-        this.modelCatalog = modelCatalog;
-        this.metrics = metrics;
-        this.transcripts = transcripts;
-        this.threadAdminEffects = threadAdminEffects;
-        this.availabilityProbe = availabilityProbe;
-        this.skillsChanged = skillsChanged;
-        this.nativeSessionCatalog = nativeSessionCatalog;
-        this.store = new LayeredHybridStore(durableStore);
-        const sessionRepository = new ClaudeSessionRepository(this.store);
-        this.sessionOutput = new ClaudeOutputAdapter(hub);
-        this.rateLimits = new ClaudeRateLimitCoordinator(logger);
-        this.sessions = new ClaudeSessionRegistry((threadId) => new ClaudeSession(threadId, sessionRepository, this.sessionOutput, undefined, metrics, (update) => this.onSessionLifecycle(threadId, update), (childThreadId) => this.sessions.registerChild(childThreadId, threadId), (childThreadId) => this.sessions.unregisterChild(childThreadId), shellRunner, undefined, {
-            claudeBinary: this.config.claudeBinary,
-            logger: this.logger,
-            queryFactory: this.queryFactory,
-            transcripts: this.transcripts,
-            rateLimits: this.rateLimits,
-            invalidateModelCatalog: () => this.modelCatalog?.invalidate?.(),
-            ...(this.skillsChanged ? { skillsChanged: this.skillsChanged } : {}),
-            isClosing: () => this.closing,
-            persistUserSideSessions: true,
-            interactiveQuestions: this.config.features?.interactiveQuestions ?? true,
-            resolveChildModel: (model) => {
-                const value = normalizeClaudeModelIdentifier(model);
-                const modelPickerId = value.startsWith(this.config.modelPrefix) ? value : `${this.config.modelPrefix}${value}`;
-                const claudeModelValue = resolveClaudeModel(this.config, modelPickerId);
-                if (!claudeModelValue)
-                    return undefined;
-                const lookup = this.cachedCatalogLookup(claudeModelValue);
-                return lookup ? this.catalogSelection(modelPickerId, claudeModelValue, lookup) : { modelPickerId, claudeModelValue };
-            },
-        }));
-        const records = this.store.allThreadRecords();
-        const pendingRemovals = this.store.listPendingThreadRemovals();
-        const pendingRemovalIds = new Set(pendingRemovals.map((removal) => removal.rootThreadId));
-        const byId = new Map(records.map((record) => [record.thread.id, record]));
-        const orphanProjectionIds = new Set();
-        for (const record of records) {
-            if (!record.thread.parentThreadId)
-                continue;
-            const seen = new Set([record.thread.id]);
-            let owner = record;
-            while (owner.thread.parentThreadId) {
-                const parent = byId.get(owner.thread.parentThreadId);
-                if (!parent || seen.has(parent.thread.id)) {
-                    owner = record;
-                    break;
-                }
-                seen.add(parent.thread.id);
-                owner = parent;
-            }
-            if (owner === record) {
-                this.logger.warn("claude.orphan-projection.removed", { threadId: record.thread.id });
-                orphanProjectionIds.add(record.thread.id);
-                continue;
-            }
-            this.sessions.registerChild(record.thread.id, owner.thread.id);
-        }
-        const restartRecoveryRootIds = new Set();
-        for (const record of records) {
-            if (orphanProjectionIds.has(record.thread.id))
-                continue;
-            if (pendingRemovalIds.has(this.sessions.ownerOf(record.thread.id)))
-                continue;
-            if (record.thread.status.type === "active"
-                || this.store.listTurns(record.thread.id).some((turn) => turn.status === "inProgress")
-                || this.store.listPendingRequests(record.thread.id).length > 0
-                || this.store.listProviderEvents(record.thread.id, "pending").length > 0) {
-                restartRecoveryRootIds.add(this.sessions.ownerOf(record.thread.id));
-            }
-        }
-        this.restartRecovery = this.resumeThreadRemovals(pendingRemovals.map((removal) => removal.rootThreadId))
-            .then(() => this.reconcileAfterRestart(orphanProjectionIds, restartRecoveryRootIds));
-        for (const record of this.store.allThreadRecords()) {
-            if (orphanProjectionIds.has(record.thread.id))
-                continue;
-            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);
-    }
-    ready() {
-        return this.restartRecovery;
-    }
-    ownsModel(modelId) {
-        return resolveClaudeModel(this.config, modelId) !== undefined;
-    }
-    async readRateLimits(foregroundThreadId) {
-        if (!this.rateLimits.hasLiveSource && foregroundThreadId && this.ownsThread(foregroundThreadId)) {
-            await (await this.sessions.getOrCreate(foregroundThreadId)).ensureRuntime();
-        }
-        return this.rateLimits.read();
-    }
-    async readRateLimitStatus(foregroundThreadId) {
-        if (!this.rateLimits.hasLiveSource && foregroundThreadId && this.ownsThread(foregroundThreadId)) {
-            await (await this.sessions.getOrCreate(foregroundThreadId)).ensureRuntime();
-        }
-        if (!this.rateLimits.hasLiveSource) {
-            this.standaloneStatusRead ??= this.readStandaloneRateLimitStatus()
-                .finally(() => { this.standaloneStatusRead = undefined; });
-            return this.standaloneStatusRead;
-        }
-        return this.rateLimits.readStatus();
-    }
-    cachedRateLimits() {
-        return this.rateLimits.cached();
-    }
-    subscribeRateLimits(connectionId, listener) {
-        this.rateLimits.subscribe(connectionId, listener);
-    }
-    unsubscribeRateLimits(connectionId) {
-        this.rateLimits.unsubscribe(connectionId);
-    }
-    async handoffSource(threadId, lastTurnId) {
-        this.requireIndependentThread(threadId, "create a handoff from");
-        const snapshot = await this.sessions.submit(threadId, { type: "snapshotBranch" });
-        const through = lastTurnId
-            ? snapshot.record.thread.turns.findIndex((turn) => turn.id === lastTurnId)
-            : snapshot.record.thread.turns.length - 1;
-        if (lastTurnId && through < 0)
-            throw invalidParams(`Unknown Claude turn '${lastTurnId}'.`);
-        const turns = snapshot.record.thread.turns.slice(0, through + 1);
-        return {
-            thread: { ...this.withNativeMetadata(snapshot.record), turns },
-            turns,
-            settings: threadSettings(snapshot.record),
-            runtimeWorkspaceRoots: storedWorkspaceRoots(snapshot.record),
-        };
-    }
-    currentThreadSettings(threadId) {
-        return threadSettings(this.withCatalogModel(this.requireRecord(threadId, false)));
-    }
-    withCatalogModel(record) {
-        const lookup = this.cachedCatalogLookup(record.resolvedModel ?? record.claudeModelValue);
-        if (!lookup)
-            return record;
-        const selection = this.catalogSelection(record.modelPickerId, record.claudeModelValue, lookup);
-        return selection.modelPickerId === record.modelPickerId ? record : { ...record, ...selection };
-    }
-    /** Finds the catalog entry for a Claude model value, migrating retired ids onto the closest current model. */
-    catalogLookup(models, claudeModelValue) {
-        const catalog = this.modelCatalog;
-        const cached = catalog.cachedPickerId?.(claudeModelValue);
-        if (cached)
-            return { id: cached, model: models.find((candidate) => candidate.id === cached), reason: "exact" };
-        const prefix = this.config.modelPrefix;
-        const strip = (id) => id.slice(prefix.length);
-        const defaultId = catalog.defaultModelId?.();
-        const replacement = pickClaudeModelReplacement(claudeModelValue, models.map((candidate) => strip(candidate.id)), defaultId && strip(defaultId));
-        const model = replacement && models.find((candidate) => strip(candidate.id) === replacement.value);
-        return model ? { id: model.id, model, reason: replacement.reason } : undefined;
-    }
-    cachedCatalogLookup(claudeModelValue) {
-        return this.modelCatalog && this.catalogLookup(this.modelCatalog.cachedModels?.() ?? [], claudeModelValue);
-    }
-    catalogSelection(modelPickerId, claudeModelValue, lookup) {
-        const prefix = this.config.modelPrefix;
-        if (lookup.id === `${prefix}${claudeModelValue}` || lookup.id === claudeCatalogId(this.config, modelPickerId))
-            return { modelPickerId, claudeModelValue };
-        this.logger.warn("claude.model.migrated", { from: modelPickerId, to: lookup.id, reason: lookup.reason });
-        return { modelPickerId: lookup.id, claudeModelValue: lookup.id.slice(prefix.length) };
-    }
-    /** Persists a catalog migration for a stored thread so its runtime starts on a model the account still has. */
-    async migrateStoredModel(threadId) {
-        if (!this.modelCatalog)
-            return;
-        const record = this.requireRecord(threadId, false);
-        const models = await this.modelCatalog.list().catch(() => undefined);
-        const lookup = models && this.catalogLookup(models, record.claudeModelValue);
-        if (!lookup)
-            return;
-        const selection = this.catalogSelection(record.modelPickerId, record.claudeModelValue, lookup);
-        if (selection.modelPickerId !== record.modelPickerId)
-            await this.applySettings({ threadId, model: selection.modelPickerId });
-    }
-    sideSnapshot(sourceThreadId, targetThreadId, visibleForkedFromId) {
-        const record = this.requireRecord(sourceThreadId, false);
-        const response = threadResponse(record, false);
-        const source = this.withNativeMetadata(record);
-        return {
-            ...response,
-            thread: {
-                ...source,
-                id: targetThreadId,
-                sessionId: targetThreadId,
-                forkedFromId: visibleForkedFromId,
-                ephemeral: true,
-                path: null,
-                threadSource: "user",
-                status: { type: "idle" },
-                name: record.thread.name,
-                turns: [],
-            },
-        };
-    }
-    loadedThreadIds() {
-        const loaded = new Set(this.sessions.loadedOwnerIds());
-        for (const record of this.store.allThreadRecords()) {
-            if (record.thread.ephemeral || record.thread.status.type === "active") {
-                loaded.add(this.sessions.ownerOf(record.thread.id));
-            }
-        }
-        return [...loaded]
-            .filter((threadId) => this.store.hasThread(threadId)
-            && !this.store.isThreadArchived(threadId)
-            && !this.pendingThreadRemoval(threadId)
-            && !this.hub.isSuppressed(threadId));
-    }
-    async reportError(threadId, requestedTurnId, message, codexErrorInfo) {
-        if (this.closing || !this.ownsThread(threadId)
-            || this.pendingThreadRemoval(threadId) || this.terminalAdmins.has(threadId))
-            return false;
-        try {
-            return await this.sessions.submit(threadId, {
-                type: "reportError",
-                threadId,
-                ...(requestedTurnId ? { requestedTurnId } : {}),
-                message,
-                codexErrorInfo,
-            });
-        }
-        catch (error) {
-            if (!this.closing && this.ownsThread(threadId))
-                throw error;
-            return false;
-        }
-    }
-    async startThread(params) {
-        let record = await this.newThreadRecord(params);
-        record = await this.sessions.submit(record.thread.id, { type: "createThread", record });
-        return threadResponse(record, false);
-    }
-    async startHiddenThread(params) {
-        let record = await this.newThreadRecord(params);
-        this.sessionOutput.suppress(record.thread.id);
-        try {
-            record = await this.sessions.submit(record.thread.id, { type: "createThread", record });
-            return threadResponse(record, false);
-        }
-        catch (error) {
-            this.sessionOutput.unsuppress(record.thread.id);
-            throw error;
-        }
-    }
-    async announceThread(thread) {
-        this.requireIndependentThread(thread.id, "announce");
-        await this.sessions.submit(thread.id, { type: "announceThread" });
-    }
-    async resumeThread(params) {
-        if (this.closing)
-            throw invalidParams("Claude service is closing.");
-        const resume = typeof params === "string" ? { threadId: params } : params;
-        const { threadId } = resume;
-        this.assertThreadAvailable(threadId);
-        let record = this.store.getThreadRecord(threadId, true);
-        if (!record)
-            throw invalidParams(`Unknown Claude thread '${threadId}'.`);
-        if (record.thread.parentThreadId) {
-            record = this.withCatalogModel(record);
-            record = { ...record, thread: this.withNativeMetadata(record) };
-            return {
-                ...threadResponse(record, !resume.excludeTurns),
-                ...historyCursors(record.thread.turns),
-                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,
-            };
-        }
-        if (resume.cwd !== undefined || resume.runtimeWorkspaceRoots !== undefined) {
-            await this.applySettings({
-                threadId,
-                ...(resume.cwd !== undefined ? { cwd: resume.cwd } : {}),
-                ...(resume.runtimeWorkspaceRoots !== undefined
-                    ? { runtimeWorkspaceRoots: resume.runtimeWorkspaceRoots }
-                    : {}),
-            });
-        }
-        await this.migrateStoredModel(threadId);
-        await (await this.sessions.getOrCreate(threadId)).materializeRuntime();
-        record = await this.sessions.submit(threadId, { type: "readThread", includeTurns: true });
-        record = this.withCatalogModel(record);
-        record = { ...record, thread: this.withNativeMetadata(record) };
-        if (this.store.listQueuedSubmissions(threadId).length)
-            this.scheduleQueueDrain(threadId);
-        return {
-            ...threadResponse(record, !resume.excludeTurns),
-            ...historyCursors(record.thread.turns),
-            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,
-        };
-    }
-    async prepareResume(params) {
-        if (this.requireRecord(params.threadId, false).thread.parentThreadId) {
-            return {
-                response: await this.resumeThread(params),
-                notifyGoalSnapshot: () => Promise.resolve(),
-            };
-        }
-        const snapshot = await this.sessions.submit(params.threadId, { type: "goal", command: { kind: "resume" } });
-        try {
-            const response = await this.resumeThread(params);
-            let notified;
-            return {
-                response,
-                notifyGoalSnapshot: (notify) => notified ??= snapshot
-                    ? this.sessions.submit(params.threadId, {
-                        type: "goal", command: { kind: "resumeSnapshot", reservationId: snapshot.reservationId },
-                    }).then((current) => {
-                        if (current)
-                            notify("thread/goal/updated", current);
-                    })
-                    : Promise.resolve(),
-            };
-        }
-        catch (error) {
-            if (snapshot)
-                await this.sessions.submit(params.threadId, {
-                    type: "goal", command: { kind: "resumeSnapshot", reservationId: snapshot.reservationId },
-                }).catch(() => undefined);
-            throw error;
-        }
-    }
-    readThread(threadId, includeTurns) {
-        this.assertThreadAvailable(threadId);
-        const record = this.store.getThreadRecord(threadId, includeTurns);
-        if (!record)
-            throw invalidParams(`Unknown Claude thread '${threadId}'.`);
-        return { thread: this.withNativeMetadata(record) };
-    }
-    async prepareTurn(params, review) {
-        this.requireIndependentThread(params.threadId, "start a turn in");
-        if (params.toolOutput)
-            throw invalidParams("Claude threads do not support toolOutput.");
-        if (params.serviceTierForTurn != null)
-            this.logger.warn("claude.turn.service-tier-for-turn.ignored", { threadId: params.threadId, serviceTierForTurn: params.serviceTierForTurn });
-        const availability = await this.availabilityProbe();
-        if (availability.state !== "ready")
-            throw invalidParams(providerUnavailableMessage(availability));
-        await this.sessions.submit(params.threadId, { type: "goal", command: { kind: "reserveTurn" } });
-        let preparedTurn = false;
-        let staged;
-        let session;
-        try {
-            await this.applyTurnOverrides(params);
-            session = await this.sessions.getOrCreate(params.threadId);
-            staged = await session.prepareRuntimeTurn(params, Boolean(review));
-            const projectedParams = review
-                ? { ...params, input: [{ type: "text", text: review.display, text_elements: [] }] }
-                : params;
-            const prepared = await this.sessions.submit(params.threadId, {
-                type: "prepareTurn",
-                params: projectedParams,
-                ...(review ? { review: review.label } : {}),
-                stagedMessageUuid: staged.messageUuid,
-                readOnly: staged.readOnly,
-            });
-            preparedTurn = true;
-            const startRuntime = staged.attach(prepared.turn);
-            let announcement;
-            const startAndWait = () => announcement ? announcement.then(startRuntime) : startRuntime();
-            return {
-                response: { turn: startedTurn(prepared.turn) },
-                turn: prepared.turn,
-                announce: () => announcement ??= this.sessions.submit(params.threadId, { type: "announceTurn", turnId: prepared.turn.id }),
-                start: () => {
-                    void startAndWait().catch((error) => this.logger.error("claude.turn.start-failed", { threadId: params.threadId, error: String(error) }));
-                },
-                startAndWait,
-            };
-        }
-        catch (error) {
-            if (staged)
-                await staged.discard();
-            if (!preparedTurn)
-                await this.sessions.submit(params.threadId, { type: "goal", command: { kind: "cancelTurn" } });
-            throw error;
-        }
-    }
-    async prepareAppTurn(params) {
-        try {
-            return await this.prepareTurn(params);
-        }
-        catch (error) {
-            if (!(error instanceof ActiveClaudeTurnError))
-                throw error;
-            const { turnId } = await this.steerTurn({
-                threadId: params.threadId,
-                input: params.input,
-                expectedTurnId: error.turnId,
-                ...(params.clientUserMessageId === undefined
-                    ? {}
-                    : { clientUserMessageId: params.clientUserMessageId }),
-                ...(params.responsesapiClientMetadata === undefined
-                    ? {}
-                    : { responsesapiClientMetadata: params.responsesapiClientMetadata }),
-                ...(params.additionalContext === undefined
-                    ? {}
-                    : { additionalContext: params.additionalContext }),
-            });
-            const turn = this.requireRecord(params.threadId, true).thread.turns
-                .find((candidate) => candidate.id === turnId);
-            if (!turn)
-                throw new Error(`Active Claude turn '${turnId}' disappeared after steering.`);
-            return {
-                response: { turn },
-                announce: () => Promise.resolve(),
-                start: () => undefined,
-                startAndWait: () => Promise.resolve(),
-            };
-        }
-    }
-    async prepareStatusTurn(params, render) {
-        this.requireIndependentThread(params.threadId, "start a status turn in");
-        if (!isClaudeStatusCommand(params.input))
-            throw invalidParams("Not a CCodex status command.");
-        return this.prepareSyntheticCommandTurn(params, "status", render);
-    }
-    async prepareStateTurn(params, render) {
-        this.requireIndependentThread(params.threadId, "start a state turn in");
-        if (!isCCodexStateCommand(params.input))
-            throw invalidParams("Not a CCodex state command.");
-        return this.prepareSyntheticCommandTurn(params, "state", render);
-    }
-    stateSnapshot(threadId) {
-        this.assertThreadAvailable(threadId);
-        const record = this.requireRecord(threadId, true);
-        return {
-            provider: "claude",
-            model: stateModelName("claude", record.modelPickerId),
-            effort: record.reasoningEffort,
-            serviceTier: record.serviceTier,
-            approvalPolicy: record.approvalPolicy,
-            approvalsReviewer: record.approvalsReviewer,
-            sandboxPolicy: record.sandboxPolicy,
-            thread: record.thread,
-            tokenUsage: record.tokenUsageLast ? {
-                total: record.tokenUsageTotal,
-                last: record.tokenUsageLast,
-                modelContextWindow: record.modelContextWindow,
-            } : null,
-            providerCostUsd: record.providerCostUsdTotal ?? 0,
-        };
-    }
-    async prepareSyntheticCommandTurn(params, synthetic, render) {
-        const prepared = await this.sessions.submit(params.threadId, { type: "prepareTurn", params, synthetic });
-        let started = false;
-        return {
-            response: { turn: prepared.turn },
-            announce: () => this.sessions.submit(params.threadId, { type: "announceTurn", turnId: prepared.turn.id }),
-            start: () => {
-                if (started)
-                    return;
-                started = true;
-                void this.completeCommandTurn(params.threadId, prepared.turn.id, synthetic, render);
-            },
-        };
-    }
-    async interruptTurn(value) {
-        const params = typeof value === "string" ? { threadId: value, turnId: undefined } : value;
-        const initial = this.requireRecord(params.threadId, false);
-        if (initial.thread.parentThreadId && params.turnId) {
-            const selected = this.store.listTurns(params.threadId).find((turn) => turn.id === params.turnId);
-            if (selected && selected.status !== "inProgress")
-                return;
-        }
-        const activeOwnerSession = !initial.thread.parentThreadId
-            ? this.sessions.resolvedSession(params.threadId)
-            : undefined;
-        const stopFence = activeOwnerSession?.fenceCurrentRuntimeStop(params.turnId);
-        const ownerSession = !initial.thread.parentThreadId
-            ? activeOwnerSession ?? await this.sessions.getOrCreate(params.threadId)
-            : undefined;
-        if (stopFence)
-            await stopFence;
-        const shell = await this.sessions.submit(params.threadId, {
-            type: "prepareShellCancellation",
-            ...(params.turnId ? { turnId: params.turnId } : {}),
-        });
-        if (shell)
-            return;
-        if (await this.sessions.submit(params.threadId, {
-            type: "completeSynthetic", ...(params.turnId ? { turnId: params.turnId } : {}),
-            status: "interrupted", codexErrorInfo: null,
-        }))
-            return;
-        const record = this.requireRecord(params.threadId, false);
-        if (record.thread.parentThreadId) {
-            await (await this.sessions.getOrCreate(params.threadId))
-                .interruptChildRuntime(params.threadId, params.turnId);
-            return;
-        }
-        await ownerSession.interruptRuntime(params.turnId);
-    }
-    async cleanBackgroundTerminals(params) {
-        await (await this.sessions.getOrCreate(params.threadId)).cleanBackgroundTerminals(params.threadId);
-        return {};
-    }
-    async listBackgroundTerminals(params) {
-        const terminals = await (await this.sessions.getOrCreate(params.threadId)).listBackgroundTerminals(params.threadId);
-        const offset = params.cursor === undefined || params.cursor === null ? 0 : Number(params.cursor.replace(/^claude-bg:/u, ""));
-        if (!Number.isSafeInteger(offset) || offset < 0)
-            throw invalidParams(`Invalid Claude background-terminal cursor '${params.cursor}'.`);
-        const limit = Math.min(100, Math.max(1, params.limit ?? 50));
-        const data = terminals.slice(offset, offset + limit);
-        const next = offset + data.length;
-        return { data, nextCursor: next < terminals.length ? `claude-bg:${next}` : null };
-    }
-    async terminateBackgroundTerminal(params) {
-        const terminated = await (await this.sessions.getOrCreate(params.threadId))
-            .terminateBackgroundTerminal(params.threadId, params.processId);
-        return { terminated };
-    }
-    async steerTurn(params) {
-        return { turnId: await (await this.sessions.getOrCreate(params.threadId)).steerRuntime(params) };
-    }
-    async compactThread(threadId) {
-        this.requireIndependentThread(threadId, "compact");
-        await (await this.sessions.getOrCreate(threadId)).compactRuntime();
-        return {};
-    }
-    async compactForHandoff(threadId, prompt = "/compact") {
-        this.requireIndependentThread(threadId, "compact for handoff");
-        return (await this.sessions.getOrCreate(threadId)).compactRuntimeForHandoff(prompt);
-    }
-    async discardHandoffThread(threadId) {
-        await this.discardThreadSilently(threadId);
-    }
-    async preparePromptedCompact(threadId, input) {
-        this.requireIndependentThread(threadId, "compact");
-        const prepared = await (await this.sessions.getOrCreate(threadId))
-            .preparePromptedCompaction(input);
-        return {
-            response: { turn: prepared.turn },
-            announce: prepared.announce,
-        };
-    }
-    async updateThreadSettings(params) {
-        this.requireIndependentThread(params.threadId, "update settings for");
-        await this.applySettings(params);
-        return {};
-    }
-    async injectItems(params) {
-        this.requireIndependentThread(params.threadId, "inject items into");
-        validateResponseItems(params.items);
-        await (await this.sessions.getOrCreate(params.threadId)).injectRuntimeItems(params.items);
-        return {};
-    }
-    async summarizeHandoff(threadId, prompt) {
-        this.requireIndependentThread(threadId, "summarize a handoff from");
-        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;
-        return this.sessionOutput.withInternalThreadHidden(temporaryId, async () => {
-            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);
-            }
-        });
-    }
-    async shellCommand(params) {
-        this.requireIndependentThread(params.threadId, "run a shell command in");
-        const timeoutMs = params.timeoutMs ?? 3_600_000;
-        if (timeoutMs < 0)
-            throw invalidParams(`thread/shellCommand timeoutMs must be non-negative, got ${timeoutMs}`);
-        await this.sessions.submit(params.threadId, { type: "runShell", command: params.command, timeoutMs });
-        return {};
-    }
-    async prepareReview(params) {
-        const value = (text, field) => {
-            const trimmed = text.trim();
-            if (!trimmed)
-                throw invalidParams(`Review ${field} must not be empty.`);
-            return trimmed;
-        };
-        const review = params.target.type === "uncommittedChanges"
-            ? "current changes"
-            : params.target.type === "baseBranch"
-                ? `changes against '${value(params.target.branch, "branch")}'`
-                : params.target.type === "commit"
-                    ? `commit ${value(params.target.sha, "sha").slice(0, 7)}${params.target.title?.trim() ? `: ${params.target.title.trim()}` : ""}`
-                    : value(params.target.instructions, "instructions");
-        const prompt = params.target.type === "custom"
-            ? review
-            : `Review ${review}. Inspect the repository and report concrete bugs, regressions, and risks with file and line references. Do not modify files.`;
-        let reviewThreadId = params.threadId;
-        let forkedThread;
-        if (params.delivery === "detached") {
-            if (this.requireRecord(params.threadId, false).thread.historyMode === "paginated")
-                throw invalidRequest("paginated threads do not support detached review");
-            const fork = await this.forkThread({ threadId: params.threadId, excludeTurns: false });
-            reviewThreadId = fork.thread.id;
-            forkedThread = fork.thread;
-        }
-        try {
-            const prepared = await this.prepareTurn({
-                threadId: reviewThreadId,
-                input: [{ type: "text", text: prompt, text_elements: [] }],
-            }, { label: review, display: review });
-            const userItem = prepared.turn.items.find((item) => item.type === "userMessage");
-            return {
-                response: {
-                    turn: {
-                        ...prepared.response.turn,
-                        items: userItem ? [userItem] : [],
-                        itemsView: "notLoaded",
-                        startedAt: null,
-                        completedAt: null,
-                        durationMs: null,
-                    },
-                    reviewThreadId,
-                },
-                announce: prepared.announce,
-                start: prepared.start,
-                ...(forkedThread ? { forkedThread } : {}),
-            };
-        }
-        catch (error) {
-            if (forkedThread)
-                await this.discardThreadSilently(reviewThreadId);
-            throw error;
-        }
-    }
-    listTurns(threadId) {
-        this.assertThreadAvailable(threadId);
-        return this.store.listTurns(threadId);
-    }
-    turnsPage(params) {
-        this.assertThreadAvailable(params.threadId);
-        return paginateTurns(this.listTurns(params.threadId), params, ["hyb-turn:"]);
-    }
-    listThreads(params) {
-        return this.store.listThreads(params)
-            .map((thread) => {
-            const record = this.store.getThreadRecord(thread.id, false);
-            return record ? this.withNativeMetadata({ ...record, thread }) : thread;
-        })
-            .filter((thread) => !this.pendingThreadRemoval(thread.id) && !this.hub.isSuppressed(thread.id));
-    }
-    refreshNativeMetadata() {
-        if (Date.now() - this.nativeMetadataReadAt < 30_000)
-            return Promise.resolve();
-        if (this.nativeMetadataRead)
-            return this.nativeMetadataRead;
-        const read = this.nativeSessionCatalog().then((sessions) => {
-            this.nativeMetadata = new Map(sessions.map((session) => [session.sessionId, session]));
-            this.nativeMetadataReadAt = Date.now();
-        }).catch((error) => {
-            this.logger.warn("claude.catalog.native-metadata-failed", {
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }).finally(() => {
-            if (this.nativeMetadataRead === read)
-                this.nativeMetadataRead = undefined;
-        });
-        this.nativeMetadataRead = read;
-        return read;
-    }
-    async setGeneratedThreadName(params, userPrompt) {
-        const record = this.requireRecord(params.threadId, false);
-        if (record.thread.parentThreadId || this.nativeMetadata.get(record.claudeSessionId)?.customTitle)
-            return;
-        await this.sessions.submit(params.threadId, {
-            type: "threadAdmin",
-            command: { kind: "generatedName", name: params.name, userPrompt },
-        });
-    }
-    async setThreadName(params) {
-        const record = this.requireRecord(params.threadId, false);
-        if (record.thread.parentThreadId) {
-            await this.sessions.submit(params.threadId, {
-                type: "threadAdmin",
-                command: { kind: "renameProjection", threadId: params.threadId, name: params.name },
-            });
-            return {};
-        }
-        await this.threadAdminEffect(params.threadId, "rename", async (prepared) => {
-            if (prepared.providerRename) {
-                await this.threadAdminEffects.rename(prepared.record.claudeSessionId, params.name, prepared.record.thread.cwd);
-            }
-        }, params.name);
-        const native = this.nativeMetadata.get(record.claudeSessionId);
-        if (native)
-            this.nativeMetadata.set(record.claudeSessionId, {
-                ...native,
-                customTitle: params.name,
-                summary: params.name,
-                lastModified: Date.now(),
-            });
-        return {};
-    }
-    updateThreadMetadata(params) {
-        this.requireIndependentThread(params.threadId, "update metadata for");
-        if (params.projectId !== undefined && params.projectId !== null && params.projectId !== "") {
-            throw invalidParams("Projects are not supported for Claude threads.");
-        }
-        return this.sessions.submit(params.threadId, {
-            type: "threadAdmin",
-            command: { kind: "metadata", gitInfo: params.gitInfo },
-        });
-    }
-    sectionOrders() { return this.store.sectionOrders(); }
-    setSectionOrder(sectionId, threadIds) { this.store.setSectionOrder(sectionId, threadIds); }
-    /** Section registry stays stock-owned; CCodex records only the membership. */
-    setThreadSection(threadId, section) {
-        this.requireIndependentThread(threadId, "move into a section");
-        return this.sessions.submit(threadId, {
-            type: "threadAdmin",
-            command: { kind: "metadata", gitInfo: undefined, section },
-        });
-    }
-    async archiveThread(threadId) {
-        this.requireIndependentThread(threadId, "archive");
-        this.terminalAdmins.set(threadId, (this.terminalAdmins.get(threadId) ?? 0) + 1);
-        try {
-            await this.threadAdminEffect(threadId, "archive", async (prepared) => {
-                await this.failStatusTurnForUnload(threadId, "Claude thread archived during an active turn.");
-                await this.sessions.submit(threadId, { type: "goal", command: { kind: "detach", checkpoint: "unload" } });
-                if (!prepared.record.thread.ephemeral) {
-                    await (await this.sessions.getOrCreate(threadId))
-                        .retireRuntime("Claude thread archived during an active turn.");
-                }
-            });
-            await this.sessions.retire(threadId);
-            return {};
-        }
-        finally {
-            const remaining = this.terminalAdmins.get(threadId) - 1;
-            if (remaining)
-                this.terminalAdmins.set(threadId, remaining);
-            else
-                this.terminalAdmins.delete(threadId);
-        }
-    }
-    unarchiveThread(threadId) {
-        this.requireIndependentThread(threadId, "unarchive");
-        return this.sessions.submit(threadId, {
-            type: "threadAdmin",
-            command: { kind: "unarchive" },
-        });
-    }
-    async deleteThread(threadId) {
-        const pending = this.pendingThreadRemoval(threadId);
-        if (pending) {
-            if (pending.rootThreadId !== threadId || pending.kind !== "delete")
-                this.throwPendingRemoval(threadId, pending);
-            await this.resumeThreadRemoval(threadId);
-            return {};
-        }
-        this.requireIndependentThread(threadId, "delete");
-        await this.removeThread(threadId, "delete", "Claude thread deleted during an active turn.");
-        return {};
-    }
-    releaseEphemeralThread(threadId) {
-        this.cancelEphemeralRelease(threadId);
-        const existing = this.ephemeralReleases.get(threadId);
-        if (existing)
-            return existing;
-        if (this.closing)
-            return Promise.resolve();
-        const release = this.releaseEphemeralThreadOnce(threadId);
-        this.ephemeralReleases.set(threadId, release);
-        const remove = () => {
-            if (this.ephemeralReleases.get(threadId) === release)
-                this.ephemeralReleases.delete(threadId);
-        };
-        void release.then(remove, remove);
-        return release;
-    }
-    scheduleEphemeralRelease(threadId, delayMs = EPHEMERAL_DISCONNECT_GRACE_MS) {
-        if (this.closing || this.ephemeralReleaseTimers.has(threadId))
-            return;
-        const record = this.store.getThreadRecord(threadId, false);
-        if (!record?.thread.ephemeral || record.thread.parentThreadId || record.thread.threadSource === "user")
-            return;
-        const timer = setTimeout(() => {
-            this.ephemeralReleaseTimers.delete(threadId);
-            void this.releaseEphemeralThread(threadId).catch((error) => {
-                this.logger.warn("claude.ephemeral.release-failed", {
-                    threadId,
-                    error: error instanceof Error ? error.message : String(error),
-                });
-            });
-        }, delayMs);
-        timer.unref();
-        this.ephemeralReleaseTimers.set(threadId, timer);
-    }
-    cancelEphemeralRelease(threadId) {
-        const timer = this.ephemeralReleaseTimers.get(threadId);
-        if (!timer)
-            return;
-        clearTimeout(timer);
-        this.ephemeralReleaseTimers.delete(threadId);
-    }
-    async releaseEphemeralThreadOnce(threadId) {
-        const pending = this.pendingThreadRemoval(threadId);
-        if (pending) {
-            if (pending.rootThreadId !== threadId || pending.kind !== "release")
-                this.throwPendingRemoval(threadId, pending);
-            await this.resumeThreadRemoval(threadId);
-            return;
-        }
-        const record = this.store.getThreadRecord(threadId, false);
-        if (record?.thread.parentThreadId) {
-            throw invalidParams(`Cannot release Claude subagent thread '${threadId}'; it is a read-only projection.`);
-        }
-        if (!record?.thread.ephemeral)
-            return;
-        await this.removeThread(threadId, "release", "Ephemeral side thread released.");
-    }
-    listItems(params) {
-        this.assertThreadAvailable(params.threadId);
-        return paginateItems(this.store.listTurns(params.threadId), params, ["hyb-item:"]);
-    }
-    searchOccurrences(params) {
-        this.assertThreadAvailable(params.threadId);
-        return searchTurnOccurrences(params.threadId, this.store.listTurns(params.threadId), params);
-    }
-    /** `thread/search` over durable Claude threads: one result per thread with the first matching snippet. */
-    searchThreads(params) {
-        const searchTerm = params.searchTerm.trim();
-        return this.listThreads({ archived: params.archived ?? false }).flatMap((thread) => {
-            if (thread.ephemeral)
-                return [];
-            const snippet = threadSearchSnippet(this.store.listTurns(thread.id), searchTerm);
-            return snippet === undefined ? [] : [{ thread: { ...thread, turns: [] }, snippet }];
-        });
-    }
-    async forkThread(params, visibleForkedFromId = params.threadId, reservedSideId) {
-        if (reservedSideId && this.store.hasThread(reservedSideId)) {
-            const session = await this.sessions.getOrCreate(reservedSideId);
-            await session.ensureEphemeralRuntime();
-            return threadResponse(this.requireRecord(reservedSideId, false), false);
-        }
-        if (params.path)
-            throw invalidParams("Claude thread forks must use threadId, not a Codex rollout path.");
-        this.requireIndependentThread(params.threadId, "fork");
-        if (params.lastTurnId && params.beforeTurnId)
-            throw invalidParams("`beforeTurnId` cannot be combined with `lastTurnId`.");
-        if (params.ephemeral && params.deferGoalContinuation)
-            throw invalidParams("`deferGoalContinuation` cannot be combined with `ephemeral`.");
-        const inheritedGoal = params.deferGoalContinuation
-            ? await this.sessions.submit(params.threadId, { type: "goal", command: { kind: "snapshotFork" } })
-            : undefined;
-        const source = await this.sessions.submit(params.threadId, { type: "snapshotBranch" });
-        const sourceRecord = source.record;
-        if (sourceRecord.thread.historyMode === "paginated" && params.ephemeral && !params.excludeTurns)
-            throw invalidRequest("ephemeral paginated thread/fork requires `excludeTurns: true`");
-        const sidePromotion = Boolean((this.config.features?.sideChatPromotion ?? true)
-            && sourceRecord.thread.ephemeral
-            && sourceRecord.thread.threadSource === "user"
-            && params.ephemeral !== true);
-        if (sourceRecord.thread.ephemeral && !sidePromotion) {
-            throw invalidParams("Forking this ephemeral Claude source thread is not supported.");
-        }
-        const requestedModel = params.model ?? sourceRecord.modelPickerId;
-        if (!resolveClaudeModel(this.config, requestedModel))
-            throw invalidParams("Cannot fork a Claude thread to a Codex model.");
-        const activeSideFork = Boolean(params.ephemeral === true && params.excludeTurns === true
-            && params.threadSource === "user" && !params.lastTurnId && !params.beforeTurnId);
-        if (params.permissions && params.sandbox)
-            throw invalidParams("Claude thread fork cannot combine permissions with sandbox.");
-        const activeIndex = sourceRecord.thread.turns.findIndex((turn) => turn.status === "inProgress");
-        const selectedIndex = params.lastTurnId
-            ? sourceRecord.thread.turns.findIndex((turn) => turn.id === params.lastTurnId)
-            : -1;
-        const beforeIndex = params.beforeTurnId
-            ? sourceRecord.thread.turns.findIndex((turn) => turn.id === params.beforeTurnId)
-            : -1;
-        if (params.lastTurnId && selectedIndex < 0)
-            throw invalidParams(`Unknown Claude turn '${params.lastTurnId}'.`);
-        if (params.beforeTurnId && beforeIndex < 0)
-            throw invalidParams(`Unknown Claude turn '${params.beforeTurnId}'.`);
-        const selectedTurn = selectedIndex >= 0 ? sourceRecord.thread.turns[selectedIndex] : undefined;
-        const selectedBoundary = params.lastTurnId
-            ? source.boundaries.find((entry) => entry.turnId === params.lastTurnId)
-            : undefined;
-        if (params.lastTurnId && !selectedBoundaryIsStable(selectedTurn)) {
-            throw invalidParams(`Claude turn '${params.lastTurnId}' is not completed and cannot be used as a fork boundary.`);
-        }
-        const through = activeSideFork || sidePromotion
-            ? activeIndex >= 0 ? activeIndex - 1 : sourceRecord.thread.turns.length - 1
-            : params.lastTurnId
-                ? selectedIndex
-                : params.beforeTurnId
-                    ? beforeIndex - 1
-                    : sourceRecord.thread.turns.length - 1;
-        if (sidePromotion && through < 0) {
-            throw invalidParams("Cannot promote a Claude side chat before it has a completed turn.");
-        }
-        const sourceTurns = sourceRecord.thread.turns.slice(0, through + 1);
-        const selectedIds = new Set(sourceTurns.map((turn) => turn.id));
-        const unstableProjectionIds = new Set(sourceTurns
-            .filter((turn) => turn.status === "inProgress")
-            .map((turn) => turn.id));
-        const stableSelectedIds = new Set([...selectedIds]
-            .filter((turnId) => !unstableProjectionIds.has(turnId)));
-        const sourceBoundaries = source.boundaries.filter((entry) => stableSelectedIds.has(entry.turnId));
-        const revisionTurns = sourceTurns.filter((turn) => stableSelectedIds.has(turn.id));
-        const revision = branchRevision(sourceRecord, sourceBoundaries, revisionTurns);
-        const requestedServiceTier = normalizeClaudeServiceTier(this.config, requestedModel, params.serviceTier === undefined ? sourceRecord.serviceTier : params.serviceTier);
-        const { modelPickerId, claudeModelValue, reasoningEffort, serviceTier } = await this.resolveModelSettings(requestedModel, sourceRecord.reasoningEffort, requestedServiceTier);
-        if (serviceTier !== requestedServiceTier)
-            throw invalidParams(`Claude model '${requestedModel}' does not support the fast service tier.`);
-        const boundary = selectedBoundary?.messageUuid ?? sourceBoundaries.at(-1)?.messageUuid;
-        const branch = boundary
-            ? await this.transcripts.forkWithProvenance(sourceRecord.claudeSessionId, boundary, sourceRecord.thread.cwd, sourceBoundaries.map((entry) => entry.messageUuid), boundaryCorrelations(this.store, sourceRecord, sourceBoundaries))
-            : { sessionId: uuidv7(), uuidMap: new Map() };
-        try {
-            const current = await this.sessions.submit(params.threadId, { type: "snapshotBranch" });
-            const currentTurns = current.record.thread.turns.filter((turn) => stableSelectedIds.has(turn.id));
-            const currentBoundaries = current.boundaries.filter((entry) => stableSelectedIds.has(entry.turnId));
-            const currentRevision = branchRevision(current.record, currentBoundaries, currentTurns);
-            if (currentRevision !== revision)
-                throw invalidParams("Claude thread changed while branch was being prepared; retry the operation.");
-        }
-        catch (error) {
-            await this.transcripts.delete(branch.sessionId, sourceRecord.thread.cwd).catch(() => undefined);
-            throw error;
-        }
-        const createdAt = nowSeconds();
-        const { cwd, runtimeWorkspaceRoots } = workspaceSelection(params, {
-            cwd: sourceRecord.thread.cwd,
-            runtimeWorkspaceRoots: storedWorkspaceRoots(sourceRecord),
-        });
-        const threadId = reservedSideId ?? uuidv7();
-        const thread = {
-            ...sourceRecord.thread, id: threadId, ephemeral: params.ephemeral ?? false,
-            section: null, sectionEnteredAt: null, projectId: null,
-            sessionId: threadId, forkedFromId: visibleForkedFromId,
-            cwd, modelProvider: "claude", model: modelPickerId, reasoningEffort,
-            createdAt, updatedAt: createdAt, recencyAt: createdAt,
-            status: params.ephemeral ? { type: "idle" } : { type: "notLoaded" },
-            canAcceptDirectInput: true,
-            name: params.ephemeral
-                ? sourceRecord.thread.name
-                : sourceRecord.thread.name ? `${sourceRecord.thread.name} (fork)` : null,
-            threadSource: params.threadSource ?? sourceRecord.thread.threadSource, turns: [],
-        };
-        const copiedTurns = sourceTurns.map((turn) => forkProjection(turn, thread.id));
-        const record = {
-            ...sourceRecord, thread, runtimeWorkspaceRoots,
-            claudeSessionId: branch.sessionId, modelPickerId, claudeModelValue, serviceTier, reasoningEffort,
-            approvalPolicy: params.approvalPolicy ?? sourceRecord.approvalPolicy,
-            approvalsReviewer: approvalsReviewer(params.approvalsReviewer, sourceRecord.approvalsReviewer),
-            sandboxPolicy: params.permissions
-                ? permissionProfileSandboxPolicy(params.permissions, cwd, runtimeWorkspaceRoots)
-                : params.sandbox
-                    ? sandboxPolicy(params.sandbox, cwd, runtimeWorkspaceRoots)
-                    : inheritedSandboxPolicy(sourceRecord.sandboxPolicy, cwd, runtimeWorkspaceRoots),
-            baseInstructions: params.baseInstructions === undefined ? sourceRecord.baseInstructions : params.baseInstructions,
-            developerInstructions: claudeDeveloperInstructions(params.developerInstructions === undefined
-                ? sourceRecord.developerInstructions : params.developerInstructions),
-            lastClaudeMessageUuid: null, lastCompletedTurnId: null,
-        };
-        let responseRecord;
-        try {
-            responseRecord = await this.sessions.submit(thread.id, {
-                type: "commitForkTarget", record, turns: copiedTurns,
-                sourceBoundaries, uuidMap: [...branch.uuidMap],
-                ...(inheritedGoal ? { inheritedGoal } : {}),
-            });
-        }
-        catch (error) {
-            await this.transcripts.delete(branch.sessionId, sourceRecord.thread.cwd).catch(() => undefined);
-            throw error;
-        }
-        responseRecord = { ...responseRecord, thread: { ...responseRecord.thread, turns: copiedTurns } };
-        if (thread.ephemeral) {
-            try {
-                const targetSession = await this.sessions.getOrCreate(thread.id);
-                await targetSession.ensureEphemeralRuntime();
-                const activeTurn = activeIndex >= 0 ? sourceRecord.thread.turns[activeIndex] : undefined;
-                if (activeSideFork && activeTurn) {
-                    await targetSession.injectRuntimeItems([sideReferenceSnapshot(sourceRecord.thread.id, activeTurn)]);
-                    responseRecord = this.requireRecord(thread.id, true);
-                }
-            }
-            catch (error) {
-                await this.sessions.submit(thread.id, { type: "deleteBranchTarget" }).catch(() => undefined);
-                await this.sessions.retire(thread.id).catch(() => undefined);
-                await this.transcripts.delete(branch.sessionId, sourceRecord.thread.cwd).catch(() => undefined);
-                throw error;
-            }
-        }
-        if (sidePromotion)
-            await this.releaseEphemeralThread(params.threadId);
-        return threadResponse(responseRecord, !params.excludeTurns);
-    }
-    async rollbackThread(params) {
-        const source = await this.truncationSource(params.threadId, "roll back");
-        if (source.record.thread.historyMode === "paginated")
-            throw invalidRequest("paginated threads do not support thread/rollback");
-        if (!Number.isInteger(params.numTurns) || params.numTurns < 1)
-            throw invalidParams("numTurns must be at least 1.");
-        if (params.numTurns > source.record.thread.turns.length)
-            throw invalidParams("Cannot remove more turns than the Claude thread contains.");
-        const committed = await this.truncateThread(source, source.record.thread.turns.length - params.numTurns);
-        return { thread: committed.thread };
-    }
-    /** `thread/revert`: drops `beforeTurnId` and every later turn; the App hydrates retained history via the cursors. */
-    async revertThread(params) {
-        const source = await this.truncationSource(params.threadId, "revert");
-        const keepCount = source.record.thread.turns.findIndex((turn) => turn.id === params.beforeTurnId);
-        if (keepCount === -1)
-            throw invalidParams(`Unknown Claude turn '${params.beforeTurnId}'.`);
-        const retained = (await this.truncateThread(source, keepCount)).thread;
-        return {
-            thread: { ...retained, turns: [] },
-            ...historyCursors(retained.turns),
-        };
-    }
-    async truncationSource(threadId, verb) {
-        this.requireIndependentThread(threadId, verb);
-        const snapshot = await this.sessions.submit(threadId, { type: "snapshotBranch" });
-        if (snapshot.record.thread.ephemeral)
-            throw invalidParams(`Cannot ${verb} an ephemeral Claude thread.`);
-        const session = await this.sessions.getOrCreate(threadId);
-        if ((await session.runtimeInspection())?.quiescent === false)
-            throw invalidParams(`Cannot ${verb} a Claude thread with an active turn.`);
-        return { ...snapshot, session };
-    }
-    /** Keeps the first `keepCount` turns by forking the transcript at the last retained provider boundary. */
-    async truncateThread(source, keepCount) {
-        const sourceRecord = source.record;
-        const threadId = sourceRecord.thread.id;
-        const retainedIds = new Set(sourceRecord.thread.turns.slice(0, keepCount).map((turn) => turn.id));
-        const sourceBoundaries = source.boundaries.filter((entry) => retainedIds.has(entry.turnId));
-        const boundary = sourceBoundaries.at(-1)?.messageUuid;
-        const branch = boundary
-            ? await this.transcripts.forkWithProvenance(sourceRecord.claudeSessionId, boundary, sourceRecord.thread.cwd, sourceBoundaries.map((entry) => entry.messageUuid), boundaryCorrelations(this.store, sourceRecord, sourceBoundaries))
-            : { sessionId: uuidv7(), uuidMap: new Map() };
-        let committed;
-        try {
-            committed = await this.sessions.submit(threadId, {
-                type: "commitRollback", expectedRevision: source.revision, replacementSessionId: branch.sessionId,
-                keepCount, sourceBoundaries, uuidMap: [...branch.uuidMap],
-            });
-        }
-        catch (error) {
-            await this.transcripts.delete(branch.sessionId, sourceRecord.thread.cwd).catch(() => undefined);
-            throw error;
-        }
-        if (source.session.isLoaded) {
-            await source.session.retireRuntimeSilently().catch((error) => {
-                this.logger.warn("claude.rollback.old-runtime-retire-failed", { threadId, error: String(error) });
-            });
-        }
-        await this.transcripts.delete(sourceRecord.claudeSessionId, sourceRecord.thread.cwd).catch((error) => this.logger.warn("claude.rollback.old-session-delete-failed", { threadId, error: String(error) }));
-        return committed;
-    }
-    prepareGoalSet(params) {
-        this.requireIndependentThread(params.threadId, "set a goal on");
-        return this.sessions.submit(params.threadId, { type: "goal", command: { kind: "prepareSet", params } }).then((mutation) => this.goalHandle(params.threadId, mutation));
-    }
-    async addQueuedSubmission(params) {
-        this.requireIndependentThread(params.threadId, "queue a submission in");
-        const queuedSubmission = await this.sessions.submit(params.threadId, {
-            type: "queue",
-            command: { kind: "add", input: params.input, clientUserMessageId: params.clientUserMessageId },
-        });
-        return { response: { queuedSubmission }, after: () => this.drainQueue(params.threadId) };
-    }
-    /** Offset pagination over the durable per-thread queue; the cursor is the base-10 offset, as in stock. */
-    listQueue(params) {
-        this.requireRecord(params.threadId, false);
-        const cursor = params.cursor ?? null;
-        if (cursor !== null && !/^\d+$/u.test(cursor))
-            throw invalidRequest(`invalid queue pagination cursor: ${cursor}`);
-        const offset = cursor === null ? 0 : Number(cursor);
-        const limit = Math.min(Math.max(params.limit ?? 25, 1), 100);
-        const queue = this.store.listQueuedSubmissions(params.threadId);
-        return {
-            data: queue.slice(offset, offset + limit),
-            nextCursor: offset + limit < queue.length ? String(offset + limit) : null,
-        };
-    }
-    async updateQueuedSubmission(params) {
-        this.requireIndependentThread(params.threadId, "update a queued submission in");
-        const queuedSubmission = await this.sessions.submit(params.threadId, {
-            type: "queue",
-            command: { kind: "update", queuedSubmissionId: params.queuedSubmissionId, input: params.input },
-        });
-        return { queuedSubmission };
-    }
-    async deleteQueuedSubmission(params) {
-        this.requireIndependentThread(params.threadId, "delete a queued submission from");
-        const deleted = await this.sessions.submit(params.threadId, {
-            type: "queue", command: { kind: "delete", queuedSubmissionId: params.queuedSubmissionId },
-        });
-        return { deleted };
-    }
-    async reorderQueue(params) {
-        this.requireIndependentThread(params.threadId, "reorder the queue of");
-        await this.sessions.submit(params.threadId, {
-            type: "queue", command: { kind: "reorder", queuedSubmissionIds: params.queuedSubmissionIds },
-        });
-        return {};
-    }
-    async prepareQueueStart(params) {
-        this.requireIndependentThread(params.threadId, "start a queued submission in");
-        const entry = await this.sessions.submit(params.threadId, {
-            type: "queue",
-            command: {
-                kind: "take",
-                manual: true,
-                ...(params.queuedSubmissionId == null ? {} : { queuedSubmissionId: params.queuedSubmissionId }),
-            },
-        });
-        return this.startQueuedSubmission(params.threadId, entry);
-    }
-    async startQueuedSubmission(threadId, entry) {
-        try {
-            return await this.prepareTurn({ threadId, input: entry.input, clientUserMessageId: entry.clientUserMessageId });
-        }
-        catch (error) {
-            await this.sessions.submit(threadId, { type: "queue", command: { kind: "restore", entry } });
-            throw error;
-        }
-    }
-    /** Starts the head of the queue when the thread is idle and its last turn was not interrupted. */
-    async drainQueue(threadId) {
-        if (this.closing || this.store.listQueuedSubmissions(threadId).length === 0)
-            return;
-        const entry = await this.sessions.submit(threadId, {
-            type: "queue", command: { kind: "take", manual: false },
-        });
-        if (!entry)
-            return;
-        let prepared;
-        try {
-            prepared = await this.startQueuedSubmission(threadId, entry);
-        }
-        catch (error) {
-            this.logger[error instanceof ActiveClaudeTurnError ? "info" : "warn"]("claude.queue.drain-skipped", {
-                threadId, queuedSubmissionId: entry.id, error: String(error),
-            });
-            return;
-        }
-        await prepared.announce();
-        prepared.start();
-    }
-    scheduleQueueDrain(threadId) {
-        queueMicrotask(() => {
-            void this.drainQueue(threadId).catch((error) => {
-                this.logger.warn("claude.queue.drain-failed", { threadId, error: String(error) });
-            });
-        });
-    }
-    onSessionLifecycle(threadId, update) {
-        if (update.completed && update.completed.turn.status !== "interrupted")
-            this.queueDrainPending.add(threadId);
-        if (update.quiescent && this.queueDrainPending.delete(threadId))
-            this.scheduleQueueDrain(threadId);
-    }
-    async getGoal(threadId) {
-        if (this.requireRecord(threadId, false).thread.parentThreadId)
-            return { goal: null };
-        const goal = await this.sessions.submit(threadId, { type: "goal", command: { kind: "get" } });
-        return { goal: goal ? (({ goalId: _, ...value }) => value)(goal) : null };
-    }
-    prepareGoalClear(threadId) {
-        this.requireIndependentThread(threadId, "clear a goal from");
-        return this.sessions.submit(threadId, { type: "goal", command: { kind: "prepareClear" } }).then((mutation) => this.goalHandle(threadId, mutation));
-    }
-    goalHandle(threadId, mutation) {
-        let notified;
-        return {
-            response: mutation.response,
-            notify: () => notified ??= this.sessions.submit(threadId, { type: "goal", command: { kind: "finalize", mutation } }),
-        };
-    }
-    async resolveServerRequest(requestId, response) {
-        const request = this.store.getPendingRequest(requestId);
-        if (!request)
-            return false;
-        let owner = this.requireRecord(request.threadId, false);
-        while (owner.thread.parentThreadId)
-            owner = this.requireRecord(owner.thread.parentThreadId, false);
-        return this.sessions.submit(owner.thread.id, {
-            type: "resolveInteraction",
-            requestId,
-            response,
-        });
-    }
-    replayPendingRequests(threadId, connectionId) {
-        this.assertThreadAvailable(threadId);
-        return this.sessions.submit(threadId, {
-            type: "replayInteractions",
-            ...(connectionId ? { connectionId } : {}),
-        });
-    }
-    eventHighWatermark(threadId) {
-        this.assertThreadAvailable(threadId);
-        return this.store.eventHighWatermark(threadId);
-    }
-    eventsAfter(threadId, sequence) {
-        this.assertThreadAvailable(threadId);
-        return this.store.listEventsAfter(threadId, sequence);
-    }
-    latestTokenUsage(threadId) {
-        this.assertThreadAvailable(threadId);
-        const record = this.requireRecord(threadId, false);
-        if (!record.tokenUsageLast)
-            return undefined;
-        const current = {
-            threadId,
-            turnId: record.lastCompletedTurnId,
-            tokenUsage: {
-                total: record.tokenUsageTotal,
-                last: record.tokenUsageLast,
-                modelContextWindow: record.modelContextWindow,
-            },
-        };
-        const latest = this.store.listEventsAfter(threadId, 0)
-            .filter((event) => event.method === "thread/tokenUsage/updated")
-            .at(-1);
-        const latestTurnId = latest?.params && typeof latest.params === "object" && "turnId" in latest.params
-            ? latest.params.turnId
-            : undefined;
-        const replay = { ...current, turnId: typeof latestTurnId === "string" ? latestTurnId : current.turnId };
-        return latest && JSON.stringify(latest.params) === JSON.stringify(replay)
-            ? latest
-            : { sequence: 0, threadId, turnId: replay.turnId, method: "thread/tokenUsage/updated", params: replay, createdAt: Date.now() };
-    }
-    close() {
-        return this.closePromise ??= this.closeOnce();
-    }
-    async closeOnce() {
-        this.closing = true;
-        for (const timer of this.ephemeralReleaseTimers.values())
-            clearTimeout(timer);
-        this.ephemeralReleaseTimers.clear();
-        const releaseResults = await Promise.allSettled(this.ephemeralReleases.values());
-        await this.restartRecovery;
-        clearInterval(this.idleTimer);
-        await this.idleSweep;
-        await Promise.all(this.sessions.activeOwnerIds().map((threadId) => this.failStatusTurnForUnload(threadId, "Gateway restarted while the CCodex status request was active.")));
-        await this.sessions.close();
-        this.store.close();
-        const failures = releaseResults
-            .filter((result) => result.status === "rejected")
-            .map((result) => result.reason);
-        if (failures.length > 0) {
-            throw new AggregateError(failures, "Failed to release ephemeral Claude threads during shutdown.");
-        }
-    }
-    async discardThreadSilently(threadId) {
-        if (!this.store.getThreadRecord(threadId, false))
-            return;
-        await this.removeThread(threadId, "discard", "Internal compact handoff completed.");
-    }
-    async removeThread(threadId, kind, reason) {
-        const pending = this.pendingThreadRemoval(threadId);
-        if (pending) {
-            if (pending.rootThreadId !== threadId || pending.kind !== kind)
-                this.throwPendingRemoval(threadId, pending);
-            return this.resumeThreadRemoval(threadId);
-        }
-        const existing = this.removalRetries.get(threadId);
-        if (existing) {
-            if (existing.kind !== kind)
-                this.throwPendingRemoval(threadId, existing);
-            return existing.promise;
-        }
-        const removal = this.startThreadRemoval(threadId, kind, reason)
-            .finally(() => this.removalRetries.delete(threadId));
-        this.removalRetries.set(threadId, { kind, promise: removal });
-        return removal;
-    }
-    async startThreadRemoval(threadId, kind, reason) {
-        const session = this.sessions.resolvedSession(threadId) ?? await this.sessions.getOrCreate(threadId);
-        await session.withRuntimeAdmin(async () => {
-            let prepared;
-            let providerAttempted = false;
-            try {
-                prepared = await this.sessions.submit(threadId, {
-                    type: "threadAdmin",
-                    command: { kind: "beginRemoval", removalKind: kind },
-                });
-                await this.failStatusTurnForUnload(threadId, reason);
-                await this.sessions.submit(threadId, {
-                    type: "goal",
-                    command: { kind: "detach", checkpoint: kind },
-                });
-                await session.retireRuntime(reason);
-                providerAttempted = true;
-                await this.deleteProviderSession(prepared.claudeSessionId, prepared.cwd);
-                const committed = await this.sessions.submit(threadId, {
-                    type: "threadAdmin",
-                    command: { kind: "providerSucceeded", operationId: prepared.operationId },
-                });
-                if (!committed)
-                    throw new Error(`Stale Claude ${kind} completion for thread '${threadId}'.`);
-            }
-            catch (error) {
-                if (prepared) {
-                    await this.sessions.submit(threadId, {
-                        type: "threadAdmin",
-                        command: {
-                            kind: "providerFailed",
-                            operationId: prepared.operationId,
-                            providerAttempted,
-                        },
-                    });
-                }
-                throw error;
-            }
-        });
-        if (await session.mayRelease())
-            await this.sessions.retire(threadId);
-    }
-    async threadAdminEffect(threadId, operation, effect, name) {
-        const session = this.sessions.resolvedSession(threadId) ?? await this.sessions.getOrCreate(threadId);
-        await session.withRuntimeAdmin(async () => {
-            const prepared = await this.sessions.submit(threadId, {
-                type: "threadAdmin",
-                command: { kind: "prepare", operation, ...(name === undefined ? {} : { name }) },
-            });
-            try {
-                await effect(prepared);
-            }
-            catch (error) {
-                await this.sessions.submit(threadId, {
-                    type: "threadAdmin",
-                    command: { kind: "abort", operationId: prepared.operationId },
-                }).catch(() => undefined);
-                throw error;
-            }
-            try {
-                const current = await this.sessions.submit(threadId, {
-                    type: "threadAdmin",
-                    command: { kind: "finish", operationId: prepared.operationId },
-                });
-                if (!current && operation !== "rename") {
-                    throw new Error(`Stale Claude ${operation} completion for thread '${threadId}'.`);
-                }
-            }
-            catch (error) {
-                await this.sessions.submit(threadId, {
-                    type: "threadAdmin",
-                    command: { kind: "abort", operationId: prepared.operationId },
-                }).catch(() => undefined);
-                throw error;
-            }
-        });
-        if (await session.mayRelease())
-            await this.sessions.retire(threadId);
-    }
-    async resumeThreadRemovals(rootThreadIds) {
-        for (const rootThreadId of rootThreadIds) {
-            try {
-                await this.resumeThreadRemoval(rootThreadId);
-            }
-            catch (error) {
-                this.logger.warn("claude.thread-removal.recovery-failed", {
-                    threadId: rootThreadId,
-                    error: String(error),
-                });
-            }
-        }
-    }
-    async resumeThreadRemoval(rootThreadId) {
-        const existing = this.removalRetries.get(rootThreadId);
-        if (existing)
-            return existing.promise;
-        const kind = this.store.listPendingThreadRemovals()
-            .find((removal) => removal.rootThreadId === rootThreadId)?.kind ?? "delete";
-        const retry = this.resumeThreadRemovalOnce(rootThreadId)
-            .finally(() => this.removalRetries.delete(rootThreadId));
-        this.removalRetries.set(rootThreadId, { kind, promise: retry });
-        return retry;
-    }
-    async resumeThreadRemovalOnce(rootThreadId) {
-        const session = await this.sessions.getOrCreate(rootThreadId);
-        await session.withRuntimeAdmin(async () => {
-            let prepared;
-            try {
-                prepared = await this.sessions.submit(rootThreadId, {
-                    type: "threadAdmin",
-                    command: { kind: "recoverRemoval" },
-                });
-                await this.deleteProviderSession(prepared.claudeSessionId, prepared.cwd);
-                const committed = await this.sessions.submit(rootThreadId, {
-                    type: "threadAdmin",
-                    command: { kind: "providerSucceeded", operationId: prepared.operationId },
-                });
-                if (!committed) {
-                    throw new Error(`Stale Claude ${prepared.kind} recovery for thread '${rootThreadId}'.`);
-                }
-            }
-            catch (error) {
-                if (prepared) {
-                    await this.sessions.submit(rootThreadId, {
-                        type: "threadAdmin",
-                        command: {
-                            kind: "providerFailed",
-                            operationId: prepared.operationId,
-                            providerAttempted: true,
-                        },
-                    });
-                }
-                throw error;
-            }
-        });
-        await this.sessions.retire(rootThreadId).catch((error) => {
-            this.logger.warn("claude.thread-removal.session-retire-failed", {
-                threadId: rootThreadId,
-                error: String(error),
-            });
-        });
-    }
-    async deleteProviderSession(sessionId, cwd) {
-        try {
-            await this.threadAdminEffects.delete(sessionId, cwd);
-        }
-        catch (error) {
-            if (!String(error).toLowerCase().includes("not found"))
-                throw error;
-        }
-    }
-    async reconcileAfterRestart(orphanProjectionIds, recoveryRootIds) {
-        for (const threadId of orphanProjectionIds) {
-            await this.sessions.submit(threadId, { type: "purgeStartupProjection" });
-            await this.sessions.retire(threadId);
-        }
-        for (const threadId of recoveryRootIds) {
-            try {
-                const recovery = await this.sessions.submit(threadId, {
-                    type: "recoverAfterRestart",
-                    statusCommandEnabled: this.config.features?.statusCommand ?? true,
-                });
-                for (const eventType of recovery.abandonedProviderEventTypes) {
-                    this.metrics.providerEvent(eventType, "abandoned");
-                }
-            }
-            finally {
-                await this.sessions.retire(threadId);
-            }
-        }
-    }
-    async unloadIdleRuntimes() {
-        const idleMs = this.config.idleTimeoutSeconds * 1_000;
-        for (const threadId of this.sessions.loadedOwnerIds()) {
-            const session = await this.sessions.getOrCreate(threadId);
-            const result = await session.retireRuntimeIfIdle(idleMs);
-            if (result === "ephemeral") {
-                await this.releaseEphemeralThread(threadId);
-                continue;
-            }
-            if (result === "retired") {
-                this.logger.info("claude.runtime.unloaded", { threadId });
-                await this.sessions.retire(threadId);
-            }
-        }
-    }
-    requireRecord(threadId, includeTurns) {
-        this.assertThreadAvailable(threadId);
-        const record = this.store.getThreadRecord(threadId, includeTurns);
-        if (!record)
-            throw invalidParams(`Unknown Claude thread '${threadId}'.`);
-        return record;
-    }
-    withNativeMetadata(record) {
-        if (record.thread.ephemeral && record.thread.threadSource === "user"
-            && !record.thread.parentThreadId && record.thread.status.type === "notLoaded") {
-            record = { ...record, thread: { ...record.thread, status: { type: "idle" } } };
-        }
-        const native = this.nativeMetadata.get(record.claudeSessionId);
-        if (!native)
-            return {
-                ...record.thread,
-                section: record.thread.section ?? null,
-                sectionEnteredAt: record.thread.sectionEnteredAt ?? null,
-                projectId: record.thread.projectId ?? null,
-                canAcceptDirectInput: record.thread.parentThreadId ? false : true,
-            };
-        const createdAt = native.createdAt === undefined
-            ? record.thread.createdAt
-            : Math.floor(native.createdAt / 1_000);
-        const updatedAt = Math.floor(native.lastModified / 1_000);
-        return {
-            ...record.thread,
-            section: record.thread.section ?? null,
-            sectionEnteredAt: record.thread.sectionEnteredAt ?? null,
-            projectId: record.thread.projectId ?? null,
-            canAcceptDirectInput: record.thread.parentThreadId ? false : true,
-            name: record.thread.name || native.customTitle || native.summary,
-            preview: native.firstPrompt ?? record.thread.preview,
-            cwd: native.cwd ?? record.thread.cwd,
-            createdAt,
-            updatedAt,
-            recencyAt: updatedAt,
-        };
-    }
-    requireIndependentThread(threadId, operation) {
-        const record = this.requireRecord(threadId, false);
-        if (record.thread.parentThreadId) {
-            throw invalidParams(`Cannot ${operation} Claude subagent thread '${threadId}'; it is a read-only projection.`);
-        }
-    }
-    isChildProjection(threadId) {
-        return Boolean(this.store.getThreadRecord(threadId, false)?.thread.parentThreadId);
-    }
-    assertThreadAvailable(threadId) {
-        const pending = this.pendingThreadRemoval(threadId);
-        if (pending)
-            this.throwPendingRemoval(threadId, pending);
-    }
-    throwPendingRemoval(threadId, removal) {
-        throw invalidParams(`Claude thread '${threadId}' is pending ${removal.kind}; retry the ${removal.kind} request after cleanup completes.`);
-    }
-    pendingThreadRemoval(threadId) {
-        const removals = this.store.listPendingThreadRemovals();
-        const pending = (rootThreadId) => {
-            const durable = removals.find((removal) => removal.rootThreadId === rootThreadId);
-            if (durable)
-                return durable;
-            const inFlight = this.removalRetries.get(rootThreadId);
-            const record = inFlight && this.store.getThreadRecord(rootThreadId, false);
-            return inFlight && record ? {
-                rootThreadId,
-                claudeSessionId: record.claudeSessionId,
-                cwd: record.thread.cwd,
-                kind: inFlight.kind,
-            } : undefined;
-        };
-        const direct = pending(threadId);
-        if (direct)
-            return direct;
-        let record = this.store.getThreadRecord(threadId, false);
-        const seen = new Set();
-        while (record?.thread.parentThreadId && !seen.has(record.thread.id)) {
-            seen.add(record.thread.id);
-            const parentId = record.thread.parentThreadId;
-            const removal = pending(parentId);
-            if (removal)
-                return removal;
-            record = this.store.getThreadRecord(parentId, false);
-        }
-        return undefined;
-    }
-    async newThreadRecord(params, settings) {
-        const requestedModel = params.model;
-        if (!requestedModel || !resolveClaudeModel(this.config, requestedModel))
-            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 requestedServiceTier = normalizeClaudeServiceTier(this.config, requestedModel, params.serviceTier);
-        if (requestedServiceTier !== null && requestedServiceTier !== "default" && requestedServiceTier !== "fast")
-            throw invalidParams(`Unsupported Claude service tier '${requestedServiceTier}'.`);
-        const { modelPickerId, claudeModelValue, reasoningEffort, serviceTier } = await this.resolveModelSettings(requestedModel, settings?.effort ?? null, requestedServiceTier);
-        const createdAt = nowSeconds();
-        const workspace = workspaceSelection(params);
-        const { cwd, runtimeWorkspaceRoots } = workspace;
-        return {
-            thread: {
-                id: uuidv7(),
-                extra: null,
-                sessionId: uuidv7(),
-                forkedFromId: null,
-                parentThreadId: null,
-                preview: "",
-                ephemeral: params.ephemeral ?? false,
-                section: null,
-                sectionEnteredAt: null,
-                projectId: null,
-                historyMode: params.historyMode ?? (params.ephemeral ? "legacy" : "paginated"),
-                modelProvider: "claude", model: modelPickerId, reasoningEffort,
-                createdAt,
-                updatedAt: createdAt,
-                recencyAt: createdAt,
-                status: { type: "idle" },
-                canAcceptDirectInput: true,
-                path: null,
-                cwd,
-                cliVersion: "claude-code",
-                source: "vscode",
-                threadSource: params.threadSource ?? null,
-                agentNickname: null,
-                agentRole: null,
-                gitInfo: null,
-                name: null,
-                turns: [],
-            },
-            runtimeWorkspaceRoots,
-            claudeSessionId: uuidv7(),
-            modelPickerId,
-            claudeModelValue,
-            serviceTier,
-            approvalPolicy: params.approvalPolicy ?? "on-request",
-            approvalsReviewer: approvalsReviewer(params.approvalsReviewer),
-            sandboxPolicy: params.permissions
-                ? permissionProfileSandboxPolicy(params.permissions, cwd, runtimeWorkspaceRoots)
-                : sandboxPolicy(params.sandbox, cwd, runtimeWorkspaceRoots),
-            baseInstructions: params.baseInstructions ?? null,
-            developerInstructions: claudeDeveloperInstructions(params.developerInstructions),
-            personality: settings?.personality ?? params.personality ?? null,
-            resolvedModel: null,
-            lastClaudeMessageUuid: null,
-            lastCompletedTurnId: null,
-            claudeCodeVersion: null,
-            reasoningEffort,
-            reasoningSummary: settings?.summary ?? null,
-            collaborationMode: settings?.collaborationMode === undefined || settings.collaborationMode === null
-                ? null
-                : syncedCollaborationMode(settings.collaborationMode, modelPickerId, reasoningEffort),
-            outputSchema: null,
-            tokenUsageTotal: {
-                totalTokens: 0, inputTokens: 0, cachedInputTokens: 0, cacheWriteInputTokens: 0,
-                outputTokens: 0, reasoningOutputTokens: 0,
-            },
-            tokenUsageLast: null,
-            modelContextWindow: null,
-            providerCostUsdTotal: 0,
-        };
-    }
-    async applyTurnOverrides(params) {
-        await this.applySettings({ ...params, effort: turnReasoningEffort(params) }, params.outputSchema ?? null);
-    }
-    async applySettings(params, outputSchema) {
-        const previous = this.settingsUpdates.get(params.threadId) ?? Promise.resolve();
-        const update = previous.catch(() => undefined).then(() => this.applySettingsNow(params, outputSchema));
-        this.settingsUpdates.set(params.threadId, update);
-        try {
-            await update;
-        }
-        finally {
-            if (this.settingsUpdates.get(params.threadId) === update)
-                this.settingsUpdates.delete(params.threadId);
-        }
-    }
-    async applySettingsNow(params, outputSchema) {
-        if (params.permissions && params.sandboxPolicy)
-            throw invalidParams("Claude thread settings cannot combine permissions with sandboxPolicy.");
-        if (params.effort && !["low", "medium", "high", "xhigh", "max"].includes(params.effort))
-            throw invalidParams(`Unsupported Claude effort '${params.effort}'.`);
-        let update;
-        let syncCanonicalSettings = false;
-        const session = await this.sessions.getOrCreate(params.threadId);
-        for (;;) {
-            const before = await this.sessions.submit(params.threadId, { type: "readThread", includeTurns: false });
-            const requestedModel = params.model ?? before.modelPickerId;
-            if (!resolveClaudeModel(this.config, requestedModel))
-                throw invalidParams("Cannot switch a Claude thread to a Codex model.");
-            const requestedServiceTier = normalizeClaudeServiceTier(this.config, requestedModel, params.serviceTier === undefined ? before.serviceTier : params.serviceTier);
-            if (requestedServiceTier !== null && requestedServiceTier !== "default" && requestedServiceTier !== "fast")
-                throw invalidParams(`Unsupported Claude service tier '${requestedServiceTier}'.`);
-            const { cwd, runtimeWorkspaceRoots } = workspaceSelection(params, {
-                cwd: before.thread.cwd,
-                runtimeWorkspaceRoots: storedWorkspaceRoots(before),
-            });
-            const workspaceChanged = cwd !== before.thread.cwd
-                || runtimeWorkspaceRoots.length !== storedWorkspaceRoots(before).length
-                || runtimeWorkspaceRoots.some((root, index) => root !== storedWorkspaceRoots(before)[index]);
-            const { modelPickerId, claudeModelValue, reasoningEffort, serviceTier } = await this.resolveModelSettings(requestedModel, params.effort === undefined ? before.reasoningEffort : params.effort, requestedServiceTier, params.effort !== undefined);
-            syncCanonicalSettings = requestedServiceTier === "fast" && serviceTier !== "fast";
-            const collaborationMode = params.collaborationMode === undefined
-                ? before.collaborationMode
-                : params.collaborationMode;
-            const candidate = {
-                ...before,
-                thread: { ...before.thread, cwd },
-                runtimeWorkspaceRoots,
-                modelPickerId,
-                claudeModelValue,
-                serviceTier,
-                approvalPolicy: params.approvalPolicy ?? before.approvalPolicy,
-                approvalsReviewer: approvalsReviewer(params.approvalsReviewer, before.approvalsReviewer),
-                sandboxPolicy: params.permissions
-                    ? permissionProfileSandboxPolicy(params.permissions, cwd, runtimeWorkspaceRoots)
-                    : params.sandboxPolicy ?? (workspaceChanged
-                        ? inheritedSandboxPolicy(before.sandboxPolicy, cwd, runtimeWorkspaceRoots)
-                        : before.sandboxPolicy),
-                reasoningEffort,
-                reasoningSummary: params.summary === undefined ? before.reasoningSummary : params.summary,
-                collaborationMode: collaborationMode === null ? null : syncedCollaborationMode(collaborationMode, modelPickerId, reasoningEffort),
-                personality: params.personality === undefined ? before.personality : params.personality,
-                outputSchema: outputSchema === undefined ? before.outputSchema : outputSchema,
-            };
-            update = await this.sessions.submit(params.threadId, {
-                type: "updateDesiredSettings",
-                expectedGeneration: settingsGeneration(before),
-                candidate,
-                threadSettings: threadSettings(candidate),
-            });
-            if (!update.conflict)
-                break;
-            await update.retryAfter;
-        }
-        if (!update.changed) {
-            if (syncCanonicalSettings) {
-                await this.sessions.submit(params.threadId, {
-                    type: "publishThreadSettings",
-                    threadSettings: threadSettings(update.record),
-                });
-            }
-            return;
-        }
-        const updated = update.record;
-        if (updated.thread.ephemeral && update.replacementId && update.replay) {
-            try {
-                await session.replaceEphemeralRuntime(update.replay, update.replacementId);
-            }
-            catch (error) {
-                await this.discardThreadSilently(params.threadId).catch(() => undefined);
-                throw error;
-            }
-        }
-    }
-    /**
-     * Resolves requested model settings against the account catalog. A model id the catalog no longer
-     * lists is migrated onto its closest current entry instead of failing the request, and an effort the
-     * target model does not support is coerced to that model's default unless it was requested explicitly.
-     */
-    async resolveModelSettings(modelPickerId, effort, serviceTier, explicitEffort = false) {
-        const claudeModelValue = resolveClaudeModel(this.config, modelPickerId);
-        if (!this.modelCatalog)
-            return { modelPickerId, claudeModelValue, reasoningEffort: effort, serviceTier };
-        const lookup = this.catalogLookup(await this.modelCatalog.list(), claudeModelValue);
-        const model = lookup?.model;
-        if (!lookup || !model)
-            throw invalidParams(`Claude model '${modelPickerId}' is not present in the current account catalog.`);
-        const selection = this.catalogSelection(modelPickerId, claudeModelValue, lookup);
-        const effortSupported = !effort || model.supportedReasoningEfforts.some((level) => level.reasoningEffort === effort);
-        if (!effortSupported && explicitEffort && selection.modelPickerId === modelPickerId)
-            throw invalidParams(`Claude model '${modelPickerId}' does not support effort '${effort}'.`);
-        if (!effortSupported)
-            this.logger.warn("claude.effort.coerced", { model: model.id, from: effort, to: model.defaultReasoningEffort });
-        return {
-            ...selection,
-            reasoningEffort: effortSupported ? effort : model.supportedReasoningEfforts.length ? model.defaultReasoningEffort : null,
-            serviceTier: serviceTier === "fast" && !model.serviceTiers.some((tier) => tier.id === "fast") ? null : serviceTier,
-        };
-    }
-    async readStandaloneRateLimitStatus() {
-        const abort = new AbortController();
-        const sdkQuery = this.queryFactory({
-            prompt: idleUsagePrompt(abort.signal),
-            options: {
-                pathToClaudeCodeExecutable: this.config.claudeBinary,
-                persistSession: false,
-                abortController: abort,
-                allowedTools: [],
-                settingSources: ["user", "project", "local"],
-                env: claudeEnvironment(),
-                stderr: (line) => this.logger.debug("claude.usage-probe.stderr", { output: line }),
-            },
-        });
-        let generation;
-        let timer;
-        try {
-            const timeout = new Promise((_, reject) => {
-                timer = setTimeout(() => reject(new Error("Claude usage probe timed out.")), 10_000);
-                timer.unref();
-            });
-            await Promise.race([sdkQuery.initializationResult(), timeout]);
-            generation = this.rateLimits.register(sdkQuery);
-            return await this.rateLimits.readStatus();
-        }
-        finally {
-            if (timer)
-                clearTimeout(timer);
-            if (generation !== undefined)
-                this.rateLimits.unregister(generation);
-            abort.abort();
-            await Promise.resolve(sdkQuery.close()).catch(() => undefined);
-        }
-    }
-    async completeCommandTurn(threadId, turnId, synthetic, render) {
-        let completion;
-        try {
-            completion = {
-                type: "completeSynthetic", turnId,
-                text: await render(),
-                status: "completed", codexErrorInfo: null,
-            };
-        }
-        catch (cause) {
-            const message = cause instanceof Error ? cause.message : String(cause);
-            completion = {
-                type: "completeSynthetic", turnId,
-                text: systemNoticeText(`${synthetic === "status" ? "Unable to read Claude usage" : "Unable to read thread state"}: ${message}`, "error"),
-                status: "failed", errorMessage: message, codexErrorInfo: "internalServerError",
-            };
-        }
-        await this.sessions.submit(threadId, completion).catch(() => undefined);
-    }
-    async failStatusTurnForUnload(threadId, message) {
-        await this.sessions.submit(threadId, {
-            type: "completeSynthetic", text: systemNoticeText(message, "error"),
-            status: "failed", errorMessage: message,
-            codexErrorInfo: { responseStreamDisconnected: { httpStatusCode: null } },
-        });
-    }
-}
-//# sourceMappingURL=service.js.map