@cjhyy/code-shell-server 0.9.32 → 0.9.33

package/dist/hub/run-replay.d.ts

@@ -1,3 +1,4 @@
+import type { SessionOutputCoverageStore } from "@cjhyy/code-shell-core/internal";
 export interface HubStreamCursor {
     epoch: string;
     sequence: number;
@@ -10,20 +11,36 @@ export interface HubStreamCursor {
  */
 export declare class HubRunReplay {
     private readonly limits;
+    private readonly persistence?;
     private readonly epoch;
     private sequence;
     private totalBytes;
     private readonly sessions;
+    private readonly coverage;
+    private coverageBytes;
     constructor(limits?: {
         maxBytes: number;
         maxEvents: number;
         maxTotalBytes?: number;
-    });
+    }, persistence?: SessionOutputCoverageStore | undefined);
     begin(sessionId: string, requestId: string, baselineEvents: number): void;
     /** Only a new, still-tracked conversation can safely replay before disk publication. */
     hasEmptyBaseline(sessionId: string): boolean;
     append(sessionId: string, event: unknown): HubStreamCursor;
     finish(sessionId: string, requestId: string): void;
+    private retireCoverage;
+    outputCoverage(sessionId: string): {
+        streamCursor: {
+            epoch: `${string}-${string}-${string}-${string}-${string}`;
+            sequence: number;
+        };
+        outputCursor?: string | undefined;
+        journalIdentity?: string | undefined;
+        incarnation?: string | undefined;
+        unpaired: boolean;
+        inputIds: string[];
+    };
+    forget(sessionId: string): void;
     snapshot<T>(sessionId: string, durableEvents: readonly T[]): {
         liveStream?: {
             events: {
@@ -37,6 +54,17 @@ export declare class HubRunReplay {
             epoch: `${string}-${string}-${string}-${string}-${string}`;
             sequence: number;
         };
+        outputCoverage: {
+            streamCursor: {
+                epoch: `${string}-${string}-${string}-${string}-${string}`;
+                sequence: number;
+            };
+            outputCursor?: string | undefined;
+            journalIdentity?: string | undefined;
+            incarnation?: string | undefined;
+            unpaired: boolean;
+            inputIds: string[];
+        };
     };
     clear(): void;
 }

package/dist/hub/run-replay.js

@@ -1,3 +1,4 @@
+import { OutputCoverage } from "@cjhyy/code-shell-web";
 import { randomUUID } from "node:crypto";
 /**
  * A refresh can happen before the worker persists its current assistant text.
@@ -7,16 +8,20 @@ import { randomUUID } from "node:crypto";
  */
 export class HubRunReplay {
     limits;
+    persistence;
     epoch = randomUUID();
     sequence = 0;
     totalBytes = 0;
     sessions = new Map();
+    coverage = new Map();
+    coverageBytes = 0;
     constructor(limits = {
         maxBytes: 8 * 1024 * 1024,
         maxEvents: 16_000,
         maxTotalBytes: 64 * 1024 * 1024,
-    }) {
+    }, persistence) {
         this.limits = limits;
+        this.persistence = persistence;
     }
     begin(sessionId, requestId, baselineEvents) {
         let log = this.sessions.get(sessionId);
@@ -37,6 +42,48 @@ export class HubRunReplay {
         return this.sessions.get(sessionId)?.baselineEvents === 0;
     }
     append(sessionId, event) {
+        let coverage = this.coverage.get(sessionId);
+        if (!coverage) {
+            coverage = { proof: new OutputCoverage() };
+            this.coverage.set(sessionId, coverage);
+        }
+        this.coverageBytes -= coverage.proof.memoryBytes;
+        const previousProof = coverage.proof;
+        coverage.proof = previousProof.copy();
+        coverage.proof.observe(event);
+        if (this.coverageBytes + coverage.proof.memoryBytes > 4 * 1024 * 1024)
+            coverage.proof.discardProof();
+        let withheldBeforeSession = false;
+        try {
+            if (this.persistence &&
+                ((coverage.proof.incomplete && !coverage.persistedBlocked) ||
+                    coverage.proof.inputIds.length)) {
+                const saved = this.persistence.record(sessionId, {
+                    unpaired: coverage.proof.incomplete,
+                    inputIds: coverage.proof.inputIds,
+                });
+                if (!saved.incarnation) {
+                    withheldBeforeSession = saved.status === "unavailable";
+                    throw new Error("Session output coverage is unavailable before publication");
+                }
+                if (saved.incarnation) {
+                    coverage.proof.acknowledgeInputs(coverage.proof.inputIds);
+                    coverage.persistedBlocked = saved.unpaired;
+                }
+            }
+        }
+        catch (cause) {
+            coverage.proof = previousProof;
+            if (!withheldBeforeSession)
+                coverage.publicationFailed = true;
+            throw cause;
+        }
+        finally {
+            this.coverageBytes += coverage.proof.memoryBytes;
+        }
+        const outputCursor = event?.outputCursor;
+        if (typeof outputCursor === "string")
+            coverage.outputCursor = outputCursor;
         const sequence = ++this.sequence;
         const log = this.sessions.get(sessionId);
         if (log && !log.truncated) {
@@ -70,13 +117,53 @@ export class HubRunReplay {
         if (!log.requests.size) {
             this.totalBytes -= log.bytes;
             this.sessions.delete(sessionId);
+            this.retireCoverage(sessionId);
         }
     }
+    retireCoverage(sessionId) {
+        const live = this.coverage.get(sessionId);
+        if (!live || !this.persistence || live.publicationFailed)
+            return;
+        const saved = this.persistence.read(sessionId);
+        // Only disk-owned proof can outlive RAM. In-memory-only embedders retain
+        // their existing gap barrier, and an unknown publication failure stays live.
+        if (saved.status === "incomplete" ||
+            !saved.incarnation ||
+            live.proof.inputIds.length ||
+            (live.proof.incomplete && !saved.unpaired))
+            return;
+        this.coverageBytes -= live.proof.memoryBytes;
+        this.coverage.delete(sessionId);
+    }
+    outputCoverage(sessionId) {
+        const saved = this.persistence?.read(sessionId);
+        const live = this.coverage.get(sessionId);
+        return {
+            unpaired: !!saved?.unpaired || !!live?.proof.incomplete || !!live?.publicationFailed,
+            inputIds: [...new Set([...(saved?.inputIds ?? []), ...(live?.proof.inputIds ?? [])])],
+            ...(saved?.incarnation ? { incarnation: saved.incarnation } : {}),
+            ...(saved?.journalIdentity ? { journalIdentity: saved.journalIdentity } : {}),
+            ...(live?.outputCursor ? { outputCursor: live.outputCursor } : {}),
+            streamCursor: { epoch: this.epoch, sequence: this.sequence },
+        };
+    }
+    forget(sessionId) {
+        const log = this.sessions.get(sessionId);
+        if (log)
+            this.totalBytes -= log.bytes;
+        this.sessions.delete(sessionId);
+        const coverage = this.coverage.get(sessionId);
+        if (coverage)
+            this.coverageBytes -= coverage.proof.memoryBytes;
+        this.coverage.delete(sessionId);
+        this.persistence?.forget(sessionId);
+    }
     snapshot(sessionId, durableEvents) {
         const log = this.sessions.get(sessionId);
         return {
             transcript: log && !log.truncated ? durableEvents.slice(0, log.baselineEvents) : durableEvents.slice(),
             streamCursor: { epoch: this.epoch, sequence: this.sequence },
+            outputCoverage: this.outputCoverage(sessionId),
             ...(log
                 ? { liveStream: { events: structuredClone(log.events), truncated: log.truncated } }
                 : {}),
@@ -85,5 +172,7 @@ export class HubRunReplay {
     clear() {
         this.sessions.clear();
         this.totalBytes = 0;
+        for (const sessionId of this.coverage.keys())
+            this.retireCoverage(sessionId);
     }
 }

package/dist/hub/session-management.js

@@ -369,6 +369,8 @@ export function transcriptMarkdown(title, transcript) {
         }
         else if (item.kind === "system_error")
             sections.push(`### 错误\n\n${item.text}`);
+        else if (item.kind === "system")
+            sections.push(`### 通知\n\n${item.text}`);
         else
             sections.push(`### 子代理：${item.label}\n\n${item.status}`);
     }

package/dist/index.panels.d.ts

@@ -3,6 +3,8 @@ export * from "./panels/automations.js";
 export * from "./panels/hub-automations.js";
 export { createPanelManagement, PanelManagementError } from "./panels/management.js";
 export { createPanelRuntime, panelWebCompatibility } from "./panels/runtime.js";
+export { createHubPanelBinding } from "./panels/hub-binding.js";
+export * from "./panels/project-scope.js";
 export { PanelRuntimeServices } from "./panels/runtime-services.js";
 export * from "./panels/process-service.js";
 export * from "./panels/agent-task-service.js";

package/dist/index.panels.js

@@ -3,6 +3,8 @@ export * from "./panels/automations.js";
 export * from "./panels/hub-automations.js";
 export { createPanelManagement, PanelManagementError } from "./panels/management.js";
 export { createPanelRuntime, panelWebCompatibility } from "./panels/runtime.js";
+export { createHubPanelBinding } from "./panels/hub-binding.js";
+export * from "./panels/project-scope.js";
 export { PanelRuntimeServices } from "./panels/runtime-services.js";
 export * from "./panels/process-service.js";
 export * from "./panels/agent-task-service.js";

package/dist/panels/automations.d.ts

@@ -7,6 +7,8 @@ export interface PanelAutomationScope {
     sessionId: string;
     /** Host-selected installed package revision, never a field from Panel call JSON. */
     revision?: string;
+    /** Optional synchronous transport fence immediately before a Host mutation. */
+    assertAuthorized?(): void;
     isAuthorized(): Promise<boolean>;
 }
 /** Borrowed Host service. A page/transport closing never stops the scheduler. */

package/dist/panels/bridge-contract.d.ts

@@ -11,7 +11,7 @@ export declare const panelBridgeLimits: Readonly<{
     callTimeoutMs: 15000;
     consentTimeoutMs: number;
 }>;
-export type PanelBridgeErrorCode = "PERMISSION_DENIED" | "REVOKED" | "NOT_SUPPORTED" | "RATE_LIMITED" | "PARAMS_TOO_LARGE" | "RESULT_TOO_LARGE" | "TIMEOUT" | "INVALID_ARGUMENT" | "OPERATION_FAILED";
+export type PanelBridgeErrorCode = "PERMISSION_DENIED" | "REVOKED" | "SESSION_CHANGED" | "NOT_SUPPORTED" | "RATE_LIMITED" | "PARAMS_TOO_LARGE" | "RESULT_TOO_LARGE" | "TIMEOUT" | "INVALID_ARGUMENT" | "OPERATION_FAILED";
 export declare class PanelBridgeError extends Error {
     readonly code: PanelBridgeErrorCode;
     readonly retryAfterMs?: number | undefined;

package/dist/panels/bridge-contract.js

@@ -77,6 +77,7 @@ export function panelRuntimeCapabilities(input) {
         errors: [
             "PERMISSION_DENIED",
             "REVOKED",
+            "SESSION_CHANGED",
             "NOT_SUPPORTED",
             "RATE_LIMITED",
             "PARAMS_TOO_LARGE",

package/dist/panels/http.d.ts

@@ -4,9 +4,11 @@ import type { PanelDirectoryAuthorizer } from "./directory-bookmarks.js";
 import type { SharedPanelToolHost } from "./shared-tool-jobs.js";
 import type { PanelAutomationHost } from "./automations.js";
 import { type PanelAgentTaskHostOptions } from "./agent-task-host.js";
+import type { PanelProjectScopeBinding } from "./project-scope.js";
 export declare function createPanelHttp(options: PanelManagementHttpOptions & {
     dataDir: string;
     host: "hub" | "desktop";
+    projectScope?: () => Promise<PanelProjectScopeBinding | undefined>;
     publicPathPrefix?: string;
     agentTaskOptions?: PanelAgentTaskHostOptions;
     sharedToolJobs?: SharedPanelToolHost;

package/dist/panels/project-scope.d.ts

@@ -0,0 +1,24 @@
+/** Context identity only. This value grants no Host permissions. */
+export interface PanelProjectScope {
+    version: 1;
+    environmentId: string;
+    projectId: string;
+    rootId: string;
+}
+export interface PanelProjectScopeBinding {
+    readonly scope: Readonly<PanelProjectScope>;
+    /** Revalidates the frozen authority; a failed binding can never be revived. */
+    assertCurrent(): void;
+}
+/** Only Host composition calls this factory, after resolving its selected roots. */
+export declare function capturePanelProjectScope(options: {
+    environmentDir: string;
+    /** Hub supplies its already advertised descriptor identity. */
+    environmentId?: string;
+    projectPath: string;
+    cwd: string;
+    /** Desktop supplies opaque IDs resolved from its authoritative project registry. */
+    projectId?: string;
+    rootId?: string;
+    assertAuthority(): void;
+}): Promise<PanelProjectScopeBinding>;

package/dist/panels/project-scope.js

@@ -0,0 +1,101 @@
+import { createHash } from "node:crypto";
+import { closeSync, constants, fstatSync, lstatSync, openSync, readSync, realpathSync, } from "node:fs";
+import { join, resolve } from "node:path";
+import { environmentIdentity } from "../environment-identity.js";
+const digest = (value) => createHash("sha256").update(JSON.stringify(value)).digest("hex");
+function directory(path) {
+    const selected = resolve(path);
+    const canonical = realpathSync(selected);
+    const info = lstatSync(canonical, { bigint: true });
+    if (!info.isDirectory() || info.isSymbolicLink())
+        throw new Error("Invalid Panel project root");
+    const identity = [canonical, String(info.dev), String(info.ino), String(info.birthtimeNs)];
+    return {
+        identity,
+        assertCurrent() {
+            if (realpathSync(selected) !== canonical)
+                throw new Error("Panel project root changed");
+            const current = lstatSync(canonical, { bigint: true });
+            if (!current.isDirectory() ||
+                current.isSymbolicLink() ||
+                current.dev !== info.dev ||
+                current.ino !== info.ino ||
+                current.birthtimeNs !== info.birthtimeNs)
+                throw new Error("Panel project root changed");
+        },
+    };
+}
+function readEnvironment(path, expectedId) {
+    const fd = openSync(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0) | (constants.O_NONBLOCK ?? 0));
+    try {
+        const before = fstatSync(fd, { bigint: true });
+        if (!before.isFile() || before.size <= 0n || before.size > 256n)
+            throw new Error("Invalid Panel environment identity");
+        const bytes = Buffer.alloc(Number(before.size));
+        let offset = 0;
+        while (offset < bytes.length) {
+            const count = readSync(fd, bytes, offset, bytes.length - offset, offset);
+            if (!count)
+                throw new Error("Panel environment identity changed");
+            offset += count;
+        }
+        const after = fstatSync(fd, { bigint: true });
+        const named = lstatSync(path, { bigint: true });
+        const value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+        if (after.dev !== before.dev ||
+            after.ino !== before.ino ||
+            after.size !== before.size ||
+            after.mtimeNs !== before.mtimeNs ||
+            after.ctimeNs !== before.ctimeNs ||
+            named.isSymbolicLink() ||
+            named.dev !== before.dev ||
+            named.ino !== before.ino ||
+            value?.version !== 1 ||
+            value.id !== expectedId)
+            throw new Error("Panel environment identity changed");
+        return [String(before.dev), String(before.ino), String(before.birthtimeNs)];
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+/** Only Host composition calls this factory, after resolving its selected roots. */
+export async function capturePanelProjectScope(options) {
+    options.assertAuthority();
+    const environmentId = options.environmentId ?? (await environmentIdentity(options.environmentDir));
+    options.assertAuthority();
+    const environmentRoot = directory(options.environmentDir);
+    const environmentFile = join(options.environmentDir, "environment.json");
+    const environmentPin = readEnvironment(environmentFile, environmentId);
+    const project = directory(options.projectPath);
+    const root = directory(options.cwd);
+    const scope = Object.freeze({
+        version: 1,
+        environmentId,
+        projectId: options.projectId ?? digest(["project", project.identity]),
+        // The registered mount and the execution root are different for worktrees.
+        rootId: digest(["root", options.rootId ?? null, root.identity]),
+    });
+    let revoked = false;
+    const binding = {
+        scope,
+        assertCurrent() {
+            if (revoked)
+                throw new Error("Panel project scope was revoked; reopen the panel");
+            try {
+                options.assertAuthority();
+                environmentRoot.assertCurrent();
+                if (digest(readEnvironment(environmentFile, environmentId)) !== digest(environmentPin))
+                    throw new Error("Panel environment identity changed");
+                project.assertCurrent();
+                root.assertCurrent();
+            }
+            catch (cause) {
+                revoked = true;
+                throw new Error("Panel project scope changed; reopen the panel", { cause });
+            }
+        },
+    };
+    binding.assertCurrent();
+    return binding;
+}

package/dist/panels/runtime-services.d.ts

@@ -5,6 +5,8 @@ export interface PanelRuntimeScope {
     permissions: readonly string[];
     /** Checks the live owner, its project binding, and the installed revision. */
     isAuthorized: () => Promise<boolean>;
+    /** Optional synchronous transport check at the storage publication boundary. */
+    assertAuthorized?: () => void;
 }
 /** Node-only implementation of the existing Panel SDK's bounded disk operations. */
 export declare class PanelRuntimeServices {

package/dist/panels/runtime-services.js

@@ -157,7 +157,7 @@ export class PanelRuntimeServices {
                 if (change) {
                     const result = applyPanelAppStorageChange(state, change);
                     if (result.updated)
-                        await writePanelAppStorage(file, state, quota, () => authorized(scope));
+                        await writePanelAppStorage(file, state, quota, () => authorized(scope), scope.assertAuthorized);
                     return result;
                 }
                 const existed = Object.hasOwn(state, key);
@@ -165,7 +165,7 @@ export class PanelRuntimeServices {
                     state[key] = JSON.parse(encoded);
                 else
                     delete state[key];
-                await writePanelAppStorage(file, state, quota, () => authorized(scope));
+                await writePanelAppStorage(file, state, quota, () => authorized(scope), scope.assertAuthorized);
                 return method === "storage.set" ? true : existed;
             }
             finally {

package/dist/panels/runtime.d.ts

@@ -4,6 +4,7 @@ import type { SharedPanelToolHost } from "./shared-tool-jobs.js";
 import { type PanelDirectoryAuthorizer } from "./directory-bookmarks.js";
 import type { PanelSnapshot } from "./types.js";
 import { type PanelAutomationHost } from "./automations.js";
+import type { PanelProjectScopeBinding } from "./project-scope.js";
 export declare const panelWebCompatibility: (app: Pick<InstalledPanelApp, "permissions">, options?: {
     automations?: boolean;
 }) => {
@@ -34,6 +35,8 @@ export interface PanelRuntimeOptions {
     projectPackages?: boolean;
     dataDir: string;
     host: "hub" | "desktop";
+    /** Host authority only, never a field accepted from Panel HTTP requests. */
+    projectScope?: () => Promise<PanelProjectScopeBinding | undefined>;
     publicPathPrefix?: string;
     snapshot: (appId?: string) => Promise<PanelSnapshot>;
     ownerId: (request: IncomingMessage) => Promise<string | undefined>;

package/dist/panels/runtime.js

@@ -1,7 +1,7 @@
 import { panelVideoLimits, panelVideoOptions } from "./browser-capture.js";
 import { panelExecutionGate, PanelExecutionBusyError } from "./execution-gate.js";
 import { randomBytes, createHash } from "node:crypto";
-import { constants } from "node:fs";
+import { constants, lstatSync } from "node:fs";
 import { lstat, mkdir, open, opendir, realpath } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, extname, join, resolve, sep } from "node:path";
@@ -1001,12 +1001,14 @@ export function createPanelRuntime(options) {
             return false;
         }
         try {
+            grant.projectScope?.assertCurrent();
             const panel = (await snapshot(grant.app.id)).panels.find((candidate) => candidate.id === grant.app.id);
             const info = await lstat(grant.root);
             const ownerStillAuthorized = await options.isAuthorized(grant.request);
             const currentOwner = await options.ownerId(grant.request);
             if (grant.app.permissions.includes("process"))
                 await options.authorizePanelDirectory?.(grant.app, options.bindingCwd ?? options.cwd, options.cwd);
+            grant.projectScope?.assertCurrent();
             const valid = !closed &&
                 grants.get(grant.id) === grant &&
                 grant.expiresAt > now() &&
@@ -1199,7 +1201,17 @@ export function createPanelRuntime(options) {
                 context.sessionId = input.sessionId;
                 context.busy = false;
             }
+            const projectScope = app.permissions.includes("context.workspace")
+                ? await options.projectScope?.()
+                : undefined;
+            if (projectScope) {
+                projectScope.assertCurrent();
+                context.projectScope = { ...projectScope.scope };
+            }
+            if (closed || generation !== startedGeneration || preparation.cancelled)
+                error(410, "面板授权已失效，请重新打开。");
             const grant = {
+                projectScope,
                 sharedTools,
                 guestId: ++nextGuest,
                 id,
@@ -1600,12 +1612,33 @@ export function createPanelRuntime(options) {
                 error(400, "面板通知内容无效。");
             return { effect: method, title: value.title ?? grant.app.title.default, body: value.body };
         }
+        const expectedRevision = grant.revision;
         return services.call({
             appId: grant.app.id,
             cwd: options.cwd,
             projectPath: options.bindingCwd ?? options.cwd,
             permissions: grant.app.permissions,
             isAuthorized: () => authorized(grant),
+            assertAuthorized: () => {
+                try {
+                    grant.projectScope?.assertCurrent();
+                    const root = lstatSync(grant.root);
+                    if (closed ||
+                        grants.get(grant.id) !== grant ||
+                        byGuest.get(grant.guestId) !== grant ||
+                        grant.revision !== expectedRevision ||
+                        grant.expiresAt <= now() ||
+                        !grant.app.permissions.includes("storage") ||
+                        root.isSymbolicLink() ||
+                        !root.isDirectory() ||
+                        root.dev + ":" + root.ino !== grant.rootIdentity)
+                        throw new PanelBridgeError("REVOKED", "Panel App storage scope changed");
+                }
+                catch (cause) {
+                    remove(grant);
+                    throw cause;
+                }
+            },
         }, method, params);
     }
     return {

package/dist/panels/storage-store.d.ts

@@ -27,4 +27,4 @@ export declare function applyPanelAppStorageChange(storage: PanelAppStorage, cha
 };
 export declare function preparePanelAppStorage(file: string): Promise<void>;
 export declare function readPanelAppStorage(file: string, quotaBytes: number): Promise<PanelAppStorage>;
-export declare function writePanelAppStorage(file: string, storage: PanelAppStorage, quotaBytes: number, beforeCommit?: () => Promise<void>): Promise<void>;
+export declare function writePanelAppStorage(file: string, storage: PanelAppStorage, quotaBytes: number, beforeCommit?: () => Promise<void>, finalCommitFence?: () => void): Promise<void>;

package/dist/panels/storage-store.js

@@ -1,5 +1,5 @@
 import { createHash, randomUUID } from "node:crypto";
-import { constants } from "node:fs";
+import { constants, renameSync } from "node:fs";
 import { chmod, lstat, mkdir, open, rename, rm, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 /** Matches the existing Desktop namespace, so its remote Web shares saved panel state. */
@@ -161,7 +161,7 @@ export async function readPanelAppStorage(file, quotaBytes) {
         await handle?.close().catch(() => undefined);
     }
 }
-export async function writePanelAppStorage(file, storage, quotaBytes, beforeCommit) {
+export async function writePanelAppStorage(file, storage, quotaBytes, beforeCommit, finalCommitFence) {
     const quota = panelAppStorageQuotaBytes(quotaBytes);
     const entries = Object.entries(storage);
     if (entries.length > MAX_PANEL_APP_STORAGE_KEYS) {
@@ -187,7 +187,12 @@ export async function writePanelAppStorage(file, storage, quotaBytes, beforeComm
         // Recheck both authorization and the target after staging, before publishing.
         await beforeCommit?.();
         await preparePanelAppStorage(file);
-        await rename(temporary, file);
+        if (finalCommitFence) {
+            finalCommitFence();
+            renameSync(temporary, file);
+        }
+        else
+            await rename(temporary, file);
         if (process.platform !== "win32")
             await chmod(file, 0o600);
     }

package/dist/serve/headless-server.js

@@ -22,7 +22,7 @@ import { basename, dirname, extname, join, resolve } from "node:path";
 import { randomBytes, randomUUID } from "node:crypto";
 import { WebSocketServer } from "ws";
 import { SessionManager, SettingsManager } from "@cjhyy/code-shell-core";
-import { readOutputJournal, readOutputJournalLegacyBase } from "@cjhyy/code-shell-core/internal";
+import { SessionOutputCoverageStore, readOutputJournal, readOutputJournalLegacyBase, } from "@cjhyy/code-shell-core/internal";
 import { AccessPasscode } from "../mobile-remote/access-passcode.js";
 import { resolveSafe } from "../mobile-remote/mobile-static.js";
 import { contentTypeFor } from "../static-files.js";
@@ -37,6 +37,7 @@ import { createHubMcpConfiguration } from "../hub/mcp-configuration.js";
 import { createLinkHttp } from "../links/http.js";
 import { createPanelHttp } from "../panels/http.js";
 import { createHubPanelBinding } from "../panels/hub-binding.js";
+import { capturePanelProjectScope } from "../panels/project-scope.js";
 import { createHubSessions, hubSessionPreview, readHubSessionState, readHubTranscript, } from "../hub/session-management.js";
 import { createHubFiles } from "../hub/files.js";
 import { createSessionHttpResponses } from "../session-http-responses.js";
@@ -123,7 +124,7 @@ export async function startHeadlessServer(opts) {
     // Independent of response routing: leaving a tab does not stop its worker run.
     const runningSessions = new Map();
     const runOwners = new Map();
-    const runReplay = new HubRunReplay();
+    const runReplay = new HubRunReplay(undefined, new SessionOutputCoverageStore(() => sessionRootDir));
     const runInputs = new Map();
     let preparingRuns = 0;
     let configurationChanging = false;
@@ -146,13 +147,21 @@ export async function startHeadlessServer(opts) {
         broadcast(JSON.stringify({ jsonrpc: "2.0", method, params }));
     };
     const publishStream = (sessionId, event) => {
-        const cursor = runReplay.append(sessionId, event);
+        let cursor;
+        try {
+            cursor = runReplay.append(sessionId, event);
+        }
+        catch {
+            log("stream.coverage_unavailable", { sessionId });
+            return false;
+        }
         notify("agent/streamEvent", {
             sessionId,
             event,
             hubSequence: cursor.sequence,
             hubEpoch: cursor.epoch,
         });
+        return true;
     };
     const leases = new ApprovalLeases((lease) => notify("serve/approvalLease", lease));
     const authReaper = hubAuth
@@ -235,6 +244,7 @@ export async function startHeadlessServer(opts) {
                 const params = message.params;
                 if (typeof params?.sessionId === "string" && params.event !== undefined) {
                     let event = params.event;
+                    let deliveredInput;
                     const value = event;
                     if (value?.type === "session_user_message" && typeof value.clientMessageId === "string") {
                         const input = [...runInputs.values()].find((candidate) => candidate.sessionId === params.sessionId &&
@@ -242,11 +252,17 @@ export async function startHeadlessServer(opts) {
                         if (input) {
                             if (input.echoed)
                                 return;
-                            input.echoed = true;
-                            event = input.event;
+                            deliveredInput = input;
+                            event = {
+                                ...input.event,
+                                ...(typeof value.outputCursor === "string"
+                                    ? { outputCursor: value.outputCursor }
+                                    : {}),
+                            };
                         }
                     }
-                    publishStream(params.sessionId, event);
+                    if (publishStream(params.sessionId, event) && deliveredInput)
+                        deliveredInput.echoed = true;
                     return;
                 }
             }
@@ -255,8 +271,7 @@ export async function startHeadlessServer(opts) {
                 const requestId = String(params?.requestId);
                 const input = runInputs.get(requestId);
                 if (input && !input.echoed) {
-                    input.echoed = true;
-                    publishStream(input.sessionId, input.event);
+                    input.echoed = publishStream(input.sessionId, input.event);
                 }
                 const route = pendingWorkerResponses.get(requestId);
                 if (route)
@@ -462,6 +477,17 @@ export async function startHeadlessServer(opts) {
             ...panelBinding,
             dataDir: opts.dataDir,
             host: "hub",
+            projectScope: () => {
+                if (!environment || !panelBinding)
+                    throw new Error("Hub project identity is unavailable");
+                return capturePanelProjectScope({
+                    environmentDir: opts.dataDir,
+                    environmentId: environment.id,
+                    projectPath: panelBinding.bindingCwd,
+                    cwd: workspaceCwd,
+                    assertAuthority: panelBinding.assertBinding,
+                });
+            },
             automations: {
                 conditionalMutations: true,
                 call: (scope, method, params) => {
@@ -506,7 +532,11 @@ export async function startHeadlessServer(opts) {
             dataDir: opts.dataDir,
             isAuthorized: configurationOptions.isAuthorized,
             isRunning,
-            onChanged: (sessionId) => notify("serve/sessionsChanged", { sessionId }),
+            onChanged: (sessionId) => {
+                if (!existsSync(join(sessionRootDir, sessionId, "state.json")))
+                    runReplay.forget(sessionId);
+                notify("serve/sessionsChanged", { sessionId });
+            },
         })
         : undefined;
     const files = hubAuth
@@ -1135,7 +1165,9 @@ function replyToHostSessionQuery(message, sessionManager, workspaceCwd, isRunnin
             result: { type: "sessions", data: sessions },
         });
     }
-    if (queryType !== "session_detail" && queryType !== "output_journal")
+    if (queryType !== "session_detail" &&
+        queryType !== "output_journal" &&
+        queryType !== "output_coverage")
         return undefined;
     const sessionId = message.params?.sessionId;
     if (typeof sessionId !== "string" || sessionId.length === 0) {
@@ -1150,6 +1182,27 @@ function replyToHostSessionQuery(message, sessionManager, workspaceCwd, isRunnin
         if (resolve(state.cwd) !== workspaceCwd) {
             return hostQueryError(message.id, -32001, "Session not found in this workspace");
         }
+        if (queryType === "output_coverage") {
+            // Completed RAM entries can be retired once their proof belongs to disk.
+            // Freeze the real current journal head, so a lost live notification or
+            // run finish during pagination cannot hide a later durable prefix.
+            const head = readOutputJournal(sessionManager.getStorageDir(), sessionId, { maxFrames: 1 });
+            const coverage = runReplay?.outputCoverage(sessionId);
+            return JSON.stringify({
+                jsonrpc: "2.0",
+                id: message.id,
+                result: {
+                    type: "output_coverage",
+                    data: {
+                        ...coverage,
+                        unpaired: !!coverage?.unpaired ||
+                            (head.status !== "ok" &&
+                                (head.status !== "unavailable" || !!coverage?.journalIdentity)),
+                        ...(head.through ? { outputCursor: head.through } : {}),
+                    },
+                },
+            });
+        }
         if (queryType === "output_journal") {
             const data = readOutputJournal(sessionManager.getStorageDir(), sessionId, {
                 after: message.params?.after,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cjhyy/code-shell-server",
-  "version": "0.9.32",
+  "version": "0.9.33",
   "description": "CodeShell server transport layer — mobile remote HTTP/WS host, pairing, passcode gate, tunnel, rooms, uploads, and session/attachment services. Electron-free; precursor of the auth gateway.",
   "type": "module",
   "main": "./dist/index.js",
@@ -60,13 +60,13 @@
     "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\""
   },
   "dependencies": {
-    "@cjhyy/code-shell-capability-coding": "0.9.32",
-    "@cjhyy/code-shell-core": "0.9.32",
-    "@cjhyy/code-shell-web": "0.9.32",
+    "@cjhyy/code-shell-capability-coding": "0.9.33",
+    "@cjhyy/code-shell-core": "0.9.33",
+    "@cjhyy/code-shell-web": "0.9.33",
     "@modelcontextprotocol/sdk": "^1.31.0",
     "@types/ws": "^8.18.1",
     "ws": "^8.21.0",
-    "@cjhyy/code-shell-link": "0.9.32"
+    "@cjhyy/code-shell-link": "0.9.33"
   },
   "engines": {
     "node": ">=20.10"