@cjhyy/code-shell-web 0.9.32 → 0.9.33

package/dist/index.d.ts

@@ -14,6 +14,7 @@ export * from "./hooks/remoteAppSync.js";
 export * from "./lib/streamReducer.js";
 export * from "./lib/transcriptReplay.js";
 export * from "./lib/outputJournalRecovery.js";
+export * from "./lib/outputCoverage.js";
 export * from "./lib/messageMappers.js";
 export * from "./lib/riskClassify.js";
 export * from "./lib/format.js";

package/dist/index.js

@@ -16,6 +16,7 @@ export * from "./hooks/remoteAppSync.js";
 export * from "./lib/streamReducer.js";
 export * from "./lib/transcriptReplay.js";
 export * from "./lib/outputJournalRecovery.js";
+export * from "./lib/outputCoverage.js";
 export * from "./lib/messageMappers.js";
 // ── Pure helpers ─────────────────────────────────────────────────────────────
 export * from "./lib/riskClassify.js";

package/dist/lib/mobileOutputRecovery.js

@@ -1,4 +1,5 @@
 import { applyOutputJournalPage, compareOutputCursors, } from "./outputJournalRecovery.js";
+import { assertOutputCoverage } from "./outputCoverage.js";
 import { initialChatState, reduceStream } from "./streamReducer.js";
 /** Valid identities may arrive before their new Core Run acquires a durable anchor. */
 export class MobilePendingInput extends Error {
@@ -29,7 +30,18 @@ export async function recoverMobileOutput(args) {
     let reply = await args.read({});
     if (!args.canContinue())
         throw new Error("Recovery cancelled");
-    if (reply.page.status === "unavailable" && args.requireJournal) {
+    if (reply.page.status === "unavailable") {
+        const snapshot = reply.snapshot;
+        assertOutputCoverage({ unpaired: snapshot?.unpaired, inputIds: snapshot?.inputIds }, {}, () => true);
+        if (snapshot?.journalIdentity && !snapshot.outputCursor && !args.latestCursor())
+            throw new Error("Required output journal is unavailable");
+        // Valid live input may precede the first canonical Run. Preserve its typed
+        // retry; an already observed cursor instead requires the real reread below.
+        if (snapshot?.inputIds?.length && !snapshot.outputCursor && !args.latestCursor())
+            throw new MobilePendingInput(snapshot.inputIds);
+    }
+    if (reply.page.status === "unavailable" &&
+        (args.requireJournal || reply.snapshot?.outputCursor || args.latestCursor())) {
         const snapshot = reply.snapshot;
         if (!snapshot ||
             snapshot.unpaired ||
@@ -91,6 +103,7 @@ export async function recoverMobileOutput(args) {
                 !Number.isSafeInteger(snapshot.nextSeq) ||
                 snapshot.nextSeq < 1)
                 throw new Error("Recovery snapshot is unpaired");
+            assertOutputCoverage({ ...snapshot, inputIds: undefined }, reply.page, () => true);
             let target = recovery.cursor;
             for (const value of [snapshot.outputCursor, args.latestCursor()]) {
                 if (value === undefined)
@@ -112,6 +125,7 @@ export async function recoverMobileOutput(args) {
                 const missing = ids?.filter((id) => !chat.items.some((item) => item.kind === "user" && item.clientMessageId === id));
                 if (missing?.length)
                     throw new MobilePendingInput(missing);
+                assertOutputCoverage(snapshot, reply.page, (id) => chat.items.some((item) => item.kind === "user" && item.clientMessageId === id));
                 return { chat, outputCursor: recovery.cursor, snapshot };
             }
             recovery = { incomplete: false, cursor: recovery.appliedCursor };

package/dist/lib/outputCoverage.d.ts

@@ -0,0 +1,26 @@
+export declare class OutputCoverage {
+    private lastCursor?;
+    private blocked;
+    private overflowed;
+    private readonly inputs;
+    /** Stage observation before a Host publication; failure can discard this copy. */
+    copy(): OutputCoverage;
+    observe(raw: unknown): void;
+    acknowledgeInputs(ids: readonly string[]): void;
+    get inputIds(): string[];
+    get incomplete(): boolean;
+    get memoryBytes(): number;
+    discardProof(): void;
+}
+/** Validate the authoritative final coverage join without exposing a partial candidate. */
+export declare function assertOutputCoverage(proof: {
+    unpaired?: boolean;
+    inputIds?: string[];
+    incarnation?: string;
+    journalIdentity?: string;
+}, page: {
+    coverageIdentity?: string;
+    coverageStart?: string;
+}, hasInput: (id: string) => boolean, options?: {
+    requireIdentity?: boolean;
+}): void;

package/dist/lib/outputCoverage.js

@@ -0,0 +1,153 @@
+import { compareOutputCursors } from "./outputJournalRecovery.js";
+/** Bounded display-coverage proof, independent of the evictable Main event suffix. */
+const visible = new Set([
+    "session_started",
+    "stream_request_start",
+    "text_delta",
+    "thinking_delta",
+    "tool_use_start",
+    "tool_use_args_delta",
+    "tool_result",
+    "room_tool_result",
+    "tool_summary",
+    "tombstone",
+    "assistant_message",
+    "turn_complete",
+    "goal_set",
+    "goal_updated",
+    "goal_cleared",
+    "goal_progress",
+    "task_update",
+    "agent_start",
+    "agent_end",
+    "background_agent_completed",
+    "context_compact",
+    "error",
+    "session_user_message",
+    "steer_injected",
+    "user_message",
+    "assistant_text",
+]);
+function validCursor(value) {
+    if (typeof value !== "string" || value.length > 2048 || !/^[A-Za-z0-9_-]+$/.test(value))
+        return false;
+    try {
+        const cursor = JSON.parse(atob(value.replace(/-/g, "+").replace(/_/g, "/")));
+        return (typeof cursor.identity === "string" &&
+            typeof cursor.hash === "string" &&
+            /^[a-f0-9]{64}$/.test(cursor.identity) &&
+            /^[a-f0-9]{64}$/.test(cursor.hash) &&
+            Number.isSafeInteger(cursor.sequence) &&
+            cursor.sequence > 0 &&
+            Number.isSafeInteger(cursor.offset) &&
+            cursor.offset > 0);
+    }
+    catch {
+        return false;
+    }
+}
+export class OutputCoverage {
+    lastCursor;
+    blocked = false;
+    overflowed = false;
+    inputs = new Set();
+    /** Stage observation before a Host publication; failure can discard this copy. */
+    copy() {
+        const proof = new OutputCoverage();
+        proof.lastCursor = this.lastCursor;
+        proof.blocked = this.blocked;
+        proof.overflowed = this.overflowed;
+        for (const id of this.inputs)
+            proof.inputs.add(id);
+        return proof;
+    }
+    observe(raw) {
+        if (this.overflowed)
+            return;
+        const event = raw;
+        if (!event)
+            return;
+        if (event.outputCursor !== undefined) {
+            const order = validCursor(event.outputCursor)
+                ? this.lastCursor
+                    ? compareOutputCursors(event.outputCursor, this.lastCursor)
+                    : 1
+                : undefined;
+            if (order === undefined || order <= 0) {
+                this.discardProof();
+                return;
+            }
+            this.lastCursor = event.outputCursor;
+            // A new Run does not remove historical errors or the current Goal from
+            // the display reducer. Only explicit coverage can release their barrier.
+            return;
+        }
+        if (!event.type || !visible.has(event.type))
+            return;
+        if (["session_user_message", "steer_injected", "user_message"].includes(event.type) &&
+            (event.agentId ||
+                event.injected === true ||
+                ["agent", "system", "policy"].includes(String(event.authority))))
+            return;
+        if (event.type === "session_user_message") {
+            const id = event.clientMessageId;
+            if (typeof id !== "string" || !id.trim() || id.length > 512)
+                this.blocked = true;
+            else
+                this.inputs.add(id);
+            if (this.inputIds.length > 128 || this.memoryBytes > 32 * 1024)
+                this.discardProof();
+        }
+        else
+            this.blocked = true;
+    }
+    acknowledgeInputs(ids) {
+        for (const id of ids)
+            this.inputs.delete(id);
+    }
+    get inputIds() {
+        return [...this.inputs];
+    }
+    get incomplete() {
+        return this.blocked || this.overflowed;
+    }
+    get memoryBytes() {
+        return this.inputIds.reduce((sum, id) => sum + new TextEncoder().encode(id).length, 0);
+    }
+    discardProof() {
+        // Overflow never silently forgets a required identity or becomes success.
+        this.overflowed = true;
+        this.inputs.clear();
+    }
+}
+/** Validate the authoritative final coverage join without exposing a partial candidate. */
+export function assertOutputCoverage(proof, page, hasInput, options = {}) {
+    if (proof.unpaired)
+        throw new Error("Output recovery contains unpaired visible output");
+    if (page.coverageIdentity !== undefined &&
+        options.requireIdentity !== false &&
+        (proof.incarnation === undefined || proof.journalIdentity === undefined))
+        throw new Error("Output recovery Session incarnation proof is unavailable");
+    if (proof.incarnation !== undefined && proof.incarnation !== page.coverageIdentity)
+        throw new Error("Output recovery Session incarnation changed");
+    if (proof.journalIdentity !== undefined) {
+        let pin;
+        try {
+            pin = JSON.parse(atob((page.coverageStart ?? "").replace(/-/g, "+").replace(/_/g, "/"))).hash;
+        }
+        catch {
+            throw new Error("Output recovery journal pin is unpaired");
+        }
+        if (pin !== proof.journalIdentity)
+            throw new Error("Output recovery journal pin changed");
+    }
+    const ids = proof.inputIds ?? [];
+    if (!Array.isArray(ids) ||
+        ids.length > 128 ||
+        new Set(ids).size !== ids.length ||
+        ids.some((id) => typeof id !== "string" || !id.trim() || id.length > 512) ||
+        ids.reduce((sum, id) => sum + new TextEncoder().encode(id).length, 0) > 32 * 1024)
+        throw new Error("Output recovery input identities are unpaired");
+    if (ids.some((id) => !hasInput(id)))
+        throw new Error("Output recovery input has no recorded anchor");
+}

package/dist/lib/streamReducer.d.ts

@@ -53,6 +53,10 @@ export type ChatItem = {
     agentId: string;
     label: string;
     status: string;
+} | {
+    kind: "system";
+    id: string;
+    text: string;
 } | {
     kind: "system_error";
     id: string;

package/dist/lib/streamReducer.js

@@ -489,6 +489,25 @@ export function reduceStream(state, raw) {
                     : i),
             };
         }
+        case "background_agent_completed": {
+            const agentId = typeof event.agentId === "string" ? event.agentId : "";
+            const failed = event.status === "failed";
+            const status = failed ? "error" : event.status === "cancelled" ? "cancelled" : "completed";
+            const name = typeof event.name === "string" ? event.name : "后台任务";
+            const preview = failed
+                ? (event.error ?? event.description)
+                : (event.finalText ?? event.description);
+            const text = `${name} · ${status}${typeof preview === "string" && preview.trim() ? `: ${preview.trim().slice(0, 240)}` : ""}`;
+            const [id, next] = freshId("bg-done");
+            return {
+                ...next,
+                // A late background result cannot finish the concurrently active turn.
+                items: [
+                    ...s.items.map((item) => item.kind === "subagent" && item.agentId === agentId ? { ...item, status } : item),
+                    { kind: "system", id, text },
+                ],
+            };
+        }
         case "error": {
             const [id, s2] = freshId("err");
             return {