@cjhyy/code-shell-web 0.9.44 → 0.9.47

package/dist/hooks/mobileOutputClient.js

@@ -4,6 +4,7 @@ import { compareOutputCursors } from "../lib/outputJournalRecovery.js";
 export class MobileOutputClient {
     deps;
     enabled = false;
+    basePages = false;
     auth = 0;
     sequence = 0;
     selection;
@@ -17,13 +18,25 @@ export class MobileOutputClient {
             clearTimeout(old.readyTimer);
         if (old?.capacityTimer)
             clearTimeout(old.capacityTimer);
-        if (old?.waiter) {
-            clearTimeout(old.waiter.timer);
-            old.waiter.reject(new Error("Recovery cancelled"));
-        }
+        if (old)
+            this.clearPending(old, "Recovery cancelled");
         if (notify && old)
             this.deps.send({ type: "session.recovery.cancel" });
     }
+    clearPending(selection, message) {
+        if (selection.waiter) {
+            const waiter = selection.waiter;
+            selection.waiter = undefined;
+            clearTimeout(waiter.timer);
+            waiter.reject(new Error(message));
+        }
+        if (selection.retry) {
+            const retry = selection.retry;
+            selection.retry = undefined;
+            clearTimeout(retry.timer);
+            retry.reject(new Error(message));
+        }
+    }
     begin(sessionId) {
         if (!this.enabled)
             return false;
@@ -61,7 +74,7 @@ export class MobileOutputClient {
         return true;
     }
     fail(selection) {
-        if (!this.current(selection))
+        if (!this.current(selection) || selection.failed)
             return;
         if (selection.readyTimer)
             clearTimeout(selection.readyTimer);
@@ -72,6 +85,7 @@ export class MobileOutputClient {
         selection.readyTimer = undefined;
         selection.recovering = false;
         selection.failed = true;
+        this.clearPending(selection, "Recovery failed");
         this.deps.failed(selection.sessionId);
     }
     observe(event) {
@@ -79,9 +93,12 @@ export class MobileOutputClient {
             this.cancel(false);
             this.auth++;
             this.enabled = event.capabilities?.outputJournal === 1;
+            this.basePages = this.enabled && event.capabilities?.legacyBasePages === 1;
             return false;
         }
-        if (event.type !== "session.recovery.ready" && event.type !== "session.outputJournal")
+        if (event.type !== "session.recovery.ready" &&
+            event.type !== "session.outputJournal" &&
+            event.type !== "session.legacyBase")
             return false;
         const selection = this.selection;
         if (!selection ||
@@ -107,7 +124,7 @@ export class MobileOutputClient {
             else
                 void this.recover(selection);
         }
-        else if (selection.waiter?.id === event.requestId) {
+        else if (selection.waiter?.id === event.requestId && selection.waiter.type === event.type) {
             const waiter = selection.waiter;
             selection.waiter = undefined;
             clearTimeout(waiter.timer);
@@ -115,6 +132,60 @@ export class MobileOutputClient {
         }
         return true;
     }
+    request(selection, type, options) {
+        return new Promise((resolve, reject) => {
+            if (!this.current(selection) || selection.failed || selection.waiter || selection.retry)
+                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,
+                type,
+                timer,
+                reject,
+                resolve: (page) => resolve(page),
+            };
+            try {
+                if (!this.deps.send({
+                    ...options,
+                    type,
+                    sessionId: selection.sessionId,
+                    recoveryId: selection.id,
+                    requestId: id,
+                }))
+                    throw new Error("Recovery disconnected");
+            }
+            catch (error) {
+                clearTimeout(timer);
+                selection.waiter = undefined;
+                reject(error);
+            }
+        });
+    }
+    async readBase(selection, options) {
+        for (let retries = 0;; retries++) {
+            const reply = await this.request(selection, "session.legacyBase", options);
+            if (new TextEncoder().encode(JSON.stringify(reply)).length > 1024 * 1024 + 4096 ||
+                (reply.ok === false &&
+                    ((reply.reason !== "busy" && reply.reason !== "incomplete") ||
+                        Object.keys(reply).some((key) => !["type", "sessionId", "recoveryId", "requestId", "ok", "reason"].includes(key)))))
+                throw new Error("Invalid recovery base reply");
+            if (reply.ok !== false || reply.reason !== "busy" || retries >= 8)
+                return reply;
+            await new Promise((resolve, reject) => {
+                if (!this.current(selection) || selection.failed)
+                    return reject(new Error("Recovery cancelled"));
+                const timer = setTimeout(() => {
+                    selection.retry = undefined;
+                    resolve();
+                }, 25);
+                selection.retry = { timer, reject };
+            });
+        }
+    }
     async recover(selection, resume) {
         try {
             const result = await (resume
@@ -123,28 +194,12 @@ export class MobileOutputClient {
                     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"));
+                    read: (options) => this.request(selection, "session.outputJournal", options),
+                    ...(this.basePages
+                        ? {
+                            readBase: (options) => this.readBase(selection, options),
                         }
-                    }),
+                        : {}),
                 }));
             if (!this.current(selection))
                 return;

package/dist/hooks/useRemoteApp.d.ts

@@ -19,6 +19,14 @@ export interface PendingApproval {
     options?: string[];
     /** When true, the user must pick an option (no free text). */
     optionsOnly?: boolean;
+    /** CLI AskUserQuestion asking several questions in one request. They are
+     *  answered together: the request accepts exactly one response. */
+    questions?: Array<{
+        question: string;
+        header?: string;
+        options: string[];
+        multiSelect: boolean;
+    }>;
     /** A nonblocking question remains answerable after the run ends. */
     asynchronous?: boolean;
     /** True for path-scoped tools (Read/Edit/Write/…) → show file/dir scope. */
@@ -36,6 +44,8 @@ export interface RemoteApp {
     /** The bound room — for the user this is always an external CC (Claude Code)
      *  session. The room is internal transport; there is no user-facing room list. */
     activeRoom?: RoomPublic;
+    /** Set while a CLI room is bound, even before its metadata has loaded. */
+    activeRoomId?: string;
     approvals: PendingApproval[];
     permissionMode: PermissionMode;
     loading: {
@@ -50,9 +60,17 @@ export interface RemoteApp {
     };
     notice?: string;
     logout: () => void;
+    /** Resolves true once the host accepted the message. */
     sendChat: (input: {
         text: string;
         attachments: MobileComposerAttachment[];
+        modelTraceSource?: string;
+        /** Retry an earlier intent whose delivery could not be confirmed. The host
+         *  ignores an ID it already recorded, so the task never runs twice. */
+        clientMessageId?: string;
+        /** The frame reached the socket but neither acceptance nor rejection
+         *  arrived (lost connection or timeout): the host may have run it. */
+        onUncertain?: (clientMessageId: string) => void;
     }) => Promise<boolean>;
     stopRun: () => void;
     selectSession: (id: string) => void;
@@ -81,14 +99,11 @@ export interface RemoteApp {
     ccCliKind: CcCliKind;
     setCcCliKind: (kind: CcCliKind) => void;
     openCcSession: (sessionId: string, cwd: string, mode: PermissionMode) => void;
-    respondCcApproval: (roomId: string, requestId: string, decision: {
-        behavior: "allow";
-        updatedInput?: unknown;
-    } | {
-        behavior: "deny";
-        message: string;
-    }) => void;
+    respondCcApproval: (roomId: string, requestId: string, decision: CcApprovalDecision) => void;
 }
+type CcApprovalDecision = Extract<import("@cjhyy/code-shell-core").MobileClientEvent, {
+    type: "ccRoom.respondApproval";
+}>["decision"];
 export type MobileSessionCreateTarget = {
     projectId: string;
     rootId?: string;
@@ -101,3 +116,4 @@ export interface RemoteAppOptions {
     onNotification?: (method: string, params: Record<string, unknown>) => void;
 }
 export declare function useRemoteApp(options?: RemoteAppOptions): RemoteApp;
+export {};

package/dist/hooks/useRemoteApp.js

@@ -9,6 +9,9 @@ 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";
+/** The host explicitly refused a message, so it was not admitted. */
+class MessageRejectedError extends Error {
+}
 /** Tools whose grants can be remembered with a path scope (file/dir). */
 const PATH_SCOPED = new Set([
     "Read",
@@ -80,6 +83,10 @@ export function useRemoteApp(options = {}) {
     const approvalsRef = useRef(approvals);
     approvalsRef.current = approvals;
     const submittingAsyncApprovalsRef = useRef(new Set());
+    /** Synchronous approvals whose card was consumed on send. A correlated
+     *  delivery error asks Main to replay them if Core still holds the request. */
+    const submittedApprovalsRef = useRef(new Set());
+    const requestActiveResyncRef = useRef(() => undefined);
     // The SELECTED project (one-true-source for "what am I looking at"), distinct
     // from activeSessionCwd which is derived from the bound session. Drives session
     // list filtering AND ccRoom.listSessions.
@@ -101,6 +108,8 @@ export function useRemoteApp(options = {}) {
      *  socket's callback), so it can't close over `socket` directly. */
     const sendRef = useRef(null);
     const connectionGenerationRef = useRef(0);
+    /** Image PUTs in flight; a lost connection aborts them so sending recovers. */
+    const uploadAbortsRef = useRef(new Set());
     const uploadWaitersRef = useRef(new Map());
     const conversationRevisionRef = useRef(0);
     const pendingCreateRef = useRef(null);
@@ -185,6 +194,9 @@ export function useRemoteApp(options = {}) {
             waiter.resolve();
     }, []);
     useEffect(() => () => {
+        for (const upload of uploadAbortsRef.current)
+            upload.abort(new Error("Remote app closed"));
+        uploadAbortsRef.current.clear();
         for (const waiter of uploadWaitersRef.current.values()) {
             clearTimeout(waiter.timer);
             waiter.reject(new Error("Remote app closed"));
@@ -226,8 +238,10 @@ export function useRemoteApp(options = {}) {
      * subscription cwd from activeProjectCwd. */
     const ccHistoryCwdRef = useRef(undefined);
     /** openSession replies do not echo cwd. Keep it keyed by the requested
-     * session until ccRoom.opened confirms which room acquired it. */
-    const pendingCcOpenCwdsRef = useRef(new Map());
+     * session until ccRoom.opened confirms which room acquired it. The
+     * conversation revision of the request lets a reply that arrives after the
+     * user navigated elsewhere be discarded instead of navigating back. */
+    const pendingCcOpensRef = useRef(new Map());
     const ccBacklogLoadedRef = useRef(false);
     /** Which CLI the currently-open cc session belongs to — selects the on-disk
      *  history reader (claude vs codex rollout) for ccRoom.readHistory. Captured
@@ -247,6 +261,7 @@ export function useRemoteApp(options = {}) {
     }, []);
     const clearApproval = useCallback((requestId) => {
         submittingAsyncApprovalsRef.current.delete(requestId);
+        submittedApprovalsRef.current.delete(requestId);
         approvalsRef.current = removeResolvedApproval(approvalsRef.current, requestId);
         setApprovals((prev) => removeResolvedApproval(prev, requestId));
     }, []);
@@ -317,6 +332,9 @@ export function useRemoteApp(options = {}) {
         if (a.sessionId) {
             if (boundSessionRef.current && a.sessionId !== boundSessionRef.current)
                 return;
+            // A pending creation owns the unbound view; only its acceptance binds it.
+            if (!boundSessionRef.current && pendingCreateRef.current)
+                return;
             if (!boundSessionRef.current) {
                 boundSessionRef.current = a.sessionId;
                 setActiveSessionId(a.sessionId);
@@ -558,6 +576,12 @@ export function useRemoteApp(options = {}) {
                         break;
                     }
                 }
+                else if (pendingCreateRef.current) {
+                    // Another task's output while a new session awaits its acceptance:
+                    // binding it would move the new conversation (and its draft) there.
+                    setUnreadSessionIds((prev) => markSessionUnread(prev, event.sessionId));
+                    break;
+                }
                 else {
                     boundSessionRef.current = event.sessionId;
                     setActiveSessionId(event.sessionId);
@@ -753,6 +777,11 @@ export function useRemoteApp(options = {}) {
             case "room.closed":
                 // Keep the internal room snapshot in sync (resolves activeRoom metadata).
                 setRooms((prev) => prev.map((r) => (r.id === event.roomId ? { ...r, open: false } : r)));
+                // The room's process is gone, so no turn is running any more. Its
+                // stopped process cannot report its own turn end.
+                if (event.roomId === activeRoomIdRef.current) {
+                    dispatchChat({ kind: "raw", raw: { type: "turn_complete", reason: "aborted_tools" } });
+                }
                 break;
             case "room.recovery":
                 if (event.roomId === activeRoomIdRef.current) {
@@ -772,16 +801,21 @@ export function useRemoteApp(options = {}) {
                     setLoadingKey("roomHistory", false);
                 }
                 if (event.clientMessageId) {
-                    settleMessageAck(event.clientMessageId, new Error(event.message));
+                    settleMessageAck(event.clientMessageId, new MessageRejectedError(event.message));
                 }
                 setNotice(event.message || t("mobile.notice.roomError"));
                 break;
             case "error":
                 if (event.approvalId) {
                     submittingAsyncApprovalsRef.current.delete(event.approvalId);
+                    // The decision did not reach Core. The request may still be
+                    // pending there; an authoritative resync replays its card.
+                    if (submittedApprovalsRef.current.delete(event.approvalId)) {
+                        requestActiveResyncRef.current();
+                    }
                 }
                 if (event.clientMessageId) {
-                    settleMessageAck(event.clientMessageId, new Error(event.message));
+                    settleMessageAck(event.clientMessageId, new MessageRejectedError(event.message));
                 }
                 setNotice(event.message);
                 setLoading({
@@ -829,9 +863,13 @@ export function useRemoteApp(options = {}) {
                     setLoadingKey("ccSessions", false);
                 }
                 break;
-            case "ccRoom.opened":
+            case "ccRoom.opened": {
+                const request = pendingCcOpensRef.current.get(event.sessionId);
+                pendingCcOpensRef.current.delete(event.sessionId);
+                // Only this browser's latest open request may change navigation.
+                if (!request || request.revision !== conversationRevisionRef.current)
+                    break;
                 if (event.status === "missing") {
-                    pendingCcOpenCwdsRef.current.delete(event.sessionId);
                     setNotice(t("mobile.notice.ccRoomOpenFailed"));
                     break;
                 }
@@ -854,17 +892,14 @@ export function useRemoteApp(options = {}) {
                         ...room,
                         open: event.status === "running",
                         observing: event.status === "observing",
+                        ...(event.permissionMode ? { permissionMode: event.permissionMode } : {}),
                     }
                     : room));
                 // Refresh metadata even when this room was created after the last
                 // room.list snapshot, so the mobile view can display read-only state.
                 sendRef.current?.({ type: "room.list" });
                 ccHistorySessionRef.current = event.sessionId;
-                ccHistoryCwdRef.current =
-                    pendingCcOpenCwdsRef.current.get(event.sessionId) ??
-                        activeProjectCwdRef.current ??
-                        undefined;
-                pendingCcOpenCwdsRef.current.delete(event.sessionId);
+                ccHistoryCwdRef.current = request.cwd;
                 ccBacklogLoadedRef.current = false;
                 boundSessionRef.current = undefined;
                 setApprovals([]);
@@ -887,6 +922,7 @@ export function useRemoteApp(options = {}) {
                     requestRoomCatchup(event.roomId, 0);
                 }
                 break;
+            }
             case "ccRoom.transcriptSubscribed":
                 // Atomic snapshot + live subscription. roomCursor identifies exactly
                 // where the snapshot ended in the shared room log; the incremental
@@ -948,6 +984,9 @@ export function useRemoteApp(options = {}) {
                             risk,
                             options: askUser?.options,
                             optionsOnly: false,
+                            ...(askUser?.questions && askUser.questions.length > 1
+                                ? { questions: askUser.questions }
+                                : {}),
                             pathScoped: PATH_SCOPED.has(event.req.toolName),
                         },
                     ]);
@@ -1024,6 +1063,9 @@ export function useRemoteApp(options = {}) {
                 if (sid && sid !== boundSessionRef.current)
                     return;
             }
+            else if (pendingCreateRef.current) {
+                return; // the pending creation's acceptance decides the binding
+            }
             else if (sid) {
                 // Auto-bind to the first session we see so the feed is coherent.
                 boundSessionRef.current = sid;
@@ -1084,6 +1126,7 @@ export function useRemoteApp(options = {}) {
             ...(cursor.epoch ? { epoch: cursor.epoch } : {}),
         });
     }, [setLoadingKey, sessionCursor, requestRoomCatchup]);
+    requestActiveResyncRef.current = requestActiveResync;
     const socket = useRemoteSocket({
         onServerEvent,
         onRawLine,
@@ -1096,7 +1139,11 @@ export function useRemoteApp(options = {}) {
             return;
         outputClient.cancel(false);
         submittingAsyncApprovalsRef.current.clear();
+        submittedApprovalsRef.current.clear();
         const error = new Error("Remote connection was lost");
+        for (const upload of uploadAbortsRef.current)
+            upload.abort(error);
+        uploadAbortsRef.current.clear();
         for (const waiter of uploadWaitersRef.current.values()) {
             clearTimeout(waiter.timer);
             waiter.reject(error);
@@ -1119,17 +1166,21 @@ export function useRemoteApp(options = {}) {
         const conversationRevision = conversationRevisionRef.current;
         const roomId = activeRoomIdRef.current;
         const sessionId = boundSessionRef.current;
-        const clientMessageId = globalThis.crypto?.randomUUID?.() ??
+        const clientMessageId = input.clientMessageId ??
+            globalThis.crypto?.randomUUID?.() ??
             `mobile-message-${Date.now()}-${Math.random().toString(36).slice(2)}`;
         let attachments;
         if (roomId && roomsRef.current.find((room) => room.id === roomId)?.observing) {
             setNotice(t("mobile.notice.ccRoomObserving"));
             return false;
         }
+        const upload = new AbortController();
+        uploadAbortsRef.current.add(upload);
         try {
             attachments = await prepareMobileAttachments(input.attachments, {
                 beginUpload: (metadata) => beginMobileUpload(metadata, connectionGeneration),
                 fetch: window.fetch.bind(window),
+                signal: upload.signal,
             });
         }
         catch (error) {
@@ -1138,6 +1189,9 @@ export function useRemoteApp(options = {}) {
             }));
             return false;
         }
+        finally {
+            uploadAbortsRef.current.delete(upload);
+        }
         if (conversationRevision !== conversationRevisionRef.current)
             return false;
         const summaries = attachments.map(({ name, mime, size }) => ({ name, mime, size }));
@@ -1159,6 +1213,7 @@ export function useRemoteApp(options = {}) {
         else {
             queued = socket.send({
                 type: "chat.send",
+                ...(input.modelTraceSource ? { modelTraceSource: input.modelTraceSource } : {}),
                 text,
                 sessionId,
                 clientMessageId,
@@ -1174,6 +1229,9 @@ export function useRemoteApp(options = {}) {
             await acknowledged;
         }
         catch (error) {
+            // Only an explicit host rejection proves the message was not admitted.
+            if (!(error instanceof MessageRejectedError))
+                input.onUncertain?.(clientMessageId);
             setNotice(t("mobile.notice.attachmentSendFailed", {
                 error: error instanceof Error ? error.message : String(error),
             }));
@@ -1190,6 +1248,14 @@ export function useRemoteApp(options = {}) {
         return true;
     }, [beginMobileUpload, setNotice, settleMessageAck, socket, waitForMessageAck]);
     const stopRun = useCallback(() => {
+        const roomId = activeRoomIdRef.current;
+        if (roomId) {
+            // A CLI room runs in its own resident process, not a native session.
+            // Closing it stops the process; the next message resumes the same CLI
+            // conversation.
+            socket.send({ type: "room.close", roomId });
+            return;
+        }
         socket.send({ type: "run.stop", sessionId: boundSessionRef.current });
     }, [socket]);
     const refreshSessions = useCallback(() => {
@@ -1246,22 +1312,51 @@ export function useRemoteApp(options = {}) {
         // 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.
         ccHistoryKindRef.current = ccCliKindRef.current;
-        pendingCcOpenCwdsRef.current.set(sessionId, cwd);
+        pendingCcOpensRef.current.set(sessionId, {
+            cwd,
+            revision: conversationRevisionRef.current,
+        });
         socket.send({ type: "ccRoom.openSession", sessionId, cwd, mode, kind: ccCliKindRef.current });
     }, [socket]);
     const respondCcApproval = useCallback((roomId, requestId, decision) => {
         const a = approvalsRef.current.find((p) => p.requestId === requestId);
         if (!a)
             return; // approve-once: already resolved
-        socket.send({ type: "ccRoom.respondApproval", roomId, requestId, decision });
+        // An unsent response never reaches the CLI, which is still waiting.
+        // Keep the card so the user can retry once the connection recovers.
+        if (!socket.send({ type: "ccRoom.respondApproval", roomId, requestId, decision })) {
+            setNotice(t("mobile.notice.approvalSendFailed"));
+            return;
+        }
         approvalsRef.current = approvalsRef.current.filter((p) => p.requestId !== requestId);
         setApprovals((prev) => prev.filter((p) => p.requestId !== requestId));
-    }, [socket]);
+    }, [setNotice, 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)}`;
+        const stableTarget = target === undefined && activeProjectIdRef.current
+            ? { projectId: activeProjectIdRef.current }
+            : target;
+        // Creation needs the host's acceptance. Send it before switching the
+        // view: offline, a dropped frame used to leave the view on the new target
+        // while a later first send fell back to the previous (possibly another
+        // project's) session.
+        const created = socket.send(stableTarget && typeof stableTarget === "object"
+            ? { type: "session.create", clientRequestId, ...stableTarget, ...(name ? { name } : {}) }
+            : stableTarget === undefined
+                ? { type: "session.create", clientRequestId, ...(name ? { name } : {}) }
+                : {
+                    type: "session.create",
+                    clientRequestId,
+                    cwd: stableTarget,
+                    ...(name ? { name } : {}),
+                });
+        if (!created) {
+            setNotice(t("mobile.notice.createOffline"));
+            return;
+        }
+        outputClient.cancel();
+        conversationRevisionRef.current += 1;
         pendingCreateRef.current = {
             clientRequestId,
             conversationRevision: conversationRevisionRef.current,
@@ -1273,9 +1368,6 @@ export function useRemoteApp(options = {}) {
                 roomId: activeRoomIdRef.current,
             });
         }
-        const stableTarget = target === undefined && activeProjectIdRef.current
-            ? { projectId: activeProjectIdRef.current }
-            : target;
         const selectedProject = stableTarget && typeof stableTarget === "object" && stableTarget.projectId
             ? projectsRef.current.find((project) => project.id === stableTarget.projectId)
             : undefined;
@@ -1315,25 +1407,7 @@ export function useRemoteApp(options = {}) {
         setApprovals([]);
         setLoadingKey("sessionHistory", false);
         dispatchChat({ kind: "reset" });
-        if (stableTarget && typeof stableTarget === "object") {
-            socket.send({
-                type: "session.create",
-                clientRequestId,
-                ...stableTarget,
-                ...(name ? { name } : {}),
-            });
-        }
-        else {
-            socket.send(stableTarget === undefined
-                ? { type: "session.create", clientRequestId, ...(name ? { name } : {}) }
-                : {
-                    type: "session.create",
-                    clientRequestId,
-                    cwd: stableTarget,
-                    ...(name ? { name } : {}),
-                });
-        }
-    }, [socket, setLoadingKey]);
+    }, [socket, setLoadingKey, setNotice]);
     const respondApproval = useCallback((requestId, decision, opts) => {
         const a = approvalsRef.current.find((p) => p.requestId === requestId);
         // Dedup at the source: if this approval is already gone from the ref it was
@@ -1361,12 +1435,17 @@ export function useRemoteApp(options = {}) {
             submittingAsyncApprovalsRef.current.add(requestId);
             return;
         }
+        submittedApprovalsRef.current.add(requestId);
         // Update the ref synchronously too so a second tap in the same tick (before
         // the async setApprovals commits) sees it gone and no-ops above.
         approvalsRef.current = approvalsRef.current.filter((p) => p.requestId !== requestId);
         setApprovals((prev) => prev.filter((p) => p.requestId !== requestId));
     }, [socket]);
     const setPermissionMode = useCallback((mode) => {
+        // A CLI room's mode is a spawn-time argument of its process; the native
+        // session mode does not govern it. Never pretend to change it here.
+        if (activeRoomIdRef.current)
+            return;
         setPermissionModeState(mode);
         socket.send({ type: "permission.setMode", sessionId: boundSessionRef.current, mode });
     }, [socket]);
@@ -1388,6 +1467,11 @@ export function useRemoteApp(options = {}) {
         ccHistorySessionRef.current = undefined;
         ccHistoryCwdRef.current = undefined;
         ccBacklogLoadedRef.current = false;
+        // The room's cards belong to the conversation being left and must not
+        // block other conversations. The host keeps the requests pending and
+        // replays them when the room is opened again.
+        approvalsRef.current = approvalsRef.current.filter((approval) => !approval.roomId);
+        setApprovals((prev) => prev.filter((approval) => !approval.roomId));
         setLoadingKey("roomHistory", false);
         dispatchChat({ kind: "reset" });
     }, [setLoadingKey, socket]);
@@ -1439,6 +1523,7 @@ export function useRemoteApp(options = {}) {
         activeCwd,
         projects,
         activeRoom,
+        activeRoomId,
         approvals,
         permissionMode,
         loading,

package/dist/i18n/mobile.d.ts

@@ -97,6 +97,8 @@ export declare const mobile: {
                 readonly ccRoomOpenFailed: "cc 会话无法打开";
                 readonly ccRoomObserving: "此 CC 会话当前为只读查看，消息未发送";
                 readonly attachmentSendFailed: "图片发送失败：{error}";
+                readonly createOffline: "连接已断开，重新连接后才能新建任务。";
+                readonly approvalSendFailed: "审批未送达，请检查连接后重试";
             };
             readonly permissionMode: {
                 readonly default: "默认";
@@ -261,6 +263,8 @@ export declare const mobile: {
                 readonly ccRoomOpenFailed: "Could not open cc session";
                 readonly ccRoomObserving: "This CC session is read-only; the message was not sent";
                 readonly attachmentSendFailed: "Could not send images: {error}";
+                readonly createOffline: "Disconnected. Reconnect before starting a new task.";
+                readonly approvalSendFailed: "The approval was not delivered. Check the connection and try again.";
             };
             readonly permissionMode: {
                 readonly default: "Default";

package/dist/i18n/mobile.js

@@ -97,6 +97,8 @@ export const mobile = {
                 ccRoomOpenFailed: "cc 会话无法打开",
                 ccRoomObserving: "此 CC 会话当前为只读查看，消息未发送",
                 attachmentSendFailed: "图片发送失败：{error}",
+                createOffline: "连接已断开，重新连接后才能新建任务。",
+                approvalSendFailed: "审批未送达，请检查连接后重试",
             },
             permissionMode: {
                 default: "默认",
@@ -261,6 +263,8 @@ export const mobile = {
                 ccRoomOpenFailed: "Could not open cc session",
                 ccRoomObserving: "This CC session is read-only; the message was not sent",
                 attachmentSendFailed: "Could not send images: {error}",
+                createOffline: "Disconnected. Reconnect before starting a new task.",
+                approvalSendFailed: "The approval was not delivered. Check the connection and try again.",
             },
             permissionMode: {
                 default: "Default",