@gkorepanov/ccodex 0.3.0 → 0.4.0

package/dist/claude/service.js

@@ -1,16 +1,35 @@
 import { join, resolve } from "node:path";
 import { statSync } from "node:fs";
-import { spawn } from "node:child_process";
-import { deleteSession, forkSession, getSessionMessages, renameSession } from "@anthropic-ai/claude-agent-sdk";
+import { deleteSession, renameSession, } from "@anthropic-ai/claude-agent-sdk";
 import { v7 as uuidv7 } from "uuid";
+import { settingsGeneration } from "../store/HybridStore.js";
 import { SqliteHybridStore } from "../store/sqliteStore.js";
 import { LayeredHybridStore } from "../store/memoryStore.js";
-import { ClaudeSessionRuntime } from "./sessionRuntime.js";
 import { createClaudeQuery } from "./queryFactory.js";
-import { InteractionBridge } from "./interactions.js";
 import { invalidParams } from "../protocol/errors.js";
 import { MetricsRegistry } from "../observability/metrics.js";
+import { SdkTranscriptBrancher } from "./transcriptBrancher.js";
+import { ClaudeRateLimitCoordinator, } from "./rateLimits.js";
+import { isClaudeStatusCommand } from "./statusCommand.js";
+import { systemNoticeText } from "../gateway/transientNotice.js";
 import { claudeCatalogId, normalizeClaudeServiceTier, resolveClaudeModel, } from "./modelSelection.js";
+import { ClaudeOutputAdapter } from "./session/outputAdapter.js";
+import { branchRevision, ClaudeSessionRepository } from "./session/repository.js";
+import { 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";
+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);
 }
@@ -26,6 +45,16 @@ function existingThreadCwd(value) {
     }
     throw invalidParams(`Claude thread cwd '${cwd}' does not exist or is not a directory.`);
 }
+function syncedCollaborationMode(value, model, effort) {
+    const mode = (value ?? {
+        mode: "default",
+        settings: { model, reasoning_effort: effort, developer_instructions: null },
+    });
+    return { ...mode, settings: { ...mode.settings, model, reasoning_effort: effort } };
+}
+function turnReasoningEffort(params) {
+    return params.collaborationMode?.settings.reasoning_effort ?? params.effort ?? undefined;
+}
 function sandboxPolicy(mode, cwd) {
     if (mode === "read-only")
         return { type: "readOnly", networkAccess: false };
@@ -48,44 +77,119 @@ function permissionProfileSandboxPolicy(profile, cwd) {
         return sandboxPolicy("danger-full-access", cwd);
     throw invalidParams(`Claude threads do not support Codex permission profile '${profile}'.`);
 }
+function activePermissionProfile(policy) {
+    if (policy.type === "readOnly")
+        return { id: ":read-only", extends: null };
+    if (policy.type === "workspaceWrite")
+        return { id: ":workspace", extends: null };
+    if (policy.type === "dangerFullAccess")
+        return { id: ":danger-full-access", extends: null };
+    return null;
+}
 function approvalsReviewer(value, fallback = "user") {
     return value ?? fallback;
 }
-function threadResponse(record, includeTurns) {
+function threadSettings(record) {
+    const sandboxPolicy = record.sandboxPolicy;
     return {
-        thread: { ...record.thread, turns: includeTurns ? record.thread.turns : [] },
+        cwd: record.thread.cwd,
+        approvalPolicy: record.approvalPolicy,
+        approvalsReviewer: record.approvalsReviewer,
+        sandboxPolicy,
+        activePermissionProfile: activePermissionProfile(sandboxPolicy),
         model: record.modelPickerId,
         modelProvider: "claude",
         serviceTier: record.serviceTier,
-        cwd: record.thread.cwd,
+        effort: record.reasoningEffort,
+        summary: record.reasoningSummary,
+        collaborationMode: syncedCollaborationMode(record.collaborationMode, record.modelPickerId, record.reasoningEffort),
+        multiAgentMode: "explicitRequestOnly",
+        personality: record.personality,
+    };
+}
+function threadResponse(record, includeTurns) {
+    const { sandboxPolicy: sandbox, effort: reasoningEffort, summary: _summary, collaborationMode: _collaborationMode, personality: _personality, ...settings } = threadSettings(record);
+    return {
+        ...settings,
+        thread: { ...record.thread, turns: includeTurns ? record.thread.turns : [] },
         runtimeWorkspaceRoots: [record.thread.cwd],
         instructionSources: [],
-        approvalPolicy: record.approvalPolicy,
-        approvalsReviewer: record.approvalsReviewer,
-        sandbox: record.sandboxPolicy,
-        activePermissionProfile: null,
-        reasoningEffort: record.reasoningEffort,
-        multiAgentMode: "explicitRequestOnly",
+        sandbox,
+        reasoningEffort,
     };
 }
 function clonedTurn(turn) {
     return structuredClone(turn);
 }
-function failedAfterCrash(turn) {
-    const completedAt = nowSeconds();
+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 {
-        ...turn,
-        items: turn.items.map((item) => "status" in item && item.status === "inProgress" ? { ...item, status: "failed" } : item),
-        status: "failed",
-        completedAt,
-        durationMs: turn.startedAt === null ? null : Math.max(0, (completedAt - turn.startedAt) * 1_000),
-        error: {
-            message: "Gateway restarted while the Claude turn was active.",
-            codexErrorInfo: { responseStreamDisconnected: { httpStatusCode: null } },
-            additionalDetails: null,
+        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;
@@ -93,22 +197,100 @@ export class ClaudeService {
     queryFactory;
     modelCatalog;
     metrics;
-    runtimes = new Map();
+    transcripts;
+    threadAdminEffects;
+    availabilityProbe;
+    ephemeralReleases = new Map();
+    ephemeralReleaseTimers = new Map();
+    removalRetries = new Map();
+    terminalAdmins = new Map();
     idleTimer;
     store;
-    interactions;
+    sessionOutput;
+    sessions;
+    rateLimits;
     idleSweep = Promise.resolve();
-    constructor(config, hub, logger, durableStore = new SqliteHybridStore(join(config.dataDir, "state.sqlite")), queryFactory = createClaudeQuery, modelCatalog, metrics = new MetricsRegistry()) {
+    restartRecovery;
+    closing = false;
+    closePromise;
+    standaloneStatusRead;
+    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",
+    })) {
         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.store = new LayeredHybridStore(durableStore);
-        this.interactions = new InteractionBridge(this.store, hub, metrics);
-        this.reconcileAfterRestart();
+        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, undefined, (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?.(),
+            isClosing: () => this.closing,
+        }));
+        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))
+            .then(() => {
+            for (const record of this.store.allThreadRecords()) {
+                if (record.thread.ephemeral && !record.thread.parentThreadId) {
+                    this.scheduleEphemeralRelease(record.thread.id);
+                }
+            }
+        });
         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);
             }
@@ -122,147 +304,120 @@ export class ClaudeService {
     ownsThread(threadId) {
         return this.store.hasThread(threadId);
     }
+    ready() {
+        return this.restartRecovery;
+    }
     ownsModel(modelId) {
         return resolveClaudeModel(this.config, modelId) !== undefined;
     }
-    handoffSource(threadId, lastTurnId) {
-        const record = this.requireRecord(threadId, true);
+    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
-            ? record.thread.turns.findIndex((turn) => turn.id === lastTurnId)
-            : record.thread.turns.length - 1;
+            ? 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: record.thread,
-            turns: record.thread.turns.slice(0, through + 1),
-            settings: this.threadSettings(record),
+            thread: { ...snapshot.record.thread, turns },
+            turns,
+            settings: threadSettings(snapshot.record),
         };
     }
     currentThreadSettings(threadId) {
-        return this.threadSettings(this.requireRecord(threadId, false));
+        return threadSettings(this.requireRecord(threadId, false));
     }
     loadedThreadIds() {
-        return [...this.runtimes.keys()].filter((threadId) => !this.hub.isSuppressed(threadId));
-    }
-    reportError(threadId, requestedTurnId, message, codexErrorInfo) {
-        const record = this.requireRecord(threadId, false);
-        const turnId = requestedTurnId
-            ?? this.runtimes.get(threadId)?.activeTurnId
-            ?? record.lastCompletedTurnId
-            ?? uuidv7();
-        const params = {
-            error: { message, codexErrorInfo, additionalDetails: null },
-            willRetry: false,
-            threadId,
-            turnId,
-        };
-        this.emit(threadId, turnId, "error", params);
-    }
-    async startThread(params) {
-        const modelPickerId = params.model;
-        const claudeModelValue = modelPickerId && resolveClaudeModel(this.config, modelPickerId);
-        if (!modelPickerId || !claudeModelValue) {
-            throw invalidParams("Claude thread requires a configured Claude model or alias.");
-        }
-        if (params.permissions && params.sandbox) {
-            throw invalidParams("Claude thread start cannot combine permissions with sandbox.");
-        }
-        const serviceTier = normalizeClaudeServiceTier(this.config, modelPickerId, params.serviceTier);
-        if (serviceTier !== null && serviceTier !== "default" && serviceTier !== "fast") {
-            throw invalidParams(`Unsupported Claude service tier '${serviceTier}'.`);
+        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));
+            }
         }
-        await this.validateModelSettings(modelPickerId, null, serviceTier);
-        const createdAt = nowSeconds();
-        const cwd = existingThreadCwd(params.cwd ?? process.cwd());
-        const thread = {
-            id: uuidv7(),
-            extra: null,
-            sessionId: uuidv7(),
-            forkedFromId: null,
-            parentThreadId: null,
-            preview: "",
-            ephemeral: params.ephemeral ?? false,
-            historyMode: params.historyMode ?? "legacy",
-            modelProvider: "claude",
-            createdAt,
-            updatedAt: createdAt,
-            recencyAt: createdAt,
-            status: { type: "notLoaded" },
-            path: null,
-            cwd,
-            cliVersion: "claude-code",
-            source: "appServer",
-            threadSource: params.threadSource ?? null,
-            agentNickname: null,
-            agentRole: null,
-            gitInfo: null,
-            name: null,
-            turns: [],
-        };
-        let record = {
-            thread,
-            claudeSessionId: uuidv7(),
-            modelPickerId,
-            claudeModelValue,
-            serviceTier,
-            approvalPolicy: params.approvalPolicy ?? "on-request",
-            approvalsReviewer: approvalsReviewer(params.approvalsReviewer),
-            sandboxPolicy: params.permissions
-                ? permissionProfileSandboxPolicy(params.permissions, cwd)
-                : sandboxPolicy(params.sandbox, cwd),
-            baseInstructions: params.baseInstructions ?? null,
-            developerInstructions: params.developerInstructions ?? null,
-            personality: params.personality ?? null,
-            resolvedModel: null,
-            lastClaudeMessageUuid: null,
-            lastCompletedTurnId: null,
-            claudeCodeVersion: null,
-            reasoningEffort: null,
-            reasoningSummary: null,
-            collaborationMode: null,
-            outputSchema: null,
-            tokenUsageTotal: { totalTokens: 0, inputTokens: 0, cachedInputTokens: 0, outputTokens: 0, reasoningOutputTokens: 0 },
-        };
-        this.store.createThread(record);
+        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;
         try {
-            const runtime = await ClaudeSessionRuntime.create(record, this.store, this.hub, this.logger, this.config, false, this.queryFactory, this.interactions, () => this.modelCatalog?.invalidate?.(), this.metrics);
-            this.runtimes.set(thread.id, runtime);
-            this.metrics.runtimeLoaded(false);
-            record = { ...record, thread: { ...thread, status: { type: "idle" } } };
-            this.store.updateThread(record);
-            return threadResponse(record, false);
+            await this.sessions.submit(threadId, {
+                type: "reportError",
+                threadId,
+                ...(requestedTurnId ? { requestedTurnId } : {}),
+                message,
+                codexErrorInfo,
+            });
         }
         catch (error) {
-            if (/auth|oauth|model.?not.?found/i.test(String(error)))
-                this.modelCatalog?.invalidate?.();
-            this.store.deleteThread(thread.id);
-            throw error;
+            if (!this.closing && this.ownsThread(threadId))
+                throw error;
         }
     }
-    announceThread(thread) {
-        this.store.appendEvent(thread.id, null, "thread/started", { thread });
-        this.hub.emit(thread.id, "thread/started", { thread });
+    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 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}'.`);
-        const loaded = this.runtimes.get(threadId);
-        if (loaded) {
-            await loaded.reinitialize();
-        }
-        else {
-            if (record.thread.ephemeral)
-                throw invalidParams(`Ephemeral Claude thread '${threadId}' is no longer loaded.`);
-            const shouldResume = record.lastClaudeMessageUuid !== null;
-            const runtime = await ClaudeSessionRuntime.create(record, this.store, this.hub, this.logger, this.config, shouldResume, this.queryFactory, this.interactions, () => this.modelCatalog?.invalidate?.(), this.metrics);
-            this.runtimes.set(threadId, runtime);
-            this.metrics.runtimeLoaded(shouldResume);
-            record = { ...record, thread: { ...record.thread, status: { type: "idle" } } };
-            this.store.updateThread(record);
+        if (record.thread.parentThreadId) {
+            return {
+                ...threadResponse(record, !resume.excludeTurns),
+                initialTurnsPage: resume.initialTurnsPage
+                    ? this.turnsPage({
+                        threadId,
+                        ...(resume.initialTurnsPage.limit !== undefined ? { limit: resume.initialTurnsPage.limit } : {}),
+                        ...(resume.initialTurnsPage.sortDirection !== undefined ? { sortDirection: resume.initialTurnsPage.sortDirection } : {}),
+                        ...(resume.initialTurnsPage.itemsView !== undefined ? { itemsView: resume.initialTurnsPage.itemsView } : {}),
+                    })
+                    : null,
+            };
         }
+        await (await this.sessions.getOrCreate(threadId)).materializeRuntime();
+        record = await this.sessions.submit(threadId, { type: "readThread", includeTurns: true });
         return {
             ...threadResponse(record, !resume.excludeTurns),
             initialTurnsPage: resume.initialTurnsPage
@@ -275,37 +430,226 @@ export class ClaudeService {
                 : 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: record.thread };
     }
-    async prepareTurn(params) {
-        await this.applyTurnOverrides(params);
-        const runtime = await this.requireRuntime(params.threadId);
-        const prepared = await runtime.prepareTurn(params);
-        return { response: { turn: prepared.turn }, announce: prepared.announce, start: prepared.start };
+    async prepareTurn(params, review) {
+        this.requireIndependentThread(params.threadId, "start a turn in");
+        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: 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 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 interruptTurn(threadId) {
-        await (await this.requireRuntime(threadId)).interrupt();
+    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.requireRuntime(params.threadId)).steer(params) };
+        return { turnId: await (await this.sessions.getOrCreate(params.threadId)).steerRuntime(params) };
     }
     async compactThread(threadId) {
-        await (await this.requireRuntime(threadId)).compact();
+        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) {
-        await this.applySettings(params, false);
+        this.requireIndependentThread(params.threadId, "update settings for");
+        await this.applySettings(params);
         return {};
     }
     async injectItems(params) {
-        await (await this.requireRuntime(params.threadId)).injectItems(params.items);
+        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,
@@ -318,153 +662,63 @@ export class ClaudeService {
             threadSource: "subAgent",
         });
         const temporaryId = started.thread.id;
-        this.hub.suppress(temporaryId);
-        try {
-            const prepared = await this.prepareTurn({
-                threadId: temporaryId,
-                input: [{ type: "text", text: prompt, text_elements: [] }],
-            });
-            prepared.announce();
-            prepared.start();
-            const completed = await new Promise((resolve, reject) => {
-                const timeout = setTimeout(() => {
-                    clearInterval(poll);
-                    reject(new Error("Claude compact handoff timed out."));
-                }, 120_000);
-                const poll = setInterval(() => {
-                    const turn = this.store.listTurns(temporaryId).at(-1);
-                    if (!turn || turn.status === "inProgress")
-                        return;
-                    clearTimeout(timeout);
-                    clearInterval(poll);
-                    if (turn.status !== "completed")
-                        reject(new Error(turn.error?.message ?? "Claude compact handoff failed."));
-                    else
-                        resolve(turn);
-                }, 25);
-            });
-            const text = completed.items.flatMap((item) => item.type === "agentMessage" ? [item.text] : []).join("\n").trim();
-            if (!text)
-                throw new Error("Claude compact handoff returned no text.");
-            return text;
-        }
-        finally {
-            await this.discardThreadSilently(temporaryId);
-            this.hub.unsuppress(temporaryId);
-        }
-    }
-    async createHandoffFork(params, sourceThread, inheritedTurns, settings, developerInstructions, targetName) {
-        if (!params.model || !this.ownsModel(params.model))
-            throw invalidParams("Claude handoff fork requires a Claude target model.");
-        const started = await this.startThread({
-            model: params.model,
-            modelProvider: "claude",
-            cwd: params.cwd ?? sourceThread.cwd,
-            developerInstructions,
-            ...(params.serviceTier !== undefined ? { serviceTier: params.serviceTier } : {}),
-            ...(params.approvalPolicy !== undefined ? { approvalPolicy: params.approvalPolicy } : {}),
-            ...(params.approvalsReviewer !== undefined ? { approvalsReviewer: params.approvalsReviewer } : {}),
-            ...(params.sandbox !== undefined ? { sandbox: params.sandbox } : {}),
-            ...(params.permissions !== undefined ? { permissions: params.permissions } : {}),
-            ...(params.config !== undefined ? { config: params.config } : {}),
-            ...(params.baseInstructions !== undefined ? { baseInstructions: params.baseInstructions } : {}),
-            ...(settings.personality !== undefined ? { personality: settings.personality } : {}),
-            ...(params.ephemeral !== undefined ? { ephemeral: params.ephemeral } : {}),
-            ...(params.threadSource !== undefined ? { threadSource: params.threadSource } : {}),
+        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);
+            }
         });
-        let current = this.requireRecord(started.thread.id, false);
-        const configured = {
-            ...current,
-            reasoningEffort: settings.effort === undefined ? current.reasoningEffort : settings.effort,
-            reasoningSummary: settings.summary === undefined ? current.reasoningSummary : settings.summary,
-            collaborationMode: settings.collaborationMode === undefined ? current.collaborationMode : settings.collaborationMode,
-        };
-        await this.validateModelSettings(configured.modelPickerId, configured.reasoningEffort, configured.serviceTier);
-        if (["reasoningEffort", "reasoningSummary", "collaborationMode"].some((key) => JSON.stringify(configured[key]) !== JSON.stringify(current[key]))) {
-            await this.unloadRuntime(started.thread.id, "Fresh handoff target settings applied.");
-            this.store.updateThread(configured);
-            const runtime = await ClaudeSessionRuntime.create(configured, this.store, this.hub, this.logger, this.config, false, this.queryFactory, this.interactions, () => this.modelCatalog?.invalidate?.(), this.metrics);
-            this.runtimes.set(started.thread.id, runtime);
-            this.metrics.runtimeLoaded(false);
-            current = { ...configured, thread: { ...configured.thread, status: { type: "idle" } } };
-            this.store.updateThread(current);
-        }
-        const now = nowSeconds();
-        const updated = {
-            ...current,
-            lastCompletedTurnId: inheritedTurns.at(-1)?.id ?? null,
-            thread: {
-                ...current.thread,
-                forkedFromId: sourceThread.id,
-                preview: sourceThread.preview,
-                name: targetName,
-                updatedAt: now,
-                recencyAt: now,
-            },
-        };
-        this.store.updateThread(updated);
-        for (const turn of inheritedTurns)
-            this.store.createTurn(updated.thread.id, clonedTurn(turn));
-        this.runtimes.get(updated.thread.id)?.synchronizeRecord(updated);
-        return threadResponse({ ...updated, thread: { ...updated.thread, turns: inheritedTurns } }, !params.excludeTurns);
     }
     async shellCommand(params) {
-        const runtime = this.runtimes.get(params.threadId);
-        if (runtime?.isActive)
-            throw invalidParams("Cannot run a thread shell command during an active Claude turn.");
-        const record = this.requireRecord(params.threadId, false);
-        const now = nowSeconds();
-        let item = {
-            type: "commandExecution", id: uuidv7(), command: params.command, cwd: record.thread.cwd,
-            processId: null, source: "userShell", status: "inProgress", commandActions: [],
-            aggregatedOutput: "", exitCode: null, durationMs: null,
-        };
-        let turn = {
-            id: uuidv7(), items: [item], itemsView: "full", status: "inProgress", error: null,
-            startedAt: now, completedAt: null, durationMs: null,
-        };
-        this.store.createTurn(params.threadId, turn);
-        this.store.updateThread({ ...record, thread: { ...record.thread, status: { type: "active", activeFlags: [] }, updatedAt: now } });
-        this.emit(params.threadId, turn.id, "turn/started", { threadId: params.threadId, turn });
-        this.emit(params.threadId, turn.id, "item/started", { item, threadId: params.threadId, turnId: turn.id, startedAtMs: Date.now() });
-        const startedAt = Date.now();
-        const child = spawn(process.env.SHELL ?? "/bin/sh", ["-lc", params.command], { cwd: record.thread.cwd, env: process.env });
-        const append = (bytes) => {
-            const delta = bytes.toString();
-            if (item.type !== "commandExecution")
-                return;
-            item = { ...item, aggregatedOutput: `${item.aggregatedOutput ?? ""}${delta}` };
-            turn = { ...turn, items: [item] };
-            this.store.updateTurn(params.threadId, turn);
-            this.emit(params.threadId, turn.id, "item/commandExecution/outputDelta", { threadId: params.threadId, turnId: turn.id, itemId: item.id, delta });
-        };
-        child.stdout.on("data", append);
-        child.stderr.on("data", append);
-        const exitCode = await new Promise((done, reject) => {
-            child.once("error", reject);
-            child.once("close", (code) => done(code ?? 1));
-        });
-        const completedAt = nowSeconds();
-        item = { ...item, status: exitCode === 0 ? "completed" : "failed", exitCode, durationMs: Date.now() - startedAt };
-        turn = {
-            ...turn, items: [item], status: exitCode === 0 ? "completed" : "failed",
-            completedAt, durationMs: Date.now() - startedAt,
-            error: exitCode === 0 ? null : { message: `Shell command exited with code ${exitCode}.`, codexErrorInfo: null, additionalDetails: null },
-        };
-        this.store.updateTurn(params.threadId, turn);
-        const current = this.requireRecord(params.threadId, false);
-        const updatedRecord = {
-            ...current,
-            lastCompletedTurnId: turn.id,
-            thread: { ...current.thread, status: { type: "idle" }, updatedAt: completedAt, recencyAt: completedAt },
-        };
-        this.store.updateThread(updatedRecord);
-        runtime?.synchronizeRecord(updatedRecord);
-        this.emit(params.threadId, turn.id, "item/completed", { item, threadId: params.threadId, turnId: turn.id, completedAtMs: Date.now() });
-        this.emit(params.threadId, turn.id, "turn/completed", { threadId: params.threadId, turn });
+        this.requireIndependentThread(params.threadId, "run a shell command in");
+        await this.sessions.submit(params.threadId, { type: "runShell", command: params.command });
         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") {
@@ -472,37 +726,41 @@ export class ClaudeService {
             reviewThreadId = fork.thread.id;
             forkedThread = fork.thread;
         }
-        const review = params.target.type === "uncommittedChanges"
-            ? "uncommitted changes"
-            : params.target.type === "baseBranch"
-                ? `changes against base branch ${params.target.branch}`
-                : params.target.type === "commit"
-                    ? `commit ${params.target.sha}${params.target.title ? ` (${params.target.title})` : ""}`
-                    : "custom review";
-        const prompt = params.target.type === "custom"
-            ? params.target.instructions
-            : `Review ${review}. Inspect the repository and report concrete bugs, regressions, and risks with file and line references. Do not modify files.`;
-        await this.applySettings({
-            threadId: reviewThreadId,
-            sandboxPolicy: { type: "readOnly", networkAccess: false },
-            approvalsReviewer: "user",
-        }, true);
-        const runtime = await this.requireRuntime(reviewThreadId);
-        const prepared = await runtime.prepareTurn({
-            threadId: reviewThreadId,
-            input: [{ type: "text", text: prompt, text_elements: [] }],
-        }, review);
-        return {
-            response: { turn: prepared.turn, reviewThreadId },
-            announce: prepared.announce,
-            start: prepared.start,
-            ...(forkedThread ? { forkedThread } : {}),
-        };
+        try {
+            const prepared = await this.prepareTurn({
+                threadId: reviewThreadId,
+                input: [{ type: "text", text: prompt, text_elements: [] }],
+            }, { label: review, display: review });
+            const userItem = prepared.response.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);
         const turns = this.listTurns(params.threadId);
         const ordered = params.sortDirection === "asc" ? turns : [...turns].reverse();
         if (params.cursor && !params.cursor.startsWith("hyb-turn:"))
@@ -524,61 +782,133 @@ export class ClaudeService {
         };
     }
     listThreads(params) {
-        return this.store.listThreads(params).filter((thread) => !this.hub.isSuppressed(thread.id));
+        return this.store.listThreads(params)
+            .filter((thread) => !this.pendingThreadRemoval(thread.id) && !this.hub.isSuppressed(thread.id));
     }
     async setThreadName(params) {
         const record = this.requireRecord(params.threadId, false);
-        if (!record.thread.ephemeral && record.lastCompletedTurnId) {
-            await renameSession(record.claudeSessionId, params.name, { dir: record.thread.cwd });
+        if (record.thread.parentThreadId) {
+            await this.sessions.submit(params.threadId, {
+                type: "threadAdmin",
+                command: { kind: "renameProjection", threadId: params.threadId, name: params.name },
+            });
+            return {};
         }
-        const updated = { ...record, thread: { ...record.thread, name: params.name, updatedAt: nowSeconds() } };
-        this.store.updateThread(updated);
-        this.runtimes.get(params.threadId)?.synchronizeRecord(updated);
-        this.hub.emit(params.threadId, "thread/name/updated", { threadId: params.threadId, threadName: params.name });
+        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);
         return {};
     }
     updateThreadMetadata(params) {
-        const record = this.requireRecord(params.threadId, false);
-        const previous = record.thread.gitInfo ?? { sha: null, branch: null, originUrl: null };
-        const patch = params.gitInfo;
-        const gitInfo = patch === null ? null : patch === undefined ? record.thread.gitInfo : {
-            sha: patch.sha === undefined ? previous.sha : patch.sha,
-            branch: patch.branch === undefined ? previous.branch : patch.branch,
-            originUrl: patch.originUrl === undefined ? previous.originUrl : patch.originUrl,
-        };
-        const updated = { ...record, thread: { ...record.thread, gitInfo, updatedAt: nowSeconds() } };
-        this.store.updateThread(updated);
-        this.runtimes.get(params.threadId)?.synchronizeRecord(updated);
-        return { thread: updated.thread };
+        this.requireIndependentThread(params.threadId, "update metadata for");
+        return this.sessions.submit(params.threadId, {
+            type: "threadAdmin",
+            command: { kind: "metadata", gitInfo: params.gitInfo },
+        });
     }
     async archiveThread(threadId) {
-        const record = this.requireRecord(threadId, false);
-        if (!record.thread.ephemeral)
-            await this.unloadRuntime(threadId, "Claude thread archived during an active turn.");
-        this.store.setThreadArchived(threadId, true);
-        this.hub.emit(threadId, "thread/archived", { threadId });
-        return {};
+        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.requireRecord(threadId, false);
-        this.store.setThreadArchived(threadId, false);
-        const thread = this.requireRecord(threadId, false).thread;
-        this.hub.emit(threadId, "thread/unarchived", { threadId });
-        return { thread };
+        this.requireIndependentThread(threadId, "unarchive");
+        return this.sessions.submit(threadId, {
+            type: "threadAdmin",
+            command: { kind: "unarchive" },
+        });
     }
     async deleteThread(threadId) {
-        const record = this.requireRecord(threadId, false);
-        this.interactions.cancelThread(threadId);
-        await this.unloadRuntime(threadId, "Claude thread deleted during an active turn.");
-        await deleteSession(record.claudeSessionId, { dir: record.thread.cwd }).catch((error) => {
-            if (!String(error).toLocaleLowerCase().includes("not found"))
-                throw error;
-        });
-        this.store.deleteThread(threadId);
-        this.hub.emit(threadId, "thread/deleted", { threadId });
+        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)
+            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);
         const items = this.store.listTurns(params.threadId)
             .flatMap((turn) => params.turnId && turn.id !== params.turnId ? [] : turn.items);
         const ordered = params.sortDirection === "desc" ? [...items].reverse() : items;
@@ -598,350 +928,663 @@ export class ClaudeService {
     async forkThread(params) {
         if (params.path)
             throw invalidParams("Claude thread forks must use threadId, not a Codex rollout path.");
-        const source = this.requireRecord(params.threadId, true);
-        if (source.thread.ephemeral)
+        this.requireIndependentThread(params.threadId, "fork");
+        const source = await this.sessions.submit(params.threadId, { type: "snapshotBranch" });
+        const sourceRecord = source.record;
+        if (sourceRecord.thread.ephemeral)
             throw invalidParams("Forking an ephemeral Claude source thread is not supported.");
-        if (this.runtimes.get(params.threadId)?.isActive)
-            throw invalidParams("Cannot fork a Claude thread with an active turn.");
-        const modelPickerId = params.model ?? source.modelPickerId;
+        const modelPickerId = params.model ?? sourceRecord.modelPickerId;
         const claudeModelValue = resolveClaudeModel(this.config, modelPickerId);
         if (!claudeModelValue)
             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);
         if (params.permissions && params.sandbox)
             throw invalidParams("Claude thread fork cannot combine permissions with sandbox.");
-        const serviceTier = normalizeClaudeServiceTier(this.config, modelPickerId, params.serviceTier === undefined ? source.serviceTier : params.serviceTier);
-        await this.validateModelSettings(modelPickerId, source.reasoningEffort, serviceTier);
-        const through = params.lastTurnId
-            ? source.thread.turns.findIndex((turn) => turn.id === params.lastTurnId)
-            : source.thread.turns.length - 1;
-        if (params.lastTurnId && through < 0)
+        const activeIndex = sourceRecord.thread.turns.findIndex((turn) => turn.status === "inProgress");
+        const selectedIndex = params.lastTurnId
+            ? sourceRecord.thread.turns.findIndex((turn) => turn.id === params.lastTurnId)
+            : -1;
+        if (params.lastTurnId && selectedIndex < 0)
             throw invalidParams(`Unknown Claude turn '${params.lastTurnId}'.`);
-        if (through >= 0 && source.thread.turns[through]?.status === "inProgress")
-            throw invalidParams("Cannot fork through an active turn.");
-        const sourceTurns = source.thread.turns.slice(0, through + 1);
-        const boundary = this.lastProviderBoundary(source.thread.id, sourceTurns);
-        const branch = await this.forkTranscript(source, boundary);
+        const 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
+            ? activeIndex >= 0 ? activeIndex - 1 : sourceRecord.thread.turns.length - 1
+            : params.lastTurnId
+                ? selectedIndex
+                : sourceRecord.thread.turns.length - 1;
+        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 serviceTier = normalizeClaudeServiceTier(this.config, modelPickerId, params.serviceTier === undefined ? sourceRecord.serviceTier : params.serviceTier);
+        await this.validateModelSettings(modelPickerId, sourceRecord.reasoningEffort, serviceTier);
+        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))
+            : { 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 = existingThreadCwd(params.cwd ?? source.thread.cwd);
+        const cwd = existingThreadCwd(params.cwd ?? sourceRecord.thread.cwd);
         const thread = {
-            ...source.thread,
-            id: uuidv7(),
-            ephemeral: params.ephemeral ?? false,
-            sessionId: source.thread.sessionId,
-            forkedFromId: source.thread.id,
-            cwd,
-            modelProvider: "claude",
-            createdAt,
-            updatedAt: createdAt,
-            recencyAt: createdAt,
-            status: { type: "notLoaded" },
-            name: source.thread.name ? `${source.thread.name} (fork)` : null,
-            threadSource: params.threadSource ?? source.thread.threadSource,
-            turns: [],
+            ...sourceRecord.thread, id: uuidv7(), ephemeral: params.ephemeral ?? false,
+            sessionId: sourceRecord.thread.sessionId, forkedFromId: sourceRecord.thread.id,
+            cwd, modelProvider: "claude", createdAt, updatedAt: createdAt, recencyAt: createdAt,
+            status: params.ephemeral ? { type: "idle" } : { type: "notLoaded" },
+            name: sourceRecord.thread.name ? `${sourceRecord.thread.name} (fork)` : null,
+            threadSource: params.threadSource ?? sourceRecord.thread.threadSource, turns: [],
         };
-        const copiedTurns = sourceTurns.map(clonedTurn);
+        const copiedTurns = sourceTurns.map((turn) => forkProjection(turn, thread.id));
         const record = {
-            ...source,
-            thread,
-            claudeSessionId: branch.sessionId,
-            modelPickerId,
-            claudeModelValue,
-            serviceTier,
-            approvalPolicy: params.approvalPolicy ?? source.approvalPolicy,
-            approvalsReviewer: approvalsReviewer(params.approvalsReviewer, source.approvalsReviewer),
+            ...sourceRecord, thread, claudeSessionId: branch.sessionId, modelPickerId, claudeModelValue, serviceTier,
+            approvalPolicy: params.approvalPolicy ?? sourceRecord.approvalPolicy,
+            approvalsReviewer: approvalsReviewer(params.approvalsReviewer, sourceRecord.approvalsReviewer),
             sandboxPolicy: params.permissions
                 ? permissionProfileSandboxPolicy(params.permissions, cwd)
-                : params.sandbox
-                    ? sandboxPolicy(params.sandbox, cwd)
-                    : source.sandboxPolicy,
-            baseInstructions: params.baseInstructions === undefined ? source.baseInstructions : params.baseInstructions,
-            developerInstructions: params.developerInstructions === undefined ? source.developerInstructions : params.developerInstructions,
-            lastClaudeMessageUuid: boundary ? branch.uuidMap.get(boundary) ?? null : null,
-            lastCompletedTurnId: copiedTurns.at(-1)?.id ?? null,
+                : params.sandbox ? sandboxPolicy(params.sandbox, cwd) : sourceRecord.sandboxPolicy,
+            baseInstructions: params.baseInstructions === undefined ? sourceRecord.baseInstructions : params.baseInstructions,
+            developerInstructions: params.developerInstructions === undefined
+                ? sourceRecord.developerInstructions : params.developerInstructions,
+            lastClaudeMessageUuid: null, lastCompletedTurnId: null,
         };
-        this.store.createThread(record);
-        for (let index = 0; index < copiedTurns.length; index += 1) {
-            const turn = copiedTurns[index];
-            this.store.createTurn(thread.id, turn);
-            const oldUuid = this.store.getTurnClaudeMessageUuid(source.thread.id, sourceTurns[index].id);
-            const newUuid = oldUuid && branch.uuidMap.get(oldUuid);
-            if (newUuid)
-                this.store.setTurnClaudeMessageUuid(thread.id, turn.id, newUuid);
-        }
-        let responseRecord = { ...record, thread: { ...thread, turns: copiedTurns } };
+        let responseRecord;
+        try {
+            responseRecord = await this.sessions.submit(thread.id, {
+                type: "commitForkTarget", record, turns: copiedTurns,
+                sourceBoundaries, uuidMap: [...branch.uuidMap],
+            });
+        }
+        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 runtime = await ClaudeSessionRuntime.create(responseRecord, this.store, this.hub, this.logger, this.config, boundary !== undefined, this.queryFactory, this.interactions, () => this.modelCatalog?.invalidate?.(), this.metrics);
-                this.runtimes.set(thread.id, runtime);
-                this.metrics.runtimeLoaded(boundary !== undefined);
-                responseRecord = { ...responseRecord, thread: { ...responseRecord.thread, status: { type: "idle" } } };
-                this.store.updateThread(responseRecord);
+                const targetSession = await this.sessions.getOrCreate(thread.id);
+                await targetSession.ensureRuntime();
+                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) {
-                this.store.deleteThread(thread.id);
-                await deleteSession(branch.sessionId, { dir: cwd }).catch(() => undefined);
+                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;
             }
         }
-        const response = threadResponse(responseRecord, !params.excludeTurns);
-        return response;
+        return threadResponse(responseRecord, !params.excludeTurns);
     }
     async rollbackThread(params) {
+        this.requireIndependentThread(params.threadId, "roll back");
+        const source = await this.sessions.submit(params.threadId, { type: "snapshotBranch" });
+        const sourceRecord = source.record;
+        if (sourceRecord.thread.ephemeral)
+            throw invalidParams("Rolling back an ephemeral Claude thread is not supported.");
         if (!Number.isInteger(params.numTurns) || params.numTurns < 1)
             throw invalidParams("numTurns must be at least 1.");
-        const source = this.requireRecord(params.threadId, true);
-        if (source.thread.ephemeral)
-            throw invalidParams("Rolling back an ephemeral Claude thread is not supported.");
-        if (params.numTurns > source.thread.turns.length)
+        if (params.numTurns > sourceRecord.thread.turns.length)
             throw invalidParams("Cannot remove more turns than the Claude thread contains.");
-        if (this.runtimes.get(params.threadId)?.isActive)
+        const sourceSession = await this.sessions.getOrCreate(params.threadId);
+        if ((await sourceSession.runtimeInspection())?.quiescent === false)
             throw invalidParams("Cannot roll back a Claude thread with an active turn.");
-        const keepCount = source.thread.turns.length - params.numTurns;
-        const retained = source.thread.turns.slice(0, keepCount);
-        const boundary = this.lastProviderBoundary(params.threadId, retained);
-        const branch = await this.forkTranscript(source, boundary);
-        await this.unloadRuntime(params.threadId, "Claude thread rolled back.");
-        this.store.truncateTurns(params.threadId, keepCount);
-        for (const turn of retained) {
-            const oldUuid = this.store.getTurnClaudeMessageUuid(params.threadId, turn.id);
-            const newUuid = oldUuid && branch.uuidMap.get(oldUuid);
-            if (newUuid)
-                this.store.setTurnClaudeMessageUuid(params.threadId, turn.id, newUuid);
-        }
-        const current = this.requireRecord(params.threadId, false);
-        const updated = {
-            ...current,
-            claudeSessionId: branch.sessionId,
-            lastClaudeMessageUuid: boundary ? branch.uuidMap.get(boundary) ?? null : null,
-            lastCompletedTurnId: retained.at(-1)?.id ?? null,
-            thread: { ...current.thread, status: { type: "notLoaded" }, updatedAt: nowSeconds(), recencyAt: nowSeconds() },
+        const keepCount = sourceRecord.thread.turns.length - params.numTurns;
+        const retained = sourceRecord.thread.turns.slice(0, keepCount);
+        const retainedIds = new Set(retained.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))
+            : { sessionId: uuidv7(), uuidMap: new Map() };
+        let committed;
+        try {
+            committed = await this.sessions.submit(params.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 (sourceSession.isLoaded) {
+            await sourceSession.retireRuntimeSilently().catch((error) => {
+                this.logger.warn("claude.rollback.old-runtime-retire-failed", { threadId: params.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: params.threadId, error: String(error) }));
+        return { thread: committed.thread };
+    }
+    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 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 } }),
         };
-        this.store.updateThread(updated);
-        await deleteSession(source.claudeSessionId, { dir: source.thread.cwd }).catch((error) => {
-            this.logger.warn("claude.rollback.old-session-delete-failed", { threadId: params.threadId, error: String(error) });
+    }
+    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,
         });
-        return { thread: { ...updated.thread, turns: retained } };
-    }
-    setGoal(params) {
-        this.requireRecord(params.threadId, false);
-        const now = nowSeconds();
-        const previous = this.currentGoal(params.threadId, now);
-        const goal = {
-            threadId: params.threadId,
-            objective: params.objective ?? previous?.objective ?? "",
-            status: params.status ?? previous?.status ?? "active",
-            tokenBudget: params.tokenBudget === undefined ? previous?.tokenBudget ?? null : params.tokenBudget,
-            tokensUsed: previous?.tokensUsed ?? 0,
-            timeUsedSeconds: previous?.timeUsedSeconds ?? 0,
-            createdAt: previous?.createdAt ?? now,
-            updatedAt: now,
-        };
-        this.store.setGoal(goal);
-        this.hub.emit(params.threadId, "thread/goal/updated", { threadId: params.threadId, turnId: null, goal });
-        return { goal };
     }
-    getGoal(threadId) {
-        this.requireRecord(threadId, false);
-        return { goal: this.currentGoal(threadId, nowSeconds()) ?? null };
+    replayPendingRequests(threadId, connectionId) {
+        this.assertThreadAvailable(threadId);
+        return this.sessions.submit(threadId, {
+            type: "replayInteractions",
+            ...(connectionId ? { connectionId } : {}),
+        });
     }
-    clearGoal(threadId) {
-        this.requireRecord(threadId, false);
-        const cleared = this.store.clearGoal(threadId);
-        if (cleared)
-            this.hub.emit(threadId, "thread/goal/cleared", { threadId });
-        return { cleared };
+    eventHighWatermark(threadId) {
+        this.assertThreadAvailable(threadId);
+        return this.store.eventHighWatermark(threadId);
     }
-    resolveServerRequest(requestId, response) {
-        return this.interactions.resolve(requestId, response);
+    eventsAfter(threadId, sequence) {
+        this.assertThreadAvailable(threadId);
+        return this.store.listEventsAfter(threadId, sequence);
     }
-    replayPendingRequests(threadId) {
-        this.interactions.replay(threadId);
+    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 close() {
+    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;
-        const runtimes = [...this.runtimes.values()];
-        await Promise.all(runtimes.map((runtime) => runtime.stop("Gateway shut down during an active Claude turn.")));
-        for (const _runtime of runtimes)
-            this.metrics.runtimeUnloaded();
-        this.runtimes.clear();
+        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) {
-        const record = this.store.getThreadRecord(threadId, false);
-        if (!record)
+        if (!this.store.getThreadRecord(threadId, false))
             return;
-        await this.unloadRuntime(threadId, "Internal compact handoff completed.");
-        this.store.deleteThread(threadId);
-        await deleteSession(record.claudeSessionId, { dir: record.thread.cwd }).catch(() => undefined);
+        await this.removeThread(threadId, "discard", "Internal compact handoff completed.");
     }
-    reconcileAfterRestart() {
-        for (const record of this.store.allThreadRecords()) {
-            const crashed = record.thread.turns.filter((turn) => turn.status === "inProgress").map(failedAfterCrash);
-            if (crashed.length > 0)
-                this.interactions.cancelThread(record.thread.id);
-            for (const turn of crashed) {
-                this.store.appendEvent(record.thread.id, turn.id, "turn/completed", { threadId: record.thread.id, turn }, {
-                    turn, dedupKey: `turn/completed:${turn.id}`,
+    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 },
                 });
-                this.metrics.turnCompleted("failed");
+                if (!committed)
+                    throw new Error(`Stale Claude ${kind} completion for thread '${threadId}'.`);
             }
-            const status = record.thread.status.type === "active" || crashed.length > 0
-                ? { type: "systemError" }
-                : { type: "notLoaded" };
-            this.store.updateThread({
-                ...record,
-                ...(crashed.length > 0 ? { lastCompletedTurnId: crashed.at(-1).id } : {}),
-                thread: { ...record.thread, status },
+            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, runtime] of this.runtimes) {
-            if (runtime.isEphemeral || !runtime.isIdleFor(idleMs))
+        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;
-            this.runtimes.delete(threadId);
-            await runtime.stop();
-            this.metrics.runtimeUnloaded();
-            this.logger.info("claude.runtime.unloaded", { threadId });
-        }
-    }
-    async requireRuntime(threadId) {
-        const loaded = this.runtimes.get(threadId);
-        if (loaded)
-            return loaded;
-        await this.resumeThread(threadId);
-        const runtime = this.runtimes.get(threadId);
-        if (!runtime)
-            throw new Error(`Failed to load Claude thread '${threadId}'.`);
-        return runtime;
+            }
+            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;
     }
-    lastProviderBoundary(threadId, turns) {
-        for (let index = turns.length - 1; index >= 0; index -= 1) {
-            const boundary = this.store.getTurnClaudeMessageUuid(threadId, turns[index].id);
-            if (boundary)
-                return boundary;
+    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.`);
         }
-        return undefined;
     }
-    async unloadRuntime(threadId, reason) {
-        const runtime = this.runtimes.get(threadId);
-        if (!runtime)
-            return;
-        this.runtimes.delete(threadId);
-        await runtime.stop(reason);
-        this.metrics.runtimeUnloaded();
+    isChildProjection(threadId) {
+        return Boolean(this.store.getThreadRecord(threadId, false)?.thread.parentThreadId);
     }
-    async applyTurnOverrides(params) {
-        const record = this.requireRecord(params.threadId, false);
-        const nextOutputSchema = params.outputSchema ?? null;
-        const outputSchema = JSON.stringify(record.outputSchema) === JSON.stringify(nextOutputSchema)
-            ? undefined
-            : nextOutputSchema;
-        await this.applySettings({
-            threadId: params.threadId,
-            ...(params.cwd !== undefined ? { cwd: params.cwd } : {}),
-            ...(params.approvalPolicy !== undefined ? { approvalPolicy: params.approvalPolicy } : {}),
-            ...(params.approvalsReviewer !== undefined ? { approvalsReviewer: params.approvalsReviewer } : {}),
-            ...(params.sandboxPolicy !== undefined ? { sandboxPolicy: params.sandboxPolicy } : {}),
-            ...(params.permissions !== undefined ? { permissions: params.permissions } : {}),
-            ...(params.model !== undefined ? { model: params.model } : {}),
-            ...(params.serviceTier !== undefined ? { serviceTier: params.serviceTier } : {}),
-            ...(params.effort !== undefined ? { effort: params.effort } : {}),
-            ...(params.summary !== undefined ? { summary: params.summary } : {}),
-            ...(params.collaborationMode !== undefined ? { collaborationMode: params.collaborationMode } : {}),
-            ...(params.personality !== undefined ? { personality: params.personality } : {}),
-        }, true, outputSchema);
-    }
-    async applySettings(params, turnOverride, outputSchema) {
-        const before = this.requireRecord(params.threadId, false);
-        if (params.permissions && params.sandboxPolicy) {
-            throw invalidParams("Claude thread settings cannot combine permissions with sandboxPolicy.");
-        }
-        if (params.model && !resolveClaudeModel(this.config, params.model))
-            throw invalidParams("Cannot switch a Claude thread to a Codex model.");
-        if (params.effort && !["low", "medium", "high", "xhigh", "max"].includes(params.effort)) {
-            throw invalidParams(`Unsupported Claude effort '${params.effort}'.`);
+    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);
         }
-        const modelPickerId = params.model ?? before.modelPickerId;
-        const claudeModelValue = resolveClaudeModel(this.config, modelPickerId);
-        if (!claudeModelValue)
-            throw invalidParams("Cannot switch a Claude thread to a Codex model.");
-        const serviceTier = normalizeClaudeServiceTier(this.config, modelPickerId, params.serviceTier === undefined ? before.serviceTier : params.serviceTier);
-        if (serviceTier !== null && serviceTier !== "default" && serviceTier !== "fast") {
-            throw invalidParams(`Unsupported Claude service tier '${serviceTier}'.`);
-        }
-        const cwd = existingThreadCwd(params.cwd ?? before.thread.cwd);
-        const selectedSandboxPolicy = params.permissions
-            ? permissionProfileSandboxPolicy(params.permissions, cwd)
-            : params.sandboxPolicy ?? before.sandboxPolicy;
-        const candidate = {
-            ...before,
-            thread: { ...before.thread, cwd },
+        return undefined;
+    }
+    async newThreadRecord(params, settings) {
+        const modelPickerId = params.model;
+        const claudeModelValue = modelPickerId && resolveClaudeModel(this.config, modelPickerId);
+        if (!modelPickerId || !claudeModelValue)
+            throw invalidParams("Claude thread requires a configured Claude model or alias.");
+        if (params.permissions && params.sandbox)
+            throw invalidParams("Claude thread start cannot combine permissions with sandbox.");
+        const requestedServiceTier = normalizeClaudeServiceTier(this.config, modelPickerId, params.serviceTier);
+        if (requestedServiceTier !== null && requestedServiceTier !== "default" && requestedServiceTier !== "fast")
+            throw invalidParams(`Unsupported Claude service tier '${requestedServiceTier}'.`);
+        const reasoningEffort = settings?.effort ?? null;
+        const serviceTier = await this.validatedServiceTier(modelPickerId, reasoningEffort, requestedServiceTier);
+        const createdAt = nowSeconds();
+        const cwd = existingThreadCwd(params.cwd ?? process.cwd());
+        return {
+            thread: {
+                id: uuidv7(),
+                extra: null,
+                sessionId: uuidv7(),
+                forkedFromId: null,
+                parentThreadId: null,
+                preview: "",
+                ephemeral: params.ephemeral ?? false,
+                historyMode: params.historyMode ?? "legacy",
+                modelProvider: "claude",
+                createdAt,
+                updatedAt: createdAt,
+                recencyAt: createdAt,
+                status: { type: "idle" },
+                path: null,
+                cwd,
+                cliVersion: "claude-code",
+                source: "appServer",
+                threadSource: params.threadSource ?? null,
+                agentNickname: null,
+                agentRole: null,
+                gitInfo: null,
+                name: null,
+                turns: [],
+            },
+            claudeSessionId: uuidv7(),
             modelPickerId,
             claudeModelValue,
-            approvalPolicy: params.approvalPolicy ?? before.approvalPolicy,
-            approvalsReviewer: approvalsReviewer(params.approvalsReviewer, before.approvalsReviewer),
-            sandboxPolicy: selectedSandboxPolicy,
             serviceTier,
-            reasoningEffort: params.effort === undefined ? before.reasoningEffort : params.effort,
-            reasoningSummary: params.summary === undefined ? before.reasoningSummary : params.summary,
-            collaborationMode: params.collaborationMode === undefined ? before.collaborationMode : params.collaborationMode,
-            personality: params.personality === undefined ? before.personality : params.personality,
-            outputSchema: outputSchema === undefined ? before.outputSchema : outputSchema,
+            approvalPolicy: params.approvalPolicy ?? "on-request",
+            approvalsReviewer: approvalsReviewer(params.approvalsReviewer),
+            sandboxPolicy: params.permissions
+                ? permissionProfileSandboxPolicy(params.permissions, cwd)
+                : sandboxPolicy(params.sandbox, cwd),
+            baseInstructions: params.baseInstructions ?? null,
+            developerInstructions: params.developerInstructions ?? null,
+            personality: 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, outputTokens: 0, reasoningOutputTokens: 0 },
+            tokenUsageLast: null,
+            modelContextWindow: null,
+            providerCostUsdTotal: 0,
         };
-        await this.validateModelSettings(candidate.modelPickerId, candidate.reasoningEffort, candidate.serviceTier);
-        const changed = cwd !== before.thread.cwd || [
-            "modelPickerId", "claudeModelValue", "approvalPolicy", "approvalsReviewer", "sandboxPolicy", "serviceTier",
-            "reasoningEffort", "reasoningSummary", "collaborationMode", "personality", "outputSchema",
-        ].some((key) => JSON.stringify(candidate[key]) !== JSON.stringify(before[key]));
-        if (!changed)
+    }
+    async applyTurnOverrides(params) {
+        await this.applySettings({ ...params, effort: turnReasoningEffort(params) }, params.outputSchema ?? null);
+    }
+    async applySettings(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 modelPickerId = params.model ?? before.modelPickerId;
+            const claudeModelValue = resolveClaudeModel(this.config, modelPickerId);
+            if (!claudeModelValue)
+                throw invalidParams("Cannot switch a Claude thread to a Codex model.");
+            const requestedServiceTier = normalizeClaudeServiceTier(this.config, modelPickerId, params.serviceTier === undefined ? before.serviceTier : params.serviceTier);
+            if (requestedServiceTier !== null && requestedServiceTier !== "default" && requestedServiceTier !== "fast")
+                throw invalidParams(`Unsupported Claude service tier '${requestedServiceTier}'.`);
+            const cwd = existingThreadCwd(params.cwd ?? before.thread.cwd);
+            const reasoningEffort = params.effort === undefined ? before.reasoningEffort : params.effort;
+            const serviceTier = await this.validatedServiceTier(modelPickerId, reasoningEffort, requestedServiceTier);
+            syncCanonicalSettings = requestedServiceTier === "fast" && serviceTier !== "fast";
+            const collaborationMode = params.collaborationMode === undefined
+                ? before.collaborationMode
+                : params.collaborationMode;
+            const candidate = {
+                ...before,
+                thread: { ...before.thread, cwd },
+                modelPickerId,
+                claudeModelValue,
+                serviceTier,
+                approvalPolicy: params.approvalPolicy ?? before.approvalPolicy,
+                approvalsReviewer: approvalsReviewer(params.approvalsReviewer, before.approvalsReviewer),
+                sandboxPolicy: params.permissions
+                    ? permissionProfileSandboxPolicy(params.permissions, cwd)
+                    : params.sandboxPolicy ?? 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 runtime = this.runtimes.get(params.threadId);
-        if (runtime?.isActive)
-            throw invalidParams("Cannot change Claude settings during an active turn.");
-        if (before.thread.ephemeral && runtime && !runtime.canRestartEphemeral) {
-            throw invalidParams("Cannot reconfigure an ephemeral Claude thread after model-visible input was submitted.");
         }
-        await this.unloadRuntime(params.threadId, "Claude runtime reconfigured.");
-        const record = this.requireRecord(params.threadId, false);
-        const updated = {
-            ...candidate,
-            thread: { ...candidate.thread, status: record.thread.status, updatedAt: nowSeconds() },
-        };
-        this.store.updateThread(updated);
-        let finalUpdated = updated;
-        if (updated.thread.ephemeral) {
-            const shouldResume = updated.lastClaudeMessageUuid !== null;
-            let replacement;
+        const updated = update.record;
+        if (updated.thread.ephemeral && update.replacementId && update.replay) {
             try {
-                replacement = await ClaudeSessionRuntime.create(updated, this.store, this.hub, this.logger, this.config, shouldResume, this.queryFactory, this.interactions, () => this.modelCatalog?.invalidate?.(), this.metrics);
+                await session.replaceEphemeralRuntime(update.replay, update.replacementId);
             }
             catch (error) {
-                this.store.deleteThread(params.threadId);
-                await deleteSession(updated.claudeSessionId, { dir: updated.thread.cwd }).catch(() => undefined);
+                await this.discardThreadSilently(params.threadId).catch(() => undefined);
                 throw error;
             }
-            this.runtimes.set(params.threadId, replacement);
-            this.metrics.runtimeLoaded(shouldResume);
-            finalUpdated = { ...updated, thread: { ...updated.thread, status: { type: "idle" } } };
-            this.store.updateThread(finalUpdated);
         }
-        const threadSettings = this.threadSettings(finalUpdated);
-        this.hub.emit(params.threadId, "thread/settings/updated", { threadId: params.threadId, threadSettings });
-        if (!turnOverride)
-            this.logger.info("claude.thread.settings-updated", { threadId: params.threadId });
     }
-    async validateModelSettings(modelId, effort, serviceTier) {
+    async validatedServiceTier(modelId, effort, serviceTier) {
         if (!this.modelCatalog)
-            return;
+            return serviceTier;
         const catalogId = claudeCatalogId(this.config, modelId);
         const model = (await this.modelCatalog.list()).find((candidate) => candidate.id === catalogId);
         if (!model)
@@ -949,60 +1592,74 @@ export class ClaudeService {
         if (effort && !model.supportedReasoningEfforts.some((level) => level.reasoningEffort === effort)) {
             throw invalidParams(`Claude model '${modelId}' does not support effort '${effort}'.`);
         }
-        if (serviceTier === "fast" && !model.serviceTiers.some((tier) => tier.id === "fast")) {
+        return serviceTier === "fast" && !model.serviceTiers.some((tier) => tier.id === "fast")
+            ? null
+            : serviceTier;
+    }
+    async validateModelSettings(modelId, effort, serviceTier) {
+        if (await this.validatedServiceTier(modelId, effort, serviceTier) !== serviceTier) {
             throw invalidParams(`Claude model '${modelId}' does not support the fast service tier.`);
         }
     }
-    threadSettings(record) {
-        return {
-            cwd: record.thread.cwd,
-            approvalPolicy: record.approvalPolicy,
-            approvalsReviewer: record.approvalsReviewer,
-            sandboxPolicy: record.sandboxPolicy,
-            activePermissionProfile: null,
-            model: record.modelPickerId,
-            modelProvider: "claude",
-            serviceTier: record.serviceTier,
-            effort: record.reasoningEffort,
-            summary: record.reasoningSummary,
-            collaborationMode: record.collaborationMode ?? {
-                mode: "default",
-                settings: { model: record.modelPickerId, reasoning_effort: record.reasoningEffort, developer_instructions: null },
+    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: process.env,
+                stderr: (line) => this.logger.debug("claude.usage-probe.stderr", { output: line }),
             },
-            multiAgentMode: "explicitRequestOnly",
-            personality: record.personality,
-        };
+        });
+        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);
+        }
     }
-    emit(threadId, turnId, method, params) {
-        this.store.appendEvent(threadId, turnId, method, params);
-        if (method === "turn/completed" && params && typeof params === "object" && "turn" in params) {
-            const turn = params.turn;
-            if (turn.status !== "inProgress")
-                this.metrics.turnCompleted(turn.status);
-        }
-        this.hub.emit(threadId, method, params);
-    }
-    currentGoal(threadId, now) {
-        const goal = this.store.getGoal(threadId);
-        if (!goal || goal.status !== "active")
-            return goal;
-        return { ...goal, timeUsedSeconds: goal.timeUsedSeconds + Math.max(0, now - goal.updatedAt), updatedAt: now };
-    }
-    async forkTranscript(source, boundary) {
-        if (!boundary)
-            return { sessionId: uuidv7(), uuidMap: new Map() };
-        const original = await getSessionMessages(source.claudeSessionId, { dir: source.thread.cwd });
-        const boundaryIndex = original.findIndex((message) => message.uuid === boundary);
-        if (boundaryIndex < 0)
-            throw new Error(`Claude transcript does not contain fork boundary '${boundary}'.`);
-        const fork = await forkSession(source.claudeSessionId, { dir: source.thread.cwd, upToMessageId: boundary });
-        const copied = await getSessionMessages(fork.sessionId, { dir: source.thread.cwd });
-        const prefix = original.slice(0, boundaryIndex + 1);
-        if (copied.length !== prefix.length || copied.some((message, index) => message.type !== prefix[index]?.type)) {
-            await deleteSession(fork.sessionId, { dir: source.thread.cwd }).catch(() => undefined);
-            throw new Error("Claude fork transcript could not be correlated with the source branch.");
-        }
-        return { sessionId: fork.sessionId, uuidMap: new Map(prefix.map((message, index) => [message.uuid, copied[index].uuid])) };
+    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