@cjhyy/code-shell-web 0.9.28 → 0.9.30

package/dist/hooks/mobileOutputClient.d.ts

@@ -0,0 +1,37 @@
+import type { MobileClientEvent, MobileServerEvent } from "@cjhyy/code-shell-core";
+import { recoverMobileOutput } from "../lib/mobileOutputRecovery.js";
+type Result = NonNullable<Awaited<ReturnType<typeof recoverMobileOutput>>>;
+/** One bounded recovery request per selected conversation, tied to this authenticated socket. */
+export declare class MobileOutputClient {
+    private readonly deps;
+    private enabled;
+    private auth;
+    private sequence;
+    private selection?;
+    constructor(deps: {
+        send: (event: MobileClientEvent) => boolean;
+        current: () => {
+            sessionId?: string;
+            roomId?: string;
+            revision: number;
+        };
+        commit: (sessionId: string, result: Result) => void;
+        legacy: (sessionId: string) => void;
+        failed: (sessionId: string) => void;
+        awaitingJournal?: (sessionId: string) => void;
+    });
+    cancel(notify?: boolean): void;
+    begin(sessionId: string): boolean;
+    private current;
+    owns(sessionId: string): boolean;
+    rejectUnsequenced(sessionId: string): boolean;
+    private fail;
+    observe(event: MobileServerEvent): boolean;
+    private recover;
+    /** Live output is withheld until it is covered by the frozen candidate. */
+    hold(sessionId: string, raw: unknown): false | "pending" | "covered";
+    applied(sessionId: string, raw: unknown): void;
+    /** A coalesced committed head requests pages; it never invents visible output. */
+    advanceSnapshot(sessionId: string, outputCursor: string | undefined): void;
+}
+export {};

package/dist/hooks/mobileOutputClient.js

@@ -0,0 +1,351 @@
+import { recoverMobileOutput, MobilePendingInput, MobileOutputCatchupPending, MobileAwaitingJournal, } from "../lib/mobileOutputRecovery.js";
+import { compareOutputCursors } from "../lib/outputJournalRecovery.js";
+/** One bounded recovery request per selected conversation, tied to this authenticated socket. */
+export class MobileOutputClient {
+    deps;
+    enabled = false;
+    auth = 0;
+    sequence = 0;
+    selection;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    cancel(notify = true) {
+        const old = this.selection;
+        this.selection = undefined;
+        if (old?.readyTimer)
+            clearTimeout(old.readyTimer);
+        if (old?.capacityTimer)
+            clearTimeout(old.capacityTimer);
+        if (old?.waiter) {
+            clearTimeout(old.waiter.timer);
+            old.waiter.reject(new Error("Recovery cancelled"));
+        }
+        if (notify && old)
+            this.deps.send({ type: "session.recovery.cancel" });
+    }
+    begin(sessionId) {
+        if (!this.enabled)
+            return false;
+        this.cancel();
+        const selection = {
+            id: `recovery-${this.auth}-${++this.sequence}`,
+            sessionId,
+            revision: this.deps.current().revision,
+            auth: this.auth,
+            recovering: true,
+            failed: false,
+        };
+        this.selection = selection;
+        selection.readyTimer = setTimeout(() => this.fail(selection), 10_000);
+        if (!this.deps.send({ type: "session.select", sessionId, recoveryId: selection.id }))
+            this.fail(selection);
+        return true;
+    }
+    current(selection) {
+        const current = this.deps.current();
+        return (this.selection === selection &&
+            selection.auth === this.auth &&
+            current.sessionId === selection.sessionId &&
+            !current.roomId &&
+            current.revision === selection.revision);
+    }
+    owns(sessionId) {
+        return this.selection?.sessionId === sessionId;
+    }
+    rejectUnsequenced(sessionId) {
+        const selection = this.selection;
+        if (!selection || selection.sessionId !== sessionId)
+            return false;
+        this.fail(selection);
+        return true;
+    }
+    fail(selection) {
+        if (!this.current(selection))
+            return;
+        if (selection.readyTimer)
+            clearTimeout(selection.readyTimer);
+        if (selection.capacityTimer)
+            clearTimeout(selection.capacityTimer);
+        selection.capacityTimer = undefined;
+        selection.capacityPending = false;
+        selection.readyTimer = undefined;
+        selection.recovering = false;
+        selection.failed = true;
+        this.deps.failed(selection.sessionId);
+    }
+    observe(event) {
+        if (event.type === "auth.ok" || event.type === "pair.ok") {
+            this.cancel(false);
+            this.auth++;
+            this.enabled = event.capabilities?.outputJournal === 1;
+            return false;
+        }
+        if (event.type !== "session.recovery.ready" && event.type !== "session.outputJournal")
+            return false;
+        const selection = this.selection;
+        if (!selection ||
+            !this.current(selection) ||
+            event.sessionId !== selection.sessionId ||
+            event.recoveryId !== selection.id)
+            return true;
+        if (event.type === "session.recovery.ready") {
+            // A later Main revocation also invalidates an already joined live stream.
+            if (!event.ok) {
+                this.fail(selection);
+                return true;
+            }
+            if (selection.started || selection.failed)
+                return true;
+            selection.started = true;
+            selection.journalRequired = event.journalRequired === true;
+            if (selection.readyTimer)
+                clearTimeout(selection.readyTimer);
+            selection.readyTimer = undefined;
+            if (!event.ok)
+                this.fail(selection);
+            else
+                void this.recover(selection);
+        }
+        else if (selection.waiter?.id === event.requestId) {
+            const waiter = selection.waiter;
+            selection.waiter = undefined;
+            clearTimeout(waiter.timer);
+            waiter.resolve(event);
+        }
+        return true;
+    }
+    async recover(selection, resume) {
+        try {
+            const result = await (resume
+                ? resume()
+                : recoverMobileOutput({
+                    requireJournal: selection.journalRequired,
+                    canContinue: () => this.current(selection) && !selection.failed,
+                    latestCursor: () => selection.latest,
+                    read: (options) => new Promise((resolve, reject) => {
+                        if (!this.current(selection) || selection.waiter)
+                            return reject(new Error("Recovery cancelled"));
+                        const id = `page-${this.auth}-${++this.sequence}`;
+                        const timer = setTimeout(() => {
+                            selection.waiter = undefined;
+                            reject(new Error("Recovery timed out"));
+                        }, 10_000);
+                        selection.waiter = { id, resolve, reject, timer };
+                        if (!this.deps.send({
+                            type: "session.outputJournal",
+                            sessionId: selection.sessionId,
+                            recoveryId: selection.id,
+                            requestId: id,
+                            after: options.after,
+                            through: options.through,
+                        })) {
+                            clearTimeout(timer);
+                            selection.waiter = undefined;
+                            reject(new Error("Recovery disconnected"));
+                        }
+                    }),
+                }));
+            if (!this.current(selection))
+                return;
+            if (!result) {
+                this.selection = undefined;
+                this.deps.send({ type: "session.recovery.cancel" });
+                this.deps.legacy(selection.sessionId);
+                return;
+            }
+            if (selection.pendingInputIds &&
+                [...selection.pendingInputIds].some((id) => !result.chat.items.some((item) => item.kind === "user" && item.clientMessageId === id))) {
+                // An input can arrive after Main captured this reply. Keep the older
+                // display until its matching recorded boundary starts a fresh join.
+                if (!selection.readyTimer)
+                    selection.readyTimer = setTimeout(() => this.fail(selection), 10_000);
+                return;
+            }
+            selection.recovering = false;
+            selection.capacityPending = false;
+            if (selection.readyTimer)
+                clearTimeout(selection.readyTimer);
+            selection.readyTimer = undefined;
+            selection.pendingInputIds = undefined;
+            selection.pendingInputBytes = undefined;
+            selection.applied = result.outputCursor;
+            selection.latest = result.outputCursor;
+            this.deps.commit(selection.sessionId, result);
+        }
+        catch (error) {
+            if (error instanceof MobileAwaitingJournal) {
+                if (!this.current(selection) || selection.failed)
+                    return;
+                selection.recovering = false;
+                selection.awaitingJournal = true;
+                // No prefix exists yet. Retain the selected producer without polling,
+                // publishing an empty success, or retiring its independent command selection.
+                this.deps.awaitingJournal?.(selection.sessionId);
+                return;
+            }
+            if (error instanceof MobileOutputCatchupPending) {
+                if (!this.current(selection) || selection.failed)
+                    return;
+                if (selection.capacityCursor &&
+                    compareOutputCursors(error.cursor, selection.capacityCursor) !== 1) {
+                    this.fail(selection);
+                    return;
+                }
+                selection.capacityCursor = error.cursor;
+                // Keep the old display behind its barrier. One delayed follow-up also
+                // consumes a terminal/head already observed during the last round; it
+                // never waits forever for an event that has already arrived.
+                selection.recovering = false;
+                selection.capacityPending = true;
+                this.deps.failed(selection.sessionId);
+                selection.capacityTimer = setTimeout(() => {
+                    selection.capacityTimer = undefined;
+                    if (!this.current(selection) || selection.failed)
+                        return;
+                    selection.capacityPending = false;
+                    selection.recovering = true;
+                    void this.recover(selection, error.resume);
+                }, 25);
+                return;
+            }
+            if (error instanceof MobilePendingInput &&
+                error.ids.every((id) => selection.pendingInputIds?.has(id))) {
+                if (!this.current(selection) || selection.failed)
+                    return;
+                if (!selection.readyTimer)
+                    selection.readyTimer = setTimeout(() => this.fail(selection), 10_000);
+                return;
+            }
+            this.fail(selection);
+        }
+    }
+    /** Live output is withheld until it is covered by the frozen candidate. */
+    hold(sessionId, raw) {
+        const selection = this.selection;
+        if (!selection || selection.sessionId !== sessionId)
+            return false;
+        const event = raw;
+        const priorCursor = selection.latest ?? selection.applied;
+        if (typeof event?.outputCursor === "string") {
+            const order = selection.latest
+                ? compareOutputCursors(event.outputCursor, selection.latest)
+                : 1;
+            if (order === undefined)
+                this.fail(selection);
+            else if (order > 0)
+                selection.latest = event.outputCursor;
+        }
+        if (selection.failed)
+            return "pending";
+        if (selection.awaitingJournal && typeof event?.outputCursor === "string") {
+            selection.awaitingJournal = false;
+            if (selection.readyTimer)
+                clearTimeout(selection.readyTimer);
+            selection.readyTimer = undefined;
+            selection.recovering = true;
+            void this.recover(selection);
+            return "pending";
+        }
+        if (event?.type === "session_user_message" &&
+            !event.outputCursor &&
+            !event.agentId &&
+            event.injected !== true &&
+            !["agent", "system", "policy"].includes(String(event.authority))) {
+            const ids = (selection.pendingInputIds ??= new Set());
+            if (typeof event.clientMessageId !== "string" ||
+                !event.clientMessageId.trim() ||
+                event.clientMessageId.length > 512)
+                this.fail(selection);
+            else {
+                if (!ids.has(event.clientMessageId)) {
+                    ids.add(event.clientMessageId);
+                    selection.pendingInputBytes =
+                        (selection.pendingInputBytes ?? 0) +
+                            new TextEncoder().encode(event.clientMessageId).length;
+                }
+                if (ids.size > 128 || (selection.pendingInputBytes ?? 0) > 32 * 1024)
+                    this.fail(selection);
+                if (!selection.failed && !selection.recovering && !selection.capacityPending) {
+                    const latest = selection.latest;
+                    this.begin(sessionId);
+                    if (this.selection) {
+                        this.selection.pendingInputIds = ids;
+                        this.selection.pendingInputBytes = selection.pendingInputBytes;
+                        this.selection.latest = latest;
+                    }
+                    return "pending";
+                }
+                if (!selection.readyTimer)
+                    selection.readyTimer = setTimeout(() => this.fail(selection), 10_000);
+            }
+            return "pending";
+        }
+        if (selection.pendingInputIds?.size &&
+            event?.type === "session_started" &&
+            !event.agentId &&
+            event.outputCursor &&
+            typeof event.clientMessageId === "string" &&
+            selection.pendingInputIds.has(event.clientMessageId) &&
+            (!priorCursor || compareOutputCursors(event.outputCursor, priorCursor) === 1)) {
+            // The real protocol emits preliminary input before the Engine owns a
+            // durable Run. Retry only at its recorded boundary, never on arbitrary
+            // suffix text; Main proves every pending submit ID in the candidate.
+            const latest = selection.latest;
+            this.begin(sessionId);
+            if (this.selection) {
+                this.selection.pendingInputIds = selection.pendingInputIds;
+                this.selection.pendingInputBytes = selection.pendingInputBytes;
+                this.selection.latest = latest;
+            }
+            return "pending";
+        }
+        if (selection.pendingInputIds?.size)
+            return "pending";
+        if (selection.failed || selection.recovering || selection.capacityPending)
+            return "pending";
+        if (event?.type === "session_title")
+            return false;
+        const order = event?.outputCursor && selection.applied
+            ? compareOutputCursors(event.outputCursor, selection.applied)
+            : undefined;
+        if (order === undefined) {
+            this.fail(selection);
+            return "pending";
+        }
+        return order <= 0 ? "covered" : false;
+    }
+    applied(sessionId, raw) {
+        const event = raw;
+        if (this.selection?.sessionId === sessionId && typeof event?.outputCursor === "string")
+            this.selection.applied = event.outputCursor;
+    }
+    /** A coalesced committed head requests pages; it never invents visible output. */
+    advanceSnapshot(sessionId, outputCursor) {
+        const selection = this.selection;
+        if (!selection || selection.sessionId !== sessionId || !outputCursor || selection.failed)
+            return;
+        const previous = selection.latest ?? selection.applied;
+        const order = previous ? compareOutputCursors(outputCursor, previous) : 1;
+        if (order === undefined) {
+            this.fail(selection);
+            return;
+        }
+        if (order <= 0)
+            return;
+        selection.latest = outputCursor;
+        if (selection.awaitingJournal) {
+            selection.awaitingJournal = false;
+            if (selection.readyTimer)
+                clearTimeout(selection.readyTimer);
+            selection.readyTimer = undefined;
+            selection.recovering = true;
+            void this.recover(selection);
+        }
+        else if (!selection.recovering && !selection.capacityPending) {
+            this.begin(sessionId);
+            if (this.selection)
+                this.selection.latest = outputCursor;
+        }
+    }
+}

package/dist/hooks/useRemoteApp.js

@@ -4,6 +4,7 @@ import { t } from "../i18n/translate.js";
 import { summarizeApproval } from "../lib/riskClassify.js";
 import { roomMsgToEvent, roomHistoryToEvents, ccHistoryToEvents, extractAskUserOptions, } from "../lib/messageMappers.js";
 import { projectForCwd } from "../lib/format.js";
+import { MobileOutputClient } from "./mobileOutputClient.js";
 import { useRemoteSocket } from "./useRemoteSocket.js";
 import { prepareMobileAttachments, } from "../lib/mobileAttachments.js";
 import { filterNewRoomMessages, clearUnreadSession, markSessionUnread, markRoomSeqApplied, maxRoomSeq, alignSessionEpoch, pruneUnreadSessions, rawApprovalResolvedRequestId, removeResolvedApproval, roomMessageSeq, selectSessionReplayEntries, } from "./remoteAppSync.js";
@@ -27,7 +28,12 @@ function chatReducer(state, action) {
         case "raw":
             return reduceStream(state, action.raw);
         case "user":
-            return appendUserMessage(state, action.text, action.attachments);
+            return appendUserMessage(state, action.text, action.attachments, action.clientMessageId);
+        case "hydrate": {
+            const ids = new Set(action.chat.items.flatMap((item) => item.kind === "user" && item.clientMessageId ? [item.clientMessageId] : []));
+            const pending = state.items.filter((item) => item.kind === "user" && item.clientMessageId && !ids.has(item.clientMessageId));
+            return { ...action.chat, items: [...action.chat.items, ...pending] };
+        }
         case "reset":
             return initialChatState();
         case "stream_epoch_changed": {
@@ -280,7 +286,47 @@ export function useRemoteApp(options = {}) {
         }
         setApprovals((prev) => (prev.some((p) => p.requestId === a.requestId) ? prev : [...prev, a]));
     }, []);
+    const outputClientRef = useRef(null);
+    const outputClient = (outputClientRef.current ??= new MobileOutputClient({
+        send: (event) => sendRef.current?.(event) ?? false,
+        current: () => ({
+            sessionId: boundSessionRef.current,
+            roomId: activeRoomIdRef.current,
+            revision: conversationRevisionRef.current,
+        }),
+        commit: (sessionId, result) => {
+            const cursor = sessionCursor(sessionId);
+            cursor.epoch = result.snapshot.epoch;
+            cursor.appliedSeq = result.snapshot.nextSeq - 1;
+            cursor.observedSeq = cursor.appliedSeq;
+            cursor.awaitingSnapshot = false;
+            cursor.historyUnpaired = undefined;
+            epochHistorySessionRef.current = undefined;
+            dispatchChat({ kind: "hydrate", chat: result.chat });
+            setLoadingKey("sessionHistory", false);
+            setNoticeState(undefined);
+        },
+        legacy: (sessionId) => {
+            epochHistorySessionRef.current = sessionId;
+            sessionCursor(sessionId).historyUnpaired = true;
+            sendRef.current?.({ type: "session.history", sessionId });
+        },
+        awaitingJournal: () => {
+            // A selected live producer has no prior output. No read/request remains
+            // pending while the user composes its first input.
+            setLoadingKey("sessionHistory", false);
+        },
+        failed: (sessionId) => {
+            sessionCursor(sessionId).awaitingSnapshot = true;
+            dispatchChat({ kind: "stream_epoch_changed" });
+            setNotice(t("mobile.notice.sessionRecoveryIncomplete"));
+            setLoadingKey("sessionHistory", false);
+        },
+    }));
+    useEffect(() => () => outputClient.cancel(false), [outputClient]);
     const onServerEvent = useCallback((event) => {
+        if (outputClient.observe(event))
+            return;
         switch (event.type) {
             case "auth.ok":
                 // Pull the world on connect.
@@ -370,6 +416,8 @@ export function useRemoteApp(options = {}) {
                 }
                 break;
             case "session.history.ok":
+                if (outputClient.owns(event.sessionId))
+                    break;
                 // Only apply if it's the session we're currently viewing.
                 if (event.sessionId === boundSessionRef.current && !activeRoomIdRef.current) {
                     const cursor = sessionCursor(event.sessionId);
@@ -393,11 +441,19 @@ export function useRemoteApp(options = {}) {
                 }
                 break;
             case "session.snapshot": {
+                if (outputClient.owns(event.sessionId)) {
+                    outputClient.advanceSnapshot(event.sessionId, event.outputCursor);
+                    break;
+                }
                 if (event.sessionId !== boundSessionRef.current || activeRoomIdRef.current)
                     break;
                 if (epochHistorySessionRef.current === event.sessionId)
                     break;
                 const session = sessionCursor(event.sessionId);
+                if (event.outputCursor && outputClient.begin(event.sessionId)) {
+                    session.awaitingSnapshot = true;
+                    break;
+                }
                 const changed = alignSessionEpoch(session, event.epoch);
                 if (session.historyUnpaired)
                     break;
@@ -425,6 +481,15 @@ export function useRemoteApp(options = {}) {
                     setLoadingKey("sessionHistory", false);
                     break;
                 }
+                if (event.entries.some((entry, index) => entry.seq > session.appliedSeq &&
+                    entry.seq !==
+                        (index > 0 ? event.entries[index - 1].seq + 1 : session.appliedSeq + 1))) {
+                    session.awaitingSnapshot = true;
+                    if (!outputClient.begin(event.sessionId))
+                        setNotice(t("mobile.notice.sessionRecoveryIncomplete"));
+                    setLoadingKey("sessionHistory", false);
+                    break;
+                }
                 const appliedSeq = session.appliedSeq;
                 const { events, cursor } = selectSessionReplayEntries(event.entries, appliedSeq);
                 session.appliedSeq = cursor;
@@ -461,6 +526,32 @@ export function useRemoteApp(options = {}) {
                     setActiveSessionCwd(sessionCwdById.get(event.sessionId));
                 }
                 clearSessionUnread(event.sessionId);
+                const rawOutput = event.event;
+                if (changed && outputClient.owns(event.sessionId))
+                    outputClient.begin(event.sessionId);
+                if (!outputClient.owns(event.sessionId) &&
+                    rawOutput?.outputCursor &&
+                    outputClient.begin(event.sessionId)) {
+                    session.awaitingSnapshot = true;
+                }
+                const held = outputClient.hold(event.sessionId, event.event);
+                if (held === "pending")
+                    break;
+                if (held === "covered") {
+                    if (event.seq === session.appliedSeq + 1)
+                        session.appliedSeq = event.seq;
+                    else if (event.seq > session.appliedSeq + 1) {
+                        session.awaitingSnapshot = true;
+                        outputClient.begin(event.sessionId);
+                    }
+                    break;
+                }
+                if (!changed && !session.awaitingSnapshot && event.seq > session.appliedSeq + 1) {
+                    session.awaitingSnapshot = true;
+                    if (!outputClient.begin(event.sessionId))
+                        setNotice(t("mobile.notice.sessionRecoveryIncomplete"));
+                    break;
+                }
                 if (changed) {
                     dispatchChat({ kind: "stream_epoch_changed" });
                     setApprovals([]);
@@ -492,6 +583,7 @@ export function useRemoteApp(options = {}) {
                     break;
                 session.appliedSeq = event.seq;
                 appendSessionEvents(event.sessionId, [event.event]);
+                outputClient.applied(event.sessionId, event.event);
                 break;
             }
             case "permission.mode":
@@ -620,6 +712,7 @@ export function useRemoteApp(options = {}) {
                     setNotice(t("mobile.notice.ccRoomOpenFailed"));
                     break;
                 }
+                outputClient.cancel();
                 // An opened cc room behaves like room.open — bind the room feed. But the
                 // resident room only carries messages from open-time onward; the prior
                 // external-CLI transcript lives on disk, so subscribeTranscript returns
@@ -631,6 +724,7 @@ export function useRemoteApp(options = {}) {
                         roomId: activeRoomIdRef.current,
                     });
                 }
+                activeRoomIdRef.current = event.roomId;
                 setActiveRoomId(event.roomId);
                 setRooms((previous) => previous.map((room) => room.id === event.roomId
                     ? {
@@ -818,6 +912,8 @@ export function useRemoteApp(options = {}) {
             else {
                 return;
             }
+            if (outputClient.rejectUnsequenced(boundSessionRef.current))
+                return;
             dispatchChat({ kind: "raw", raw });
             clearApprovalsIfTerminal([params.event]);
         }
@@ -853,6 +949,11 @@ export function useRemoteApp(options = {}) {
         if (!sessionId)
             return;
         const cursor = sessionCursor(sessionId);
+        if (outputClient.begin(sessionId)) {
+            cursor.awaitingSnapshot = true;
+            setLoadingKey("sessionHistory", true);
+            return;
+        }
         if (epochHistorySessionRef.current === sessionId || cursor.historyUnpaired) {
             epochHistorySessionRef.current = sessionId;
             setLoadingKey("sessionHistory", true);
@@ -876,6 +977,7 @@ export function useRemoteApp(options = {}) {
     useEffect(() => {
         if (socket.status === "online")
             return;
+        outputClient.cancel(false);
         submittingAsyncApprovalsRef.current.clear();
         const error = new Error("Remote connection was lost");
         for (const waiter of uploadWaitersRef.current.values()) {
@@ -966,7 +1068,7 @@ export function useRemoteApp(options = {}) {
             (sessionId === undefined || boundSessionRef.current === sessionId)) {
             // Sessions don't echo the user turn back over the stream, so add the
             // local bubble only after the server has accepted this exact message.
-            dispatchChat({ kind: "user", text, attachments: summaries });
+            dispatchChat({ kind: "user", text, attachments: summaries, clientMessageId });
         }
         return true;
     }, [beginMobileUpload, setNotice, settleMessageAck, socket, waitForMessageAck]);
@@ -999,12 +1101,17 @@ export function useRemoteApp(options = {}) {
         setApprovals([]);
         setLoadingKey("sessionHistory", true);
         dispatchChat({ kind: "reset" });
-        socket.send({ type: "session.select", sessionId: id });
-        socket.send({ type: "session.history", sessionId: id });
+        activeRoomIdRef.current = undefined;
+        if (!outputClient.begin(id)) {
+            socket.send({ type: "session.select", sessionId: id });
+            socket.send({ type: "session.history", sessionId: id });
+        }
     }, [clearSessionUnread, socket, sessionCwdById, setLoadingKey, sessionCursor]);
     /** Select a project (like the desktop sidebar): set the one-true-source cwd and
      *  pull that project's chat sessions + external cc sessions. */
     const selectProject = useCallback((projectIdOrCwd) => {
+        outputClient.cancel();
+        conversationRevisionRef.current += 1;
         const project = projectsRef.current.find((candidate) => candidate.id === projectIdOrCwd || candidate.path === projectIdOrCwd);
         const cwd = project?.path ?? projectIdOrCwd;
         setActiveProjectId(project?.id ?? null);
@@ -1017,6 +1124,7 @@ export function useRemoteApp(options = {}) {
         // Doing it here too would double-fetch.
     }, [socket, setLoadingKey]);
     const openCcSession = useCallback((sessionId, cwd, mode) => {
+        outputClient.cancel();
         conversationRevisionRef.current += 1;
         // Pin the CLI this session belongs to so its on-disk backlog is read with
         // the right reader even if the user switches the pane's CLI afterward.
@@ -1033,6 +1141,7 @@ export function useRemoteApp(options = {}) {
         setApprovals((prev) => prev.filter((p) => p.requestId !== requestId));
     }, [socket]);
     const newSession = useCallback((target, name) => {
+        outputClient.cancel();
         conversationRevisionRef.current += 1;
         const clientRequestId = globalThis.crypto?.randomUUID?.() ??
             `mobile-create-${Date.now()}-${Math.random().toString(36).slice(2)}`;
@@ -1150,6 +1259,7 @@ export function useRemoteApp(options = {}) {
     // is no user-facing room create/open/close — CC sessions are opened via
     // openCcSession; the room is internal transport.)
     const leaveRoom = useCallback(() => {
+        outputClient.cancel();
         conversationRevisionRef.current += 1;
         if (activeRoomIdRef.current) {
             socket.send({

package/dist/lib/mobileOutputRecovery.d.ts

@@ -0,0 +1,34 @@
+import type { MobileServerEvent } from "@cjhyy/code-shell-core";
+import type { OutputJournalOptions } from "@cjhyy/code-shell-core/internal";
+import { initialChatState } from "./streamReducer.js";
+type Reply = Extract<MobileServerEvent, {
+    type: "session.outputJournal";
+}>;
+/** Valid identities may arrive before their new Core Run acquires a durable anchor. */
+export declare class MobilePendingInput extends Error {
+    readonly ids: string[];
+    constructor(ids: string[]);
+}
+/** No journal has ever been published by this explicitly journal-owned producer. */
+export declare class MobileAwaitingJournal extends Error {
+    constructor();
+}
+/** Verified pages progressed, but the observed live head kept moving within the bound. */
+export declare class MobileOutputCatchupPending extends Error {
+    readonly cursor: string;
+    readonly resume: () => Promise<MobileOutputRecoveryResult>;
+    constructor(cursor: string, resume: () => Promise<MobileOutputRecoveryResult>);
+}
+type MobileOutputRecoveryResult = {
+    chat: ReturnType<typeof initialChatState>;
+    outputCursor: string;
+    snapshot: NonNullable<Reply["snapshot"]>;
+};
+/** Build a private candidate, then join its frozen prefix to an actual Main snapshot. */
+export declare function recoverMobileOutput(args: {
+    read: (options: OutputJournalOptions) => Promise<Reply>;
+    canContinue: () => boolean;
+    latestCursor: () => string | undefined;
+    requireJournal?: boolean;
+}): Promise<MobileOutputRecoveryResult | null>;
+export {};