@cjhyy/code-shell-server 0.9.34 → 0.9.36

package/dist/links/service.d.ts

@@ -16,6 +16,8 @@ export interface LinkServiceOptions {
     now?: () => number;
     /** Trusted Host configuration; never accepted from a browser request. */
     remoteLink?: () => RemoteLinkConfiguration | undefined;
+    /** Trusted Host opt-in: reuse a uniquely identified user connection after remote OAuth. */
+    reuseRemoteConnection?: boolean;
     /** Test seams. Production delegates to Core's fixed provider and CLI executors. */
     validateToken?: typeof validateLocalLinkToken;
     cliStatus?: typeof getCliLinkStatus;

package/dist/links/service.js

@@ -1164,8 +1164,27 @@ export function createLinkService(options = {}) {
             };
             await change(guarded, () => {
                 assertPending();
-                swap(job.prepared, credential, {
-                    retireExpected: !!job.prepared.expected,
+                let prepared = job.prepared;
+                if (options.reuseRemoteConnection &&
+                    !prepared.expected &&
+                    prepared.input.connectionId === undefined) {
+                    // Identity comes from authenticated metadata, never a browser-supplied connection ID.
+                    const current = records();
+                    const matches = current.credentials.filter((entry) => !current.projectIds.has(entry.id) &&
+                        isRemoteLinkCredential(entry) &&
+                        entry.meta?.linkProvider === credential.meta?.linkProvider &&
+                        entry.meta?.linkRemoteIssuer === credential.meta?.linkRemoteIssuer &&
+                        entry.meta?.linkRemoteConnectionId === credential.meta?.linkRemoteConnectionId);
+                    if (matches.length > 1)
+                        throw new LinkServiceError(409, "conflict");
+                    if (matches.length === 1) {
+                        const expected = matches[0];
+                        prepared = { ...prepared, id: expected.id, expected };
+                        credential = { ...credential, id: expected.id, label: expected.label };
+                    }
+                }
+                swap(prepared, credential, {
+                    retireExpected: !!prepared.expected,
                     adopt: staged,
                     now: now(),
                 });

package/dist/mobile-remote/mobile-client-event-validator.js

@@ -135,7 +135,16 @@ export function parseMobileClientEvent(value) {
             break;
         case "room.history":
             valid =
-                boundedString(event.roomId, MAX_ID_LENGTH) && optionalNonNegativeInteger(event.sinceSeq);
+                boundedString(event.roomId, MAX_ID_LENGTH) &&
+                    optionalNonNegativeInteger(event.sinceSeq) &&
+                    (event.page === undefined || typeof event.page === "boolean") &&
+                    optionalBoundedString(event.cursor, 2048) &&
+                    optionalBoundedString(event.requestId, MAX_ID_LENGTH) &&
+                    (event.limit === undefined ||
+                        (Number.isSafeInteger(event.limit) &&
+                            event.limit >= 1 &&
+                            event.limit <= 500)) &&
+                    (event.cursor === undefined || (event.page === true && event.sinceSeq === undefined));
             break;
         case "ccRoom.probe":
             valid =

package/dist/mobile-remote/room-history.d.ts

@@ -0,0 +1,20 @@
+/** Room-local history coordinates. These are never native Session/Run cursors. */
+export interface RoomHistoryPage<T = unknown> {
+    snapshotId: string;
+    throughSeq: number;
+    messages: T[];
+    nextCursor?: string;
+    complete: boolean;
+}
+export interface RoomHistoryRequest {
+    sinceSeq?: number;
+    cursor?: string;
+    limit?: number;
+}
+export declare function scanRoomHistory<T extends {
+    seq: number;
+}>(file: string, parse: (value: unknown) => T | undefined, visit?: (message: T) => void): number;
+/** Durable immutable copies keep a frozen page boundary valid across Host restarts. */
+export declare function readRoomHistoryPage<T extends {
+    seq: number;
+}>(roomDir: string, roomId: string, request: RoomHistoryRequest, parse: (value: unknown) => T | undefined): RoomHistoryPage<T>;

package/dist/mobile-remote/room-history.js

@@ -0,0 +1,327 @@
+import { createHash, createHmac, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
+import { closeSync, constants, fstatSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, renameSync, rmSync, writeFileSync, writeSync, } from "node:fs";
+import { join } from "node:path";
+const MAX_BYTES = 256 * 1024 * 1024;
+const MAX_LINE = 4 * 1024 * 1024;
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+const decoder = new TextDecoder("utf-8", { fatal: true });
+function regular(path) {
+    const stat = lstatSync(path);
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.nlink !== 1) {
+        throw new Error("room history must be a private regular file");
+    }
+    return stat;
+}
+function stamp(stat) {
+    return [stat.dev, stat.ino, stat.size, stat.mtimeMs, stat.ctimeMs].join(":");
+}
+function openRegular(path) {
+    const before = regular(path);
+    const fd = openSync(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+    if (stamp(before) !== stamp(fstatSync(fd))) {
+        closeSync(fd);
+        throw new Error("room history changed while opening");
+    }
+    return fd;
+}
+function syncDirectory(path) {
+    if (process.platform === "win32")
+        return;
+    const fd = openSync(path, "r");
+    try {
+        fsyncSync(fd);
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+/** Bounded memory, strict complete records, exact physical offsets. */
+function* lines(fd, start, end, hashes) {
+    let offset = start;
+    let carry = Buffer.alloc(0);
+    while (offset < end) {
+        const blockStart = hashes ? Math.floor(offset / 65536) * 65536 : offset;
+        const data = Buffer.allocUnsafe(Math.min(65536, end - blockStart));
+        let total = 0;
+        while (total < data.length) {
+            const count = readSync(fd, data, total, data.length - total, blockStart + total);
+            if (!count)
+                throw new Error("room history was truncated while reading");
+            total += count;
+        }
+        if (hashes && createHash("sha256").update(data).digest("hex") !== hashes[blockStart / 65536]) {
+            throw new Error("room history snapshot checksum mismatch");
+        }
+        const available = data.subarray(offset - blockStart);
+        const count = available.length;
+        offset += count;
+        const chunk = Buffer.concat([carry, available]);
+        let from = 0;
+        for (;;) {
+            const newline = chunk.indexOf(0x0a, from);
+            if (newline < 0)
+                break;
+            if (newline - from > MAX_LINE)
+                throw new Error("room history record exceeds size limit");
+            yield {
+                text: decoder.decode(chunk.subarray(from, newline)),
+                end: offset - chunk.length + newline + 1,
+            };
+            from = newline + 1;
+        }
+        carry = Buffer.from(chunk.subarray(from));
+        if (carry.length > MAX_LINE)
+            throw new Error("room history record exceeds size limit");
+    }
+    if (carry.length)
+        throw new Error("room history has an incomplete final record");
+}
+export function scanRoomHistory(file, parse, visit) {
+    const fd = openRegular(file);
+    try {
+        const before = fstatSync(fd);
+        if (before.size > MAX_BYTES)
+            throw new Error("room history exceeds 256 MiB; archive it before continuing");
+        let seq = 0;
+        for (const line of lines(fd, 0, before.size)) {
+            const msg = parse(JSON.parse(line.text));
+            if (!msg || msg.seq !== seq + 1)
+                throw new Error(`room history is corrupt at sequence ${seq + 1}`);
+            seq = msg.seq;
+            visit?.(msg);
+        }
+        if (stamp(before) !== stamp(fstatSync(fd)) || stamp(before) !== stamp(regular(file))) {
+            throw new Error("room history changed while scanning");
+        }
+        return seq;
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+function validateManifest(value, roomId, snapshotId) {
+    if (!value ||
+        value.version !== 1 ||
+        value.roomId !== roomId ||
+        value.snapshotId !== snapshotId ||
+        !Number.isSafeInteger(value.bytes) ||
+        value.bytes < 0 ||
+        value.bytes > MAX_BYTES ||
+        !Number.isSafeInteger(value.throughSeq) ||
+        value.throughSeq < 0 ||
+        !Number.isSafeInteger(value.sinceSeq) ||
+        value.sinceSeq < 0 ||
+        value.sinceSeq > value.throughSeq ||
+        typeof value.key !== "string" ||
+        !/^[0-9a-f]{64}$/.test(value.key) ||
+        typeof value.stamp !== "string" ||
+        !/^[0-9:.]+$/.test(value.stamp) ||
+        !Array.isArray(value.hashes) ||
+        value.hashes.length !== Math.ceil(value.bytes / 65536) ||
+        value.hashes.some((hash) => typeof hash !== "string" || !/^[0-9a-f]{64}$/.test(hash)))
+        throw new Error("invalid history manifest");
+}
+/** Durable immutable copies keep a frozen page boundary valid across Host restarts. */
+export function readRoomHistoryPage(roomDir, roomId, request, parse) {
+    const limit = request.limit ?? 200;
+    if (!Number.isSafeInteger(limit) || limit < 1 || limit > 500)
+        throw new Error("invalid history page limit");
+    if (request.sinceSeq !== undefined &&
+        (!Number.isSafeInteger(request.sinceSeq) || request.sinceSeq < 0)) {
+        throw new Error("invalid room sequence");
+    }
+    const directory = join(roomDir, "history-snapshots");
+    mkdirSync(directory, { recursive: true, mode: 0o700 });
+    const directoryStat = lstatSync(directory);
+    if (!directoryStat.isDirectory() || directoryStat.isSymbolicLink())
+        throw new Error("invalid history snapshot directory");
+    const assertDirectory = () => {
+        const current = lstatSync(directory);
+        if (!current.isDirectory() ||
+            current.isSymbolicLink() ||
+            current.dev !== directoryStat.dev ||
+            current.ino !== directoryStat.ino)
+            throw new Error("room history snapshot directory changed");
+    };
+    let manifest;
+    let cursor;
+    if (request.cursor !== undefined) {
+        if (request.sinceSeq !== undefined || request.cursor.length > 2048)
+            throw new Error("invalid history cursor");
+        const [body, signature, extra] = request.cursor.split(".");
+        if (!body || !signature || extra)
+            throw new Error("invalid history cursor");
+        cursor = JSON.parse(Buffer.from(body, "base64url").toString("utf8"));
+        if (!UUID.test(cursor.snapshotId))
+            throw new Error("invalid history snapshot id");
+        const path = join(directory, `${cursor.snapshotId}.json`);
+        const metaFd = openRegular(path);
+        try {
+            const before = fstatSync(metaFd);
+            if (before.size > 512 * 1024)
+                throw new Error("invalid history manifest");
+            manifest = JSON.parse(readFileSync(metaFd, "utf8"));
+            if (stamp(before) !== stamp(fstatSync(metaFd)) || stamp(before) !== stamp(regular(path)))
+                throw new Error("room history manifest changed while reading");
+        }
+        finally {
+            closeSync(metaFd);
+        }
+        validateManifest(manifest, roomId, cursor.snapshotId);
+        const expected = createHmac("sha256", manifest.key).update(body).digest();
+        const received = Buffer.from(signature, "base64url");
+        if (received.length !== expected.length || !timingSafeEqual(expected, received))
+            throw new Error("invalid history cursor signature");
+    }
+    else {
+        const snapshotId = randomUUID();
+        const source = join(roomDir, "messages.jsonl");
+        const file = join(directory, `${snapshotId}.jsonl`);
+        const input = openRegular(source);
+        let output;
+        try {
+            output = openSync(file, "wx", 0o600);
+            const before = fstatSync(input);
+            if (before.size > MAX_BYTES)
+                throw new Error("room history exceeds 256 MiB; archive it before continuing");
+            const hashes = [];
+            let offset = 0;
+            while (offset < before.size) {
+                const chunk = Buffer.allocUnsafe(Math.min(64 * 1024, before.size - offset));
+                let count = 0;
+                while (count < chunk.length) {
+                    const read = readSync(input, chunk, count, chunk.length - count, offset + count);
+                    if (!read)
+                        throw new Error("room history was truncated while freezing");
+                    count += read;
+                }
+                hashes.push(createHash("sha256").update(chunk).digest("hex"));
+                let written = 0;
+                while (written < count) {
+                    const progress = writeSync(output, chunk, written, count - written);
+                    if (!progress)
+                        throw new Error("room history freeze write made no progress");
+                    written += progress;
+                }
+                offset += count;
+            }
+            fsyncSync(output);
+            if (stamp(before) !== stamp(fstatSync(input)) || stamp(before) !== stamp(regular(source))) {
+                throw new Error("room history changed while freezing");
+            }
+            const throughSeq = scanRoomHistory(file, parse);
+            manifest = {
+                version: 1,
+                roomId,
+                snapshotId,
+                bytes: before.size,
+                throughSeq,
+                sinceSeq: request.sinceSeq ?? 0,
+                key: randomBytes(32).toString("hex"),
+                stamp: stamp(fstatSync(output)),
+                hashes,
+            };
+            const temporary = join(directory, `${snapshotId}.tmp`);
+            writeFileSync(temporary, JSON.stringify(manifest), { flag: "wx", mode: 0o600 });
+            const metaFd = openRegular(temporary);
+            try {
+                fsyncSync(metaFd);
+            }
+            finally {
+                closeSync(metaFd);
+            }
+            assertDirectory();
+            renameSync(temporary, join(directory, `${snapshotId}.json`));
+            syncDirectory(directory);
+            cursor = { snapshotId, offset: 0, afterSeq: 0 };
+            // Old cursors fail explicitly when their retained copy expires. Never
+            // remove another in-progress copy or an unknown directory entry.
+            try {
+                const old = readdirSync(directory)
+                    .filter((name) => UUID.test(name.replace(/\.json$/, "")) && name.endsWith(".json"))
+                    .map((name) => ({ name, time: regular(join(directory, name)).mtimeMs }))
+                    .sort((a, b) => b.time - a.time)
+                    .slice(8);
+                for (const item of old) {
+                    if (item.name === `${snapshotId}.json`)
+                        continue;
+                    rmSync(join(directory, item.name));
+                    rmSync(join(directory, item.name.replace(/\.json$/, ".jsonl")), { force: true });
+                }
+            }
+            catch {
+                /* Retention failure must not invalidate the successfully published snapshot. */
+            }
+        }
+        catch (error) {
+            // Remove the publication marker before its data on an unpublished/failed
+            // freeze. Retention failures are isolated after successful publication.
+            rmSync(join(directory, `${snapshotId}.json`), { force: true });
+            rmSync(join(directory, `${snapshotId}.tmp`), { force: true });
+            rmSync(file, { force: true });
+            throw error;
+        }
+        finally {
+            closeSync(input);
+            if (output !== undefined)
+                closeSync(output);
+        }
+    }
+    if (manifest.version !== 1 ||
+        manifest.roomId !== roomId ||
+        manifest.snapshotId !== cursor.snapshotId ||
+        !Number.isSafeInteger(manifest.bytes) ||
+        manifest.bytes < 0 ||
+        manifest.bytes > MAX_BYTES ||
+        !Number.isSafeInteger(manifest.throughSeq) ||
+        manifest.throughSeq < 0 ||
+        !Number.isSafeInteger(cursor.offset) ||
+        cursor.offset < 0 ||
+        cursor.offset > manifest.bytes ||
+        !Number.isSafeInteger(cursor.afterSeq) ||
+        cursor.afterSeq < 0 ||
+        cursor.afterSeq > manifest.throughSeq) {
+        throw new Error("invalid room history snapshot");
+    }
+    assertDirectory();
+    validateManifest(manifest, roomId, cursor.snapshotId);
+    const file = join(directory, `${cursor.snapshotId}.jsonl`);
+    const fd = openRegular(file);
+    const messages = [];
+    try {
+        if (stamp(fstatSync(fd)) !== manifest.stamp)
+            throw new Error("room history snapshot was modified");
+        for (const line of lines(fd, cursor.offset, manifest.bytes, manifest.hashes)) {
+            const msg = parse(JSON.parse(line.text));
+            if (!msg || msg.seq !== cursor.afterSeq + 1)
+                throw new Error("room history snapshot is corrupt");
+            cursor.offset = line.end;
+            cursor.afterSeq = msg.seq;
+            if (msg.seq > manifest.sinceSeq)
+                messages.push(msg);
+            if (messages.length === limit)
+                break;
+        }
+        if (stamp(fstatSync(fd)) !== manifest.stamp || stamp(regular(file)) !== manifest.stamp)
+            throw new Error("room history snapshot changed while paging");
+    }
+    finally {
+        closeSync(fd);
+    }
+    assertDirectory();
+    const complete = cursor.offset === manifest.bytes;
+    if (complete && cursor.afterSeq !== manifest.throughSeq)
+        throw new Error("incomplete room history snapshot");
+    const body = Buffer.from(JSON.stringify(cursor)).toString("base64url");
+    return {
+        snapshotId: manifest.snapshotId,
+        throughSeq: manifest.throughSeq,
+        messages,
+        complete,
+        ...(!complete
+            ? {
+                nextCursor: `${body}.${createHmac("sha256", manifest.key).update(body).digest("base64url")}`,
+            }
+            : {}),
+    };
+}

package/dist/mobile-remote/room-manager.d.ts

@@ -1,3 +1,5 @@
+import { type RoomHistoryRequest, type RoomHistoryPage } from "./room-history.js";
+export type { RoomHistoryPage, RoomHistoryRequest } from "./room-history.js";
 import type { ResidentAgentEvent } from "./resident-agent.js";
 import type { InputAttachmentMeta } from "../attachment-service.js";
 export declare function isValidRoomId(id: unknown): id is string;
@@ -73,6 +75,8 @@ export interface RoomMessage {
      *  card expands to so the real parameters are visible. Absent on legacy
      *  messages that predate args persistence. */
     args?: Record<string, unknown>;
+    /** Durable external transcript provenance, scoped to its actual file incarnation. */
+    transcriptSource?: string;
     attachments?: Array<{
         name: string;
         mime?: string;
@@ -156,6 +160,7 @@ export declare class RoomManager {
     /** User turns are echoed immediately for responsive room UX. When a
      * transcript follower later sees the same CLI-written user line, this queue
      * suppresses that duplicate. */
+    private readonly transcriptSources;
     private pendingTranscriptUserEchoes;
     /**
      * Rooms whose agent events must be buffered instead of handled immediately.
@@ -172,12 +177,16 @@ export declare class RoomManager {
      * JSONL. Seeded lazily from disk on the first append after startup; dropped
      * when the room's messages are deleted so the next append re-derives it.
      */
+    private readonly messageStampByRoom;
+    private messageStamp;
     private lastSeqByRoom;
     /** Throttled lastActiveAt bookkeeping — see touchLastActive. */
     private pendingLastActive;
     private lastActiveWrittenAt;
     private now;
     private readonly rootRealPath;
+    private readonly rootIdentity;
+    private readonly failedWrites;
     /** Drop all pending AskUser entries for a room. Called when its agent goes
      *  away (exit/close) so a request that can no longer be answered doesn't leak
      *  in the map (small memory leak) and its approval card doesn't hang until the
@@ -222,7 +231,9 @@ export declare class RoomManager {
      *  next open() can continue the same conversation. No-op if unchanged. */
     setRoomSessionId(id: string, sessionId: string): void;
     getMessages(id: string, sinceSeq?: number): RoomMessage[];
+    getHistoryPage(id: string, request?: RoomHistoryRequest): RoomHistoryPage<RoomMessage>;
     latestSeq(id: string): number;
+    hasTranscriptHistory(id: string): boolean;
     beginTranscriptFollow(id: string): void;
     endTranscriptFollow(id: string): void;
     /** Persist normalized transcript-tail messages through the same seq/history/

package/dist/mobile-remote/room-manager.js

@@ -1,4 +1,5 @@
-import { chmodSync, closeSync, existsSync, fchmodSync, fstatSync, lstatSync, mkdirSync, openSync, readSync, realpathSync, readdirSync, renameSync, writeFileSync, appendFileSync, rmSync, } from "node:fs";
+import { chmodSync, closeSync, existsSync, fchmodSync, fstatSync, fsyncSync, lstatSync, mkdirSync, openSync, readSync, realpathSync, readdirSync, renameSync, writeFileSync, appendFileSync, rmSync, } from "node:fs";
+import { readRoomHistoryPage, scanRoomHistory, } from "./room-history.js";
 import { randomUUID } from "node:crypto";
 import { isAbsolute, join, relative, resolve, sep } from "node:path";
 /**
@@ -24,6 +25,17 @@ function isContained(root, target) {
     const rel = relative(root, target);
     return rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
 }
+function syncRoomDirectory(path) {
+    if (process.platform === "win32")
+        return;
+    const fd = openSync(path, "r");
+    try {
+        fsyncSync(fd);
+    }
+    finally {
+        closeSync(fd);
+    }
+}
 function readBoundedUtf8File(path, maxBytes) {
     const fd = openSync(path, "r");
     try {
@@ -105,7 +117,14 @@ function parseRoomMessage(value) {
         raw.type.length > 128) {
         return undefined;
     }
-    for (const field of ["text", "tool", "summary", "reason", "toolId"]) {
+    for (const field of [
+        "text",
+        "tool",
+        "summary",
+        "reason",
+        "toolId",
+        "transcriptSource",
+    ]) {
         const item = raw[field];
         if (item !== undefined && (typeof item !== "string" || item.includes("\0")))
             return undefined;
@@ -235,6 +254,7 @@ export class RoomManager {
     /** User turns are echoed immediately for responsive room UX. When a
      * transcript follower later sees the same CLI-written user line, this queue
      * suppresses that duplicate. */
+    transcriptSources = new Map();
     pendingTranscriptUserEchoes = new Map();
     /**
      * Rooms whose agent events must be buffered instead of handled immediately.
@@ -251,12 +271,19 @@ export class RoomManager {
      * JSONL. Seeded lazily from disk on the first append after startup; dropped
      * when the room's messages are deleted so the next append re-derives it.
      */
+    messageStampByRoom = new Map();
+    messageStamp(id) {
+        const stat = lstatSync(this.msgPath(id));
+        return [stat.dev, stat.ino, stat.size, stat.mtimeMs, stat.ctimeMs].join(":");
+    }
     lastSeqByRoom = new Map();
     /** Throttled lastActiveAt bookkeeping — see touchLastActive. */
     pendingLastActive = new Map();
     lastActiveWrittenAt = new Map();
     now;
     rootRealPath;
+    rootIdentity;
+    failedWrites = new Set();
     /** Drop all pending AskUser entries for a room. Called when its agent goes
      *  away (exit/close) so a request that can no longer be answered doesn't leak
      *  in the map (small memory leak) and its approval card doesn't hang until the
@@ -281,6 +308,7 @@ export class RoomManager {
             throw new Error(`invalid room storage root: ${opts.rootDir}`);
         }
         this.rootRealPath = realpathSync(opts.rootDir);
+        this.rootIdentity = `${rootInfo.dev}:${rootInfo.ino}`;
         if (process.platform !== "win32")
             chmodSync(opts.rootDir, 0o700);
     }
@@ -288,7 +316,8 @@ export class RoomManager {
         const info = lstatSync(this.opts.rootDir);
         if (info.isSymbolicLink() ||
             !info.isDirectory() ||
-            realpathSync(this.opts.rootDir) !== this.rootRealPath) {
+            realpathSync(this.opts.rootDir) !== this.rootRealPath ||
+            `${info.dev}:${info.ino}` !== this.rootIdentity) {
             throw new Error(`invalid room storage root: ${this.opts.rootDir}`);
         }
     }
@@ -318,7 +347,7 @@ export class RoomManager {
         const path = join(this.roomDir(id), name);
         if (existsSync(path)) {
             const info = lstatSync(path);
-            if (info.isSymbolicLink() || !info.isFile())
+            if (info.isSymbolicLink() || !info.isFile() || info.nlink !== 1)
                 throw new Error(`invalid room file: ${path}`);
         }
         return path;
@@ -337,7 +366,15 @@ export class RoomManager {
                 encoding: "utf-8",
                 mode: 0o600,
             });
+            const fd = openSync(temporary, "r");
+            try {
+                fsyncSync(fd);
+            }
+            finally {
+                closeSync(fd);
+            }
             renameSync(temporary, target);
+            syncRoomDirectory(this.roomDir(id));
         }
         finally {
             try {
@@ -354,6 +391,7 @@ export class RoomManager {
         if (Buffer.byteLength(serialized, "utf8") > MAX_ROOM_MESSAGE_BYTES) {
             throw new Error("room message exceeds the size limit");
         }
+        const created = !existsSync(target);
         const fd = openSync(target, "a+", 0o600);
         try {
             if (process.platform !== "win32")
@@ -367,6 +405,13 @@ export class RoomManager {
                     prefix = "\n";
             }
             appendFileSync(fd, `${prefix}${serialized}\n`, "utf-8");
+            fsyncSync(fd);
+            if (created)
+                syncRoomDirectory(this.roomDir(id));
+        }
+        catch (error) {
+            this.failedWrites.add(id);
+            throw error;
         }
         finally {
             closeSync(fd);
@@ -408,6 +453,7 @@ export class RoomManager {
             linkedSessionMode: input.linkedSessionMode,
         };
         mkdirSync(this.roomDir(id), { recursive: true, mode: 0o700 });
+        syncRoomDirectory(this.opts.rootDir);
         this.writeRoomMeta(id, meta);
         // Audit anchor: the first line records how the room was opened (cwd +
         // permission mode), so messages.jsonl is self-describing for "what could
@@ -466,14 +512,20 @@ export class RoomManager {
         // host's event loop: a long-lived room progressively slowed down new
         // messages, heartbeats and every other WebSocket client. (Measured: ~32s to
         // write 2,000 short messages.)
+        if (this.failedWrites.has(id))
+            throw new Error("room persistence failed; reopen after inspecting its history");
         const cached = this.lastSeqByRoom.get(id);
         if (cached !== undefined) {
+            if (this.messageStampByRoom.get(id) !== this.messageStamp(id)) {
+                this.failedWrites.add(id);
+                throw new Error("room history changed outside this writer; inspect it before reopening");
+            }
             const next = cached + 1;
             this.lastSeqByRoom.set(id, next);
             return next;
         }
-        const msgs = this.getMessages(id, 0);
-        const next = msgs.length === 0 ? 1 : msgs[msgs.length - 1].seq + 1;
+        const path = this.msgPath(id);
+        const next = existsSync(path) ? scanRoomHistory(path, parseRoomMessage) + 1 : 1;
         this.lastSeqByRoom.set(id, next);
         return next;
     }
@@ -484,6 +536,7 @@ export class RoomManager {
         const msg = { seq, ts, ...partial };
         try {
             this.appendRoomMessage(id, msg);
+            this.messageStampByRoom.set(id, this.messageStamp(id));
         }
         catch (error) {
             // Sequence assignment is a commit effect, not an attempt counter. A
@@ -601,8 +654,29 @@ export class RoomManager {
                 closeSync(fd);
         }
     }
+    getHistoryPage(id, request = {}) {
+        if (!this.getRoom(id))
+            throw new Error("room is missing or its metadata is corrupt");
+        return readRoomHistoryPage(this.roomDir(id), id, request, parseRoomMessage);
+    }
     latestSeq(id) {
-        return this.getMessages(id).at(-1)?.seq ?? 0;
+        if (this.failedWrites.has(id))
+            throw new Error("room persistence failed");
+        const cached = this.lastSeqByRoom.get(id);
+        if (cached !== undefined)
+            return cached;
+        const path = this.msgPath(id);
+        return existsSync(path) ? scanRoomHistory(path, parseRoomMessage) : 0;
+    }
+    hasTranscriptHistory(id) {
+        let found = false;
+        const file = this.msgPath(id);
+        if (existsSync(file))
+            scanRoomHistory(file, parseRoomMessage, (message) => {
+                if (message.transcriptSource)
+                    found = true;
+            });
+        return found;
     }
     beginTranscriptFollow(id) {
         if (this.getRoom(id))
@@ -614,9 +688,30 @@ export class RoomManager {
     /** Persist normalized transcript-tail messages through the same seq/history/
      * broadcast path as resident-agent output. */
     ingestTranscriptMessages(id, messages) {
-        if (!this.transcriptFollowedRooms.has(id) || !this.getRoom(id))
+        if (!messages.length)
             return;
+        if (!this.transcriptFollowedRooms.has(id) || !this.getRoom(id))
+            throw new Error("transcript room is not active");
+        let sources = this.transcriptSources.get(id);
+        if (!sources) {
+            sources = new Set();
+            const path = this.msgPath(id);
+            if (existsSync(path))
+                scanRoomHistory(path, parseRoomMessage, (message) => {
+                    if (message.transcriptSource)
+                        sources.add(message.transcriptSource);
+                });
+            this.transcriptSources.set(id, sources);
+        }
         for (const message of messages) {
+            const source = message.transcriptSource;
+            if (source !== undefined &&
+                (typeof source !== "string" ||
+                    source.length > 200 ||
+                    !/^[0-9a-f-]{36}:[0-9]+:[0-9]+$/.test(source)))
+                throw new Error("invalid transcript source coordinate");
+            if (source && sources.has(source))
+                continue;
             if (message.from === "user" && typeof message.text === "string") {
                 const text = stripRoomAttachmentBlock(message.text);
                 const pending = this.pendingTranscriptUserEchoes.get(id);
@@ -628,15 +723,16 @@ export class RoomManager {
                     pending.shift();
                 if (pending?.length === 0)
                     this.pendingTranscriptUserEchoes.delete(id);
-                // `send` already persisted and broadcast this exact user turn. The
-                // transcript remains authoritative for agent/tool output, but must not
-                // render a second copy of the prompt.
                 if (!matched)
                     this.append(id, { ...message, text });
+                else if (source)
+                    this.append(id, { from: "system", type: "transcript_echo", transcriptSource: source });
             }
             else {
                 this.append(id, message);
             }
+            if (source)
+                sources.add(source);
         }
     }
     /**

package/dist/panels/runtime-services.js

@@ -2,7 +2,7 @@ import { createHash, randomUUID } from "node:crypto";
 import { constants } from "node:fs";
 import { chmod, link, lstat, mkdir, open, opendir, realpath, rename, rm, writeFile, } from "node:fs/promises";
 import { basename, dirname, extname, isAbsolute, join, resolve, sep } from "node:path";
-import { acquireLockOnPath } from "@cjhyy/code-shell-core/internal";
+import { acquireLockOnPath, acquireWorkspaceWriteLock } from "@cjhyy/code-shell-core/internal";
 import { DEFAULT_PANEL_APP_STORAGE_QUOTA_BYTES, panelAppStorageSnapshot, panelAppStorageChange, applyPanelAppStorageChange, panelAppStorageKey, panelAppStoragePath, preparePanelAppStorage, readPanelAppStorage, writePanelAppStorage, } from "./storage-store.js";
 const MAX_READ_BYTES = 480 * 1024;
 const MAX_WRITE_BYTES = 384 * 1024;
@@ -390,7 +390,15 @@ export class PanelRuntimeServices {
             const parent = await this.openPath(root, dirname(path), true);
             const stableTarget = join(parent.path, basename(path));
             const temporary = join(parent.path, `.${basename(path)}.${randomUUID()}.tmp`);
+            let releaseWorkspaceLock;
+            let outcome;
             try {
+                await parent.verify();
+                releaseWorkspaceLock = await acquireWorkspaceWriteLock(parent.path, basename(path));
+                await parent.verify();
+                await this.root(scope);
+                await authorized(scope);
+                await parent.verify();
                 let modifiedAt = null, currentRevision = null, mode = 0o644;
                 let existing;
                 try {
@@ -459,17 +467,34 @@ export class PanelRuntimeServices {
                     await rename(temporary, stableTarget);
                 await chmod(stableTarget, mode).catch(() => { });
                 const metadata = await lstat(stableTarget);
-                return {
-                    path,
-                    size: bytes.length,
-                    modifiedAt: metadata.mtimeMs,
-                    revision: revision(bytes),
+                outcome = {
+                    ok: true,
+                    value: {
+                        path,
+                        size: bytes.length,
+                        modifiedAt: metadata.mtimeMs,
+                        revision: revision(bytes),
+                    },
                 };
             }
+            catch (error) {
+                outcome = { ok: false, error };
+            }
+            await rm(temporary, { force: true }).catch(() => { });
+            try {
+                await releaseWorkspaceLock?.();
+            }
+            catch (error) {
+                if (!outcome.ok)
+                    throw new AggregateError([outcome.error, error], `${String(outcome.error)}; ${String(error)}`, { cause: error });
+                throw error;
+            }
             finally {
-                await rm(temporary, { force: true }).catch(() => { });
                 await parent.close();
             }
+            if (!outcome.ok)
+                throw outcome.error;
+            return outcome.value;
         });
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cjhyy/code-shell-server",
-  "version": "0.9.34",
+  "version": "0.9.36",
   "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.34",
-    "@cjhyy/code-shell-core": "0.9.34",
-    "@cjhyy/code-shell-web": "0.9.34",
+    "@cjhyy/code-shell-capability-coding": "0.9.36",
+    "@cjhyy/code-shell-core": "0.9.36",
+    "@cjhyy/code-shell-web": "0.9.36",
     "@modelcontextprotocol/sdk": "^1.31.0",
     "@types/ws": "^8.18.1",
     "ws": "^8.21.0",
-    "@cjhyy/code-shell-link": "0.9.34"
+    "@cjhyy/code-shell-link": "0.9.36"
   },
   "engines": {
     "node": ">=20.10"