@gkorepanov/ccodex 0.4.4 → 0.4.6

package/dist/gateway/clientConnection.js

@@ -7,8 +7,8 @@ import { mergedModelList } from "./modelList.js";
 import { StockRpc } from "./stockRpc.js";
 import { mergedLoadedList, mergedThreadList } from "./threadList.js";
 import { ServerRequestIds } from "./serverRequestIds.js";
-import { providerMigrationCompleted, providerMigrationFailed, providerMigrationNotice, transientCommandNotice, transientSystemNotice, } from "./transientNotice.js";
-import { rateLimitNotifications } from "../claude/rateLimits.js";
+import { providerMigrationCompleted, providerMigrationFailed, providerMigrationNotice, transientCommandNotice, transientSystemNotice, transientSystemItemNotice, } from "./transientNotice.js";
+import { rateLimitNotifications, } from "../claude/rateLimits.js";
 import { formatCCodexStatus, isCCodexStatusCommand } from "../claude/statusCommand.js";
 import { claudeCompactCommand } from "../claude/compactCommand.js";
 import { DEFAULT_FEATURES } from "../config/config.js";
@@ -16,9 +16,13 @@ import { providerUnavailableMessage } from "../runtime/providerAvailability.js";
 import { formatCCodexState, isCCodexStateCommand } from "../state/stateCommand.js";
 import { StockStateTracker } from "../state/stockStateTracker.js";
 import { STOCK_SIDE_THREAD_SOURCE } from "./stockSideThreads.js";
+import { projectRpcToPublicThread } from "./logicalThreadProjection.js";
 function requestedFast(serviceTier) {
     return serviceTier === "fast" || serviceTier === "priority";
 }
+function isUserSideFork(params) {
+    return params.ephemeral === true && params.excludeTurns === true && params.threadSource === "user";
+}
 function claudeModelNoticeName(model) {
     const name = model.replace(/^claude:/u, "").replace(/^claude-/u, "").split("-")[0] ?? model;
     return `${name.charAt(0).toUpperCase()}${name.slice(1)}`;
@@ -33,7 +37,7 @@ function fastTransitionNotice(before, after, requestedTier) {
     }
     return undefined;
 }
-export function attachClientConnection(client, stockSocket, claudeModels, claude, handoffs, subscriptions, logger, cursors, metrics, recorder, remoteControl, features = DEFAULT_FEATURES, providerAvailability, sharedStockState, stockSideThreads) {
+export function attachClientConnection(client, stockSocket, claudeModels, claude, handoffs, subscriptions, logger, cursors, metrics, recorder, remoteControl, features = DEFAULT_FEATURES, providerAvailability, sharedStockState, stockSideThreads, optimisticSideThreads) {
     const connectionId = uuidv7();
     let resolveClosed;
     let rejectClosed;
@@ -50,6 +54,7 @@ export function attachClientConnection(client, stockSocket, claudeModels, claude
     const requestStarted = new Map();
     const forwardedRequests = new Map();
     const recentSystemErrors = new Map();
+    const knownLogicalNames = new Map();
     const serverRequestIds = new ServerRequestIds();
     const requestKey = (id) => `${typeof id}:${id}`;
     const completeLatency = (id, provider) => {
@@ -96,6 +101,25 @@ export function attachClientConnection(client, stockSocket, claudeModels, claude
         recorder.frame(connectionId, "gateway_to_client", data, false);
         client.send(data);
     };
+    const syncLogicalName = (thread) => {
+        if (!handoffs.logical?.(thread.id))
+            return;
+        if (knownLogicalNames.has(thread.id) && knownLogicalNames.get(thread.id) === thread.name)
+            return;
+        knownLogicalNames.set(thread.id, thread.name);
+        sendJson({
+            method: "thread/name/updated",
+            params: { threadId: thread.id, ...(thread.name === null ? {} : { threadName: thread.name }) },
+        });
+    };
+    const syncLogicalNameFromResult = (result) => {
+        const thread = result && typeof result === "object"
+            ? result.thread
+            : undefined;
+        if (thread && typeof thread === "object" && typeof thread.id === "string") {
+            syncLogicalName(thread);
+        }
+    };
     const emitNotice = (notice) => {
         for (const notification of notice.notifications)
             sendJson(notification);
@@ -139,6 +163,27 @@ export function attachClientConnection(client, stockSocket, claudeModels, claude
         for (const notification of rateLimitNotifications(response))
             sendJson(notification);
     };
+    const activeClaudeTurns = new Map();
+    const pendingRateLimitTransitions = new Map();
+    const rateLimitNoticeText = (transition) => {
+        const reset = transition.resetsAt === null
+            ? ""
+            : `\n  ↳ resets ${new Date(transition.resetsAt * 1_000).toISOString().replace("T", " ").slice(0, 16)} UTC`;
+        return transition.status === "rejected"
+            ? `❌ Claude rate limit reached${reset}`
+            : `⚠️ Claude usage is nearing its limit${reset}`;
+    };
+    const emitRateLimitTransition = (threadId, transition) => {
+        const turnId = activeClaudeTurns.get(threadId);
+        if (!turnId) {
+            const pending = pendingRateLimitTransitions.get(threadId) ?? [];
+            pending.push(transition);
+            pendingRateLimitTransitions.set(threadId, pending);
+            return;
+        }
+        for (const notification of transientSystemItemNotice(threadId, turnId, rateLimitNoticeText(transition)))
+            sendJson(notification);
+    };
     const emitStockRateLimits = (value) => {
         if (!value || typeof value !== "object")
             return;
@@ -241,6 +286,28 @@ export function attachClientConnection(client, stockSocket, claudeModels, claude
         });
     };
     const notificationSink = (method, params) => {
+        let startedTurn;
+        if (method === "turn/started" && params && typeof params === "object") {
+            const value = params;
+            if (typeof value.threadId === "string" && typeof value.turn?.id === "string") {
+                activeClaudeTurns.set(value.threadId, value.turn.id);
+                startedTurn = { threadId: value.threadId, turnId: value.turn.id };
+            }
+        }
+        else if (method === "turn/completed" && params && typeof params === "object") {
+            const value = params;
+            if (typeof value.threadId === "string" && typeof value.turn?.id === "string"
+                && activeClaudeTurns.get(value.threadId) === value.turn.id) {
+                activeClaudeTurns.delete(value.threadId);
+            }
+        }
+        if (method === "thread/name/updated" && params && typeof params === "object") {
+            const update = params;
+            if (typeof update.threadId === "string"
+                && (typeof update.threadName === "string" || update.threadName === null)) {
+                knownLogicalNames.set(update.threadId, update.threadName);
+            }
+        }
         if (method === "error" && params && typeof params === "object") {
             const failure = params;
             if (typeof failure.threadId === "string" && typeof failure.error?.message === "string") {
@@ -259,14 +326,23 @@ export function attachClientConnection(client, stockSocket, claudeModels, claude
             }
         }
         sendJson({ method, params });
+        if (startedTurn) {
+            const pending = pendingRateLimitTransitions.get(startedTurn.threadId) ?? [];
+            pendingRateLimitTransitions.delete(startedTurn.threadId);
+            for (const transition of pending)
+                emitRateLimitTransition(startedTurn.threadId, transition);
+        }
     };
     const serverRequestSink = (id, method, params) => {
         sendJson({ id: serverRequestIds.wireId(id), method, params });
     };
     subscriptions.attach(connectionId, notificationSink, serverRequestSink);
-    claude.subscribeRateLimits(connectionId, (response) => {
-        if (foreground?.provider === "claude")
-            emitRateLimits(response);
+    claude.subscribeRateLimits(connectionId, (response, transition) => {
+        if (foreground?.provider !== "claude")
+            return;
+        emitRateLimits(response);
+        if (transition)
+            emitRateLimitTransition(foreground.threadId, transition);
     });
     const subscribedClaudeThreads = new Set();
     const subscribeClaude = (threadId) => {
@@ -281,6 +357,271 @@ export function attachClientConnection(client, stockSocket, claudeModels, claude
         subscribeClaude(threadId);
         subscriptions.mute(threadId, connectionId);
     };
+    const projectSideResult = (publicThreadId, target, result) => projectRpcToPublicThread({ result }, { publicThreadId, backendThreadId: target.backendThreadId }).result;
+    const projectSideParams = (publicThreadId, target, params) => projectRpcToPublicThread({ params }, { publicThreadId, backendThreadId: target.backendThreadId }).params;
+    const optimisticStockRequest = (method, params) => stockSideThreads?.request(method, params) ?? stockRpc.request(method, params);
+    const reportOptimisticFailure = (threadId) => {
+        if (!connectionAlive)
+            return;
+        const failure = optimisticSideThreads?.claimFailure(threadId);
+        if (failure) {
+            emitTransientNotice(threadId, `Could not prepare side chat\n  ↳ ${failure.message}`, "error");
+        }
+    };
+    const openOptimisticSide = (requestId, snapshot, provider, prepare) => {
+        const threadId = snapshot.thread.id;
+        subscriptions.subscribe(threadId, connectionId, notificationSink, serverRequestSink);
+        const response = optimisticSideThreads.open(connectionId, snapshot, prepare, async (target) => {
+            if (target.provider === "claude") {
+                subscriptions.unaliasThread(target.backendThreadId);
+                await claude.deleteThread(target.backendThreadId);
+            }
+            else {
+                await stockSideThreads?.discardOptimistic(threadId);
+            }
+        }, reportOptimisticFailure);
+        sendResult(requestId, response);
+        sendJson({ method: "thread/started", params: { thread: response.thread } });
+        selectForeground(provider === "claude" ? "claude" : "codex", threadId);
+    };
+    const handleOptimisticRequest = async (request, publicThreadId) => {
+        const sides = optimisticSideThreads;
+        sides.attach(publicThreadId, connectionId);
+        subscriptions.subscribe(publicThreadId, connectionId, notificationSink, serverRequestSink);
+        const snapshot = sides.snapshot(publicThreadId);
+        const publicParams = (request.params ?? {});
+        if (request.method === "thread/read") {
+            if (sides.phase(publicThreadId) !== "ready") {
+                sendResult(request.id, { thread: snapshot.thread });
+                reportOptimisticFailure(publicThreadId);
+                return;
+            }
+        }
+        if (request.method === "thread/resume") {
+            if (sides.phase(publicThreadId) !== "ready") {
+                sendResult(request.id, {
+                    ...snapshot,
+                    initialTurnsPage: null,
+                });
+                reportOptimisticFailure(publicThreadId);
+                return;
+            }
+        }
+        if (request.method === "thread/turns/list") {
+            if (sides.phase(publicThreadId) !== "ready") {
+                sendResult(request.id, { data: [], nextCursor: null, backwardsCursor: null });
+                return;
+            }
+        }
+        if (request.method === "thread/items/list") {
+            if (sides.phase(publicThreadId) !== "ready") {
+                sendResult(request.id, { data: [], nextCursor: null, backwardsCursor: null });
+                return;
+            }
+        }
+        if (request.method === "thread/goal/get" && sides.phase(publicThreadId) !== "ready") {
+            sendResult(request.id, { goal: null });
+            reportOptimisticFailure(publicThreadId);
+            return;
+        }
+        if (request.method === "thread/unsubscribe") {
+            subscriptions.unsubscribe(publicThreadId, connectionId);
+            await sides.delete(publicThreadId);
+            sendResult(request.id, { status: "unsubscribed" });
+            clearForeground(publicThreadId);
+            return;
+        }
+        if (request.method === "thread/delete") {
+            await sides.delete(publicThreadId);
+            subscriptions.unsubscribe(publicThreadId, connectionId);
+            sendResult(request.id, {});
+            clearForeground(publicThreadId);
+            return;
+        }
+        if (request.method === "thread/inject_items") {
+            const queued = sides.run(publicThreadId, async (target) => {
+                const params = { ...publicParams, threadId: target.backendThreadId };
+                try {
+                    if (target.provider === "claude") {
+                        await claude.injectItems(params);
+                    }
+                    else {
+                        await optimisticStockRequest(request.method, params);
+                    }
+                }
+                catch (value) {
+                    const error = value instanceof Error ? value : new Error(String(value));
+                    sides.fail(publicThreadId, error);
+                    throw error;
+                }
+            });
+            sendResult(request.id, {});
+            void queued.catch(() => reportOptimisticFailure(publicThreadId));
+            return;
+        }
+        try {
+            await sides.run(publicThreadId, async (target) => {
+                const params = { ...publicParams, threadId: target.backendThreadId };
+                if (request.method === "thread/read") {
+                    const result = target.provider === "claude"
+                        ? claude.readThread(target.backendThreadId, Boolean(publicParams.includeTurns))
+                        : await optimisticStockRequest("thread/read", params);
+                    sendResult(request.id, projectSideResult(publicThreadId, target, result));
+                    return;
+                }
+                if (request.method === "thread/resume") {
+                    if (target.provider === "claude") {
+                        subscriptions.mute(publicThreadId, connectionId);
+                        try {
+                            const prepared = await claude.prepareResume(params);
+                            const snapshotHighWatermark = claude.eventHighWatermark(target.backendThreadId);
+                            const tokenUsage = claude.latestTokenUsage(target.backendThreadId);
+                            sendResult(request.id, projectSideResult(publicThreadId, target, prepared.response));
+                            subscriptions.unmute(publicThreadId, connectionId);
+                            if (tokenUsage && tokenUsage.sequence <= snapshotHighWatermark) {
+                                notificationSink(tokenUsage.method, projectSideParams(publicThreadId, target, tokenUsage.params));
+                            }
+                            for (const event of claude.eventsAfter(target.backendThreadId, snapshotHighWatermark)) {
+                                notificationSink(event.method, projectSideParams(publicThreadId, target, event.params));
+                            }
+                            await prepared.notifyGoalSnapshot((method, eventParams) => notificationSink(method, projectSideParams(publicThreadId, target, eventParams)));
+                            await claude.replayPendingRequests(target.backendThreadId, connectionId);
+                        }
+                        catch (error) {
+                            subscriptions.unmute(publicThreadId, connectionId);
+                            throw error;
+                        }
+                    }
+                    else {
+                        sendResult(request.id, projectSideResult(publicThreadId, target, await optimisticStockRequest("thread/resume", params)));
+                    }
+                    selectForeground(target.provider === "claude" ? "claude" : "codex", publicThreadId);
+                    return;
+                }
+                if (request.method === "thread/turns/list") {
+                    const result = target.provider === "claude"
+                        ? claude.turnsPage(params)
+                        : await optimisticStockRequest(request.method, params);
+                    sendResult(request.id, projectSideResult(publicThreadId, target, result));
+                    return;
+                }
+                if (request.method === "thread/items/list") {
+                    const result = target.provider === "claude"
+                        ? claude.listItems(params)
+                        : await optimisticStockRequest(request.method, params);
+                    sendResult(request.id, projectSideResult(publicThreadId, target, result));
+                    return;
+                }
+                if (request.method === "thread/goal/get") {
+                    sendResult(request.id, target.provider === "claude"
+                        ? await claude.getGoal(target.backendThreadId)
+                        : await optimisticStockRequest(request.method, params));
+                    return;
+                }
+                if (request.method === "thread/name/set") {
+                    sendResult(request.id, target.provider === "claude"
+                        ? await claude.setThreadName(params)
+                        : await optimisticStockRequest(request.method, params));
+                    return;
+                }
+                if (request.method === "thread/settings/update") {
+                    if (target.provider === "claude") {
+                        const before = claude.currentThreadSettings(target.backendThreadId);
+                        const result = await claude.updateThreadSettings(params);
+                        sendResult(request.id, result);
+                        emitFastTransition(publicThreadId, before, claude.currentThreadSettings(target.backendThreadId), params.serviceTier);
+                    }
+                    else {
+                        sendResult(request.id, await optimisticStockRequest(request.method, params));
+                    }
+                    return;
+                }
+                if (request.method === "turn/start") {
+                    if (target.provider === "claude") {
+                        const turn = params;
+                        const before = claude.currentThreadSettings(target.backendThreadId);
+                        const prepared = await claude.prepareTurn(turn);
+                        sendResult(request.id, prepared.response);
+                        selectForeground("claude", publicThreadId);
+                        emitFastTransition(publicThreadId, before, claude.currentThreadSettings(target.backendThreadId), turn.serviceTier);
+                        await prepared.announce();
+                        prepared.start();
+                    }
+                    else {
+                        sendResult(request.id, await optimisticStockRequest(request.method, params));
+                        selectForeground("codex", publicThreadId);
+                    }
+                    return;
+                }
+                if (request.method === "turn/interrupt") {
+                    if (target.provider === "claude") {
+                        await claude.interruptTurn(params);
+                        sendResult(request.id, {});
+                    }
+                    else
+                        sendResult(request.id, await optimisticStockRequest(request.method, params));
+                    return;
+                }
+                if (request.method === "turn/steer") {
+                    sendResult(request.id, target.provider === "claude"
+                        ? await claude.steerTurn(params)
+                        : await optimisticStockRequest(request.method, params));
+                    return;
+                }
+                if (request.method === "thread/compact/start") {
+                    sendResult(request.id, target.provider === "claude"
+                        ? await claude.compactThread(target.backendThreadId)
+                        : await optimisticStockRequest(request.method, params));
+                    return;
+                }
+                if (request.method === "thread/backgroundTerminals/clean") {
+                    sendResult(request.id, target.provider === "claude"
+                        ? await claude.cleanBackgroundTerminals(params)
+                        : await optimisticStockRequest(request.method, params));
+                    return;
+                }
+                if (request.method === "thread/backgroundTerminals/list") {
+                    sendResult(request.id, target.provider === "claude"
+                        ? await claude.listBackgroundTerminals(params)
+                        : await optimisticStockRequest(request.method, params));
+                    return;
+                }
+                if (request.method === "thread/backgroundTerminals/terminate") {
+                    sendResult(request.id, target.provider === "claude"
+                        ? await claude.terminateBackgroundTerminal(params)
+                        : await optimisticStockRequest(request.method, params));
+                    return;
+                }
+                if (request.method === "thread/fork") {
+                    let result;
+                    if (target.provider === "claude") {
+                        result = await claude.forkThread(params, publicThreadId);
+                        sendResult(request.id, result);
+                        subscribeClaude(result.thread.id);
+                        await claude.announceThread(result.thread);
+                        subscriptions.unaliasThread(target.backendThreadId);
+                    }
+                    else {
+                        result = projectSideResult(publicThreadId, target, await optimisticStockRequest(request.method, params));
+                        sendResult(request.id, result);
+                        await stockSideThreads?.discardOptimistic(publicThreadId);
+                    }
+                    sides.forgetPromoted(publicThreadId);
+                    selectForeground(target.provider === "claude" ? "claude" : "codex", result.thread.id);
+                    return;
+                }
+                throw new RpcError(-32601, `Method '${request.method}' is not implemented for optimistic side threads yet.`);
+            });
+        }
+        catch (error) {
+            reportOptimisticFailure(publicThreadId);
+            const failure = rpcError(error);
+            if (request.method === "thread/inject_items")
+                sendResult(request.id, {});
+            else
+                sendError(request.id, failure.code, failure.message);
+        }
+    };
     client.on("message", async (data, isBinary) => {
         recorder.frame(connectionId, "client_to_gateway", data, isBinary);
         const message = isBinary ? undefined : parseRpcMessage(data);
@@ -292,6 +633,9 @@ export function attachClientConnection(client, stockSocket, claudeModels, claude
             if (handoffs.resolveStockServerRequest
                 && await handoffs.resolveStockServerRequest(internalServerRequestId, response))
                 return;
+            if (stockSideThreads
+                && await stockSideThreads.resolveServerRequest(internalServerRequestId, response))
+                return;
             if (!await claude.resolveServerRequest(internalServerRequestId, response)) {
                 logger.warn("claude.interaction.unknown-response", { connectionId, requestId: internalServerRequestId });
             }
@@ -332,7 +676,10 @@ export function attachClientConnection(client, stockSocket, claudeModels, claude
                 if (message.method === "account/rateLimits/read" && !foreground)
                     diagnoseUnknownStatus("account/rateLimits/read");
                 if (message.method === "thread/list") {
-                    sendResult(message.id, await mergedThreadList((message.params ?? {}), stockRpc, claude, cursors, handoffs, stockSideThreads));
+                    const result = await mergedThreadList((message.params ?? {}), stockRpc, claude, cursors, handoffs, stockSideThreads);
+                    sendResult(message.id, result);
+                    for (const thread of result.data)
+                        syncLogicalName(thread);
                     return;
                 }
                 if (message.method === "thread/loaded/list") {
@@ -353,6 +700,10 @@ export function attachClientConnection(client, stockSocket, claudeModels, claude
                     }
                 }
                 const params = (message.params ?? {});
+                if (params.threadId && optimisticSideThreads?.owns(params.threadId)) {
+                    await handleOptimisticRequest(message, params.threadId);
+                    return;
+                }
                 if (params.threadId && message.method === "turn/start"
                     && (claude.ownsThread(params.threadId)
                         || handoffs.logical?.(params.threadId)?.epoch.provider === "claude")) {
@@ -528,6 +879,7 @@ export function attachClientConnection(client, stockSocket, claudeModels, claude
                     subscriptions.subscribe(params.threadId, connectionId, notificationSink, serverRequestSink);
                     const handled = await handoffs.requestLogical(message.method, (message.params ?? {}), stockRpc);
                     sendResult(message.id, handled.result);
+                    syncLogicalNameFromResult(handled.result);
                     selectForeground(handled.provider === "claude" ? "claude" : "codex", params.threadId);
                     await handled.after?.();
                     return;
@@ -547,6 +899,72 @@ export function attachClientConnection(client, stockSocket, claudeModels, claude
                         sendResult(message.id, await handoffs.forkSystemEphemeral(forkParams, stockRpc, connectionId));
                         return;
                     }
+                    const logicalSource = handoffs.logical?.(forkParams.threadId);
+                    if (logicalSource && isUserSideFork(forkParams)) {
+                        const targetThreadId = uuidv7();
+                        const snapshot = handoffs.sideSnapshot(forkParams, targetThreadId);
+                        if (snapshot && optimisticSideThreads) {
+                            openOptimisticSide(message.id, snapshot, logicalSource.epoch.provider, async () => {
+                                if (logicalSource.epoch.provider === "claude") {
+                                    const result = await claude.forkThread({
+                                        ...forkParams,
+                                        threadId: logicalSource.epoch.backendThreadId,
+                                    }, forkParams.threadId);
+                                    subscriptions.aliasThread(result.thread.id, targetThreadId);
+                                    claude.cancelEphemeralRelease(result.thread.id);
+                                    return { provider: "claude", backendThreadId: result.thread.id };
+                                }
+                                if (!stockSideThreads)
+                                    throw new Error("Stock side-chat support is unavailable.");
+                                const prepared = await stockSideThreads.prepareOptimisticSide({ ...forkParams, threadId: logicalSource.epoch.backendThreadId }, forkParams.threadId, targetThreadId);
+                                return { provider: "stock", backendThreadId: prepared.backendThreadId };
+                            });
+                            return;
+                        }
+                        let result;
+                        if (logicalSource.epoch.provider === "claude") {
+                            result = await claude.forkThread({
+                                ...forkParams,
+                                threadId: logicalSource.epoch.backendThreadId,
+                            }, forkParams.threadId);
+                            sendResult(message.id, result);
+                            selectForeground("claude", result.thread.id);
+                            subscribeClaude(result.thread.id);
+                            await claude.announceThread(result.thread);
+                            return;
+                        }
+                        if (!stockSideThreads)
+                            throw new Error("Stock side-chat support is unavailable.");
+                        result = await stockSideThreads.forkSide(connectionId, { ...forkParams, threadId: logicalSource.epoch.backendThreadId }, forkParams.threadId, stockRpc);
+                        sendResult(message.id, result);
+                        selectForeground("codex", result.thread.id);
+                        return;
+                    }
+                    if (!logicalSource && isUserSideFork(forkParams) && optimisticSideThreads) {
+                        const targetThreadId = uuidv7();
+                        const sourceProvider = claude.ownsThread(forkParams.threadId) ? "claude" : "stock";
+                        const completedParams = sourceProvider === "stock"
+                            ? stockState.completeForkParams(forkParams)
+                            : forkParams;
+                        const snapshot = sourceProvider === "claude"
+                            ? claude.sideSnapshot(forkParams.threadId, targetThreadId, forkParams.threadId)
+                            : stockState.sideSnapshot(completedParams, targetThreadId);
+                        if (snapshot) {
+                            openOptimisticSide(message.id, snapshot, sourceProvider, async () => {
+                                if (sourceProvider === "claude") {
+                                    const result = await claude.forkThread(completedParams, forkParams.threadId);
+                                    subscriptions.aliasThread(result.thread.id, targetThreadId);
+                                    claude.cancelEphemeralRelease(result.thread.id);
+                                    return { provider: "claude", backendThreadId: result.thread.id };
+                                }
+                                if (!stockSideThreads)
+                                    throw new Error("Stock side-chat support is unavailable.");
+                                const prepared = await stockSideThreads.prepareOptimisticSide(completedParams, forkParams.threadId, targetThreadId);
+                                return { provider: "stock", backendThreadId: prepared.backendThreadId };
+                            });
+                            return;
+                        }
+                    }
                     const logicalFork = handoffs.forkLogical;
                     const overlay = handoffs.overlay(params.threadId);
                     if ((logicalFork && handoffs.logical?.(params.threadId)) || overlay?.epochs) {
@@ -589,17 +1007,12 @@ export function attachClientConnection(client, stockSocket, claudeModels, claude
                     return;
                 }
                 if (params.threadId && message.method === "thread/rollback" && handoffs.logical?.(params.threadId)) {
-                    sendResult(message.id, await handoffs.rollbackLogicalFork((message.params ?? {}), stockRpc, connectionId));
+                    sendResult(message.id, await handoffs.rollbackLogicalThread((message.params ?? {}), stockRpc, connectionId));
                     return;
                 }
                 if (params.threadId && handoffs.overlay(params.threadId)) {
                     if (message.method === "thread/rollback") {
                         const rollback = (message.params ?? {});
-                        const logicalRollback = handoffs.rollbackLogicalFork;
-                        if (logicalRollback) {
-                            sendResult(message.id, await logicalRollback.call(handoffs, rollback, stockRpc, connectionId));
-                            return;
-                        }
                         const overlay = handoffs.overlay(params.threadId);
                         if (overlay.epochs) {
                             const turns = overlay.epochs.flatMap((epoch) => epoch.publicTurnIds.map((turnId) => ({ epoch, turnId })));
@@ -910,106 +1323,119 @@ export function attachClientConnection(client, stockSocket, claudeModels, claude
             stock.send(message.data, { binary: message.isBinary });
         }
     });
+    const closeClient = (code, reason) => {
+        if (client.readyState === WebSocketState.OPEN)
+            client.close(code, reason);
+    };
     stock.on("message", (data, isBinary) => {
-        const incoming = isBinary ? undefined : parseRpcMessage(data);
-        let message = incoming;
-        if (message) {
-            stockState.observeResponse(connectionId, message);
-            stockState.observeNotification(message);
-        }
-        if (message && stockRpc.handle(message))
-            return;
-        if (message && stockSideThreads)
-            message = stockSideThreads.projectMessage(connectionId, message);
-        let foregroundAfterForward;
-        if (message && "method" in message && !("id" in message) && message.method === "remoteControl/status/changed" && remoteControl) {
-            remoteControl.intercept(connectionId, notificationSink, message.params);
-            return;
-        }
-        if (message && isResponse(message)) {
-            completeLatency(message.id, "stock");
-            const forwarded = forwardedRequests.get(requestKey(message.id));
-            forwardedRequests.delete(requestKey(message.id));
-            if (forwarded?.systemEphemeral && "result" in message) {
-                const result = message.result && typeof message.result === "object"
-                    ? message.result
-                    : undefined;
-                if (typeof result?.thread?.id === "string") {
-                    handoffs.registerForwardedEphemeralCandidate(connectionId, result.thread.id, forwarded.systemEphemeral);
-                }
-            }
-            if (forwarded?.threadId && isUuid(forwarded.threadId) && "error" in message) {
-                emitSystemError(forwarded.threadId, message.error.message);
-            }
-            if (forwarded && "result" in message) {
-                const result = message.result && typeof message.result === "object"
-                    ? message.result
-                    : undefined;
-                const resultThreadId = typeof result?.thread?.id === "string" ? result.thread.id : forwarded.threadId;
-                if (forwarded.foreground && resultThreadId) {
-                    handoffs.observeDurableThread(connectionId, "stock");
-                    foregroundAfterForward = () => selectForeground(forwarded.foreground, resultThreadId);
-                }
-                else if (forwarded.clearForeground && forwarded.threadId) {
-                    foregroundAfterForward = () => clearForeground(forwarded.threadId);
-                }
-            }
-        }
-        if (message && "method" in message) {
-            if (!("id" in message) && message.method === "account/rateLimits/updated" && foreground?.provider === "claude") {
-                publishForegroundRateLimits(foregroundGeneration);
-                return;
-            }
-            if (!("id" in message) && message.method === "account/rateLimits/updated" && !foreground) {
-                diagnoseUnknownStatus("account/rateLimits/updated");
-            }
-            if (handoffs.captureInternalStockMessage(connectionId, message)) {
-                if (isRequest(message))
-                    stock.send(JSON.stringify({ id: message.id, result: { decision: "decline" } }));
-                return;
+        try {
+            const incoming = isBinary ? undefined : parseRpcMessage(data);
+            let message = incoming;
+            if (message) {
+                stockState.observeResponse(connectionId, message);
+                stockState.observeNotification(message);
             }
-            const rewritten = handoffs.rewriteTitleMessages(message);
-            if (rewritten) {
-                for (const output of rewritten)
-                    sendJson(output);
+            if (message && stockRpc.handle(message))
                 return;
+            if (message && stockSideThreads) {
+                const projection = stockSideThreads.projectMessage(connectionId, message);
+                if (projection.kind === "drop")
+                    return;
+                message = projection.message;
             }
-            if (handoffs.suppressStockTargetMessage(connectionId, message)) {
-                if (isRequest(message))
-                    stock.send(JSON.stringify({ id: message.id, result: { decision: "decline" } }));
+            let foregroundAfterForward;
+            if (message && "method" in message && !("id" in message) && message.method === "remoteControl/status/changed" && remoteControl) {
+                remoteControl.intercept(connectionId, notificationSink, message.params);
                 return;
             }
-            if (handoffs.ownsStockBackendMessage?.(message)) {
-                if (isRequest(message))
-                    stock.send(JSON.stringify({ id: message.id, result: { decision: "decline" } }));
-                return;
+            if (message && isResponse(message)) {
+                completeLatency(message.id, "stock");
+                const forwarded = forwardedRequests.get(requestKey(message.id));
+                forwardedRequests.delete(requestKey(message.id));
+                if (forwarded?.systemEphemeral && "result" in message) {
+                    const result = message.result && typeof message.result === "object"
+                        ? message.result
+                        : undefined;
+                    if (typeof result?.thread?.id === "string") {
+                        handoffs.registerForwardedEphemeralCandidate(connectionId, result.thread.id, forwarded.systemEphemeral);
+                    }
+                }
+                if (forwarded?.threadId && isUuid(forwarded.threadId) && "error" in message) {
+                    emitSystemError(forwarded.threadId, message.error.message);
+                }
+                if (forwarded && "result" in message) {
+                    const result = message.result && typeof message.result === "object"
+                        ? message.result
+                        : undefined;
+                    const resultThreadId = typeof result?.thread?.id === "string" ? result.thread.id : forwarded.threadId;
+                    if (forwarded.foreground && resultThreadId) {
+                        handoffs.observeDurableThread(connectionId, "stock");
+                        foregroundAfterForward = () => selectForeground(forwarded.foreground, resultThreadId);
+                    }
+                    else if (forwarded.clearForeground && forwarded.threadId) {
+                        foregroundAfterForward = () => clearForeground(forwarded.threadId);
+                    }
+                }
             }
-            const params = message.params && typeof message.params === "object" ? message.params : undefined;
-            const nestedThread = params?.thread && typeof params.thread === "object"
-                ? params.thread.id
-                : undefined;
-            const threadId = typeof params?.threadId === "string"
-                ? params.threadId
-                : typeof nestedThread === "string" ? nestedThread : undefined;
-            if (message.method === "error" && threadId) {
-                const error = params?.error && typeof params.error === "object"
-                    ? params.error
+            if (message && "method" in message) {
+                if (!("id" in message) && message.method === "account/rateLimits/updated" && foreground?.provider === "claude") {
+                    publishForegroundRateLimits(foregroundGeneration);
+                    return;
+                }
+                if (!("id" in message) && message.method === "account/rateLimits/updated" && !foreground) {
+                    diagnoseUnknownStatus("account/rateLimits/updated");
+                }
+                if (handoffs.captureInternalStockMessage(connectionId, message)) {
+                    if (isRequest(message))
+                        stock.send(JSON.stringify({ id: message.id, result: { decision: "decline" } }));
+                    return;
+                }
+                const rewritten = handoffs.rewriteTitleMessages(message);
+                if (rewritten) {
+                    for (const output of rewritten)
+                        sendJson(output);
+                    return;
+                }
+                if (handoffs.suppressStockTargetMessage(connectionId, message)) {
+                    if (isRequest(message))
+                        stock.send(JSON.stringify({ id: message.id, result: { decision: "decline" } }));
+                    return;
+                }
+                if (handoffs.ownsStockBackendMessage?.(message)) {
+                    if (isRequest(message))
+                        stock.send(JSON.stringify({ id: message.id, result: { decision: "decline" } }));
+                    return;
+                }
+                const params = message.params && typeof message.params === "object" ? message.params : undefined;
+                const nestedThread = params?.thread && typeof params.thread === "object"
+                    ? params.thread.id
                     : undefined;
-                if (typeof error?.message === "string")
-                    emitSystemError(threadId, error.message);
+                const threadId = typeof params?.threadId === "string"
+                    ? params.threadId
+                    : typeof nestedThread === "string" ? nestedThread : undefined;
+                if (message.method === "error" && threadId) {
+                    const error = params?.error && typeof params.error === "object"
+                        ? params.error
+                        : undefined;
+                    if (typeof error?.message === "string")
+                        emitSystemError(threadId, error.message);
+                }
+            }
+            if (client.readyState === WebSocketState.OPEN) {
+                const outbound = message === incoming ? data : JSON.stringify(message);
+                recorder.frame(connectionId, "gateway_to_client", outbound, isBinary && message === incoming);
+                client.send(outbound, { binary: isBinary && message === incoming });
             }
+            foregroundAfterForward?.();
         }
-        if (client.readyState === WebSocketState.OPEN) {
-            const outbound = message === incoming ? data : JSON.stringify(message);
-            recorder.frame(connectionId, "gateway_to_client", outbound, isBinary && message === incoming);
-            client.send(outbound, { binary: isBinary && message === incoming });
+        catch (error) {
+            logger.error("connection.stock.message-failed", {
+                connectionId,
+                error: error instanceof Error ? error.stack ?? error.message : String(error),
+            });
+            closeClient(1011, "CCodex failed to process a stock event");
         }
-        foregroundAfterForward?.();
     });
-    const closeClient = (code, reason) => {
-        if (client.readyState === WebSocketState.OPEN)
-            client.close(code, reason);
-    };
     stock.on("error", (error) => {
         logger.error("connection.stock.error", { connectionId, error: error.message });
         closeClient(1011, "Stock app-server connection failed");
@@ -1042,6 +1468,7 @@ export function attachClientConnection(client, stockSocket, claudeModels, claude
             }
             stockState.detach(connectionId);
             stockSideThreads?.detachConnection(connectionId);
+            optimisticSideThreads?.detachConnection(connectionId);
             stockRpc.close(new Error("Client connection closed."));
             if (stock.readyState === WebSocketState.OPEN || stock.readyState === WebSocketState.CONNECTING) {
                 stock.close();