@cjhyy/code-shell-web 0.9.8 → 0.9.10

package/dist/hooks/remoteAppSync.d.ts

@@ -6,6 +6,16 @@ export interface SessionReplaySelection {
     events: unknown[];
     cursor: number;
 }
+/** The Main process owns one sequence domain; legacy peers omit its epoch. */
+export interface SessionStreamCursor {
+    epoch?: string;
+    appliedSeq: number;
+    observedSeq: number;
+    awaitingSnapshot: boolean;
+    /** A selected durable history has no cursor linking it to this live log. */
+    historyUnpaired?: boolean;
+}
+export declare function alignSessionEpoch(cursor: SessionStreamCursor, epoch?: string): boolean;
 export declare function selectSessionReplayEntries(entries: SessionReplayEntry[], appliedSeq: number): SessionReplaySelection;
 export declare function rawApprovalResolvedRequestId(raw: unknown): string | null;
 export declare function removeResolvedApproval<T extends {

package/dist/hooks/remoteAppSync.js

@@ -1,3 +1,17 @@
+export function alignSessionEpoch(cursor, epoch) {
+    if (!epoch || epoch === cursor.epoch)
+        return false;
+    // A legacy cursor is also untrusted when the peer first supplies an epoch.
+    // Missing epoch on a later legacy packet must not erase a known domain.
+    cursor.epoch = epoch;
+    cursor.appliedSeq = 0;
+    cursor.observedSeq = 0;
+    // A history read without an associated cursor remains unpaired even when
+    // the next packet is the first one to identify another Main lifetime.
+    if (!cursor.historyUnpaired)
+        cursor.historyUnpaired = undefined;
+    return true;
+}
 export function selectSessionReplayEntries(entries, appliedSeq) {
     let cursor = appliedSeq;
     const events = [];

package/dist/hooks/useRemoteApp.d.ts

@@ -93,4 +93,9 @@ export type MobileSessionCreateTarget = {
 } | {
     projectId: null;
 } | string | null;
-export declare function useRemoteApp(): RemoteApp;
+export interface RemoteAppOptions {
+    /** Browser host features may observe notifications without opening a second
+     * transport or changing the session/room reducer's ownership. */
+    onNotification?: (method: string, params: Record<string, unknown>) => void;
+}
+export declare function useRemoteApp(options?: RemoteAppOptions): RemoteApp;

package/dist/hooks/useRemoteApp.js

@@ -6,7 +6,7 @@ import { roomMsgToEvent, roomHistoryToEvents, ccHistoryToEvents, extractAskUserO
 import { projectForCwd } from "../lib/format.js";
 import { useRemoteSocket } from "./useRemoteSocket.js";
 import { prepareMobileAttachments, } from "../lib/mobileAttachments.js";
-import { filterNewRoomMessages, clearUnreadSession, markSessionUnread, markRoomSeqApplied, maxRoomSeq, noteSessionSeq, pruneUnreadSessions, rawApprovalResolvedRequestId, removeResolvedApproval, roomMessageSeq, selectSessionReplayEntries, } from "./remoteAppSync.js";
+import { filterNewRoomMessages, clearUnreadSession, markSessionUnread, markRoomSeqApplied, maxRoomSeq, alignSessionEpoch, pruneUnreadSessions, rawApprovalResolvedRequestId, removeResolvedApproval, roomMessageSeq, selectSessionReplayEntries, } from "./remoteAppSync.js";
 /** Tools whose grants can be remembered with a path scope (file/dir). */
 const PATH_SCOPED = new Set([
     "Read",
@@ -30,13 +30,30 @@ function chatReducer(state, action) {
             return appendUserMessage(state, action.text, action.attachments);
         case "reset":
             return initialChatState();
+        case "stream_epoch_changed": {
+            const seq = state.seq + 1;
+            return {
+                ...state,
+                seq,
+                run: "idle",
+                liveByAgent: {},
+                orphanResults: undefined,
+                items: state.items.map((item) => item.kind === "assistant"
+                    ? { ...item, done: true }
+                    : item.kind === "tool"
+                        ? { ...item, id: `prior-${seq}-${item.id}`, done: true }
+                        : item),
+            };
+        }
         case "replay":
             return action.events.reduce(reduceStream, initialChatState());
         case "append":
             return action.events.reduce(reduceStream, state);
     }
 }
-export function useRemoteApp() {
+export function useRemoteApp(options = {}) {
+    const optionsRef = useRef(options);
+    optionsRef.current = options;
     const [chat, dispatchChat] = useReducer(chatReducer, undefined, initialChatState);
     const [sessions, setSessions] = useState([]);
     const [unreadSessionIds, setUnreadSessionIds] = useState(() => new Set());
@@ -77,6 +94,8 @@ export function useRemoteApp() {
     const sendRef = useRef(null);
     const connectionGenerationRef = useRef(0);
     const uploadWaitersRef = useRef(new Map());
+    const conversationRevisionRef = useRef(0);
+    const pendingCreateRef = useRef(null);
     const messageAckWaitersRef = useRef(new Map());
     const [permissionMode, setPermissionModeState] = useState("default");
     /** Transient banner message (errors, room-missing, …). Auto-clears. */
@@ -116,7 +135,7 @@ export function useRemoteApp() {
             }
         });
     }, []);
-    const waitForMessageAck = useCallback((clientMessageId, connectionGeneration) => new Promise((resolve, reject) => {
+    const waitForMessageAck = useCallback((clientMessageId, connectionGeneration, conversationRevision) => new Promise((resolve, reject) => {
         const timer = setTimeout(() => {
             messageAckWaitersRef.current.delete(clientMessageId);
             reject(new Error("Message acknowledgement timed out"));
@@ -126,6 +145,7 @@ export function useRemoteApp() {
             reject,
             timer,
             connectionGeneration,
+            conversationRevision,
         });
     }), []);
     const settleMessageAck = useCallback((clientMessageId, error) => {
@@ -153,10 +173,18 @@ export function useRemoteApp() {
     }, []);
     /** Which session id the chat view is bound to (for filtering live stream). */
     const boundSessionRef = useRef(undefined);
-    /** Highest mobile snapshot seq applied per desktop session. */
-    const appliedSeqRef = useRef(new Map());
-    /** Highest live/snapshot seq observed per desktop session, including sessions not being viewed. */
-    const lastSessionSeqRef = useRef(new Map());
+    /** Observed/applied cursors always belong to the same Main process epoch. */
+    const sessionCursorsRef = useRef(new Map());
+    /** A newly selected epoch must load its durable history before live recovery. */
+    const epochHistorySessionRef = useRef(undefined);
+    const sessionCursor = useCallback((sessionId) => {
+        let cursor = sessionCursorsRef.current.get(sessionId);
+        if (!cursor) {
+            cursor = { appliedSeq: 0, observedSeq: 0, awaitingSnapshot: false };
+            sessionCursorsRef.current.set(sessionId, cursor);
+        }
+        return cursor;
+    }, []);
     /** Highest room message seq seen per active room. Used as room.history cursor. */
     const lastRoomSeqRef = useRef(new Map());
     /** Recent room seqs already folded into the reducer, for idempotent history/live merge. */
@@ -253,24 +281,39 @@ export function useRemoteApp() {
             case "auth.ok":
                 // Pull the world on connect.
                 break;
-            case "chat.accepted":
+            case "chat.accepted": {
+                const waiter = event.clientMessageId
+                    ? messageAckWaitersRef.current.get(event.clientMessageId)
+                    : undefined;
+                const creation = pendingCreateRef.current;
+                const mayBind = event.clientRequestId
+                    ? Boolean(creation &&
+                        creation.clientRequestId === event.clientRequestId &&
+                        creation.conversationRevision === conversationRevisionRef.current &&
+                        creation.connectionGeneration === connectionGenerationRef.current)
+                    : !event.clientMessageId ||
+                        Boolean(waiter &&
+                            waiter.conversationRevision === conversationRevisionRef.current &&
+                            waiter.connectionGeneration === connectionGenerationRef.current);
+                if (event.clientRequestId && creation?.clientRequestId === event.clientRequestId)
+                    pendingCreateRef.current = null;
                 if (event.clientMessageId) {
-                    const waiter = messageAckWaitersRef.current.get(event.clientMessageId);
                     settleMessageAck(event.clientMessageId, waiter && waiter.connectionGeneration !== connectionGenerationRef.current
                         ? new Error("Message acknowledgement arrived on a different connection")
                         : undefined);
                 }
-                if (event.sessionId) {
+                if (mayBind && event.sessionId) {
                     setActiveSessionId(event.sessionId);
                     boundSessionRef.current = event.sessionId;
                     clearSessionUnread(event.sessionId);
                 }
-                if ("cwd" in event)
+                if (mayBind && "cwd" in event)
                     setActiveSessionCwd(event.cwd ?? null);
                 // A freshly minted session won't be on disk until its first turn, so
                 // pull the list now so the new conversation shows up as a row.
                 sendRef.current?.({ type: "session.list" });
                 break;
+            }
             case "attachment.upload.ready": {
                 const waiter = uploadWaitersRef.current.get(event.clientId);
                 if (!waiter)
@@ -308,7 +351,12 @@ export function useRemoteApp() {
                     return clearUnreadSession(pruned, event.activeSessionId);
                 });
                 setLoadingKey("sessions", false);
-                if (event.activeSessionId) {
+                if (event.activeSessionId &&
+                    (conversationRevisionRef.current === 0 ||
+                        event.activeSessionId === boundSessionRef.current)) {
+                    // A refresh may reflect an earlier async create or another tab's
+                    // device selection. Only an explicit acknowledgement/select owns
+                    // navigation once this browser has chosen its conversation.
                     setActiveSessionId(event.activeSessionId);
                     const active = event.sessions.find((s) => s.id === event.activeSessionId);
                     if (active)
@@ -319,27 +367,80 @@ export function useRemoteApp() {
                 break;
             case "session.history.ok":
                 // Only apply if it's the session we're currently viewing.
-                if (event.sessionId === boundSessionRef.current) {
+                if (event.sessionId === boundSessionRef.current && !activeRoomIdRef.current) {
+                    const cursor = sessionCursor(event.sessionId);
+                    // An earlier retry may finish after a fresh live turn starts.
+                    // Only an explicitly requested history can replace that projection.
+                    if (cursor.historyUnpaired !== undefined &&
+                        epochHistorySessionRef.current !== event.sessionId)
+                        break;
                     dispatchChat({ kind: "replay", events: event.events });
+                    if (epochHistorySessionRef.current === event.sessionId) {
+                        epochHistorySessionRef.current = undefined;
+                        dispatchChat({ kind: "stream_epoch_changed" });
+                        // History carries no live cursor. A full snapshot could repeat
+                        // a reply already saved here, so keep the durable projection
+                        // until a subsequent top-level start proves a fresh boundary.
+                        cursor.historyUnpaired = true;
+                        cursor.awaitingSnapshot = true;
+                        setNotice(t("mobile.notice.sessionRecoveryHistoryOnly"));
+                    }
                     setLoadingKey("sessionHistory", false);
                 }
                 break;
             case "session.snapshot": {
                 if (event.sessionId !== boundSessionRef.current || activeRoomIdRef.current)
                     break;
-                const appliedSeq = appliedSeqRef.current.get(event.sessionId) ?? 0;
+                if (epochHistorySessionRef.current === event.sessionId)
+                    break;
+                const session = sessionCursor(event.sessionId);
+                const changed = alignSessionEpoch(session, event.epoch);
+                if (session.historyUnpaired)
+                    break;
+                if (changed) {
+                    dispatchChat({ kind: "stream_epoch_changed" });
+                    setApprovals([]);
+                    session.awaitingSnapshot = true;
+                }
+                // After a restart only a full new-domain prefix can release the
+                // barrier. An older filtered reply (or an evicted prefix) cannot.
+                if (session.awaitingSnapshot &&
+                    event.nextSeq > 1 &&
+                    !event.entries.some((entry) => entry.seq === 1)) {
+                    if (changed) {
+                        sendRef.current?.({
+                            type: "session.sync",
+                            sessionId: event.sessionId,
+                            sinceSeq: 0,
+                            epoch: session.epoch,
+                        });
+                    }
+                    else {
+                        setNotice(t("mobile.notice.sessionRecoveryIncomplete"));
+                    }
+                    setLoadingKey("sessionHistory", false);
+                    break;
+                }
+                const appliedSeq = session.appliedSeq;
                 const { events, cursor } = selectSessionReplayEntries(event.entries, appliedSeq);
-                if (cursor > appliedSeq)
-                    appliedSeqRef.current.set(event.sessionId, cursor);
-                if (cursor > 0)
-                    noteSessionSeq(lastSessionSeqRef.current, event.sessionId, cursor);
+                session.appliedSeq = cursor;
+                session.observedSeq = Math.max(session.observedSeq, cursor);
+                session.awaitingSnapshot = false;
                 appendSessionEvents(event.sessionId, events);
                 setLoadingKey("sessionHistory", false);
                 break;
             }
             case "session.stream": {
-                if (!noteSessionSeq(lastSessionSeqRef.current, event.sessionId, event.seq))
+                if (!Number.isSafeInteger(event.seq) || event.seq < 1)
+                    break;
+                const session = sessionCursor(event.sessionId);
+                const hadCursor = session.epoch !== undefined || session.appliedSeq > 0 || session.observedSeq > 0;
+                const changed = alignSessionEpoch(session, event.epoch);
+                if (changed)
+                    session.awaitingSnapshot = hadCursor || event.seq > 1;
+                if (event.seq <= session.observedSeq)
                     break;
+                session.observedSeq = event.seq;
                 if (activeRoomIdRef.current) {
                     setUnreadSessionIds((prev) => markSessionUnread(prev, event.sessionId));
                     break;
@@ -356,10 +457,36 @@ export function useRemoteApp() {
                     setActiveSessionCwd(sessionCwdById.get(event.sessionId));
                 }
                 clearSessionUnread(event.sessionId);
-                const appliedSeq = appliedSeqRef.current.get(event.sessionId) ?? 0;
-                if (event.seq <= appliedSeq)
+                if (changed) {
+                    dispatchChat({ kind: "stream_epoch_changed" });
+                    setApprovals([]);
+                    session.awaitingSnapshot = hadCursor || event.seq > 1;
+                    if (session.awaitingSnapshot && epochHistorySessionRef.current !== event.sessionId) {
+                        // Main captures/replies synchronously on this ordered socket.
+                        // Its full snapshot covers every live frame preceding the reply,
+                        // so waiting needs no unbounded client-side event journal.
+                        sendRef.current?.({
+                            type: "session.sync",
+                            sessionId: event.sessionId,
+                            sinceSeq: 0,
+                            epoch: session.epoch,
+                        });
+                    }
+                }
+                if (session.historyUnpaired && epochHistorySessionRef.current !== event.sessionId) {
+                    const raw = event.event;
+                    if (raw?.type === "stream_request_start" && !raw.agentId) {
+                        session.historyUnpaired = false;
+                        session.awaitingSnapshot = false;
+                        // Every older snapshot entry is either already in history or
+                        // unprovable. None may be replayed into this new live turn.
+                        session.appliedSeq = event.seq - 1;
+                        setNoticeState((notice) => notice === t("mobile.notice.sessionRecoveryHistoryOnly") ? undefined : notice);
+                    }
+                }
+                if (session.awaitingSnapshot || event.seq <= session.appliedSeq)
                     break;
-                appliedSeqRef.current.set(event.sessionId, event.seq);
+                session.appliedSeq = event.seq;
                 appendSessionEvents(event.sessionId, [event.event]);
                 break;
             }
@@ -621,9 +748,15 @@ export function useRemoteApp() {
         setLoadingKey,
         settleMessageAck,
         setNotice,
+        sessionCursor,
     ]);
     const onRawLine = useCallback((raw) => {
         const obj = raw;
+        if (typeof obj.method === "string") {
+            optionsRef.current.onNotification?.(obj.method, obj.params && typeof obj.params === "object"
+                ? obj.params
+                : {});
+        }
         // Permission requests arrive as agent/approvalRequest worker lines.
         if (obj.method === "agent/approvalRequest" && obj.params) {
             const params = obj.params;
@@ -720,12 +853,20 @@ export function useRemoteApp() {
         const sessionId = boundSessionRef.current;
         if (!sessionId)
             return;
+        const cursor = sessionCursor(sessionId);
+        if (epochHistorySessionRef.current === sessionId || cursor.historyUnpaired) {
+            epochHistorySessionRef.current = sessionId;
+            setLoadingKey("sessionHistory", true);
+            sendRef.current?.({ type: "session.history", sessionId });
+            return;
+        }
         sendRef.current?.({
             type: "session.sync",
             sessionId,
-            sinceSeq: appliedSeqRef.current.get(sessionId) ?? 0,
+            sinceSeq: cursor.awaitingSnapshot ? 0 : cursor.appliedSeq,
+            ...(cursor.epoch ? { epoch: cursor.epoch } : {}),
         });
-    }, [setLoadingKey]);
+    }, [setLoadingKey, sessionCursor]);
     const socket = useRemoteSocket({
         onServerEvent,
         onRawLine,
@@ -756,6 +897,7 @@ export function useRemoteApp() {
         if (socket.status !== "online")
             return false;
         const connectionGeneration = socket.connectionGeneration;
+        const conversationRevision = conversationRevisionRef.current;
         const roomId = activeRoomIdRef.current;
         const sessionId = boundSessionRef.current;
         const clientMessageId = globalThis.crypto?.randomUUID?.() ??
@@ -777,8 +919,10 @@ export function useRemoteApp() {
             }));
             return false;
         }
+        if (conversationRevision !== conversationRevisionRef.current)
+            return false;
         const summaries = attachments.map(({ name, mime, size }) => ({ name, mime, size }));
-        const acknowledged = waitForMessageAck(clientMessageId, connectionGeneration);
+        const acknowledged = waitForMessageAck(clientMessageId, connectionGeneration, conversationRevision);
         let queued;
         if (roomId) {
             // NO optimistic echo for rooms: RoomManager persists the user line and
@@ -817,6 +961,7 @@ export function useRemoteApp() {
             return false;
         }
         if (!roomId &&
+            conversationRevision === conversationRevisionRef.current &&
             !activeRoomIdRef.current &&
             (sessionId === undefined || boundSessionRef.current === sessionId)) {
             // Sessions don't echo the user turn back over the stream, so add the
@@ -833,6 +978,7 @@ export function useRemoteApp() {
         socket.send({ type: "session.list" });
     }, [socket, setLoadingKey]);
     const selectSession = useCallback((id) => {
+        conversationRevisionRef.current += 1;
         if (activeRoomIdRef.current) {
             socket.send({
                 type: "ccRoom.unsubscribeTranscript",
@@ -843,6 +989,9 @@ export function useRemoteApp() {
         clearSessionUnread(id);
         setActiveSessionCwd(sessionCwdById.get(id) ?? null);
         boundSessionRef.current = id;
+        const cursor = sessionCursor(id);
+        epochHistorySessionRef.current =
+            cursor.awaitingSnapshot || cursor.historyUnpaired !== undefined ? id : undefined;
         ccHistorySessionRef.current = undefined;
         ccHistoryCwdRef.current = undefined;
         ccBacklogLoadedRef.current = false;
@@ -852,7 +1001,7 @@ export function useRemoteApp() {
         dispatchChat({ kind: "reset" });
         socket.send({ type: "session.select", sessionId: id });
         socket.send({ type: "session.history", sessionId: id });
-    }, [clearSessionUnread, socket, sessionCwdById, setLoadingKey]);
+    }, [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) => {
@@ -868,6 +1017,7 @@ export function useRemoteApp() {
         // Doing it here too would double-fetch.
     }, [socket, setLoadingKey]);
     const openCcSession = useCallback((sessionId, cwd, mode) => {
+        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.
         ccHistoryKindRef.current = ccCliKindRef.current;
@@ -883,6 +1033,14 @@ export function useRemoteApp() {
         setApprovals((prev) => prev.filter((p) => p.requestId !== requestId));
     }, [socket]);
     const newSession = useCallback((target, name) => {
+        conversationRevisionRef.current += 1;
+        const clientRequestId = globalThis.crypto?.randomUUID?.() ??
+            `mobile-create-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+        pendingCreateRef.current = {
+            clientRequestId,
+            conversationRevision: conversationRevisionRef.current,
+            connectionGeneration: socket.connectionGeneration,
+        };
         if (activeRoomIdRef.current) {
             socket.send({
                 type: "ccRoom.unsubscribeTranscript",
@@ -932,12 +1090,22 @@ export function useRemoteApp() {
         setLoadingKey("sessionHistory", false);
         dispatchChat({ kind: "reset" });
         if (stableTarget && typeof stableTarget === "object") {
-            socket.send({ type: "session.create", ...stableTarget, ...(name ? { name } : {}) });
+            socket.send({
+                type: "session.create",
+                clientRequestId,
+                ...stableTarget,
+                ...(name ? { name } : {}),
+            });
         }
         else {
             socket.send(stableTarget === undefined
-                ? { type: "session.create", ...(name ? { name } : {}) }
-                : { type: "session.create", cwd: stableTarget, ...(name ? { name } : {}) });
+                ? { type: "session.create", clientRequestId, ...(name ? { name } : {}) }
+                : {
+                    type: "session.create",
+                    clientRequestId,
+                    cwd: stableTarget,
+                    ...(name ? { name } : {}),
+                });
         }
     }, [socket, setLoadingKey]);
     const respondApproval = useCallback((requestId, decision, opts) => {
@@ -972,6 +1140,7 @@ export function useRemoteApp() {
     // is no user-facing room create/open/close — CC sessions are opened via
     // openCcSession; the room is internal transport.)
     const leaveRoom = useCallback(() => {
+        conversationRevisionRef.current += 1;
         if (activeRoomIdRef.current) {
             socket.send({
                 type: "ccRoom.unsubscribeTranscript",

package/dist/i18n/mobile.d.ts

@@ -91,6 +91,8 @@ export declare const mobile: {
             readonly notice: {
                 readonly roomMissing: "会话不存在或未就绪";
                 readonly roomError: "会话错误";
+                readonly sessionRecoveryIncomplete: "当前回复的开头尚未恢复，请重新打开会话以读取已保存的内容。";
+                readonly sessionRecoveryHistoryOnly: "已恢复保存的聊天记录。当前回复的实时部分暂时无法接续，请稍后重新打开会话。";
                 readonly goalExtendFailed: "延长目标失败";
                 readonly ccRoomOpenFailed: "cc 会话无法打开";
                 readonly ccRoomObserving: "此 CC 会话当前为只读查看，消息未发送";
@@ -253,6 +255,8 @@ export declare const mobile: {
             readonly notice: {
                 readonly roomMissing: "Session does not exist or is not ready";
                 readonly roomError: "Session error";
+                readonly sessionRecoveryIncomplete: "The beginning of this reply could not be restored. Reopen the conversation to read its saved content.";
+                readonly sessionRecoveryHistoryOnly: "Saved chat history has been restored. Reopen the conversation later to see the rest of this reply.";
                 readonly goalExtendFailed: "Failed to extend goal";
                 readonly ccRoomOpenFailed: "Could not open cc session";
                 readonly ccRoomObserving: "This CC session is read-only; the message was not sent";

package/dist/i18n/mobile.js

@@ -91,6 +91,8 @@ export const mobile = {
             notice: {
                 roomMissing: "会话不存在或未就绪",
                 roomError: "会话错误",
+                sessionRecoveryIncomplete: "当前回复的开头尚未恢复，请重新打开会话以读取已保存的内容。",
+                sessionRecoveryHistoryOnly: "已恢复保存的聊天记录。当前回复的实时部分暂时无法接续，请稍后重新打开会话。",
                 goalExtendFailed: "延长目标失败",
                 ccRoomOpenFailed: "cc 会话无法打开",
                 ccRoomObserving: "此 CC 会话当前为只读查看，消息未发送",
@@ -253,6 +255,8 @@ export const mobile = {
             notice: {
                 roomMissing: "Session does not exist or is not ready",
                 roomError: "Session error",
+                sessionRecoveryIncomplete: "The beginning of this reply could not be restored. Reopen the conversation to read its saved content.",
+                sessionRecoveryHistoryOnly: "Saved chat history has been restored. Reopen the conversation later to see the rest of this reply.",
                 goalExtendFailed: "Failed to extend goal",
                 ccRoomOpenFailed: "Could not open cc session",
                 ccRoomObserving: "This CC session is read-only; the message was not sent",

package/dist/i18n/translate.d.ts

@@ -101,6 +101,8 @@ export declare const webMessages: {
             readonly notice: {
                 readonly roomMissing: "会话不存在或未就绪";
                 readonly roomError: "会话错误";
+                readonly sessionRecoveryIncomplete: "当前回复的开头尚未恢复，请重新打开会话以读取已保存的内容。";
+                readonly sessionRecoveryHistoryOnly: "已恢复保存的聊天记录。当前回复的实时部分暂时无法接续，请稍后重新打开会话。";
                 readonly goalExtendFailed: "延长目标失败";
                 readonly ccRoomOpenFailed: "cc 会话无法打开";
                 readonly ccRoomObserving: "此 CC 会话当前为只读查看，消息未发送";
@@ -263,6 +265,8 @@ export declare const webMessages: {
             readonly notice: {
                 readonly roomMissing: "Session does not exist or is not ready";
                 readonly roomError: "Session error";
+                readonly sessionRecoveryIncomplete: "The beginning of this reply could not be restored. Reopen the conversation to read its saved content.";
+                readonly sessionRecoveryHistoryOnly: "Saved chat history has been restored. Reopen the conversation later to see the rest of this reply.";
                 readonly goalExtendFailed: "Failed to extend goal";
                 readonly ccRoomOpenFailed: "Could not open cc session";
                 readonly ccRoomObserving: "This CC session is read-only; the message was not sent";

package/dist/index.d.ts

@@ -8,10 +8,11 @@
  * The desktop mobile UI (packages/desktop/src/mobile) renders on top of this;
  * a future standalone browser client is meant to grow from this package.
  */
-export { useRemoteApp, type CcCliKind, type PendingApproval, type RemoteApp, type MobileSessionCreateTarget, } from "./hooks/useRemoteApp.js";
+export { useRemoteApp, type CcCliKind, type PendingApproval, type RemoteApp, type RemoteAppOptions, type MobileSessionCreateTarget, } from "./hooks/useRemoteApp.js";
 export { useRemoteSocket, type ConnStatus, type ResyncReason, type RemoteSocket, type RemoteSocketHandlers, } from "./hooks/useRemoteSocket.js";
 export * from "./hooks/remoteAppSync.js";
 export * from "./lib/streamReducer.js";
+export * from "./lib/transcriptReplay.js";
 export * from "./lib/messageMappers.js";
 export * from "./lib/riskClassify.js";
 export * from "./lib/format.js";

package/dist/index.js

@@ -14,6 +14,7 @@ export { useRemoteSocket, } from "./hooks/useRemoteSocket.js";
 export * from "./hooks/remoteAppSync.js";
 // ── Stream folding (shared with the desktop renderer's CC room view) ────────
 export * from "./lib/streamReducer.js";
+export * from "./lib/transcriptReplay.js";
 export * from "./lib/messageMappers.js";
 // ── Pure helpers ─────────────────────────────────────────────────────────────
 export * from "./lib/riskClassify.js";

package/dist/lib/streamReducer.d.ts

@@ -20,15 +20,18 @@ export interface UserAttachmentSummary {
     name: string;
     mime?: string;
     size: number;
+    path?: string;
 }
 export type ChatItem = {
     kind: "user";
     id: string;
     text: string;
     attachments?: UserAttachmentSummary[];
+    clientMessageId?: string;
 } | {
     kind: "assistant";
     id: string;
+    messageId?: string;
     text: string;
     reasoning: string;
     done: boolean;
@@ -87,4 +90,4 @@ export interface ChatState {
 export declare function initialChatState(): ChatState;
 export declare function reduceStream(state: ChatState, raw: unknown): ChatState;
 /** Append a local user echo (the phone shows its own message immediately). */
-export declare function appendUserMessage(state: ChatState, text: string, attachments?: UserAttachmentSummary[]): ChatState;
+export declare function appendUserMessage(state: ChatState, text: string, attachments?: UserAttachmentSummary[], clientMessageId?: string): ChatState;