@gkorepanov/ccodex 0.3.0 → 0.4.1

package/dist/handoff/service.js

@@ -1,4 +1,10 @@
+import { DEFAULT_RENAME_PROMPT } from "../config/config.js";
+import { projectRpcToBackendThread, projectRpcToPublicThread } from "../gateway/logicalThreadProjection.js";
 import { invalidParams } from "../protocol/errors.js";
+import { v7 as uuidv7 } from "uuid";
+import { ProviderEpochs } from "./providerEpochs.js";
+import { normalizedTitlePayload, rewrittenTitlePrompt, titlePrompt } from "./titleGeneration.js";
+export const HANDOFF_DAEMON_CONNECTION_ID = "ccodex-handoff-daemon";
 const SUMMARY_INSTRUCTIONS = `Create a compact, portable handoff for another coding agent/provider.
 Return plain text only. Preserve: user goal, important decisions and constraints, repository/cwd, files and symbols touched,
 commands and tests run, current state, unresolved bugs, and exact next steps. Do not call tools. Do not continue the task.
@@ -26,19 +32,25 @@ function sandboxMode(policy) {
         return "read-only";
     return "workspace-write";
 }
-function selectedTurns(thread, lastTurnId) {
-    if (!lastTurnId)
-        return thread.turns;
-    const through = thread.turns.findIndex((turn) => turn.id === lastTurnId);
-    if (through < 0)
-        throw invalidParams(`Unknown source turn '${lastTurnId}'.`);
-    return thread.turns.slice(0, through + 1);
-}
 function agentText(turn) {
     return turn.items.flatMap((item) => item.type === "agentMessage" ? [item.text] : []).join("\n").trim();
 }
+function stockTitleContext(turns) {
+    return turns.flatMap((turn) => turn.items.flatMap((item) => {
+        if (item.type === "userMessage") {
+            const text = item.content.flatMap((content) => content.type === "text" ? [content.text] : []).join("\n").trim();
+            return text ? [{ type: "message", role: "user", content: [{ type: "input_text", text }] }] : [];
+        }
+        if (item.type === "agentMessage" && item.text.trim()) {
+            return [{ type: "message", role: "assistant", content: [{ type: "output_text", text: item.text }] }];
+        }
+        return [];
+    }));
+}
 function stagedSettings(base, pending) {
     const settings = pending.settings;
+    const effort = settings.effort === undefined ? base.effort : settings.effort;
+    const collaborationMode = settings.collaborationMode ?? base.collaborationMode;
     return {
         ...base,
         ...(settings.cwd !== undefined && settings.cwd !== null ? { cwd: settings.cwd } : {}),
@@ -48,10 +60,16 @@ function stagedSettings(base, pending) {
         model: pending.targetModel,
         modelProvider: pending.targetProvider === "claude" ? "claude" : "openai",
         serviceTier: settings.serviceTier === undefined ? base.serviceTier : settings.serviceTier,
-        effort: settings.effort === undefined ? base.effort : settings.effort,
+        effort,
         summary: settings.summary === undefined ? base.summary : settings.summary,
-        collaborationMode: settings.collaborationMode === undefined || settings.collaborationMode === null
-            ? base.collaborationMode : settings.collaborationMode,
+        collaborationMode: {
+            ...collaborationMode,
+            settings: {
+                ...collaborationMode.settings,
+                model: pending.targetModel,
+                reasoning_effort: effort,
+            },
+        },
         personality: settings.personality === undefined ? base.personality : settings.personality,
     };
 }
@@ -89,6 +107,17 @@ function pageItems(turns, params) {
         backwardsCursor: data.length > 0 ? `hyb-overlay-item:${Math.max(0, offset - limit)}` : null,
     };
 }
+function messageThreadId(message) {
+    if (!message.params || typeof message.params !== "object")
+        return undefined;
+    const params = message.params;
+    const nestedThread = params.thread && typeof params.thread === "object"
+        ? params.thread
+        : undefined;
+    return typeof params.threadId === "string"
+        ? params.threadId
+        : typeof nestedThread?.id === "string" ? nestedThread.id : undefined;
+}
 function providerModel(params) {
     return params.model ?? params.collaborationMode?.settings.model ?? undefined;
 }
@@ -99,16 +128,708 @@ function forkName(thread, sourceProvider) {
 export class CrossProviderForks {
     store;
     claude;
+    renamePrompt;
+    epochs;
     internalStockThreads = new Set();
+    suppressedInternalStockThreads = new Set();
     internalStockTurns = new Map();
+    internalStockBuilds = new Map();
     stockTargetBuilds = new Map();
-    constructor(store, claude) {
+    systemEphemeralThreads = new Map();
+    directTitleCandidates = new Map();
+    titleTurns = new Map();
+    stockServerRequests = new Map();
+    stockServerRequestAliases = new Map();
+    recentDurableProviders = new Map();
+    daemonStock;
+    subscriptions;
+    jobTail = Promise.resolve();
+    constructor(store, claude, renamePrompt = DEFAULT_RENAME_PROMPT) {
         this.store = store;
         this.claude = claude;
+        this.renamePrompt = renamePrompt;
+        this.epochs = new ProviderEpochs(store);
     }
     pending(threadId) { return this.store.getPending(threadId); }
+    logical(threadId) { return this.epochs.resolve(threadId); }
+    hiddenBackendIds(provider) { return this.epochs.hiddenBackendIds(provider); }
+    projectThreadCatalog(stockThreads, claudeThreads) {
+        const physical = new Map([...stockThreads, ...claudeThreads].map((thread) => [thread.id, thread]));
+        const mappings = this.store.listBackendMappings();
+        const hidden = new Set(mappings.map((mapping) => mapping.backendThreadId));
+        const ordinary = [...physical.values()].filter((thread) => !hidden.has(thread.id));
+        const logical = mappings.flatMap((mapping) => {
+            if (mapping.state !== "current")
+                return [];
+            const backend = physical.get(mapping.backendThreadId);
+            if (backend)
+                return [this.epochs.projectThread(mapping.publicThreadId, backend, false)];
+            if (mapping.backendThreadId.startsWith("ccodex-provisional:")) {
+                const provisional = this.store.getLogicalThread(mapping.publicThreadId);
+                return provisional ? [{ ...provisional.thread, turns: [] }] : [];
+            }
+            return [];
+        });
+        return [...ordinary, ...logical];
+    }
+    projectLoadedThreadIds(stockIds, claudeIds) {
+        const loaded = new Set([...stockIds, ...claudeIds]);
+        const mappings = this.store.listBackendMappings();
+        const hidden = new Set(mappings.map((mapping) => mapping.backendThreadId));
+        const ordinary = [...loaded].filter((threadId) => !hidden.has(threadId));
+        const logical = mappings.flatMap((mapping) => mapping.state === "current" && loaded.has(mapping.backendThreadId) ? [mapping.publicThreadId] : []);
+        return [...new Set([...ordinary, ...logical])];
+    }
+    projectStockMessage(message) {
+        if (!message.method)
+            return false;
+        const backendThreadId = messageThreadId({ params: message.params });
+        if (!backendThreadId)
+            return false;
+        const epoch = this.store.findEpochByBackend("stock", backendThreadId);
+        if (!epoch || epoch.state !== "current" || !this.subscriptions)
+            return false;
+        if (message.method === "serverRequest/resolved" && message.params && typeof message.params === "object") {
+            const params = message.params;
+            const providerRequestId = params.requestId;
+            const requestId = providerRequestId === undefined
+                ? undefined
+                : this.stockServerRequestAliases.get(String(providerRequestId));
+            if (requestId) {
+                this.subscriptions.emit(backendThreadId, message.method, { ...params, requestId });
+                this.stockServerRequestAliases.delete(String(providerRequestId));
+                this.stockServerRequests.delete(requestId);
+                return true;
+            }
+        }
+        if (message.id !== undefined) {
+            const requestId = `logical-stock:${uuidv7()}`;
+            this.stockServerRequests.set(requestId, message.id);
+            this.stockServerRequestAliases.set(String(message.id), requestId);
+            if (!this.subscriptions.request(backendThreadId, requestId, message.method, message.params)) {
+                this.stockServerRequests.delete(requestId);
+                this.stockServerRequestAliases.delete(String(message.id));
+                void this.daemonStock?.respond(message.id, { decision: "decline" });
+            }
+        }
+        else {
+            this.subscriptions.emit(backendThreadId, message.method, message.params);
+        }
+        return true;
+    }
+    ownsStockBackendMessage(message) {
+        const backendThreadId = messageThreadId(message);
+        return backendThreadId !== undefined && this.store.findEpochByBackend("stock", backendThreadId) !== undefined;
+    }
+    async resolveStockServerRequest(requestId, result) {
+        const stockRequestId = this.stockServerRequests.get(requestId);
+        if (stockRequestId === undefined || !this.daemonStock)
+            return false;
+        this.stockServerRequests.delete(requestId);
+        await this.daemonStock.respond(stockRequestId, result);
+        return true;
+    }
+    async requestLogical(method, publicParams, clientStock) {
+        const publicThreadId = publicParams.threadId;
+        if (typeof publicThreadId !== "string")
+            throw invalidParams("Logical thread request has no threadId.");
+        const resolved = this.epochs.resolve(publicThreadId);
+        if (!resolved)
+            throw invalidParams(`Unknown logical thread '${publicThreadId}'.`);
+        const owner = { publicThreadId, backendThreadId: resolved.epoch.backendThreadId };
+        const params = projectRpcToBackendThread({ params: publicParams }, owner).params;
+        if (method === "thread/delete") {
+            await this.deleteLogicalThread(publicThreadId, clientStock);
+            return { provider: resolved.epoch.provider, result: {} };
+        }
+        if (resolved.epoch.backendThreadId.startsWith("ccodex-provisional:")) {
+            return this.requestProvisionalLogical(method, publicParams, resolved);
+        }
+        if (resolved.epoch.provider === "stock") {
+            const stock = this.daemonStock ?? clientStock;
+            if (method === "thread/read" || method === "thread/resume") {
+                const result = await stock.request(method, params);
+                const resume = method === "thread/resume" ? params : undefined;
+                const includeTurns = resume
+                    ? !resume.excludeTurns
+                    : params.includeTurns ?? false;
+                const backendTurns = resume?.initialTurnsPage && !includeTurns
+                    ? (await stock.request("thread/read", {
+                        threadId: resolved.epoch.backendThreadId,
+                        includeTurns: true,
+                    })).thread.turns
+                    : result.thread.turns;
+                const initialTurnsPage = resume?.initialTurnsPage
+                    ? pageTurns(this.epochs.visibleTurns(publicThreadId, backendTurns), {
+                        threadId: publicThreadId,
+                        ...resume.initialTurnsPage,
+                    })
+                    : "initialTurnsPage" in result ? result.initialTurnsPage : undefined;
+                return {
+                    provider: "stock",
+                    result: {
+                        ...result,
+                        thread: this.epochs.projectThread(publicThreadId, result.thread, includeTurns),
+                        ...(resume ? { initialTurnsPage } : {}),
+                    },
+                };
+            }
+            if (method === "thread/turns/list" || method === "thread/items/list") {
+                const read = await stock.request("thread/read", {
+                    threadId: resolved.epoch.backendThreadId,
+                    includeTurns: true,
+                });
+                const turns = this.epochs.visibleTurns(publicThreadId, read.thread.turns);
+                return {
+                    provider: "stock",
+                    result: method === "thread/turns/list"
+                        ? pageTurns(turns, publicParams)
+                        : pageItems(turns, publicParams),
+                };
+            }
+            const result = await stock.request(method, params);
+            if (method === "thread/settings/update" || method === "turn/start") {
+                this.updateLogicalEpochFromParams(resolved, publicParams);
+            }
+            if (method === "thread/name/set" && typeof publicParams.name === "string") {
+                this.patchLogicalThread(publicThreadId, { name: publicParams.name });
+            }
+            return {
+                provider: "stock",
+                result: projectRpcToPublicThread({ result }, owner).result,
+            };
+        }
+        const threadId = resolved.epoch.backendThreadId;
+        if (method === "thread/read") {
+            const includeTurns = params.includeTurns ?? false;
+            const thread = this.epochs.projectThread(publicThreadId, this.claude.readThread(threadId, includeTurns).thread, includeTurns);
+            return { provider: "claude", result: { thread } };
+        }
+        if (method === "thread/resume") {
+            const resume = params;
+            const prepared = await this.claude.prepareResume(resume);
+            const response = prepared.response;
+            const thread = this.epochs.projectThread(publicThreadId, response.thread, !resume.excludeTurns);
+            const backendTurns = resume.initialTurnsPage && resume.excludeTurns
+                ? this.claude.readThread(threadId, true).thread.turns
+                : response.thread.turns;
+            return {
+                provider: "claude",
+                result: {
+                    ...response,
+                    thread,
+                    ...(resume.initialTurnsPage ? {
+                        initialTurnsPage: pageTurns(this.epochs.visibleTurns(publicThreadId, backendTurns), {
+                            threadId: publicThreadId,
+                            ...resume.initialTurnsPage,
+                        }),
+                    } : {}),
+                },
+                after: async () => prepared.notifyGoalSnapshot((event, eventParams) => {
+                    this.subscriptions?.emit(threadId, event, eventParams);
+                }),
+            };
+        }
+        if (method === "thread/turns/list") {
+            const read = this.claude.readThread(threadId, true).thread;
+            return {
+                provider: "claude",
+                result: pageTurns(this.epochs.visibleTurns(publicThreadId, read.turns), publicParams),
+            };
+        }
+        if (method === "thread/items/list") {
+            const read = this.claude.readThread(threadId, true).thread;
+            return {
+                provider: "claude",
+                result: pageItems(this.epochs.visibleTurns(publicThreadId, read.turns), publicParams),
+            };
+        }
+        if (method === "thread/settings/update") {
+            const result = await this.claude.updateThreadSettings(params);
+            this.updateLogicalEpochFromParams(resolved, publicParams);
+            return {
+                provider: "claude",
+                result,
+            };
+        }
+        if (method === "thread/name/set") {
+            const result = await this.claude.setThreadName(params);
+            if (typeof publicParams.name === "string")
+                this.patchLogicalThread(publicThreadId, { name: publicParams.name });
+            return { provider: "claude", result };
+        }
+        if (method === "thread/metadata/update") {
+            return {
+                provider: "claude",
+                result: await this.claude.updateThreadMetadata(params),
+            };
+        }
+        if (method === "thread/archive") {
+            return { provider: "claude", result: await this.claude.archiveThread(threadId) };
+        }
+        if (method === "thread/unarchive") {
+            return { provider: "claude", result: await this.claude.unarchiveThread(threadId) };
+        }
+        if (method === "thread/compact/start") {
+            return { provider: "claude", result: await this.claude.compactThread(threadId) };
+        }
+        if (method === "thread/inject_items") {
+            return { provider: "claude", result: await this.claude.injectItems(params) };
+        }
+        if (method === "thread/shellCommand") {
+            return { provider: "claude", result: await this.claude.shellCommand(params) };
+        }
+        if (method === "thread/backgroundTerminals/clean") {
+            return {
+                provider: "claude",
+                result: await this.claude.cleanBackgroundTerminals(params),
+            };
+        }
+        if (method === "thread/backgroundTerminals/list") {
+            return {
+                provider: "claude",
+                result: await this.claude.listBackgroundTerminals(params),
+            };
+        }
+        if (method === "thread/backgroundTerminals/terminate") {
+            return {
+                provider: "claude",
+                result: await this.claude.terminateBackgroundTerminal(params),
+            };
+        }
+        if (method === "thread/goal/set") {
+            const prepared = await this.claude.prepareGoalSet(params);
+            return { provider: "claude", result: prepared.response, after: prepared.notify };
+        }
+        if (method === "thread/goal/get") {
+            return { provider: "claude", result: await this.claude.getGoal(threadId) };
+        }
+        if (method === "thread/goal/clear") {
+            const prepared = await this.claude.prepareGoalClear(threadId);
+            return { provider: "claude", result: prepared.response, after: prepared.notify };
+        }
+        if (method === "turn/start") {
+            const prepared = await this.claude.prepareTurn(params);
+            this.updateLogicalEpochFromParams(resolved, publicParams);
+            return {
+                provider: "claude",
+                result: prepared.response,
+                after: async () => { await prepared.announce(); prepared.start(); },
+            };
+        }
+        if (method === "turn/interrupt") {
+            await this.claude.interruptTurn(params);
+            return { provider: "claude", result: {} };
+        }
+        if (method === "turn/steer") {
+            return { provider: "claude", result: await this.claude.steerTurn(params) };
+        }
+        throw invalidParams(`Method '${method}' is not implemented for a migrated Claude task yet.`);
+    }
+    requestProvisionalLogical(method, params, resolved) {
+        const turns = this.store.listLogicalTurns(resolved.logical.publicThreadId).map((value) => value.turn);
+        const thread = (includeTurns) => ({
+            ...resolved.logical.thread,
+            id: resolved.logical.publicThreadId,
+            turns: includeTurns ? turns : [],
+        });
+        if (method === "thread/read") {
+            return {
+                provider: resolved.epoch.provider,
+                result: { thread: thread(params.includeTurns ?? false) },
+            };
+        }
+        if (method === "thread/resume") {
+            const settings = resolved.epoch.settings;
+            return {
+                provider: resolved.epoch.provider,
+                result: {
+                    thread: thread(!params.excludeTurns),
+                    model: resolved.epoch.model,
+                    modelProvider: resolved.epoch.provider === "claude" ? "claude" : "openai",
+                    serviceTier: typeof settings.serviceTier === "string" ? settings.serviceTier : null,
+                    cwd: resolved.logical.thread.cwd,
+                    runtimeWorkspaceRoots: Array.isArray(settings.runtimeWorkspaceRoots)
+                        ? settings.runtimeWorkspaceRoots : [],
+                    instructionSources: Array.isArray(settings.instructionSources) ? settings.instructionSources : [],
+                    approvalPolicy: settings.approvalPolicy ?? "on-request",
+                    approvalsReviewer: settings.approvalsReviewer ?? "user",
+                    sandbox: settings.sandbox ?? settings.sandboxPolicy ?? { type: "readOnly" },
+                    activePermissionProfile: settings.activePermissionProfile ?? null,
+                    reasoningEffort: settings.reasoningEffort ?? settings.effort ?? null,
+                    multiAgentMode: settings.multiAgentMode ?? "explicitRequestOnly",
+                    initialTurnsPage: null,
+                },
+            };
+        }
+        if (method === "thread/turns/list") {
+            return {
+                provider: resolved.epoch.provider,
+                result: pageTurns(turns, params),
+            };
+        }
+        if (method === "thread/items/list") {
+            return {
+                provider: resolved.epoch.provider,
+                result: pageItems(turns, params),
+            };
+        }
+        if (method === "thread/name/set" && typeof params.name === "string") {
+            this.patchLogicalThread(resolved.logical.publicThreadId, { name: params.name });
+            return { provider: resolved.epoch.provider, result: {} };
+        }
+        throw invalidParams("This fork is waiting for Codex App to select a completed history boundary.");
+    }
+    async forkLogical(params, clientStock) {
+        const source = this.epochs.resolve(params.threadId);
+        if (!source)
+            throw invalidParams(`Unknown logical thread '${params.threadId}'.`);
+        if (params.model && providerForModel(this.claude, params.model) !== source.epoch.provider) {
+            throw invalidParams("Fork is same-provider only. Change the model and send a message to switch provider.");
+        }
+        const currentTurns = await this.currentBackendTurns(source, this.daemonStock ?? clientStock);
+        const visible = this.epochs.snapshotTurns(params.threadId, currentTurns);
+        const targetId = uuidv7();
+        const placeholderId = `ccodex-provisional:${uuidv7()}`;
+        const now = Math.floor(Date.now() / 1_000);
+        const thread = {
+            ...source.logical.thread,
+            id: targetId,
+            sessionId: source.logical.thread.sessionId,
+            forkedFromId: params.threadId,
+            parentThreadId: null,
+            createdAt: now,
+            updatedAt: now,
+            recencyAt: now,
+            status: { type: "notLoaded" },
+            name: source.logical.thread.name ? `${source.logical.thread.name} (fork)` : null,
+            turns: visible.map((turn) => turn.turn),
+        };
+        const target = this.store.createLogicalThread({
+            thread,
+            epoch: {
+                id: uuidv7(),
+                provider: source.epoch.provider,
+                backendThreadId: placeholderId,
+                model: source.epoch.model,
+                settings: source.epoch.settings,
+            },
+        });
+        if (visible.length > 0 && !this.store.replaceLogicalTurns(targetId, target.revision, visible)) {
+            throw new Error("Failed to persist provisional logical fork history.");
+        }
+        const provisional = this.epochs.resolve(targetId);
+        if (!this.store.createForkSelection({
+            targetPublicThreadId: targetId,
+            sourcePublicThreadId: params.threadId,
+            provisionalEpochId: provisional.epoch.id,
+        }))
+            throw new Error("Failed to persist logical fork selection.");
+        const settings = source.epoch.settings;
+        const response = {
+            thread: { ...thread, turns: params.excludeTurns ? [] : thread.turns },
+            model: source.epoch.model,
+            modelProvider: source.epoch.provider === "claude" ? "claude" : "openai",
+            serviceTier: typeof settings.serviceTier === "string" ? settings.serviceTier : null,
+            cwd: thread.cwd,
+            runtimeWorkspaceRoots: Array.isArray(settings.runtimeWorkspaceRoots)
+                ? settings.runtimeWorkspaceRoots : [],
+            instructionSources: Array.isArray(settings.instructionSources)
+                ? settings.instructionSources : [],
+            approvalPolicy: (settings.approvalPolicy ?? "on-request"),
+            approvalsReviewer: (settings.approvalsReviewer ?? "user"),
+            sandbox: (settings.sandbox ?? settings.sandboxPolicy ?? { type: "readOnly" }),
+            activePermissionProfile: (settings.activePermissionProfile ?? null),
+            reasoningEffort: (settings.reasoningEffort ?? settings.effort ?? null),
+            multiAgentMode: "explicitRequestOnly",
+        };
+        this.subscriptions?.emit(targetId, "thread/started", { thread: { ...thread, turns: [] } });
+        return response;
+    }
+    async rollbackLogicalFork(params, clientStock, connectionId) {
+        const selection = this.store.getForkSelection(params.threadId);
+        const target = this.epochs.resolve(params.threadId);
+        if (!selection || selection.status !== "pending" || !target) {
+            throw invalidParams(`Thread '${params.threadId}' is not awaiting a logical fork selection.`);
+        }
+        const turns = this.store.listLogicalTurns(params.threadId);
+        const keep = turns.length - params.numTurns;
+        if (keep <= 0)
+            throw invalidParams("Fork rollback removed every provider turn.");
+        const retained = turns.slice(0, keep);
+        const boundary = [...retained].reverse().find((turn) => turn.epochId && turn.providerTurnId);
+        if (!boundary?.epochId || !boundary.providerTurnId) {
+            throw invalidParams("Fork selection has no provider-backed turn boundary.");
+        }
+        const selectedEpoch = this.store.getEpoch(boundary.epochId);
+        if (!selectedEpoch || selectedEpoch.publicThreadId !== selection.sourcePublicThreadId) {
+            throw invalidParams("Fork selection points outside the source provider lineage.");
+        }
+        let forked;
+        let stockBuildOwner;
+        if (selectedEpoch.provider === "claude") {
+            forked = await this.claude.forkThread({
+                threadId: selectedEpoch.backendThreadId,
+                lastTurnId: boundary.providerTurnId,
+                model: selectedEpoch.model,
+            });
+        }
+        else {
+            stockBuildOwner = connectionId;
+            if (stockBuildOwner) {
+                if (this.stockTargetBuilds.has(stockBuildOwner)) {
+                    throw new Error("Another stock thread materialization is already active on this connection.");
+                }
+                this.stockTargetBuilds.set(stockBuildOwner, {
+                    awaitingStart: true,
+                    threadIds: new Set(),
+                    messages: [],
+                    expectedForkedFromId: selectedEpoch.backendThreadId,
+                });
+            }
+            try {
+                forked = await clientStock.request("thread/fork", {
+                    threadId: selectedEpoch.backendThreadId,
+                    lastTurnId: boundary.providerTurnId,
+                    model: selectedEpoch.model,
+                });
+            }
+            catch (error) {
+                if (stockBuildOwner)
+                    this.stockTargetBuilds.delete(stockBuildOwner);
+                throw error;
+            }
+        }
+        const publicThread = {
+            ...forked.thread,
+            id: params.threadId,
+            sessionId: target.logical.thread.sessionId,
+            forkedFromId: selection.sourcePublicThreadId,
+            parentThreadId: null,
+            createdAt: target.logical.thread.createdAt,
+            name: target.logical.thread.name,
+            turns: [],
+        };
+        const committed = this.store.commitForkSelection({
+            targetPublicThreadId: params.threadId,
+            expectedProvisionalEpochId: selection.provisionalEpochId,
+            selectedSourceEpochId: selectedEpoch.id,
+            targetEpoch: {
+                id: uuidv7(),
+                provider: selectedEpoch.provider,
+                backendThreadId: forked.thread.id,
+                model: selectedEpoch.model,
+                settings: selectedEpoch.settings,
+            },
+            turns: retained.filter((turn) => turn.epochId !== selectedEpoch.id).map((turn) => ({
+                publicTurnId: turn.publicTurnId,
+                ...(turn.epochId ? { epochId: turn.epochId } : {}),
+                ...(turn.providerTurnId ? { providerTurnId: turn.providerTurnId } : {}),
+                turn: turn.turn,
+                kind: turn.kind,
+            })),
+            thread: publicThread,
+        });
+        if (!committed) {
+            if (stockBuildOwner)
+                this.stockTargetBuilds.delete(stockBuildOwner);
+            throw new Error("Logical fork selection lost its atomic commit boundary.");
+        }
+        this.subscriptions?.suppress(target.epoch.backendThreadId);
+        this.subscriptions?.aliasThread(forked.thread.id, params.threadId);
+        if (stockBuildOwner)
+            this.stockTargetBuilds.delete(stockBuildOwner);
+        if (selectedEpoch.provider === "claude")
+            await this.claude.announceThread(forked.thread);
+        else
+            this.subscriptions?.emitPublic(params.threadId, "thread/started", {
+                thread: this.epochs.projectThread(params.threadId, forked.thread, true),
+            });
+        this.subscriptions?.emitPublic(params.threadId, "thread/settings/updated", {
+            threadId: params.threadId,
+            threadSettings: {
+                ...selectedEpoch.settings,
+                model: selectedEpoch.model,
+                modelProvider: selectedEpoch.provider === "claude" ? "claude" : "openai",
+            },
+        });
+        return { thread: this.epochs.projectThread(params.threadId, forked.thread, true) };
+    }
+    configureDaemonStock(stock) {
+        this.daemonStock = stock;
+        for (const job of this.store.recoverableJobs()) {
+            const targetId = job.target?.thread && typeof job.target.thread === "object"
+                ? job.target.thread.id
+                : undefined;
+            if (typeof targetId === "string")
+                void stock.request("thread/delete", { threadId: targetId }).catch(() => undefined);
+            this.store.failJob(job.id, "Legacy cross-provider Fork was retired; change model and send a message instead.");
+        }
+        for (const job of this.store.recoverableProviderSwitchJobs()) {
+            const run = this.jobTail.then(() => this.recoverProviderSwitch(job, stock));
+            this.jobTail = run.catch(() => undefined);
+        }
+    }
+    configureSubscriptions(subscriptions) {
+        this.subscriptions = subscriptions;
+        for (const mapping of this.store.listBackendMappings()) {
+            if (mapping.state === "current")
+                subscriptions.aliasThread(mapping.backendThreadId, mapping.publicThreadId);
+            else
+                subscriptions.suppress(mapping.backendThreadId);
+        }
+    }
+    claimFailedFork(threadId) {
+        return this.store.claimFailedJob(threadId);
+    }
+    drain() { return this.jobTail; }
+    async switchProviderTurn(params, compactionTurn, clientStock, connectionId, compacted) {
+        const stock = this.daemonStock ?? clientStock;
+        const seeded = await this.seedProviderSwitch(params.threadId, stock);
+        const pending = this.store.getPending(params.threadId);
+        if (!pending?.revision || pending.expectedEpochId !== seeded.epoch.id) {
+            throw new Error("Provider switch settings changed before the migration turn started.");
+        }
+        const created = this.store.createProviderSwitchJob({
+            id: compactionTurn.id,
+            publicThreadId: params.threadId,
+            expectedEpochId: seeded.epoch.id,
+            pendingRevision: pending.revision,
+            targetProvider: pending.targetProvider,
+            targetModel: pending.targetModel,
+            settings: pending.settings,
+            turnParams: params,
+            compactionTurn,
+        });
+        const job = created && this.store.claimProviderSwitchJob(created.id);
+        if (!job)
+            throw new Error("Another provider switch is already active for this task.");
+        return this.runProviderSwitchJob(job, stock, connectionId, compacted);
+    }
+    async runProviderSwitchJob(job, stock, connectionId, compacted) {
+        const params = job.turnParams;
+        let target;
+        let committed = false;
+        try {
+            const workerConnectionId = this.daemonStock
+                ? `${HANDOFF_DAEMON_CONNECTION_ID}:switch:${job.id}`
+                : connectionId;
+            const { source, summary, sourceTurns, developerInstructions, targetSettings } = await this.providerSwitchMaterial(job, stock, workerConnectionId);
+            if (job.targetProvider === "claude") {
+                const started = await this.claude.startThread(this.targetThreadStart(job, source.thread, developerInstructions));
+                target = { provider: "claude", threadId: started.thread.id };
+                await this.claude.updateThreadSettings({
+                    ...job.settings,
+                    threadId: started.thread.id,
+                    model: job.targetModel,
+                });
+                const prepared = await this.claude.prepareTurn({ ...params, threadId: started.thread.id });
+                if (!this.store.checkpointProviderSwitchTarget(job.id, {
+                    backendThreadId: started.thread.id,
+                    summary,
+                }))
+                    throw new Error("Provider switch target lost its durable checkpoint.");
+                await prepared.startAndWait();
+                if (!this.store.checkpointProviderSwitchTarget(job.id, {
+                    backendThreadId: started.thread.id,
+                    providerTurnId: prepared.response.turn.id,
+                }))
+                    throw new Error("Provider switch target delivery lost its durable checkpoint.");
+                this.subscriptions?.hideUserMessages(started.thread.id, prepared.response.turn.id);
+                this.commitProviderSwitch(job, started.thread, targetSettings, sourceTurns);
+                committed = true;
+                compacted();
+                await prepared.announce();
+                return;
+            }
+            const build = {
+                awaitingStart: true,
+                threadIds: new Set(),
+                messages: [],
+            };
+            this.stockTargetBuilds.set(workerConnectionId, build);
+            const started = await stock.request("thread/start", this.targetThreadStart(job, source.thread, developerInstructions));
+            target = { provider: "stock", threadId: started.thread.id };
+            if (build.awaitingStart)
+                build.awaitingStart = false;
+            build.threadIds.add(started.thread.id);
+            await stock.request("thread/settings/update", {
+                ...job.settings,
+                threadId: started.thread.id,
+                model: job.targetModel,
+            });
+            if (!this.store.checkpointProviderSwitchTarget(job.id, {
+                backendThreadId: started.thread.id,
+                summary,
+            }))
+                throw new Error("Provider switch target lost its durable checkpoint.");
+            const delivered = await stock.request("turn/start", {
+                ...params,
+                threadId: started.thread.id,
+            });
+            if (!this.store.checkpointProviderSwitchTarget(job.id, {
+                backendThreadId: started.thread.id,
+                providerTurnId: delivered.turn.id,
+            }))
+                throw new Error("Provider switch target delivery lost its durable checkpoint.");
+            this.subscriptions?.hideUserMessages(started.thread.id, delivered.turn.id);
+            this.commitProviderSwitch(job, started.thread, targetSettings, sourceTurns);
+            committed = true;
+            compacted();
+            this.flushStockTargetBuild(workerConnectionId);
+        }
+        catch (error) {
+            const failure = error instanceof Error ? error : new Error(String(error));
+            if (committed)
+                return;
+            this.store.failProviderSwitch(job.id, failure.message);
+            if (target?.provider === "claude") {
+                await this.claude.deleteThread(target.threadId).catch(() => undefined);
+            }
+            else if (target) {
+                await stock.request("thread/delete", { threadId: target.threadId }).catch(() => undefined);
+            }
+            throw failure;
+        }
+        finally {
+            for (const key of [...this.stockTargetBuilds.keys()]) {
+                if (key === connectionId || key.endsWith(`:switch:${job.id}`))
+                    this.stockTargetBuilds.delete(key);
+            }
+        }
+    }
+    async recoverProviderSwitch(job, stock) {
+        if (job.targetBackendThreadId && job.targetProviderTurnId) {
+            const target = job.targetProvider === "claude"
+                ? this.claude.readThread(job.targetBackendThreadId, true).thread
+                : (await stock.request("thread/read", {
+                    threadId: job.targetBackendThreadId,
+                    includeTurns: true,
+                })).thread;
+            if (target.turns.some((turn) => turn.id === job.targetProviderTurnId)) {
+                const material = await this.providerSwitchMaterial(job, stock, `${HANDOFF_DAEMON_CONNECTION_ID}:recovery:${job.id}`);
+                this.commitProviderSwitch(job, target, material.targetSettings, material.sourceTurns);
+                return;
+            }
+        }
+        if (job.targetBackendThreadId) {
+            if (job.targetProvider === "claude") {
+                await this.claude.deleteThread(job.targetBackendThreadId).catch(() => undefined);
+            }
+            else {
+                await stock.request("thread/delete", { threadId: job.targetBackendThreadId }).catch(() => undefined);
+            }
+        }
+        const queued = job.status === "queued" ? job : this.store.requeueProviderSwitchJob(job.id);
+        const claimed = queued && this.store.claimProviderSwitchJob(job.id);
+        if (!claimed)
+            return;
+        await this.runProviderSwitchJob(claimed, stock, `${HANDOFF_DAEMON_CONNECTION_ID}:recovery:${job.id}`, () => undefined);
+    }
     interceptSettings(params) {
-        const sourceProvider = this.claude.ownsThread(params.threadId) ? "claude" : "stock";
+        const logical = this.epochs.resolve(params.threadId);
+        const sourceProvider = logical?.epoch.provider
+            ?? (this.claude.ownsThread(params.threadId) ? "claude" : "stock");
         const previous = this.store.getPending(params.threadId);
         if (params.model) {
             const targetProvider = providerForModel(this.claude, params.model);
@@ -127,7 +848,7 @@ export class CrossProviderForks {
             return {
                 handled: true,
                 ...(sourceProvider === "claude"
-                    ? { notification: stagedSettings(this.claude.currentThreadSettings(params.threadId), pending) }
+                    ? { notification: stagedSettings(this.claude.currentThreadSettings(logical?.epoch.backendThreadId ?? params.threadId), pending) }
                     : {}),
             };
         }
@@ -138,87 +859,232 @@ export class CrossProviderForks {
         return {
             handled: true,
             ...(sourceProvider === "claude"
-                ? { notification: stagedSettings(this.claude.currentThreadSettings(params.threadId), pending) }
+                ? { notification: stagedSettings(this.claude.currentThreadSettings(logical?.epoch.backendThreadId ?? params.threadId), pending) }
                 : {}),
         };
     }
-    blockedTurnTarget(params) {
-        const pending = this.store.getPending(params.threadId);
-        const sourceProvider = this.claude.ownsThread(params.threadId) ? "claude" : "stock";
-        const selectedModel = providerModel(params);
-        if (selectedModel) {
-            return providerForModel(this.claude, selectedModel) === sourceProvider ? undefined : selectedModel;
+    stageTurnSwitch(params) {
+        const selected = providerModel(params);
+        if (!selected)
+            return this.store.getPending(params.threadId);
+        const logical = this.epochs.resolve(params.threadId);
+        const sourceProvider = logical?.epoch.provider
+            ?? (this.claude.ownsThread(params.threadId) ? "claude" : "stock");
+        if (providerForModel(this.claude, selected) === sourceProvider) {
+            this.store.clearPending(params.threadId);
+            return undefined;
         }
-        return pending?.targetModel;
+        this.interceptSettings({
+            threadId: params.threadId,
+            model: selected,
+            ...(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.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 } : {}),
+        });
+        return this.store.getPending(params.threadId);
+    }
+    blockedTurnTarget(params) {
+        return undefined;
     }
-    shouldFork(params) {
-        const sourceProvider = this.claude.ownsThread(params.threadId) ? "claude" : "stock";
-        const targetModel = params.model ?? this.store.getPending(params.threadId)?.targetModel;
-        return Boolean(targetModel && providerForModel(this.claude, targetModel) !== sourceProvider);
+    isSystemEphemeralFork(params) {
+        const logical = this.epochs.resolve(params.threadId);
+        return params.ephemeral === true
+            && params.threadSource === "system"
+            && (logical?.epoch.provider === "claude" || this.claude.ownsThread(params.threadId))
+            && Boolean(params.model && providerForModel(this.claude, params.model) === "stock");
     }
-    async fork(params, stock, connectionId = "internal") {
-        const pending = this.store.getPending(params.threadId);
-        const targetModel = params.model ?? pending?.targetModel;
-        if (!targetModel)
-            throw invalidParams("Cross-provider fork has no staged target model.");
-        const sourceProvider = this.claude.ownsThread(params.threadId) ? "claude" : "stock";
-        const targetProvider = providerForModel(this.claude, targetModel);
-        if (targetProvider === sourceProvider)
-            throw invalidParams("Cross-provider fork target resolves to the source provider.");
-        const settings = { ...(pending?.settings ?? { threadId: params.threadId }), threadId: params.threadId, model: targetModel };
-        let sourceThread;
-        let inheritedTurns;
-        let sourceSettings;
-        let summary;
-        if (sourceProvider === "claude") {
-            const source = this.claude.handoffSource(params.threadId, params.lastTurnId);
-            sourceThread = source.thread;
-            inheritedTurns = source.turns;
-            sourceSettings = source.settings;
-            summary = await this.claude.summarizeHandoff(params.threadId, summaryPrompt(inheritedTurns));
+    async forkSystemEphemeral(params, stock, connectionId) {
+        if (!this.isSystemEphemeralFork(params) || !params.model) {
+            throw invalidParams("System ephemeral fork requires a Claude source and Codex target model.");
         }
-        else {
-            const read = await stock.request("thread/read", { threadId: params.threadId, includeTurns: true });
-            sourceThread = read.thread;
-            inheritedTurns = selectedTurns(sourceThread, params.lastTurnId);
-            const resumed = await stock.request("thread/resume", {
-                threadId: params.threadId,
-                excludeTurns: true,
-            });
-            const compact = await this.summarizeStock(params, inheritedTurns, resumed.model, stock);
-            sourceSettings = compact.settings;
-            summary = compact.summary;
-        }
-        const mergedFork = {
-            ...params,
-            model: targetModel,
-            serviceTier: params.serviceTier === undefined
-                ? settings.serviceTier === undefined ? sourceSettings.serviceTier : settings.serviceTier
-                : params.serviceTier,
-            cwd: params.cwd ?? (settings.cwd || sourceSettings.cwd),
-            approvalPolicy: params.approvalPolicy ?? sourceSettings.approvalPolicy,
-            approvalsReviewer: params.approvalsReviewer ?? sourceSettings.approvalsReviewer,
-            ...(params.permissions === undefined && params.sandbox === undefined
-                ? { sandbox: sandboxMode(sourceSettings.sandboxPolicy) }
-                : {}),
+        const logical = this.epochs.resolve(params.threadId);
+        const sourceId = logical?.epoch.provider === "claude" ? logical.epoch.backendThreadId : params.threadId;
+        const source = await this.claude.handoffSource(sourceId, params.lastTurnId);
+        const start = {
+            model: params.model,
+            modelProvider: params.modelProvider ?? "openai",
+            cwd: params.cwd ?? source.thread.cwd,
+            ...(params.runtimeWorkspaceRoots !== undefined ? { runtimeWorkspaceRoots: params.runtimeWorkspaceRoots } : {}),
+            ...(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 } : {}),
+            ...(params.developerInstructions !== undefined ? { developerInstructions: params.developerInstructions } : {}),
+            ephemeral: true,
+            threadSource: "system",
         };
-        const developerInstructions = handoffInstructions(params.developerInstructions, summary);
-        const targetName = forkName(sourceThread, sourceProvider);
-        let response;
-        if (targetProvider === "claude") {
-            response = await this.claude.createHandoffFork(mergedFork, sourceThread, inheritedTurns, settings, developerInstructions, targetName);
+        const build = { awaitingStart: true, threadIds: new Set(), messages: [] };
+        this.stockTargetBuilds.set(connectionId, build);
+        let created;
+        try {
+            created = await stock.request("thread/start", start);
+            if (build.awaitingStart)
+                build.awaitingStart = false;
+            build.threadIds.add(created.thread.id);
+            const items = stockTitleContext(source.turns);
+            if (items.length > 0)
+                await stock.request("thread/inject_items", { threadId: created.thread.id, items });
+            const threads = this.systemEphemeralThreads.get(connectionId) ?? new Map();
+            threads.set(created.thread.id, { durableProvider: "claude" });
+            this.systemEphemeralThreads.set(connectionId, threads);
+            return {
+                ...created,
+                thread: {
+                    ...created.thread,
+                    ephemeral: true,
+                    threadSource: "system",
+                    forkedFromId: params.threadId,
+                    turns: params.excludeTurns ? [] : source.turns,
+                },
+            };
         }
-        else {
-            response = await this.createStockFork(mergedFork, sourceThread, inheritedTurns, settings, developerInstructions, targetName, stock, connectionId);
+        catch (error) {
+            if (created)
+                await stock.request("thread/delete", { threadId: created.thread.id }).catch(() => undefined);
+            throw error;
+        }
+        finally {
+            this.stockTargetBuilds.delete(connectionId);
         }
-        this.store.clearPending(params.threadId);
-        return response;
     }
     overlay(threadId) { return this.store.getOverlay(threadId); }
     ownsInternalStockThread(threadId) { return this.internalStockThreads.has(threadId); }
+    captureInternalStockMessage(_connectionId, message) {
+        const threadId = messageThreadId(message);
+        if (!threadId)
+            return false;
+        const params = message.params;
+        const started = params.thread;
+        const build = message.method === "thread/started" && started?.ephemeral === true && started.threadSource !== "system"
+            ? [...this.internalStockBuilds.values()].find((candidate) => candidate.awaitingStart && started.forkedFromId === candidate.sourceThreadId)
+            : undefined;
+        if (build) {
+            build.awaitingStart = false;
+            build.threadIds.add(threadId);
+            this.registerInternalStockThread(threadId);
+        }
+        if (this.internalStockThreads.has(threadId)) {
+            this.recordInternalStockMessage(message);
+            return true;
+        }
+        return this.suppressedInternalStockThreads.has(threadId);
+    }
+    registerForwardedEphemeralCandidate(connectionId, threadId, params) {
+        const directStart = !("threadId" in params);
+        if (params.ephemeral !== true)
+            return;
+        const durableProvider = "threadId" in params
+            ? this.claude.ownsThread(params.threadId) ? "claude" : "stock"
+            : this.recentDurableProviders.get(connectionId) ?? "stock";
+        const candidates = directStart && params.threadSource !== "system" && params.threadSource !== "user"
+            ? this.directTitleCandidates
+            : params.threadSource === "system" ? this.systemEphemeralThreads : undefined;
+        if (!candidates)
+            return;
+        const threads = candidates.get(connectionId) ?? new Map();
+        if (threads.size >= 64 && !threads.has(threadId))
+            threads.delete(threads.keys().next().value);
+        threads.set(threadId, { durableProvider });
+        candidates.set(connectionId, threads);
+    }
+    observeDurableThread(connectionId, provider) {
+        this.recentDurableProviders.set(connectionId, provider);
+    }
+    observeDurableTurn(connectionId, params) {
+        if (this.systemEphemeralThreads.get(connectionId)?.has(params.threadId)
+            || this.directTitleCandidates.get(connectionId)?.has(params.threadId))
+            return;
+        const text = params.input.flatMap((input) => input.type === "text" ? [input.text] : []).join("\n").trim();
+        if (!text || titlePrompt(params))
+            return;
+        const durableProvider = this.claude.ownsThread(params.threadId) ? "claude" : "stock";
+        const turn = [...this.titleTurns.values()].reverse()
+            .find((candidate) => candidate.connectionId === connectionId && candidate.userPrompt.trim() === text);
+        if (turn)
+            turn.durableProvider = durableProvider;
+    }
+    prepareTitleTurn(connectionId, params) {
+        const systemOwner = this.systemEphemeralThreads.get(connectionId)?.get(params.threadId);
+        const directOwner = this.directTitleCandidates.get(connectionId)?.get(params.threadId);
+        const owner = systemOwner ?? directOwner;
+        const prompt = owner && titlePrompt(params);
+        if (!owner || !prompt)
+            return params;
+        if (!systemOwner) {
+            const candidates = this.directTitleCandidates.get(connectionId);
+            candidates?.delete(params.threadId);
+            if (candidates?.size === 0)
+                this.directTitleCandidates.delete(connectionId);
+            const threads = this.systemEphemeralThreads.get(connectionId) ?? new Map();
+            threads.set(params.threadId, owner);
+            this.systemEphemeralThreads.set(connectionId, threads);
+        }
+        const renamePrompt = this.renamePrompt;
+        if (!renamePrompt)
+            return params;
+        const turn = {
+            durableProvider: owner.durableProvider,
+            connectionId,
+            userPrompt: prompt.userPrompt,
+            outputSchema: prompt.outputSchema,
+        };
+        this.titleTurns.set(params.threadId, turn);
+        const input = params.input.map((item, index) => index === prompt.index && item.type === "text"
+            ? { ...item, text: rewrittenTitlePrompt(prompt.text, renamePrompt) }
+            : item);
+        return { ...params, input };
+    }
+    rewriteTitleMessages(message) {
+        if (!message.params || typeof message.params !== "object")
+            return undefined;
+        const params = message.params;
+        const threadId = typeof params.threadId === "string" ? params.threadId : undefined;
+        const turn = threadId && this.titleTurns.get(threadId);
+        if (!threadId || !turn)
+            return undefined;
+        if (message.method === "item/agentMessage/delta")
+            return [];
+        const item = params.item && typeof params.item === "object"
+            ? params.item
+            : undefined;
+        if (message.method === "item/completed" && item?.type === "agentMessage" && typeof item.text === "string") {
+            const text = normalizedTitlePayload(item.text, turn);
+            turn.output = text;
+            const completed = { ...message, params: { ...params, item: { ...item, text } } };
+            const delta = typeof params.turnId === "string" && typeof item.id === "string"
+                ? [{ method: "item/agentMessage/delta", params: { threadId, turnId: params.turnId, itemId: item.id, delta: text } }]
+                : [];
+            return [...delta, completed];
+        }
+        if (message.method === "turn/completed") {
+            this.titleTurns.delete(threadId);
+            const completed = params.turn && typeof params.turn === "object"
+                ? params.turn
+                : undefined;
+            if (!turn.output || !Array.isArray(completed?.items))
+                return undefined;
+            const items = completed.items.map((candidate) => candidate && typeof candidate === "object"
+                && candidate.type === "agentMessage"
+                ? { ...candidate, text: turn.output }
+                : candidate);
+            return [{ ...message, params: { ...params, turn: { ...completed, items } } }];
+        }
+        if (message.method === "error")
+            this.titleTurns.delete(threadId);
+        return undefined;
+    }
     suppressStockTargetMessage(connectionId, message) {
-        const build = this.stockTargetBuilds.get(connectionId);
-        if (!build || !message.params || typeof message.params !== "object")
+        if (!message.params || typeof message.params !== "object")
             return false;
         const params = message.params;
         const nestedThread = params.thread && typeof params.thread === "object"
@@ -229,13 +1095,68 @@ export class CrossProviderForks {
             : typeof nestedThread?.id === "string" ? nestedThread.id : undefined;
         if (!threadId)
             return false;
-        if (message.method === "thread/started" && build.awaitingStart) {
-            build.awaitingStart = false;
-            build.threadIds.add(threadId);
+        if (message.method === "thread/started" && this.systemEphemeralThreads.get(connectionId)?.has(threadId))
+            return true;
+        if (message.method === "thread/started" && this.store.findEpochByBackend("stock", threadId))
+            return true;
+        const direct = this.stockTargetBuilds.get(connectionId);
+        if (direct && message.method === "thread/started" && direct.awaitingStart
+            && (direct.expectedForkedFromId === undefined || nestedThread?.forkedFromId === direct.expectedForkedFromId)) {
+            direct.awaitingStart = false;
+            direct.threadIds.add(threadId);
+        }
+        const pendingFork = message.method === "thread/started"
+            ? [...this.stockTargetBuilds.values()].find((candidate) => candidate.awaitingStart
+                && candidate.expectedForkedFromId !== undefined
+                && nestedThread?.forkedFromId === candidate.expectedForkedFromId)
+            : undefined;
+        if (pendingFork) {
+            pendingFork.awaitingStart = false;
+            pendingFork.threadIds.add(threadId);
+        }
+        const build = direct?.threadIds.has(threadId)
+            ? direct
+            : pendingFork ?? [...this.stockTargetBuilds.values()].find((candidate) => candidate.threadIds.has(threadId));
+        if (!build)
+            return false;
+        if (!build.threadIds.has(threadId))
+            return false;
+        if (message.method !== "thread/started" && message.method !== "thread/settings/updated") {
+            build.messages.push(message);
+        }
+        return true;
+    }
+    flushStockTargetBuild(connectionId) {
+        const build = this.stockTargetBuilds.get(connectionId);
+        if (!build)
+            return;
+        this.stockTargetBuilds.delete(connectionId);
+        for (const message of build.messages) {
+            this.projectStockMessage(message);
         }
-        return build.threadIds.has(threadId);
     }
-    detachConnection(connectionId) { this.stockTargetBuilds.delete(connectionId); }
+    releaseSystemEphemeral(connectionId, threadId) {
+        const threads = this.systemEphemeralThreads.get(connectionId);
+        if (!threads?.delete(threadId))
+            return false;
+        this.titleTurns.delete(threadId);
+        if (threads.size === 0)
+            this.systemEphemeralThreads.delete(connectionId);
+        return true;
+    }
+    ownsSystemEphemeral(connectionId, threadId) {
+        return this.systemEphemeralThreads.get(connectionId)?.has(threadId) === true;
+    }
+    async detachConnection(connectionId, stock) {
+        this.stockTargetBuilds.delete(connectionId);
+        const threads = this.systemEphemeralThreads.get(connectionId) ?? new Map();
+        this.systemEphemeralThreads.delete(connectionId);
+        this.directTitleCandidates.delete(connectionId);
+        this.recentDurableProviders.delete(connectionId);
+        for (const threadId of threads.keys())
+            this.titleTurns.delete(threadId);
+        await Promise.allSettled([...threads.keys()].map((threadId) => stock.request("thread/delete", { threadId })));
+    }
     recordInternalStockMessage(message) {
         if (!message.params || typeof message.params !== "object")
             return;
@@ -248,6 +1169,8 @@ export class CrossProviderForks {
         const wireTurn = params.turn && typeof params.turn === "object" ? params.turn : undefined;
         const turnId = typeof params.turnId === "string" ? params.turnId : wireTurn?.id;
         if (message.method === "error") {
+            if (params.willRetry === true)
+                return;
             const error = params.error && typeof params.error === "object" ? params.error : undefined;
             const failure = new Error(typeof error?.message === "string" ? error.message : "Stock compact handoff failed.");
             for (const state of turns.values())
@@ -299,21 +1222,256 @@ export class CrossProviderForks {
         this.store.clearOverlay(threadId);
     }
     close() { this.store.close(); }
-    async summarizeStock(params, inheritedTurns, sourceModel, stock) {
-        const temporary = await stock.request("thread/fork", {
-            threadId: params.threadId,
-            ...(params.lastTurnId ? { lastTurnId: params.lastTurnId } : {}),
-            model: sourceModel,
-            cwd: params.cwd,
-            approvalPolicy: "never",
-            sandbox: "read-only",
-            developerInstructions: SUMMARY_INSTRUCTIONS,
-            ephemeral: true,
-            excludeTurns: true,
+    async seedProviderSwitch(threadId, stock) {
+        let resolved = this.epochs.resolve(threadId);
+        const pending = this.store.getPending(threadId);
+        if (!pending)
+            throw new Error(`Thread '${threadId}' has no staged provider switch.`);
+        if (!resolved) {
+            if (pending.sourceProvider === "claude") {
+                const source = await this.claude.handoffSource(threadId);
+                resolved = this.epochs.seed(source.thread, "claude", source.settings.model, source.settings);
+            }
+            else {
+                const [read, resume] = await Promise.all([
+                    stock.request("thread/read", { threadId, includeTurns: true }),
+                    stock.request("thread/resume", { threadId, excludeTurns: true }),
+                ]);
+                resolved = this.epochs.seed(read.thread, "stock", resume.model, resume);
+            }
+        }
+        if (resolved.epoch.provider !== pending.sourceProvider) {
+            throw new Error("Provider switch source changed before it could be staged.");
+        }
+        const staged = this.store.stageProviderSwitch({
+            pending: { ...pending, expectedEpochId: resolved.epoch.id },
+            expectedEpochId: resolved.epoch.id,
+        });
+        if (!staged)
+            throw new Error("Provider switch lost its current provider epoch.");
+        return this.epochs.resolve(threadId);
+    }
+    async currentBackendTurns(resolved, stock) {
+        if (resolved.epoch.backendThreadId.startsWith("ccodex-provisional:"))
+            return [];
+        if (resolved.epoch.provider === "claude") {
+            return this.claude.readThread(resolved.epoch.backendThreadId, true).thread.turns;
+        }
+        const read = await stock.request("thread/read", {
+            threadId: resolved.epoch.backendThreadId,
+            includeTurns: true,
+        });
+        return read.thread.turns;
+    }
+    patchLogicalThread(publicThreadId, patch) {
+        const logical = this.store.getLogicalThread(publicThreadId);
+        if (!logical || !this.store.updateLogicalThread(publicThreadId, logical.revision, { ...logical.thread, ...patch, id: publicThreadId, turns: [] }))
+            throw new Error(`Logical thread '${publicThreadId}' changed while metadata was being updated.`);
+    }
+    updateLogicalEpochFromParams(resolved, params) {
+        const settings = { ...params };
+        delete settings.threadId;
+        delete settings.input;
+        delete settings.clientUserMessageId;
+        const model = typeof params.model === "string" ? params.model : undefined;
+        if (!this.store.updateCurrentEpoch(resolved.logical.publicThreadId, resolved.epoch.id, {
+            ...(model ? { model } : {}),
+            settings,
+        }))
+            throw new Error("Current provider epoch changed while settings were being applied.");
+    }
+    async deleteLogicalThread(publicThreadId, clientStock) {
+        const stock = this.daemonStock ?? clientStock;
+        const mappings = this.store.listBackendMappings()
+            .filter((mapping) => mapping.publicThreadId === publicThreadId
+            && !mapping.backendThreadId.startsWith("ccodex-provisional:"));
+        for (const mapping of mappings)
+            this.subscriptions?.suppress(mapping.backendThreadId);
+        await Promise.allSettled(mappings.map((mapping) => mapping.provider === "claude"
+            ? this.claude.deleteThread(mapping.backendThreadId)
+            : stock.request("thread/delete", { threadId: mapping.backendThreadId })));
+        for (const mapping of mappings) {
+            this.subscriptions?.unaliasThread(mapping.backendThreadId);
+        }
+        this.store.clearPending(publicThreadId);
+        this.store.deleteLogicalThread(publicThreadId);
+        this.subscriptions?.threadDeleted(publicThreadId);
+    }
+    async providerSwitchSource(job, stock, _connectionId) {
+        const resolved = this.epochs.resolve(job.publicThreadId);
+        if (!resolved || resolved.epoch.id !== job.expectedEpochId) {
+            throw new Error("Provider switch source epoch is no longer current.");
+        }
+        if (resolved.epoch.provider === "claude") {
+            const source = await this.claude.handoffSource(resolved.epoch.backendThreadId);
+            return {
+                thread: source.thread,
+                backendTurns: source.turns,
+                turns: this.epochs.visibleTurns(job.publicThreadId, source.turns),
+                settings: source.settings,
+            };
+        }
+        const [read, resume] = await Promise.all([
+            stock.request("thread/read", {
+                threadId: resolved.epoch.backendThreadId,
+                includeTurns: true,
+            }),
+            stock.request("thread/resume", {
+                threadId: resolved.epoch.backendThreadId,
+                excludeTurns: true,
+            }),
+        ]);
+        return {
+            thread: read.thread,
+            backendTurns: read.thread.turns,
+            turns: this.epochs.visibleTurns(job.publicThreadId, read.thread.turns),
+            settings: resume,
+        };
+    }
+    async providerSwitchMaterial(job, stock, connectionId) {
+        const source = await this.providerSwitchSource(job, stock, connectionId);
+        const summary = job.summary
+            ?? await this.providerSwitchSummary(job, source.turns, stock, connectionId);
+        const completedAt = Math.floor(Date.now() / 1_000);
+        const compactTurn = {
+            ...job.compactionTurn,
+            status: "completed",
+            completedAt,
+            durationMs: job.compactionTurn.startedAt === null
+                ? null
+                : Math.max(0, (completedAt - job.compactionTurn.startedAt) * 1_000),
+        };
+        return {
+            source,
+            summary,
+            sourceTurns: [
+                ...this.epochs.snapshotTurns(job.publicThreadId, source.backendTurns),
+                { publicTurnId: compactTurn.id, turn: compactTurn, kind: "migrationCompact" },
+            ],
+            developerInstructions: handoffInstructions(source.developerInstructions, summary),
+            targetSettings: {
+                ...source.settings,
+                ...job.settings,
+                model: job.targetModel,
+                modelProvider: job.targetProvider === "claude" ? "claude" : "openai",
+            },
+        };
+    }
+    async providerSwitchSummary(job, turns, stock, connectionId) {
+        const resolved = this.epochs.resolve(job.publicThreadId);
+        if (!resolved)
+            throw new Error(`Unknown logical thread '${job.publicThreadId}'.`);
+        if (resolved.epoch.provider === "claude") {
+            const hidden = await this.claude.forkThread({
+                threadId: resolved.epoch.backendThreadId,
+                model: resolved.epoch.model,
+                ephemeral: true,
+                threadSource: "subAgent",
+            });
+            try {
+                try {
+                    return await this.claude.compactForHandoff(hidden.thread.id, `/compact ${SUMMARY_INSTRUCTIONS}`);
+                }
+                catch (error) {
+                    if (!(error instanceof Error) || !/not enough messages to compact/i.test(error.message))
+                        throw error;
+                    return await this.claude.summarizeHandoff(resolved.epoch.backendThreadId, summaryPrompt(turns));
+                }
+            }
+            finally {
+                await this.claude.discardHandoffThread(hidden.thread.id).catch(() => undefined);
+            }
+        }
+        return (await this.summarizeStock({ threadId: resolved.epoch.backendThreadId }, turns, resolved.epoch.model, stock, connectionId)).summary;
+    }
+    targetThreadStart(job, source, developerInstructions) {
+        const turn = job.turnParams;
+        const settings = job.settings;
+        const sandbox = turn.sandboxPolicy ?? settings.sandboxPolicy;
+        return {
+            model: job.targetModel,
+            modelProvider: job.targetProvider === "claude" ? "claude" : "openai",
+            cwd: turn.cwd ?? settings.cwd ?? source.cwd,
+            developerInstructions,
+            ...(turn.serviceTier !== undefined
+                ? { serviceTier: turn.serviceTier }
+                : settings.serviceTier !== undefined ? { serviceTier: settings.serviceTier } : {}),
+            ...(turn.approvalPolicy !== undefined
+                ? { approvalPolicy: turn.approvalPolicy }
+                : settings.approvalPolicy !== undefined ? { approvalPolicy: settings.approvalPolicy } : {}),
+            ...(turn.approvalsReviewer !== undefined
+                ? { approvalsReviewer: turn.approvalsReviewer }
+                : settings.approvalsReviewer !== undefined ? { approvalsReviewer: settings.approvalsReviewer } : {}),
+            ...(turn.permissions !== undefined
+                ? { permissions: turn.permissions }
+                : settings.permissions !== undefined ? { permissions: settings.permissions } : {}),
+            ...(sandbox && turn.permissions === undefined && settings.permissions === undefined
+                ? { sandbox: sandboxMode(sandbox) }
+                : {}),
+            ephemeral: false,
+            threadSource: source.threadSource,
+        };
+    }
+    commitProviderSwitch(job, target, settings, sourceTurns) {
+        const logical = this.store.getLogicalThread(job.publicThreadId);
+        if (!logical)
+            throw new Error(`Unknown logical thread '${job.publicThreadId}'.`);
+        const publicThread = {
+            ...target,
+            id: job.publicThreadId,
+            sessionId: logical.thread.sessionId,
+            forkedFromId: logical.thread.forkedFromId,
+            parentThreadId: logical.thread.parentThreadId,
+            createdAt: logical.thread.createdAt,
+            name: logical.thread.name,
+            turns: [],
+        };
+        const committed = this.store.commitProviderSwitch({
+            jobId: job.id,
+            targetEpoch: {
+                id: uuidv7(),
+                provider: job.targetProvider,
+                backendThreadId: target.id,
+                model: job.targetModel,
+                settings,
+            },
+            sourceTurns,
+            thread: publicThread,
+        });
+        if (!committed)
+            throw new Error("Provider switch lost its atomic commit boundary.");
+        const source = this.store.getEpoch(job.expectedEpochId);
+        this.subscriptions?.suppress(source.backendThreadId);
+        this.subscriptions?.aliasThread(target.id, job.publicThreadId);
+        this.subscriptions?.emitPublic(job.publicThreadId, "thread/settings/updated", {
+            threadId: job.publicThreadId,
+            threadSettings: settings,
         });
-        this.internalStockThreads.add(temporary.thread.id);
-        this.internalStockTurns.set(temporary.thread.id, new Map());
+    }
+    async summarizeStock(params, inheritedTurns, sourceModel, stock, connectionId) {
+        const build = {
+            awaitingStart: true,
+            sourceThreadId: params.threadId,
+            threadIds: new Set(),
+            messages: [],
+        };
+        this.internalStockBuilds.set(connectionId, build);
+        let temporary;
         try {
+            temporary = await stock.request("thread/fork", {
+                threadId: params.threadId,
+                ...(params.lastTurnId ? { lastTurnId: params.lastTurnId } : {}),
+                model: sourceModel,
+                cwd: params.cwd,
+                approvalPolicy: "never",
+                sandbox: "read-only",
+                developerInstructions: SUMMARY_INSTRUCTIONS,
+                ephemeral: true,
+                excludeTurns: true,
+            });
+            build.awaitingStart = false;
+            build.threadIds.add(temporary.thread.id);
+            this.registerInternalStockThread(temporary.thread.id);
             const started = await stock.request("turn/start", {
                 threadId: temporary.thread.id,
                 input: [{ type: "text", text: summaryPrompt(inheritedTurns), text_elements: [] }],
@@ -342,11 +1500,27 @@ export class CrossProviderForks {
             };
         }
         finally {
-            await stock.request("thread/delete", { threadId: temporary.thread.id }).catch(() => undefined);
-            this.internalStockThreads.delete(temporary.thread.id);
-            this.internalStockTurns.delete(temporary.thread.id);
+            if (temporary)
+                build.threadIds.add(temporary.thread.id);
+            await Promise.allSettled([...build.threadIds].map((threadId) => stock.request("thread/delete", { threadId })));
+            for (const threadId of build.threadIds) {
+                this.internalStockThreads.delete(threadId);
+                this.internalStockTurns.delete(threadId);
+            }
+            if (this.internalStockBuilds.get(connectionId) === build)
+                this.internalStockBuilds.delete(connectionId);
         }
     }
+    registerInternalStockThread(threadId) {
+        this.internalStockThreads.add(threadId);
+        if (this.suppressedInternalStockThreads.size >= 4096
+            && !this.suppressedInternalStockThreads.has(threadId)) {
+            this.suppressedInternalStockThreads.delete(this.suppressedInternalStockThreads.values().next().value);
+        }
+        this.suppressedInternalStockThreads.add(threadId);
+        if (!this.internalStockTurns.has(threadId))
+            this.internalStockTurns.set(threadId, new Map());
+    }
     async waitStockTurn(threadId, turnId) {
         const turns = this.internalStockTurns.get(threadId);
         if (!turns)
@@ -367,72 +1541,6 @@ export class CrossProviderForks {
             state.reject = (error) => { clearTimeout(timeout); reject(error); };
         });
     }
-    async createStockFork(params, sourceThread, inheritedTurns, settings, developerInstructions, targetName, stock, connectionId) {
-        const start = {
-            model: params.model,
-            modelProvider: "openai",
-            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 } : {}),
-            ...(params.ephemeral !== undefined ? { ephemeral: params.ephemeral } : {}),
-            ...(params.threadSource !== undefined ? { threadSource: params.threadSource } : {}),
-        };
-        const build = { awaitingStart: true, threadIds: new Set() };
-        this.stockTargetBuilds.set(connectionId, build);
-        let created;
-        try {
-            created = await stock.request("thread/start", start);
-            if (build.awaitingStart)
-                build.awaitingStart = false;
-            build.threadIds.add(created.thread.id);
-            await stock.request("thread/inject_items", {
-                threadId: created.thread.id,
-                items: [{
-                        type: "message",
-                        role: "assistant",
-                        content: [{ type: "output_text", text: "Cross-provider handoff initialized." }],
-                    }],
-            });
-            await stock.request("thread/name/set", { threadId: created.thread.id, name: targetName });
-            if (settings.effort !== undefined || settings.summary !== undefined || settings.collaborationMode !== undefined || settings.personality !== undefined) {
-                await stock.request("thread/settings/update", {
-                    threadId: created.thread.id,
-                    ...(settings.effort !== undefined ? { effort: settings.effort } : {}),
-                    ...(settings.summary !== undefined ? { summary: settings.summary } : {}),
-                    ...(settings.collaborationMode !== undefined ? { collaborationMode: settings.collaborationMode } : {}),
-                    ...(settings.personality !== undefined ? { personality: settings.personality } : {}),
-                });
-            }
-            const thread = {
-                ...created.thread,
-                forkedFromId: sourceThread.id,
-                preview: sourceThread.preview,
-                name: targetName,
-                turns: params.excludeTurns ? [] : inheritedTurns,
-            };
-            this.store.setOverlay({
-                threadId: thread.id,
-                sourceThreadId: sourceThread.id,
-                sourceThread,
-                inheritedTurns,
-            });
-            return { ...created, thread };
-        }
-        catch (error) {
-            if (created)
-                await stock.request("thread/delete", { threadId: created.thread.id }).catch(() => undefined);
-            throw error;
-        }
-        finally {
-            this.stockTargetBuilds.delete(connectionId);
-        }
-    }
     requireOverlay(threadId) {
         const overlay = this.store.getOverlay(threadId);
         if (!overlay)