@cjhyy/code-shell-server 0.9.43 → 0.9.46

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

@@ -2,6 +2,7 @@ import { chmodSync, closeSync, existsSync, fchmodSync, fstatSync, fsyncSync, lst
 import { readRoomHistoryPage, scanRoomHistory, } from "./room-history.js";
 import { randomUUID } from "node:crypto";
 import { isAbsolute, join, relative, resolve, sep } from "node:path";
+import { createRoomModelTrace } from "./room-model-tracing.js";
 /**
  * The exact shape createRoom() generates: `room_<base36>_<base36>`. Anything
  * else — path separators, `..`, NUL, empty — is rejected before it can reach a
@@ -58,6 +59,26 @@ function readBoundedUtf8File(path, maxBytes) {
         closeSync(fd);
     }
 }
+/** Room metadata names are capped at this many UTF-16 units by parseRoomMeta. */
+const MAX_ROOM_NAME_LENGTH = 512;
+/**
+ * Default room name: the cwd's last path segment. Windows drive and UNC paths
+ * also split on backslashes. Bounded to the metadata name limit, without
+ * leaving half of a surrogate pair, so the reader accepts what we write.
+ */
+function defaultRoomName(cwd) {
+    const windows = /^(?:[A-Za-z]:[\\/]|\\\\)/.test(cwd);
+    const segment = cwd
+        .split(windows ? /[\\/]/ : "/")
+        .filter(Boolean)
+        .pop() ?? "room";
+    if (segment.length <= MAX_ROOM_NAME_LENGTH)
+        return segment;
+    const end = /[\uD800-\uDBFF]/.test(segment[MAX_ROOM_NAME_LENGTH - 1])
+        ? MAX_ROOM_NAME_LENGTH - 1
+        : MAX_ROOM_NAME_LENGTH;
+    return segment.slice(0, end);
+}
 function parseRoomMeta(value, expectedId) {
     if (!value || typeof value !== "object" || Array.isArray(value))
         return undefined;
@@ -67,7 +88,7 @@ function parseRoomMeta(value, expectedId) {
         (expectedId !== undefined && raw.id !== expectedId) ||
         typeof raw.name !== "string" ||
         !raw.name ||
-        raw.name.length > 512 ||
+        raw.name.length > MAX_ROOM_NAME_LENGTH ||
         raw.name.includes("\0") ||
         typeof raw.cwd !== "string" ||
         !raw.cwd ||
@@ -175,29 +196,41 @@ export function buildAskUserUpdatedInput(input, answersByQuestion) {
     }
     return { ...obj, answers };
 }
-/**
- * Parse an AskUserQuestion input into the first question's prompt/header/options
- * so the UI can render a choice card. The room UI answers one question at a time
- * (the first); returns undefined for a non-AskUser / malformed input (no
- * questions), which the caller treats as "fall back to auto-allow".
- */
-export function askUserPrompt(input) {
-    const obj = (input ?? {});
-    const q0 = (Array.isArray(obj.questions) ? obj.questions[0] : undefined);
-    if (!q0 || typeof q0.question !== "string")
+function parseAskUserQuestion(value) {
+    const q = value;
+    if (!q || typeof q.question !== "string")
         return undefined;
-    const options = Array.isArray(q0.options)
-        ? q0.options
+    const options = Array.isArray(q.options)
+        ? q.options
             .map((o) => o?.label)
             .filter((l) => typeof l === "string")
         : [];
     return {
-        question: q0.question,
-        header: typeof q0.header === "string" ? q0.header : undefined,
+        question: q.question,
+        header: typeof q.header === "string" ? q.header : undefined,
         options,
-        multiSelect: q0.multiSelect === true,
+        multiSelect: q.multiSelect === true,
     };
 }
+/**
+ * Parse an AskUserQuestion input into the first question's prompt/header/options
+ * so the UI can render a choice card. Returns undefined for a non-AskUser /
+ * malformed input (no questions), which the caller treats as "fall back to
+ * auto-allow".
+ */
+export function askUserPrompt(input) {
+    const obj = (input ?? {});
+    return parseAskUserQuestion(Array.isArray(obj.questions) ? obj.questions[0] : undefined);
+}
+/** Every well-formed question of one AskUserQuestion request, in order. One
+ * control request carries them all and is answered exactly once, so the UI
+ * must collect every answer before responding. */
+function askUserQuestions(input) {
+    const obj = (input ?? {});
+    if (!Array.isArray(obj.questions))
+        return [];
+    return obj.questions.flatMap((q) => parseAskUserQuestion(q) ?? []);
+}
 const ROOM_ATTACHMENT_START = "<codeshell-image-attachments>";
 const ROOM_ATTACHMENT_END = "</codeshell-image-attachments>";
 function roomAttachmentSummary(attachments) {
@@ -240,6 +273,10 @@ export function stripRoomAttachmentBlock(text) {
 export class RoomManager {
     opts;
     agents = new Map();
+    /** Permission mode each live agent was spawned with. The mode is a spawn-time
+     * CLI argument, so room metadata alone cannot prove what a process runs. */
+    agentModes = new WeakMap();
+    modelTraces = new Map();
     /** Rooms whose visible output is currently sourced from the external CLI's
      * transcript tail. While present, the resident agent's stdout mirror is
      * suppressed so the same CLI output is not pushed twice. */
@@ -443,7 +480,7 @@ export class RoomManager {
         const id = `room_${this.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
         const meta = {
             id,
-            name: input.name ?? input.cwd.split("/").filter(Boolean).pop() ?? "room",
+            name: input.name ?? defaultRoomName(input.cwd),
             cwd: input.cwd,
             kind: input.kind ?? "claude-code",
             permissionMode: input.permissionMode ?? "default",
@@ -762,6 +799,9 @@ export class RoomManager {
             this.writeRoomMeta(meta.id, { ...meta, permissionMode: mode });
             this.close(meta.id); // stop the old-mode process so open() respawns fresh
         }
+        // Metadata alone cannot prove the live process mode (a concurrent takeover
+        // may have rewritten it), so also compare the agent's spawn-time mode.
+        this.retireAgentUnlessMode(meta.id, mode);
         const { status } = this.open(meta.id);
         return { roomId: meta.id, status };
     }
@@ -828,6 +868,9 @@ export class RoomManager {
             linkedSessionMode: undefined,
         };
         this.writeRoomMeta(roomId, controllableMeta);
+        // Another view may have taken over and reopened this session under a
+        // different mode. Never report default while feeding that process.
+        this.retireAgentUnlessMode(roomId, controllableMeta.permissionMode);
         const { status } = this.open(roomId);
         if (status !== "running") {
             throw new Error("linked session room is unavailable");
@@ -894,8 +937,10 @@ export class RoomManager {
                 agent.respondControl(requestId, decision);
                 return true;
             }
+            // `answers` (keyed by question text) answers every question of a
+            // multi-question request; the legacy single `answer` maps to the first.
             const prompt = askUserPrompt(pending);
-            const answersByQuestion = prompt ? { [prompt.question]: decision.answer ?? "" } : {};
+            const answersByQuestion = decision.answers ?? (prompt ? { [prompt.question]: decision.answer ?? "" } : {});
             agent.respondControl(requestId, {
                 behavior: "allow",
                 updatedInput: buildAskUserUpdatedInput(pending, answersByQuestion),
@@ -931,6 +976,7 @@ export class RoomManager {
                     this.onAgentEvent(id, event);
             });
             this.agents.set(id, agent);
+            this.agentModes.set(agent, meta.permissionMode);
             try {
                 agent.start();
             }
@@ -953,6 +999,12 @@ export class RoomManager {
         }
         return { status: "running" };
     }
+    /** Stop a live agent whose spawn-time permission mode differs from `mode`. */
+    retireAgentUnlessMode(id, mode) {
+        const agent = this.agents.get(id);
+        if (agent && this.agentModes.get(agent) !== mode)
+            this.close(id);
+    }
     onAgentEvent(id, event) {
         // Buffered while send() is deciding acceptance — replayed right after the
         // user turn is appended, so a synchronous agent reply cannot precede it.
@@ -962,6 +1014,10 @@ export class RoomManager {
             this.deferredEmits.set(id, queued);
             return;
         }
+        const trace = this.modelTraces.get(id);
+        trace?.observe(event);
+        if (trace?.ended)
+            this.modelTraces.delete(id);
         if (this.transcriptFollowedRooms.has(id) &&
             (event.type === "text" ||
                 event.type === "tool" ||
@@ -1015,8 +1071,10 @@ export class RoomManager {
                 // `answers` record the CLI requires. Auto-allowing the unanswered input
                 // is what made claude report "The user did not answer the questions".
                 if (event.toolName === "AskUserQuestion") {
-                    const askUser = askUserPrompt(event.input);
-                    if (askUser) {
+                    const prompt = askUserPrompt(event.input);
+                    if (prompt) {
+                        const questions = askUserQuestions(event.input);
+                        const askUser = questions.length > 1 ? { ...prompt, questions } : prompt;
                         this.pendingAskUser.set(`${id}:${event.requestId}`, event.input);
                         this.append(id, {
                             from: "agent",
@@ -1109,6 +1167,25 @@ export class RoomManager {
             // Rejected: nothing about this turn reaches history or the phone.
             return false;
         }
+        if (this.opts.modelTracing) {
+            try {
+                let trace = this.modelTraces.get(id);
+                if (!trace || trace.ended) {
+                    trace = createRoomModelTrace({
+                        storageDir: this.opts.modelTracing.storageDir,
+                        workspacePath: meta.cwd,
+                        roomId: id,
+                        kind: meta.kind ?? "claude",
+                        parameters: this.opts.modelTracing.parameters?.(meta),
+                    });
+                    this.modelTraces.set(id, trace);
+                }
+                trace.submit(agentText);
+            }
+            catch {
+                // Observability cannot change an already accepted external submission.
+            }
+        }
         this.append(id, {
             from: "user",
             type: "text",
@@ -1131,6 +1208,8 @@ export class RoomManager {
         // throttled write.
         this.flushLastActive(id);
         const agent = this.agents.get(id);
+        this.modelTraces.get(id)?.finish("cancelled");
+        this.modelTraces.delete(id);
         try {
             agent?.stop();
         }
@@ -1147,6 +1226,9 @@ export class RoomManager {
     closeAll() {
         const ids = new Set([...this.agents.keys(), ...this.transcriptFollowedRooms]);
         let firstError;
+        for (const trace of this.modelTraces.values())
+            trace.finish("cancelled");
+        this.modelTraces.clear();
         for (const agent of this.agents.values()) {
             try {
                 agent.stop();

package/dist/mobile-remote/room-model-tracing.d.ts

@@ -0,0 +1,18 @@
+import { type ModelTraceStatus } from "@cjhyy/code-shell-core/internal";
+import type { ResidentAgentEvent } from "./resident-agent.js";
+/**
+ * Resident Claude accepts overlapping inputs without request IDs in its output.
+ * A batch preserves observed order without inventing a prompt-to-response map.
+ */
+export declare function createRoomModelTrace(options: {
+    storageDir: string;
+    workspacePath: string;
+    roomId: string;
+    kind: string;
+    parameters?: Record<string, unknown>;
+}): {
+    readonly ended: boolean;
+    submit(input: string): void;
+    observe(event: ResidentAgentEvent): void;
+    finish: (status: ModelTraceStatus) => void;
+};

package/dist/mobile-remote/room-model-tracing.js

@@ -0,0 +1,196 @@
+import { randomUUID } from "node:crypto";
+import { recordExternalModelTrace, recordModelTraceEvent, withModelTraceContext, ModelTraceStore, } from "@cjhyy/code-shell-core/internal";
+const MAX_TEXT = 128 * 1024;
+const MAX_INPUTS = 128;
+/**
+ * Resident Claude accepts overlapping inputs without request IDs in its output.
+ * A batch preserves observed order without inventing a prompt-to-response map.
+ */
+export function createRoomModelTrace(options) {
+    const context = {
+        storageDir: options.storageDir,
+        workspacePath: options.workspacePath,
+        sessionId: undefined,
+        runId: undefined,
+        parentSessionId: undefined,
+        ephemeral: false,
+        source: `external-room-${options.kind}`,
+        purpose: "external_room_batch",
+    };
+    const startedAt = Date.now();
+    const traceId = randomUUID();
+    const store = new ModelTraceStore({ storageDir: options.storageDir });
+    const policyRevision = store.getConfig().policyRevision;
+    const contentEnabled = () => {
+        try {
+            const config = store.getConfig();
+            return (capture &&
+                config.enabled &&
+                config.captureContent &&
+                config.policyRevision === policyRevision);
+        }
+        catch {
+            return false;
+        }
+    };
+    const common = { ...context, traceId, provider: options.kind, model: "CLI default", startedAt };
+    let recordId;
+    let capture = false;
+    let pending = 0;
+    let batchFailed = false;
+    let batchCancelled = false;
+    let submissionCount = 0;
+    let ended = false;
+    let text = "";
+    let error;
+    const messages = [];
+    const tools = new Map();
+    const write = (status, endedAt) => {
+        const result = recordExternalModelTrace({
+            ...common,
+            id: recordId,
+            status,
+            endedAt,
+            input: !recordId || capture
+                ? {
+                    messages,
+                    parameters: {
+                        ...options.parameters,
+                        roomId: options.roomId,
+                        submissionCount,
+                        omittedInputCount: Math.max(0, submissionCount - messages.length),
+                        outputAttribution: "accepted-room-batch-visible-output",
+                        limitation: "Overlapping submissions have no per-request CLI output identity; internal model requests are opaque.",
+                    },
+                }
+                : undefined,
+            output: capture && endedAt !== undefined ? { text, stopReason: status } : undefined,
+            error,
+        });
+        if (result && !recordId) {
+            recordId = result.id;
+            capture = result.inputState !== "not-recorded";
+            if (!capture)
+                messages.length = 0;
+        }
+        if (!result && !recordId)
+            messages.length = 0;
+    };
+    const span = (input) => withModelTraceContext(context, () => recordModelTraceEvent({
+        ...input,
+        traceId,
+        ...(!contentEnabled()
+            ? {
+                inputState: "not-recorded",
+                outputState: "not-recorded",
+                error: input.error ? "External room operation failed" : undefined,
+            }
+            : {}),
+    }));
+    const finish = (status) => {
+        if (ended)
+            return;
+        ended = true;
+        const endedAt = Date.now();
+        for (const tool of tools.values())
+            span({ ...tool, endedAt, status: status === "failed" ? "failed" : "cancelled" });
+        tools.clear();
+        if (recordId)
+            write(status, endedAt);
+        messages.length = 0;
+        text = "";
+    };
+    return {
+        get ended() {
+            return ended;
+        },
+        submit(input) {
+            if (ended)
+                return;
+            submissionCount++;
+            pending++;
+            if ((!recordId || contentEnabled()) && messages.length < MAX_INPUTS)
+                messages.push({ role: "user", content: input.slice(0, MAX_TEXT) });
+            write("running");
+        },
+        observe(event) {
+            if (ended || !recordId)
+                return;
+            switch (event.type) {
+                case "text":
+                    if (contentEnabled())
+                        text = (text + event.text).slice(0, MAX_TEXT);
+                    else if (capture && !text.endsWith("[Content capture paused]"))
+                        text = (text + "\n[Content capture paused]").slice(0, MAX_TEXT);
+                    break;
+                case "tool": {
+                    if (tools.size >= MAX_INPUTS)
+                        break;
+                    const tool = span({
+                        kind: "tool",
+                        name: event.tool,
+                        startedAt: Date.now(),
+                        status: event.id ? "running" : "observed",
+                        ...(event.id ? {} : { endedAt: Date.now() }),
+                        input: event.input,
+                    });
+                    if (tool && event.id)
+                        tools.set(event.id, tool);
+                    break;
+                }
+                case "tool_result": {
+                    const tool = event.id ? tools.get(event.id) : undefined;
+                    if (tool) {
+                        span({
+                            ...tool,
+                            endedAt: Date.now(),
+                            status: event.isError ? "failed" : "completed",
+                            output: event.summary,
+                            outputState: undefined,
+                        });
+                        tools.delete(event.id);
+                    }
+                    else
+                        span({
+                            kind: "tool",
+                            name: "External CLI tool result (identity unavailable)",
+                            startedAt: Date.now(),
+                            status: event.isError ? "failed" : "completed",
+                            output: event.summary,
+                        });
+                    break;
+                }
+                case "approval_request":
+                    span({
+                        kind: "approval",
+                        name: event.toolName,
+                        startedAt: Date.now(),
+                        status: "requested",
+                        input: event.input,
+                    });
+                    break;
+                case "error":
+                    error = contentEnabled() ? event.error.slice(0, MAX_TEXT) : "External room CLI failed";
+                    finish("failed");
+                    break;
+                case "turn_end":
+                    span({
+                        kind: "lifecycle",
+                        name: "External room CLI turn boundary",
+                        startedAt: Date.now(),
+                        status: event.reason,
+                    });
+                    batchFailed ||= /error|fail/i.test(event.reason);
+                    batchCancelled ||= /abort|cancel|interrupt/i.test(event.reason);
+                    pending = Math.max(0, pending - 1);
+                    if (pending === 0)
+                        finish(batchFailed ? "failed" : batchCancelled ? "cancelled" : "completed");
+                    break;
+                case "exit":
+                    finish(event.signal ? "cancelled" : "failed");
+                    break;
+            }
+        },
+        finish,
+    };
+}

package/dist/model-trace-history.d.ts

@@ -0,0 +1,29 @@
+import { ModelTraceStore, type ModelTraceConfig, type ModelTraceConfigPatch, type ModelTraceEvent, type ModelTraceListQuery, type ModelTracePage, type ModelTraceSessionPage, type ModelTraceRecord } from "@cjhyy/code-shell-core/internal";
+export type ModelTraceDetail = {
+    record: ModelTraceRecord;
+    events: ModelTraceEvent[];
+};
+export type ModelTraceReader = Pick<ModelTraceStore, "list" | "sessions" | "get" | "events" | "getConfig" | "setConfig">;
+export declare class ModelTraceRequestError extends Error {
+    readonly status: number;
+    constructor(status: number, message: string);
+}
+/** Never forward renderer/browser-owned filesystem paths or unknown scan options. */
+export declare function validateModelTraceQuery(input?: unknown): ModelTraceListQuery;
+export declare function validateModelTraceId(input: unknown): string;
+export declare function validateModelTraceConfigPatch(input: unknown): ModelTraceConfigPatch;
+/** Host fixes storageDir once; no query or request can select a different store. */
+export declare function createModelTraceHistory(options: {
+    storageDir: string;
+    /** Set only by the authenticated Host, never by list/get arguments. */
+    workspacePath?: string;
+    /** Additional scopes fixed and authorized by the Host, never by list/get input. */
+    workspaceScopes?: ModelTraceListQuery["workspaceScopes"];
+    store?: ModelTraceReader;
+}): {
+    list(query?: unknown): ModelTracePage;
+    sessions(query?: unknown): ModelTraceSessionPage;
+    get(id: unknown): ModelTraceDetail | null;
+    getConfig(): ModelTraceConfig;
+    setConfig(patch: unknown): ModelTraceConfig;
+};

package/dist/model-trace-history.js

@@ -0,0 +1,198 @@
+import { ModelTraceStore, isModelTraceCallType, } from "@cjhyy/code-shell-core/internal";
+import { resolve } from "node:path";
+const QUERY_FIELDS = new Set([
+    "limit",
+    "cursor",
+    "search",
+    "traceId",
+    "sessionId",
+    "withoutSession",
+    "model",
+    "provider",
+    "purpose",
+    "callType",
+    "source",
+    "status",
+    "since",
+    "until",
+]);
+const CONFIG_FIELDS = new Set(["enabled", "captureContent", "includeEphemeral", "retentionDays"]);
+export class ModelTraceRequestError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+    }
+}
+function record(value, label) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new ModelTraceRequestError(400, `Invalid model trace ${label}`);
+    return value;
+}
+/** Never forward renderer/browser-owned filesystem paths or unknown scan options. */
+export function validateModelTraceQuery(input) {
+    if (input === undefined)
+        return {};
+    const query = record(input, "query");
+    const result = {};
+    for (const [key, value] of Object.entries(query)) {
+        if (!QUERY_FIELDS.has(key))
+            throw new ModelTraceRequestError(400, `Unknown model trace query field: ${key}`);
+        if (value === undefined)
+            continue;
+        if (key === "callType") {
+            if (!isModelTraceCallType(value))
+                throw new ModelTraceRequestError(400, "Invalid model trace callType");
+        }
+        else if (key === "withoutSession") {
+            if (typeof value !== "boolean")
+                throw new ModelTraceRequestError(400, "Invalid model trace withoutSession");
+        }
+        else if (key === "limit") {
+            if (!Number.isSafeInteger(value) || value < 1 || value > 200)
+                throw new ModelTraceRequestError(400, "Model trace limit must be between 1 and 200");
+        }
+        else if (key === "since" || key === "until") {
+            if (typeof value !== "number" || !Number.isFinite(value) || value < 0)
+                throw new ModelTraceRequestError(400, `Invalid model trace ${key}`);
+        }
+        else {
+            const max = key === "search" || key === "cursor" ? 2048 : 512;
+            if (typeof value !== "string" || value.length > max || value.includes("\0"))
+                throw new ModelTraceRequestError(400, `Invalid model trace ${key}`);
+            if (key === "status" && !["running", "completed", "failed", "cancelled"].includes(value))
+                throw new ModelTraceRequestError(400, "Invalid model trace status");
+        }
+        result[key] = value;
+    }
+    if (typeof result.since === "number" &&
+        typeof result.until === "number" &&
+        result.since > result.until)
+        throw new ModelTraceRequestError(400, "Model trace time range is reversed");
+    return result;
+}
+export function validateModelTraceId(input) {
+    if (typeof input !== "string" || !/^[A-Za-z0-9_-]{1,128}$/.test(input))
+        throw new ModelTraceRequestError(400, "Invalid model trace id");
+    return input;
+}
+export function validateModelTraceConfigPatch(input) {
+    const patch = record(input, "configuration");
+    for (const [key, value] of Object.entries(patch)) {
+        if (!CONFIG_FIELDS.has(key))
+            throw new ModelTraceRequestError(400, `Unknown model trace configuration field: ${key}`);
+        if ((key === "enabled" || key === "captureContent" || key === "includeEphemeral") &&
+            typeof value !== "boolean")
+            throw new ModelTraceRequestError(400, `Invalid model trace ${key}`);
+        if (key === "retentionDays" &&
+            (!Number.isSafeInteger(value) || value < 1 || value > 365))
+            throw new ModelTraceRequestError(400, "Model trace retention must be between 1 and 365 days");
+    }
+    return { ...patch };
+}
+/** Host fixes storageDir once; no query or request can select a different store. */
+export function createModelTraceHistory(options) {
+    const store = options.store ?? new ModelTraceStore({ storageDir: options.storageDir });
+    const workspacePath = options.workspacePath === undefined ? undefined : resolve(options.workspacePath);
+    if (options.workspaceScopes !== undefined &&
+        (!Array.isArray(options.workspaceScopes) ||
+            options.workspaceScopes.length + (workspacePath === undefined ? 0 : 1) > 8 ||
+            options.workspaceScopes.some((scope) => !scope ||
+                typeof scope !== "object" ||
+                Array.isArray(scope) ||
+                Object.keys(scope).some((field) => !["workspacePath", "sourcePrefix"].includes(field)) ||
+                typeof scope.workspacePath !== "string" ||
+                !scope.workspacePath ||
+                scope.workspacePath.length > 4096 ||
+                scope.workspacePath.includes("\0") ||
+                (scope.sourcePrefix !== undefined &&
+                    (typeof scope.sourcePrefix !== "string" ||
+                        !scope.sourcePrefix ||
+                        scope.sourcePrefix.length > 256 ||
+                        scope.sourcePrefix.includes("\0"))))))
+        throw new ModelTraceRequestError(500, "Invalid Host model trace scopes");
+    const scopes = options.workspaceScopes
+        ? [
+            ...(workspacePath === undefined ? [] : [{ workspacePath }]),
+            ...options.workspaceScopes.map((scope) => ({
+                ...scope,
+                workspacePath: resolve(scope.workspacePath),
+            })),
+        ]
+        : undefined;
+    const matchesPath = (entry, path) => entry.workspacePath !== undefined && resolve(entry.workspacePath) === path;
+    const unrestricted = (entry) => scopes
+        ? scopes.some((scope) => scope.sourcePrefix === undefined && matchesPath(entry, scope.workspacePath))
+        : workspacePath === undefined || matchesPath(entry, workspacePath);
+    const visible = (entry) => unrestricted(entry) ||
+        !!scopes?.some((scope) => matchesPath(entry, scope.workspacePath) &&
+            typeof entry.source === "string" &&
+            scope.sourcePrefix !== undefined &&
+            entry.source.startsWith(scope.sourcePrefix));
+    const visibleEvents = (entry) => {
+        const events = store.events(entry.traceId);
+        const accepted = new Set(events.filter(unrestricted).map((event) => event.id));
+        // Events do not carry a source. A prefix-limited related scope may only
+        // expose the exact selected call's descendants, never another root chat's
+        // events merely because they share a trace identifier.
+        const children = new Map();
+        if (entry.workspacePath !== undefined)
+            for (const event of events)
+                if (event.parentId && matchesPath(event, resolve(entry.workspacePath))) {
+                    const siblings = children.get(event.parentId) ?? [];
+                    siblings.push(event);
+                    children.set(event.parentId, siblings);
+                }
+        const queue = [entry.id];
+        const visited = new Set(queue);
+        for (let index = 0; index < queue.length; index++)
+            for (const event of children.get(queue[index]) ?? [])
+                if (!visited.has(event.id)) {
+                    visited.add(event.id);
+                    accepted.add(event.id);
+                    queue.push(event.id);
+                }
+        return events.filter((event) => accepted.has(event.id));
+    };
+    return {
+        list(query) {
+            const validated = validateModelTraceQuery(query);
+            return store.list({
+                ...validated,
+                ...(scopes
+                    ? { workspaceScopes: scopes }
+                    : workspacePath === undefined
+                        ? {}
+                        : { workspacePath }),
+            });
+        },
+        sessions(query) {
+            const validated = validateModelTraceQuery(query);
+            try {
+                return store.sessions({
+                    ...validated,
+                    ...(scopes
+                        ? { workspaceScopes: scopes }
+                        : workspacePath === undefined
+                            ? {}
+                            : { workspacePath }),
+                });
+            }
+            catch (error) {
+                if (error instanceof Error && error.message === "Invalid model trace session cursor")
+                    throw new ModelTraceRequestError(400, error.message);
+                throw error;
+            }
+        },
+        get(id) {
+            const entry = store.get(validateModelTraceId(id));
+            return entry && visible(entry) ? { record: entry, events: visibleEvents(entry) } : null;
+        },
+        getConfig() {
+            return store.getConfig();
+        },
+        setConfig(patch) {
+            return store.setConfig(validateModelTraceConfigPatch(patch));
+        },
+    };
+}