@gkorepanov/ccodex 0.4.25 → 0.5.0-rc.2

package/dist/gateway/clientConnection.js

@@ -1,1627 +0,0 @@
-import { validate as isUuid, v7 as uuidv7 } from "uuid";
-import { WebSocket as WebSocketState } from "ws";
-import { connectStock } from "../codex/stockConnection.js";
-import { isRequest, isResponse, parseRpcMessage } from "../protocol/envelopes.js";
-import { RpcError, rpcCodexErrorInfo, rpcError } from "../protocol/errors.js";
-import { mergedModelList } from "./modelList.js";
-import { providerSkillsList } from "./skillList.js";
-import { StockRpc, findStockSection } from "./stockRpc.js";
-import { ThreadCatalog } from "./threadList.js";
-import { ServerRequestIds } from "./serverRequestIds.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";
-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";
-import { isUserSideFork, normalizeUserSideFork } from "./sideFork.js";
-/** Stock RPC failures the App handles itself; a chat banner would only add noise (e.g. app/list 403 from Cloudflare). */
-const BANNERLESS_STOCK_ERRORS = new Set(["thread/read", "turn/steer", "app/list", "app/installed", "mcpServerStatus/list"]);
-function requestedFast(serviceTier) {
-    return serviceTier === "fast" || serviceTier === "priority";
-}
-function fastTransitionNotice(before, after) {
-    if (before && !requestedFast(before.serviceTier) && requestedFast(after.serviceTier)) {
-        return "Fast mode is on — usage limits may be consumed faster.";
-    }
-    return undefined;
-}
-export function attachClientConnection(client, stockSocket, claudeModels, claude, handoffs, subscriptions, logger, cursors, metrics, recorder, remoteControl, features = DEFAULT_FEATURES, providerAvailability, sharedStockState, stockSideThreads, optimisticSideThreads, claudeSkills, threadCatalog) {
-    const connectionId = uuidv7();
-    let resolveClosed;
-    let rejectClosed;
-    const closed = new Promise((resolve, reject) => {
-        resolveClosed = resolve;
-        rejectClosed = reject;
-    });
-    void closed.catch(() => undefined);
-    let connectionAlive = true;
-    const stock = connectStock(stockSocket);
-    const stockRpc = new StockRpc(stock);
-    const catalog = threadCatalog ?? new ThreadCatalog(stockRpc, claude, cursors, handoffs, stockSideThreads);
-    const stockOwned = (threadId) => !claude.ownsThread(threadId) && handoffs.logical?.(threadId)?.epoch.provider !== "claude";
-    const stockState = sharedStockState ?? new StockStateTracker();
-    const queued = [];
-    const requestStarted = new Map();
-    const forwardedRequests = new Map();
-    const recentSystemErrors = new Map();
-    const serverRequestIds = new ServerRequestIds();
-    const requestKey = (id) => `${typeof id}:${id}`;
-    const completeLatency = (id, provider) => {
-        const key = requestKey(id);
-        const started = requestStarted.get(key);
-        if (started === undefined)
-            return;
-        requestStarted.delete(key);
-        metrics.observeLatency(provider, performance.now() - started);
-    };
-    const trackForwardedRequest = (message) => {
-        if (!message || !isRequest(message))
-            return;
-        const params = message.params && typeof message.params === "object"
-            ? message.params
-            : undefined;
-        if (message.method === "initialize" && typeof params?.clientInfo?.name === "string")
-            clientName = params.clientInfo.name;
-        const systemEphemeral = (message.method === "thread/start" || message.method === "thread/fork")
-            && params?.ephemeral === true
-            && (params.threadSource === "system" || (message.method === "thread/start" && params.threadSource !== "user"));
-        const internalEphemeralThread = typeof params?.threadId === "string"
-            && handoffs.ownsSystemEphemeral(connectionId, params.threadId);
-        const stockSide = params?.threadSource === STOCK_SIDE_THREAD_SOURCE;
-        const foreground = !systemEphemeral && !internalEphemeralThread && !stockSide
-            && ["thread/start", "thread/resume", "thread/fork", "turn/start"].includes(message.method)
-            ? "codex"
-            : undefined;
-        forwardedRequests.set(requestKey(message.id), {
-            method: message.method,
-            ...(typeof params?.threadId === "string" ? { threadId: params.threadId } : {}),
-            ...(systemEphemeral
-                ? { systemEphemeral: message.params }
-                : {}),
-            ...(foreground ? { foreground } : {}),
-            ...(message.method === "initialize" && params?.clientInfo?.name === "codex-backend"
-                ? { remoteCatalog: true }
-                : {}),
-            ...(["thread/delete", "thread/unsubscribe"].includes(message.method) ? { clearForeground: true } : {}),
-        });
-    };
-    metrics.connectionOpened();
-    logger.info("connection.opened", { connectionId });
-    recorder.connection("opened", connectionId);
-    const sendJson = (message) => {
-        if (client.readyState !== WebSocketState.OPEN)
-            return;
-        const data = JSON.stringify(message);
-        recorder.frame(connectionId, "gateway_to_client", data, false);
-        client.send(data);
-    };
-    const emitNotice = (notice) => {
-        for (const notification of notice.notifications)
-            sendJson(notification);
-    };
-    const emitTransientNotice = (threadId, text, kind = "info") => {
-        const notice = transientSystemNotice(threadId, text, kind);
-        emitNotice(notice);
-        return notice;
-    };
-    const emitFastTransition = (threadId, before, after) => {
-        const text = fastTransitionNotice(before, after);
-        if (text)
-            emitTransientNotice(threadId, text);
-    };
-    const emitSystemError = (threadId, message) => {
-        const now = Date.now();
-        const key = `${threadId}\u0000${message}`;
-        if (now - (recentSystemErrors.get(key) ?? 0) < 1_000)
-            return;
-        recentSystemErrors.set(key, now);
-        if (recentSystemErrors.size > 64) {
-            for (const [candidate, timestamp] of recentSystemErrors) {
-                if (now - timestamp >= 1_000)
-                    recentSystemErrors.delete(candidate);
-            }
-        }
-        emitTransientNotice(threadId, message, "error");
-    };
-    const sendResult = (id, result) => {
-        completeLatency(id, "claude");
-        sendJson({ id, result });
-    };
-    // Stock sends these before the response, on every qualifying call.
-    const deprecationNotice = (summary) => sendJson({ method: "deprecationNotice", params: { summary, details: null } });
-    const rollbackDeprecated = () => {
-        if (clientName !== "codex-tui")
-            deprecationNotice("thread/rollback is deprecated and will be removed soon");
-    };
-    const fullHistoryDeprecated = (threadId, hint) => {
-        if (claude.readThread(threadId, false).thread.historyMode === "paginated") {
-            deprecationNotice(`Full-history hydration is deprecated for paginated threads; ${hint}, then page with \`thread/turns/list\` and \`thread/items/list\`.`);
-        }
-    };
-    const sendError = (id, code, error) => {
-        completeLatency(id, "claude");
-        sendJson({ id, error: { code, message: error instanceof Error ? error.message : String(error) } });
-    };
-    let foreground;
-    let clientName;
-    let skillsProvider;
-    let foregroundGeneration = 0;
-    let unknownStatusDiagnosed = false;
-    const emitRateLimits = (response) => {
-        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;
-        const result = value;
-        const buckets = result.rateLimitsByLimitId ? Object.values(result.rateLimitsByLimitId) : [];
-        const snapshots = buckets.length > 0 ? buckets : result.rateLimits ? [result.rateLimits] : [];
-        for (const rateLimits of snapshots)
-            sendJson({ method: "account/rateLimits/updated", params: { rateLimits } });
-    };
-    const combinedStatus = async (threadId) => {
-        const availability = providerAvailability
-            ? await providerAvailability.refreshAll()
-            : {
-                claude: { provider: "claude", state: "ready" },
-                codex: { provider: "codex", state: "ready" },
-            };
-        const [claudeUsage, codexRateLimits] = await Promise.all([
-            availability.claude.state === "ready"
-                ? claude.readRateLimitStatus(threadId).catch((error) => ({
-                    rateLimits: claude.cachedRateLimits(),
-                    unavailableReason: error instanceof Error ? error.message : String(error),
-                }))
-                : undefined,
-            availability.codex.state === "ready"
-                ? stockRpc.request("account/rateLimits/read", undefined).catch(() => undefined)
-                : undefined,
-        ]);
-        return formatCCodexStatus({
-            claude: { availability: availability.claude, ...(claudeUsage ? { usage: claudeUsage } : {}) },
-            codex: {
-                availability: availability.codex,
-                ...(codexRateLimits ? { rateLimits: codexRateLimits } : {}),
-            },
-        });
-    };
-    const threadState = async (threadId) => {
-        const logical = handoffs.logical?.(threadId);
-        if (logical?.epoch.provider === "claude") {
-            return formatCCodexState(claude.stateSnapshot(logical.epoch.backendThreadId));
-        }
-        if (claude.ownsThread(threadId))
-            return formatCCodexState(claude.stateSnapshot(threadId));
-        let response;
-        try {
-            response = logical
-                ? (await handoffs.requestLogical("thread/read", { threadId, includeTurns: true }, stockRpc)).result
-                : await stockRpc.request("thread/read", { threadId, includeTurns: true });
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            if (!message.includes("includeTurns is unavailable")
-                && !message.includes("ephemeral threads do not support includeTurns"))
-                throw error;
-            response = logical
-                ? (await handoffs.requestLogical("thread/read", { threadId, includeTurns: false }, stockRpc)).result
-                : await stockRpc.request("thread/read", { threadId, includeTurns: false });
-        }
-        return formatCCodexState(stockState.snapshot(response.thread));
-    };
-    const publishForegroundRateLimits = (generation) => {
-        const selected = foreground;
-        if (!selected)
-            return;
-        if (selected.provider === "claude") {
-            const backend = handoffs.logical?.(selected.threadId)?.epoch.backendThreadId ?? selected.threadId;
-            void claude.readRateLimits(backend).then((response) => {
-                if (foregroundGeneration === generation && foreground?.provider === "claude")
-                    emitRateLimits(response);
-            }).catch((error) => logger.warn("claude.rate-limits.publish-failed", { connectionId, error: String(error) }));
-            return;
-        }
-        void (async () => {
-            if (providerAvailability && (await providerAvailability.read("codex")).state !== "ready")
-                return;
-            const response = await stockRpc.request("account/rateLimits/read", undefined);
-            if (foregroundGeneration === generation && foreground?.provider === "codex")
-                emitStockRateLimits(response);
-        })().catch((error) => logger.warn("codex.rate-limits.publish-failed", { connectionId, error: String(error) }));
-    };
-    const selectForeground = (provider, threadId) => {
-        foreground = { provider, threadId };
-        skillsProvider = provider;
-        unknownStatusDiagnosed = false;
-        foregroundGeneration += 1;
-        publishForegroundRateLimits(foregroundGeneration);
-    };
-    const clearForeground = (threadId) => {
-        if (foreground?.threadId !== threadId)
-            return;
-        foreground = undefined;
-        skillsProvider = undefined;
-        foregroundGeneration += 1;
-    };
-    const diagnoseUnknownStatus = (signal) => {
-        if (unknownStatusDiagnosed)
-            return;
-        unknownStatusDiagnosed = true;
-        logger.warn("provider.status.unknown", {
-            connectionId,
-            signal,
-            behavior: "preserving provider-labelled stock payload until a foreground operation succeeds",
-        });
-    };
-    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 === "error" && params && typeof params === "object") {
-            const failure = params;
-            if (typeof failure.threadId === "string" && typeof failure.error?.message === "string") {
-                emitSystemError(failure.threadId, failure.error.message);
-                if (claude.ownsThread(failure.threadId))
-                    return;
-            }
-        }
-        if (method === "serverRequest/resolved" && params && typeof params === "object") {
-            const requestId = params.requestId;
-            if (typeof requestId === "string") {
-                const wireParams = { ...params, requestId: serverRequestIds.wireId(requestId) };
-                sendJson({ method, params: wireParams });
-                serverRequestIds.release(requestId);
-                return;
-            }
-        }
-        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, transition) => {
-        if (foreground?.provider !== "claude")
-            return;
-        emitRateLimits(response);
-        if (transition)
-            emitRateLimitTransition(foreground.threadId, transition);
-    });
-    const subscribedClaudeThreads = new Set();
-    const subscribeClaude = (threadId) => {
-        if (!connectionAlive
-            || !subscriptions.subscribe(threadId, connectionId, notificationSink, serverRequestSink))
-            return false;
-        subscribedClaudeThreads.add(threadId);
-        claude.cancelEphemeralRelease(threadId);
-        return true;
-    };
-    const muteClaudeDuringSnapshot = (threadId) => {
-        subscribeClaude(threadId);
-        subscriptions.mute(threadId, connectionId);
-    };
-    const projectSideResult = (publicThreadId, target, result) => {
-        const projected = projectRpcToPublicThread({ result }, { publicThreadId, backendThreadId: target.backendThreadId }).result;
-        const thread = projected?.thread;
-        if (!thread || thread.id !== publicThreadId)
-            return projected;
-        return { ...projected, thread: {
-                ...thread, sessionId: publicThreadId, ephemeral: true, path: null, threadSource: "user",
-                status: thread.status.type === "notLoaded" ? { type: "idle" } : thread.status,
-            } };
-    };
-    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, forkParams) => {
-        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, { provider, params: forkParams });
-        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);
-            sides.detach(publicThreadId, connectionId);
-            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.inject(publicThreadId, publicParams.items, async (target, items) => {
-                const params = { ...publicParams, items, 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/searchOccurrences") {
-                    const result = target.provider === "claude"
-                        ? claude.searchOccurrences(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));
-                    }
-                    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.prepareAppTurn(turn);
-                        sendResult(request.id, prepared.response);
-                        selectForeground("claude", publicThreadId);
-                        emitFastTransition(publicThreadId, before, claude.currentThreadSettings(target.backendThreadId));
-                        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);
-        const internalServerRequestId = message && isResponse(message)
-            ? serverRequestIds.internalId(message.id)
-            : undefined;
-        if (message && isResponse(message) && internalServerRequestId) {
-            const response = "result" in message ? message.result : { rpcError: message.error };
-            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 });
-            }
-            return;
-        }
-        if (message && isRequest(message)) {
-            requestStarted.set(requestKey(message.id), performance.now());
-            try {
-                if (message.method === "remoteControl/enable" && remoteControl) {
-                    const params = message.params;
-                    sendResult(message.id, await remoteControl.enable(params?.ephemeral === true));
-                    return;
-                }
-                if (message.method === "remoteControl/disable" && remoteControl) {
-                    const params = message.params;
-                    sendResult(message.id, await remoteControl.disable(params?.ephemeral === true));
-                    return;
-                }
-                if (message.method === "remoteControl/status/read" && remoteControl?.current()) {
-                    sendResult(message.id, remoteControl.current());
-                    return;
-                }
-                if ((message.method === "remoteControl/pairing/start" || message.method === "remoteControl/pairing/status") && remoteControl) {
-                    sendResult(message.id, await remoteControl.pairing(message.method, message.params ?? null, clientName));
-                    return;
-                }
-                if (message.method === "model/list") {
-                    // model/list precedes a new composer or a model change. skills/list
-                    // carries no thread/model id, so the provider is unknown until the
-                    // next thread operation confirms the selection.
-                    skillsProvider = undefined;
-                    sendResult(message.id, await mergedModelList((message.params ?? {}), stockRpc, claudeModels, logger, cursors));
-                    return;
-                }
-                if (message.method === "skills/list" && features.claudeSkills && claudeSkills) {
-                    const backendThreadId = foreground?.provider === "claude"
-                        ? handoffs.logical?.(foreground.threadId)?.epoch.backendThreadId ?? foreground.threadId
-                        : undefined;
-                    const defaultCwd = backendThreadId && claude.ownsThread(backendThreadId)
-                        ? claude.readThread(backendThreadId, false).thread.cwd
-                        : undefined;
-                    sendResult(message.id, await providerSkillsList((message.params ?? {}), stockRpc, claudeSkills, skillsProvider, defaultCwd));
-                    return;
-                }
-                if (message.method === "account/rateLimits/read" && foreground?.provider === "claude") {
-                    const backend = handoffs.logical?.(foreground.threadId)?.epoch.backendThreadId ?? foreground.threadId;
-                    sendResult(message.id, await claude.readRateLimits(backend));
-                    return;
-                }
-                if (message.method === "account/usage/read") {
-                    // 0.149.1 adds an optional per-thread scope. Route by the requested
-                    // thread's owner; only the legacy parameterless call uses foreground.
-                    const requestedThreadId = message.params?.threadId;
-                    const claudeScoped = requestedThreadId
-                        ? (handoffs.logical?.(requestedThreadId)?.epoch.provider === "claude"
-                            || claude.ownsThread(requestedThreadId))
-                        : foreground?.provider === "claude";
-                    if (claudeScoped) {
-                        // Lifetime/streak Codex statistics have no Claude equivalent and
-                        // must not be mislabelled as provider usage.
-                        sendResult(message.id, {
-                            summary: {
-                                lifetimeTokens: null,
-                                peakDailyTokens: null,
-                                longestRunningTurnSec: null,
-                                currentStreakDays: null,
-                                longestStreakDays: null,
-                            },
-                            dailyUsageBuckets: null,
-                            threadUsage: null,
-                        });
-                        return;
-                    }
-                }
-                if (message.method === "account/rateLimits/read" && !foreground)
-                    diagnoseUnknownStatus("account/rateLimits/read");
-                if (message.method === "thread/list") {
-                    const result = await catalog.list((message.params ?? {}));
-                    sendResult(message.id, result);
-                    return;
-                }
-                if (message.method === "thread/loaded/list") {
-                    sendResult(message.id, await catalog.loaded((message.params ?? {}), optimisticSideThreads?.projectLoadedIds.bind(optimisticSideThreads)));
-                    return;
-                }
-                if (message.method === "thread/search") {
-                    sendResult(message.id, await catalog.search((message.params ?? {})));
-                    return;
-                }
-                if (message.method === "thread/start") {
-                    const params = (message.params ?? {});
-                    if (params.model && claude.ownsModel(params.model)) {
-                        const result = await claude.startThread(params);
-                        if (!result.thread.ephemeral)
-                            handoffs.observeDurableThread(connectionId, "claude", result.thread.id);
-                        sendResult(message.id, result);
-                        selectForeground("claude", result.thread.id);
-                        subscribeClaude(result.thread.id);
-                        await claude.announceThread(result.thread);
-                        emitFastTransition(result.thread.id, undefined, claude.currentThreadSettings(result.thread.id));
-                        return;
-                    }
-                }
-                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")) {
-                    const backend = handoffs.logical?.(params.threadId)?.epoch.backendThreadId ?? params.threadId;
-                    if (!claude.isChildProjection(backend)) {
-                        const promptedCompact = claudeCompactCommand((message.params ?? {}).input);
-                        if (promptedCompact) {
-                            const prepared = await claude.preparePromptedCompact(backend, promptedCompact);
-                            sendResult(message.id, prepared.response);
-                            selectForeground("claude", params.threadId);
-                            await prepared.announce();
-                            return;
-                        }
-                    }
-                }
-                if (params.threadId && message.method === "turn/start" && features.statusCommand) {
-                    const turn = (message.params ?? {});
-                    if (isCCodexStateCommand(turn.input)) {
-                        if (claude.ownsThread(params.threadId) && !claude.isChildProjection(params.threadId)) {
-                            const prepared = await claude.prepareStateTurn(turn, () => threadState(params.threadId));
-                            sendResult(message.id, prepared.response);
-                            selectForeground("claude", params.threadId);
-                            await prepared.announce();
-                            prepared.start();
-                        }
-                        else {
-                            const notice = transientCommandNotice(params.threadId, turn.input, await threadState(params.threadId), turn.clientUserMessageId ?? null);
-                            sendResult(message.id, notice.response);
-                            selectForeground(claude.ownsThread(params.threadId) ? "claude" : "codex", params.threadId);
-                            emitNotice(notice);
-                        }
-                        return;
-                    }
-                    if (isCCodexStatusCommand(turn.input)) {
-                        if (claude.ownsThread(params.threadId) && !claude.isChildProjection(params.threadId)) {
-                            const prepared = await claude.prepareStatusTurn(turn, () => combinedStatus(params.threadId));
-                            sendResult(message.id, prepared.response);
-                            selectForeground("claude", params.threadId);
-                            await prepared.announce();
-                            prepared.start();
-                        }
-                        else {
-                            const notice = transientCommandNotice(params.threadId, turn.input, await combinedStatus(claude.ownsThread(params.threadId) ? params.threadId : undefined), turn.clientUserMessageId ?? null);
-                            sendResult(message.id, notice.response);
-                            selectForeground(claude.ownsThread(params.threadId) ? "claude" : "codex", params.threadId);
-                            emitNotice(notice);
-                        }
-                        return;
-                    }
-                }
-                if (params.threadId && message.method === "turn/start"
-                    && (handoffs.logical?.(params.threadId)?.epoch.provider === "stock"
-                        || (!handoffs.logical?.(params.threadId) && !claude.ownsThread(params.threadId)))
-                    && providerAvailability) {
-                    let availability = await providerAvailability.read("codex");
-                    if (availability.state !== "ready")
-                        availability = await providerAvailability.refresh("codex");
-                    if (availability.state !== "ready") {
-                        const notice = transientSystemNotice(params.threadId, providerUnavailableMessage(availability), "error");
-                        sendResult(message.id, notice.response);
-                        selectForeground("codex", params.threadId);
-                        emitNotice(notice);
-                        return;
-                    }
-                }
-                if (params.threadId && message.method === "turn/start") {
-                    handoffs.observeDurableTurn(connectionId, (message.params ?? {}));
-                }
-                if (params.threadId && message.method === "thread/settings/update") {
-                    const update = (message.params ?? {});
-                    const staged = handoffs.interceptSettings(update);
-                    if (staged.handled) {
-                        sendResult(message.id, {});
-                        if (staged.notification)
-                            sendJson({
-                                method: "thread/settings/updated",
-                                params: { threadId: params.threadId, threadSettings: staged.notification },
-                            });
-                        return;
-                    }
-                }
-                if (params.threadId && message.method === "turn/start") {
-                    const turn = (message.params ?? {});
-                    const pending = handoffs.stageTurnSwitch
-                        ? handoffs.stageTurnSwitch(turn)
-                        : handoffs.pending(params.threadId);
-                    if (pending) {
-                        subscriptions.subscribe(params.threadId, connectionId, notificationSink, serverRequestSink);
-                        const migration = providerMigrationNotice(params.threadId);
-                        sendResult(message.id, migration.response);
-                        for (const notification of migration.notifications) {
-                            subscriptions.emitPublic(params.threadId, notification.method, notification.params);
-                        }
-                        const execute = async () => {
-                            const switchProviderTurn = handoffs.switchProviderTurn;
-                            let compacted = false;
-                            const completeCompaction = () => {
-                                if (compacted)
-                                    return;
-                                compacted = true;
-                                for (const notification of providerMigrationCompleted(params.threadId, migration)) {
-                                    subscriptions.emitPublic(params.threadId, notification.method, notification.params);
-                                }
-                            };
-                            if (switchProviderTurn) {
-                                await switchProviderTurn.call(handoffs, turn, migration.response.turn, stockRpc, connectionId, completeCompaction);
-                                selectForeground(pending.targetProvider === "claude" ? "claude" : "codex", params.threadId);
-                                return;
-                            }
-                            if (pending.sourceProvider === "claude") {
-                                const hidden = await claude.forkThread({
-                                    threadId: params.threadId, ephemeral: true, excludeTurns: true, threadSource: "subAgent",
-                                });
-                                await claude.compactThread(hidden.thread.id);
-                                const target = await stockRpc.request("thread/start", {
-                                    model: pending.targetModel,
-                                    cwd: turn.cwd,
-                                    approvalPolicy: turn.approvalPolicy,
-                                    permissions: turn.permissions,
-                                });
-                                completeCompaction();
-                                await stockRpc.request("turn/start", { ...turn, threadId: target.thread.id });
-                                selectForeground("codex", params.threadId);
-                                return;
-                            }
-                            const hidden = await stockRpc.request("thread/fork", {
-                                threadId: params.threadId, ephemeral: true, excludeTurns: true,
-                            });
-                            await stockRpc.request("turn/start", {
-                                threadId: hidden.thread.id,
-                                input: [{ type: "text", text: "Compact this task for a provider handoff.", text_elements: [] }],
-                            });
-                            const target = await claude.startThread({
-                                model: pending.targetModel,
-                                ...(turn.cwd !== undefined ? { cwd: turn.cwd } : {}),
-                                ...(turn.approvalPolicy !== undefined ? { approvalPolicy: turn.approvalPolicy } : {}),
-                                ...(turn.permissions !== undefined ? { permissions: turn.permissions } : {}),
-                            });
-                            const prepared = await claude.prepareTurn({ ...turn, threadId: target.thread.id });
-                            completeCompaction();
-                            await prepared.announce();
-                            prepared.start();
-                            selectForeground("claude", params.threadId);
-                        };
-                        void execute().catch((error) => {
-                            const message = error instanceof Error ? error.message : String(error);
-                            for (const notification of providerMigrationFailed(params.threadId, migration, message))
-                                subscriptions.emitPublic(params.threadId, notification.method, notification.params);
-                            for (const notification of transientSystemNotice(params.threadId, `Provider switch failed; your message was not sent\n  ↳ ${message}`, "error").notifications)
-                                subscriptions.emitPublic(params.threadId, notification.method, notification.params);
-                            const source = handoffs.logical?.(params.threadId);
-                            if (source)
-                                subscriptions.emitPublic(params.threadId, "thread/settings/updated", {
-                                    threadId: params.threadId,
-                                    threadSettings: {
-                                        ...source.epoch.settings,
-                                        model: source.epoch.model,
-                                        modelProvider: source.epoch.provider === "claude" ? "claude" : "openai",
-                                    },
-                                });
-                        });
-                        return;
-                    }
-                }
-                if (params.threadId && handoffs.logical?.(params.threadId)
-                    && message.method !== "thread/fork" && message.method !== "thread/rollback"
-                    && message.method !== "thread/revert") {
-                    if (message.method === "thread/unsubscribe") {
-                        subscriptions.unsubscribe(params.threadId, connectionId);
-                        sendResult(message.id, { status: "unsubscribed" });
-                        clearForeground(params.threadId);
-                        return;
-                    }
-                    subscriptions.subscribe(params.threadId, connectionId, notificationSink, serverRequestSink);
-                    const handled = await handoffs.requestLogical(message.method, (message.params ?? {}), stockRpc);
-                    sendResult(message.id, handled.result);
-                    selectForeground(handled.provider === "claude" ? "claude" : "codex", params.threadId);
-                    await handled.after?.();
-                    return;
-                }
-                if (params.threadId && message.method === "turn/start") {
-                    const target = handoffs.blockedTurnTarget((message.params ?? {}));
-                    if (target) {
-                        const notice = transientSystemNotice(params.threadId, `Provider change to '${target}' requires Fork. The source task was not modified. Choose Fork to migrate history, or select a source-provider model to continue here.`);
-                        sendResult(message.id, notice.response);
-                        emitNotice(notice);
-                        return;
-                    }
-                }
-                if (params.threadId && message.method === "thread/fork") {
-                    const forkParams = normalizeUserSideFork((message.params ?? {}));
-                    if (handoffs.isSystemEphemeralFork(forkParams)) {
-                        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 = await 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, targetThreadId);
-                                    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 };
-                            }, { ...forkParams, threadId: logicalSource.epoch.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, targetThreadId);
-                                    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 };
-                            }, completedParams);
-                            return;
-                        }
-                    }
-                    const logicalFork = handoffs.forkLogical;
-                    const overlay = handoffs.overlay(params.threadId);
-                    if ((logicalFork && handoffs.logical?.(params.threadId)) || overlay?.epochs) {
-                        if (logicalFork) {
-                            sendResult(message.id, await logicalFork.call(handoffs, forkParams, stockRpc, connectionId));
-                            return;
-                        }
-                        const turns = overlay.epochs.flatMap((epoch) => epoch.publicTurnIds.map((id) => ({ id, items: [], status: "completed" })));
-                        sendResult(message.id, { thread: { id: uuidv7(), forkedFromId: params.threadId, turns } });
-                        return;
-                    }
-                    if (forkParams.model) {
-                        const sourceProvider = claude.ownsThread(params.threadId) ? "claude" : "stock";
-                        const targetProvider = claude.ownsModel(forkParams.model) ? "claude" : "stock";
-                        if (sourceProvider !== targetProvider) {
-                            throw new RpcError(-32602, "Fork is same-provider only. Change the model and send a message to switch provider.");
-                        }
-                    }
-                }
-                if (params.threadId && message.method === "thread/delete"
-                    && handoffs.ownsSystemEphemeral(connectionId, params.threadId)) {
-                    const result = await stockRpc.request("thread/delete", message.params ?? {});
-                    handoffs.releaseSystemEphemeral(connectionId, params.threadId);
-                    sendResult(message.id, result);
-                    return;
-                }
-                if (params.threadId && message.method === "thread/unsubscribe"
-                    && handoffs.ownsSystemEphemeral(connectionId, params.threadId)) {
-                    const result = await stockRpc.request("thread/unsubscribe", message.params ?? {});
-                    handoffs.releaseSystemEphemeral(connectionId, params.threadId);
-                    sendResult(message.id, result);
-                    return;
-                }
-                if (params.threadId && message.method === "thread/delete" && !claude.ownsThread(params.threadId)
-                    && (handoffs.pending(params.threadId) || handoffs.overlay(params.threadId))) {
-                    const result = await stockRpc.request("thread/delete", message.params ?? {});
-                    handoffs.clearThread(params.threadId);
-                    sendResult(message.id, result);
-                    clearForeground(params.threadId);
-                    return;
-                }
-                if (params.threadId && message.method === "thread/rollback" && handoffs.logical?.(params.threadId)) {
-                    rollbackDeprecated();
-                    sendResult(message.id, await handoffs.rollbackLogicalThread((message.params ?? {}), stockRpc, connectionId));
-                    return;
-                }
-                if (params.threadId && message.method === "thread/revert" && handoffs.logical?.(params.threadId)) {
-                    sendResult(message.id, await handoffs.revertLogicalThread((message.params ?? {}), stockRpc, connectionId));
-                    subscriptions.emitPublic(params.threadId, "thread/reverted", { threadId: params.threadId });
-                    return;
-                }
-                if (params.threadId && handoffs.overlay(params.threadId)) {
-                    if (message.method === "thread/rollback") {
-                        const rollback = (message.params ?? {});
-                        const overlay = handoffs.overlay(params.threadId);
-                        if (overlay.epochs) {
-                            const turns = overlay.epochs.flatMap((epoch) => epoch.publicTurnIds.map((turnId) => ({ epoch, turnId })));
-                            const selected = turns.at(turns.length - rollback.numTurns - 1);
-                            if (!selected)
-                                throw new RpcError(-32602, "Fork rollback removed every provider turn.");
-                            if (selected.epoch.provider === "claude") {
-                                await claude.forkThread({
-                                    threadId: selected.epoch.backendThreadId,
-                                    lastTurnId: selected.turnId,
-                                });
-                            }
-                            else {
-                                await stockRpc.request("thread/fork", {
-                                    threadId: selected.epoch.backendThreadId,
-                                    lastTurnId: selected.turnId,
-                                });
-                            }
-                            sendResult(message.id, {});
-                            return;
-                        }
-                    }
-                    if (message.method === "thread/read") {
-                        sendResult(message.id, await handoffs.readOverlay((message.params ?? {}), stockRpc));
-                        return;
-                    }
-                    if (message.method === "thread/resume") {
-                        sendResult(message.id, await handoffs.resumeOverlay((message.params ?? {}), stockRpc));
-                        selectForeground("codex", params.threadId);
-                        return;
-                    }
-                    if (message.method === "thread/turns/list") {
-                        sendResult(message.id, await handoffs.turnsOverlay((message.params ?? {}), stockRpc));
-                        return;
-                    }
-                    if (message.method === "thread/items/list") {
-                        sendResult(message.id, await handoffs.itemsOverlay((message.params ?? {}), stockRpc));
-                        return;
-                    }
-                }
-                if (params.threadId && claude.ownsThread(params.threadId)) {
-                    if (message.method === "thread/resume") {
-                        muteClaudeDuringSnapshot(params.threadId);
-                        try {
-                            const resume = (message.params ?? {});
-                            const prepared = await claude.prepareResume(resume);
-                            const result = prepared.response;
-                            const snapshotHighWatermark = claude.eventHighWatermark(params.threadId);
-                            const tokenUsage = claude.latestTokenUsage(params.threadId);
-                            if (!resume.excludeTurns)
-                                fullHistoryDeprecated(params.threadId, "use `excludeTurns: true`");
-                            sendResult(message.id, result);
-                            selectForeground("claude", params.threadId);
-                            subscriptions.unmute(params.threadId, connectionId);
-                            if (tokenUsage && tokenUsage.sequence <= snapshotHighWatermark) {
-                                notificationSink(tokenUsage.method, tokenUsage.params);
-                            }
-                            for (const event of claude.eventsAfter(params.threadId, snapshotHighWatermark)) {
-                                notificationSink(event.method, event.params);
-                            }
-                            await prepared.notifyGoalSnapshot(notificationSink);
-                            await claude.replayPendingRequests(params.threadId, connectionId);
-                            const failedFork = handoffs.claimFailedFork(params.threadId);
-                            if (failedFork)
-                                emitTransientNotice(params.threadId, `Cross-provider fork failed while the App was disconnected: ${failedFork}`, "error");
-                        }
-                        catch (error) {
-                            subscriptions.unmute(params.threadId, connectionId);
-                            subscriptions.unsubscribe(params.threadId, connectionId);
-                            throw error;
-                        }
-                        return;
-                    }
-                    if (message.method === "thread/read") {
-                        const read = (message.params ?? {});
-                        if (read.includeTurns)
-                            fullHistoryDeprecated(params.threadId, "omit `includeTurns` or set it to `false`");
-                        sendResult(message.id, claude.readThread(read.threadId, read.includeTurns ?? false));
-                        const failedFork = handoffs.claimFailedFork(params.threadId);
-                        if (failedFork)
-                            emitTransientNotice(params.threadId, `Cross-provider fork failed while the App was disconnected: ${failedFork}`, "error");
-                        return;
-                    }
-                    if (message.method === "thread/turns/list") {
-                        const list = (message.params ?? {});
-                        sendResult(message.id, claude.turnsPage(list));
-                        return;
-                    }
-                    if (message.method === "thread/items/list") {
-                        sendResult(message.id, claude.listItems((message.params ?? {})));
-                        return;
-                    }
-                    if (message.method === "thread/searchOccurrences") {
-                        sendResult(message.id, claude.searchOccurrences((message.params ?? {})));
-                        return;
-                    }
-                    if (message.method === "thread/unsubscribe") {
-                        subscriptions.unsubscribe(params.threadId, connectionId);
-                        subscribedClaudeThreads.delete(params.threadId);
-                        sendResult(message.id, { status: "unsubscribed" });
-                        clearForeground(params.threadId);
-                        return;
-                    }
-                    if (message.method === "thread/name/set") {
-                        sendResult(message.id, await claude.setThreadName((message.params ?? {})));
-                        return;
-                    }
-                    if (message.method === "thread/metadata/update") {
-                        sendResult(message.id, await claude.updateThreadMetadata((message.params ?? {})));
-                        return;
-                    }
-                    if (message.method === "thread/settings/update") {
-                        const update = (message.params ?? {});
-                        const before = claude.currentThreadSettings(params.threadId);
-                        const result = await claude.updateThreadSettings(update);
-                        const after = claude.currentThreadSettings(params.threadId);
-                        sendResult(message.id, result);
-                        emitFastTransition(params.threadId, before, after);
-                        return;
-                    }
-                    if (message.method === "thread/archive") {
-                        sendResult(message.id, await claude.archiveThread(params.threadId));
-                        return;
-                    }
-                    if (message.method === "thread/unarchive") {
-                        sendResult(message.id, await claude.unarchiveThread(params.threadId));
-                        return;
-                    }
-                    if (message.method === "thread/delete") {
-                        const result = await claude.deleteThread(params.threadId);
-                        handoffs.clearThread(params.threadId);
-                        sendResult(message.id, result);
-                        clearForeground(params.threadId);
-                        return;
-                    }
-                    if (message.method === "thread/fork") {
-                        const fork = (message.params ?? {});
-                        const result = await claude.forkThread(normalizeUserSideFork(fork));
-                        if (!fork.excludeTurns && !fork.ephemeral)
-                            fullHistoryDeprecated(params.threadId, "use `excludeTurns: true`");
-                        sendResult(message.id, result);
-                        selectForeground("claude", result.thread.id);
-                        subscribeClaude(result.thread.id);
-                        await claude.announceThread(result.thread);
-                        return;
-                    }
-                    if (message.method === "thread/rollback") {
-                        rollbackDeprecated();
-                        sendResult(message.id, await claude.rollbackThread((message.params ?? {})));
-                        return;
-                    }
-                    if (message.method === "thread/revert") {
-                        const revert = (message.params ?? {});
-                        sendResult(message.id, await claude.revertThread(revert));
-                        // Stock ordering: the response lands before the lifecycle notification.
-                        subscriptions.emit(params.threadId, "thread/reverted", { threadId: params.threadId });
-                        return;
-                    }
-                    if (message.method === "thread/section/move") {
-                        const move = (message.params ?? {});
-                        await catalog.moveInSection(move, stockOwned);
-                        await claude.setThreadSection(params.threadId, move.sectionId === null ? null : await findStockSection(stockRpc, move.sectionId));
-                        sendResult(message.id, {});
-                        return;
-                    }
-                    if (message.method === "thread/compact/start") {
-                        sendResult(message.id, await claude.compactThread(params.threadId));
-                        return;
-                    }
-                    if (message.method === "thread/inject_items") {
-                        sendResult(message.id, await claude.injectItems((message.params ?? {})));
-                        return;
-                    }
-                    if (message.method === "thread/shellCommand") {
-                        sendResult(message.id, await claude.shellCommand((message.params ?? {})));
-                        return;
-                    }
-                    if (message.method === "thread/backgroundTerminals/clean") {
-                        sendResult(message.id, await claude.cleanBackgroundTerminals((message.params ?? {})));
-                        return;
-                    }
-                    if (message.method === "thread/backgroundTerminals/list") {
-                        sendResult(message.id, await claude.listBackgroundTerminals((message.params ?? {})));
-                        return;
-                    }
-                    if (message.method === "thread/backgroundTerminals/terminate") {
-                        sendResult(message.id, await claude.terminateBackgroundTerminal((message.params ?? {})));
-                        return;
-                    }
-                    if (message.method === "review/start") {
-                        const prepared = await claude.prepareReview((message.params ?? {}));
-                        if (prepared.forkedThread) {
-                            subscribeClaude(prepared.forkedThread.id);
-                            await claude.announceThread(prepared.forkedThread);
-                        }
-                        sendResult(message.id, prepared.response);
-                        await prepared.announce();
-                        prepared.start();
-                        return;
-                    }
-                    if (message.method === "thread/goal/set") {
-                        const prepared = await claude.prepareGoalSet((message.params ?? {}));
-                        try {
-                            sendResult(message.id, prepared.response);
-                        }
-                        finally {
-                            await prepared.notify();
-                        }
-                        return;
-                    }
-                    if (message.method === "thread/goal/get") {
-                        sendResult(message.id, await claude.getGoal(params.threadId));
-                        return;
-                    }
-                    if (message.method === "thread/queue/list") {
-                        sendResult(message.id, claude.listQueue((message.params ?? {})));
-                        return;
-                    }
-                    if (message.method === "app/list" || message.method === "mcpServerStatus/list") {
-                        // Codex apps and MCP servers never apply to a Claude runtime.
-                        sendResult(message.id, { data: [], nextCursor: null });
-                        return;
-                    }
-                    if (message.method === "app/installed") {
-                        sendResult(message.id, { apps: [] });
-                        return;
-                    }
-                    if (message.method === "thread/queue/add") {
-                        const prepared = await claude.addQueuedSubmission((message.params ?? {}));
-                        sendResult(message.id, prepared.response);
-                        await prepared.after();
-                        return;
-                    }
-                    if (message.method === "thread/queue/update") {
-                        sendResult(message.id, await claude.updateQueuedSubmission((message.params ?? {})));
-                        return;
-                    }
-                    if (message.method === "thread/queue/delete") {
-                        sendResult(message.id, await claude.deleteQueuedSubmission((message.params ?? {})));
-                        return;
-                    }
-                    if (message.method === "thread/queue/reorder") {
-                        sendResult(message.id, await claude.reorderQueue((message.params ?? {})));
-                        return;
-                    }
-                    if (message.method === "thread/queue/start") {
-                        const prepared = await claude.prepareQueueStart((message.params ?? {}));
-                        sendResult(message.id, prepared.response);
-                        selectForeground("claude", params.threadId);
-                        await prepared.announce();
-                        prepared.start();
-                        return;
-                    }
-                    if (message.method === "thread/goal/clear") {
-                        const prepared = await claude.prepareGoalClear(params.threadId);
-                        try {
-                            sendResult(message.id, prepared.response);
-                        }
-                        finally {
-                            await prepared.notify();
-                        }
-                        return;
-                    }
-                    if (message.method === "turn/start") {
-                        const turn = (message.params ?? {});
-                        const before = claude.currentThreadSettings(params.threadId);
-                        const prepared = await claude.prepareAppTurn(turn);
-                        const after = claude.currentThreadSettings(params.threadId);
-                        sendResult(message.id, prepared.response);
-                        selectForeground("claude", params.threadId);
-                        emitFastTransition(params.threadId, before, after);
-                        await prepared.announce();
-                        prepared.start();
-                        return;
-                    }
-                    if (message.method === "turn/interrupt") {
-                        await claude.interruptTurn((message.params ?? {}));
-                        sendResult(message.id, {});
-                        return;
-                    }
-                    if (message.method === "turn/steer") {
-                        sendResult(message.id, await claude.steerTurn((message.params ?? {})));
-                        return;
-                    }
-                    throw new RpcError(-32601, `Method '${message.method}' is not implemented for Claude threads yet.`);
-                }
-                if (params.threadId && (message.method === "thread/read" || message.method === "thread/resume")) {
-                    const failedFork = handoffs.claimFailedFork(params.threadId);
-                    if (failedFork)
-                        emitTransientNotice(params.threadId, `Cross-provider fork failed while the App was disconnected: ${failedFork}`, "error");
-                }
-            }
-            catch (error) {
-                const failure = rpcError(error);
-                logger.warn("claude.request.failed", {
-                    connectionId,
-                    method: message.method,
-                    code: failure.code,
-                    error: failure.message,
-                });
-                const params = message.params && typeof message.params === "object"
-                    ? message.params
-                    : undefined;
-                const threadId = typeof params?.threadId === "string" ? params.threadId : undefined;
-                const childProjection = Boolean(threadId && claude.isChildProjection(threadId));
-                // A steer that lost its turn (App races an automatic queue drain) expects a plain RPC error, not a banner.
-                const silent = message.method === "turn/steer";
-                let attachedToActiveTurn = false;
-                if (threadId && !childProjection && !silent && claude.ownsThread(threadId)) {
-                    attachedToActiveTurn = await claude.reportError(threadId, typeof params?.turnId === "string" ? params.turnId : undefined, failure.message, rpcCodexErrorInfo(failure.code)).catch((diagnosticError) => {
-                        logger.warn("claude.request.error-report-failed", {
-                            connectionId,
-                            method: message.method,
-                            originalError: failure.message,
-                            diagnosticError: diagnosticError instanceof Error
-                                ? diagnosticError.message
-                                : String(diagnosticError),
-                        });
-                        return false;
-                    });
-                }
-                if (message.method === "turn/start" && threadId && !childProjection && !attachedToActiveTurn) {
-                    const notice = transientSystemNotice(threadId, failure.message, "error");
-                    sendResult(message.id, notice.response);
-                    emitNotice(notice);
-                    return;
-                }
-                if (threadId && !childProjection && !attachedToActiveTurn && !silent)
-                    emitSystemError(threadId, failure.message);
-                sendError(message.id, failure.code, failure.message);
-                if (threadId && !childProjection && !claude.ownsThread(threadId)) {
-                    sendJson({
-                        method: "error",
-                        params: {
-                            error: { message: failure.message, codexErrorInfo: rpcCodexErrorInfo(failure.code), additionalDetails: null },
-                            willRetry: false,
-                            threadId,
-                            turnId: typeof params?.turnId === "string" ? params.turnId : uuidv7(),
-                        },
-                    });
-                }
-                return;
-            }
-        }
-        let forwarded = message;
-        if (message && isRequest(message) && message.method === "thread/section/move") {
-            // Stock only orders its own threads; the merged order lives in the gateway.
-            const move = (message.params ?? {});
-            try {
-                forwarded = { ...message, params: { ...move, beforeThreadId: await catalog.moveInSection(move, stockOwned) } };
-            }
-            catch (error) {
-                const failure = rpcError(error);
-                sendError(message.id, failure.code, failure.message);
-                return;
-            }
-        }
-        if (message && isRequest(message) && message.method === "turn/start") {
-            const params = handoffs.prepareTitleTurn(connectionId, (message.params ?? {}));
-            if (params !== message.params)
-                forwarded = { ...message, params };
-        }
-        if (message && isRequest(message) && message.method === "thread/fork") {
-            const params = normalizeUserSideFork((message.params ?? {}));
-            if (params !== message.params)
-                forwarded = { ...message, params };
-            if (params.ephemeral !== true && params.threadSource !== "system") {
-                const completed = stockState.completeForkParams(params);
-                if (completed !== params)
-                    forwarded = { ...message, params: completed };
-            }
-        }
-        if (forwarded && stockSideThreads) {
-            forwarded = await stockSideThreads.prepareRequest(connectionId, forwarded, stockRpc);
-        }
-        if (forwarded)
-            stockState.observeRequest(connectionId, forwarded);
-        trackForwardedRequest(forwarded);
-        if (stock.readyState === WebSocketState.OPEN) {
-            stock.send(forwarded === message ? data : JSON.stringify(forwarded), { binary: isBinary });
-        }
-        else {
-            queued.push({ data: forwarded === message ? data : Buffer.from(JSON.stringify(forwarded)), isBinary });
-        }
-    });
-    stock.once("open", () => {
-        for (const message of queued.splice(0)) {
-            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) => {
-        try {
-            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) {
-                const projection = stockSideThreads.projectMessage(connectionId, message);
-                if (projection.kind === "drop")
-                    return;
-                message = projection.message;
-            }
-            let foregroundAfterForward;
-            let reconcileRemoteAfterForward = false;
-            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
-                    && !BANNERLESS_STOCK_ERRORS.has(forwarded.method)) {
-                    emitSystemError(forwarded.threadId, message.error.message);
-                }
-                if (forwarded && "result" in message) {
-                    reconcileRemoteAfterForward = forwarded.remoteCatalog === true;
-                    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", resultThreadId);
-                        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;
-                }
-                if (message.method === "turn/completed") {
-                    void handoffs.persistGeneratedTitle(message).catch((error) => {
-                        logger.warn("thread.generated-title.failed", { connectionId, error: String(error) });
-                    });
-                }
-                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;
-                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 (reconcileRemoteAfterForward) {
-                void catalog.reconcileRemote((method, params) => sendJson({ method, params }))
-                    .catch((error) => logger.error("remote.catalog.reconcile-failed", {
-                    connectionId,
-                    error: error instanceof Error ? error.message : String(error),
-                }));
-            }
-        }
-        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");
-        }
-    });
-    stock.on("error", (error) => {
-        logger.error("connection.stock.error", { connectionId, error: error.message });
-        closeClient(1011, "Stock app-server connection failed");
-    });
-    stock.on("close", () => closeClient(1011, "Stock app-server closed"));
-    client.on("error", (error) => logger.warn("connection.client.error", { connectionId, error: error.message }));
-    let closeStarted = false;
-    client.on("close", (code, reason) => {
-        if (closeStarted)
-            return;
-        closeStarted = true;
-        connectionAlive = false;
-        void (async () => {
-            metrics.connectionClosed();
-            subscribedClaudeThreads.clear();
-            subscriptions.detach(connectionId);
-            claude.unsubscribeRateLimits(connectionId);
-            remoteControl?.detach(connectionId);
-            let detach;
-            try {
-                await handoffs.detachConnection(connectionId, stockRpc);
-            }
-            catch (error) {
-                detach = error;
-            }
-            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();
-            }
-            logger.info("connection.closed", { connectionId });
-            recorder.connection("closed", connectionId, { code, reason: reason.toString("utf8") });
-            const errors = [
-                ...(detach === undefined ? [] : [detach]),
-            ];
-            if (errors.length > 0)
-                throw new AggregateError(errors, "Client connection cleanup failed.");
-        })().then(resolveClosed, rejectClosed);
-    });
-    return { closed };
-}
-//# sourceMappingURL=clientConnection.js.map