ccdesk 0.2.1 → 0.2.3

package/dist/{server → core}/scan/settings.js

@@ -2,8 +2,11 @@ import { lstat } from "node:fs/promises";
 import { join } from "node:path";
 import { allowedScopes, EVERY_FILE, ignoredReason } from "../../shared/scopes.js";
 import {} from "../../shared/types.js";
+import { redactSecrets } from "../secrets.js";
 import {} from "./env.js";
-import { isRecord, listDir, mainWorktreeRoot, readJsonObject, redactSecrets } from "./files.js";
+import { listDir, readJsonObject } from "./files.js";
+import { isRecord } from "./data.js";
+import { mainWorktreeRoot } from "./git.js";
 import { sandboxFilter } from "./sandbox.js";
 /** Lowest precedence first, so later layers override earlier ones. */
 const PRECEDENCE = ["user", "project", "local", "managed"];
@@ -132,12 +135,15 @@ export async function settingsFiles(env, dir) {
     files.push({ scope: "user", path: userFile });
     return files;
 }
-/** Settings files that apply in `dir`, highest precedence first. */
-export async function readSettingsLayers(env, dir) {
+/**
+ * Settings files that apply in `dir`, highest precedence first. `managed` is what
+ * readManagedSettings read, so a scan reads the managed files once.
+ */
+export async function readSettingsLayers(env, dir, managed) {
     const layers = [];
     for (const file of await settingsFiles(env, dir)) {
         if (file.scope === "managed") {
-            layers.push(await readManagedLayer(env, file.path));
+            layers.push(managedLayer(file.path, managed));
             continue;
         }
         const result = await readJsonObject(env, file.path);
@@ -185,8 +191,8 @@ export async function readManagedSettings(env) {
     }
     return { data, sources, dropIns, errors, blocksStart };
 }
-async function readManagedLayer(env, path) {
-    const { data, sources, dropIns, errors, blocksStart } = await readManagedSettings(env);
+function managedLayer(path, managed) {
+    const { data, sources, dropIns, errors, blocksStart } = managed;
     const layer = { scope: "managed", path, exists: false, data: null };
     if (data)
         layer.data = redactSecrets(data);
@@ -211,90 +217,80 @@ export function effectiveSettings(layers) {
     }
     const keys = new Set([...byScope.values()].flatMap((data) => Object.keys(data)));
     const filterSandbox = sandboxFilter((key, scope) => allowedScopes(key).includes(scope) ? byScope.get(scope)?.[key] : undefined);
-    const out = [];
-    for (const key of [...keys].sort()) {
-        const allowed = allowedScopes(key);
-        const present = PRECEDENCE.filter((scope) => byScope.get(scope)?.[key] !== undefined);
-        const valueIn = (scope) => byScope.get(scope)?.[key];
-        const ignored = present
-            .filter((scope) => !allowed.includes(scope))
-            .map((scope) => ({ scope, value: valueIn(scope), reason: ignoredReason(key) }));
-        let defined = present.filter((scope) => allowed.includes(scope));
-        // A managed availableModels list is applied as-is; other files' entries are ignored.
-        if (key === "availableModels" && defined.includes("managed")) {
-            for (const scope of defined.filter((s) => s !== "managed"))
-                ignored.push({
-                    scope,
-                    value: valueIn(scope),
-                    reason: "Managed settings set availableModels, so Claude Code uses that list as-is",
-                });
-            defined = ["managed"];
-        }
-        if (defined.length === 0) {
-            out.push({ key, value: undefined, from: [], merged: false, overridden: [], ignored });
-            continue;
-        }
-        const values = defined.map((scope) => {
-            const { value, dropped } = withoutIgnoredFields(key, scope, valueIn(scope), filterSandbox);
-            for (const d of dropped)
-                ignored.push({ scope, ...d });
-            return { scope, value };
-        });
-        const top = values[values.length - 1];
-        if (!top)
-            continue;
-        const mergeable = !WHOLE_VALUE_KEYS.has(key) &&
-            values.every((v) => Array.isArray(v.value) || isRecord(v.value));
-        const strict = STRICTEST[key];
-        const decided = strict && strictWinner(strict, values);
-        if (strict && decided) {
-            const { winner } = decided;
-            // Only files that may just tighten it set the key, and none tightens it past the default.
-            if (!winner)
-                for (const v of values)
-                    ignored.push({ ...v, reason: "it is not stricter than Claude Code's default" });
-            out.push({
-                key,
-                value: winner?.value,
-                from: winner ? [winner.scope] : [],
-                merged: false,
-                overridden: winner ? values.filter((v) => v !== winner).reverse() : [],
-                ignored,
-                note: strictNote(strict),
-            });
-        }
-        else if (mergeable && values.length > 1) {
-            out.push({
-                key,
-                value: withStrictFields(key, values.slice(1).reduce((acc, v) => mergeKey(key, acc, v.value), values[0]?.value), values),
-                from: defined,
-                merged: true,
-                overridden: [],
-                ignored,
-            });
-        }
-        else if (isRecord(top.value)) {
-            out.push({
-                key,
-                value: withStrictFields(key, top.value, values),
-                from: [top.scope],
-                merged: false,
-                overridden: values.slice(0, -1).reverse(),
-                ignored,
-            });
-        }
-        else {
-            out.push({
-                key,
-                value: top.value,
-                from: [top.scope],
-                merged: false,
-                overridden: values.slice(0, -1).reverse(),
-                ignored,
-            });
-        }
+    return [...keys]
+        .sort()
+        .map((key) => effectiveSetting(key, (scope) => byScope.get(scope)?.[key], filterSandbox));
+}
+/** One key's value, from its value in each scope, lowest precedence first. */
+function effectiveSetting(key, valueIn, filterSandbox) {
+    const { defined, ignored } = scopesThatCount(key, valueIn);
+    const values = defined.map((scope) => {
+        const { value, dropped } = withoutIgnoredFields(key, scope, valueIn(scope), filterSandbox);
+        for (const d of dropped)
+            ignored.push({ scope, ...d });
+        return { scope, value };
+    });
+    const top = values.at(-1);
+    if (!top)
+        return { key, value: undefined, from: [], merged: false, overridden: [], ignored };
+    const strict = STRICTEST[key];
+    const decided = strict && strictWinner(strict, values);
+    if (strict && decided) {
+        const { winner } = decided;
+        // Only files that may just tighten it set the key, and none tightens it past the default.
+        if (!winner)
+            for (const v of values)
+                ignored.push({ ...v, reason: "it is not stricter than Claude Code's default" });
+        return {
+            key,
+            value: winner?.value,
+            from: winner ? [winner.scope] : [],
+            merged: false,
+            overridden: winner ? values.filter((v) => v !== winner).reverse() : [],
+            ignored,
+            note: strictNote(strict),
+        };
     }
-    return out;
+    const mergeable = !WHOLE_VALUE_KEYS.has(key) && values.every((v) => Array.isArray(v.value) || isRecord(v.value));
+    if (mergeable && values.length > 1)
+        return {
+            key,
+            value: withStrictFields(key, values.slice(1).reduce((acc, v) => mergeKey(key, acc, v.value), values[0]?.value), values),
+            from: defined,
+            merged: true,
+            overridden: [],
+            ignored,
+        };
+    return {
+        key,
+        value: withStrictFields(key, top.value, values),
+        from: [top.scope],
+        merged: false,
+        overridden: values.slice(0, -1).reverse(),
+        ignored,
+    };
+}
+/**
+ * The scopes whose value for `key` counts, lowest precedence first, and the values Claude Code
+ * ignores: ones from files the key is not read from, and, once managed settings set
+ * availableModels, every other file's list, since Claude Code uses the managed one as-is.
+ */
+function scopesThatCount(key, valueIn) {
+    const allowed = allowedScopes(key);
+    const present = PRECEDENCE.filter((scope) => valueIn(scope) !== undefined);
+    const ignored = present
+        .filter((scope) => !allowed.includes(scope))
+        .map((scope) => ({ scope, value: valueIn(scope), reason: ignoredReason(key) }));
+    const defined = present.filter((scope) => allowed.includes(scope));
+    if (key !== "availableModels" || !defined.includes("managed"))
+        return { defined, ignored };
+    for (const scope of defined.filter((s) => s !== "managed"))
+        ignored.push({
+            scope,
+            value: valueIn(scope),
+            reason: "Managed settings set availableModels, so Claude Code uses that list as-is",
+        });
+    return { defined: ["managed"], ignored };
 }
 /** An object setting with each nested strictness exception (such as permissions.x) applied. */
 function withStrictFields(key, value, values) {
@@ -305,9 +301,9 @@ function withStrictFields(key, value, values) {
         const [head, field] = path.split(".");
         if (head !== key || !field)
             continue;
-        const fieldValues = values
-            .filter((v) => isRecord(v.value) && v.value[field] !== undefined)
-            .map((v) => ({ scope: v.scope, value: v.value[field] }));
+        const fieldValues = values.flatMap((v) => isRecord(v.value) && v.value[field] !== undefined
+            ? [{ scope: v.scope, value: v.value[field] }]
+            : []);
         const decided = strictWinner(strict, fieldValues);
         if (decided)
             out = { ...out, [field]: decided.winner?.value };

package/dist/core/scan/tools.d.ts

@@ -0,0 +1,10 @@
+import { type BuiltinTool, type Hook, type Permission, type PermissionList } from "../../shared/types.ts";
+/** `Tool` or `Tool(specifier)`; `Tool(*)` names the whole tool too (docs: permissions#permission-rule-syntax). */
+export declare function parseRule(rule: string): {
+    tool: string;
+    specifier: string | null;
+};
+/** Deny and ask rules may glob the tool name; allow rules name it exactly (docs: permissions#tool-name-wildcards). */
+export declare function namesTool(list: PermissionList, tool: string, name: string): boolean;
+/** Every built-in tool, with the rules and hooks that apply to it here. */
+export declare function builtinTools(permissions: Permission[], hooks: Hook[]): BuiltinTool[];

package/dist/{server → core}/scan/tools.js

@@ -50,31 +50,39 @@ function matcherCovers(matcher, name) {
         return false;
     }
 }
+/**
+ * The rules about one tool: `whole` name the tool itself and decide it, `scoped` apply to some of
+ * its calls only. EndConversation ignores rules (see builtinTools).
+ */
+function rulesFor(name, rules) {
+    const whole = [];
+    const scoped = [];
+    if (name === EXEMPT)
+        return { whole, scoped };
+    for (const r of rules) {
+        const { tool, specifier } = parseRule(r.rule);
+        if (specifier === null) {
+            if (namesTool(r.list, tool, name))
+                whole.push(r);
+            // Monitor's commands follow the Bash rules; its WebSocket watches do not
+            // (docs: tools-reference#monitor-tool).
+            else if (name === "Monitor" && namesTool(r.list, tool, "Bash"))
+                scoped.push(r);
+        }
+        else if (tool === name && UNCHECKED_PATH_RULE_TOOLS.has(tool)) {
+            scoped.push({ ...r, unchecked: true });
+        }
+        else if (tool === name || coveredTools(tool, r.list).includes(name))
+            scoped.push(r);
+    }
+    return { whole, scoped };
+}
 /** Every built-in tool, with the rules and hooks that apply to it here. */
 export function builtinTools(permissions, hooks) {
     const rules = permissions.flatMap((p) => p.kind === "rule" && p.inEffect ? [{ list: p.list, rule: p.rule, scope: p.scope }] : []);
     const preToolUse = hooks.filter((h) => h.active && h.event === "PreToolUse");
     const tools = table.tools.map(({ name, description, asks }) => {
-        const whole = [];
-        const scoped = [];
-        for (const r of rules) {
-            if (name === EXEMPT)
-                break;
-            const { tool, specifier } = parseRule(r.rule);
-            if (specifier === null) {
-                if (namesTool(r.list, tool, name))
-                    whole.push(r);
-                // Monitor's commands follow the Bash rules; its WebSocket watches do not
-                // (docs: tools-reference#monitor-tool).
-                else if (name === "Monitor" && namesTool(r.list, tool, "Bash"))
-                    scoped.push(r);
-            }
-            else if (tool === name && UNCHECKED_PATH_RULE_TOOLS.has(tool)) {
-                scoped.push({ ...r, unchecked: true });
-            }
-            else if (tool === name || coveredTools(tool, r.list).includes(name))
-                scoped.push(r);
-        }
+        const { whole, scoped } = rulesFor(name, rules);
         const decidedBy = CHECK_ORDER.map((list) => whole.find((r) => r.list === list)).find(Boolean);
         const tool = {
             name,

package/dist/core/scan/usage.d.ts

@@ -0,0 +1,25 @@
+import { type PermissionList, type Usage } from "../../shared/types.ts";
+import { type ScanEnv } from "./env.ts";
+/** A rule in effect here, as the scan found it. */
+export interface RuleInEffect {
+    list: PermissionList;
+    rule: string;
+}
+/** A count that stopped before it finished, because it took too long or nobody wanted it. */
+export declare class CountStopped extends Error {
+}
+/**
+ * A counter with its own cache of transcripts and its own queue: counts made through it run one at
+ * a time and reuse what earlier ones read. Each core has one.
+ */
+export declare function usageCounter(): (env: ScanEnv, dir: string, rules: RuleInEffect[], { signal, timeLimitMs, maxCachedCalls, }?: {
+    signal?: AbortSignal;
+    timeLimitMs?: number;
+    maxCachedCalls?: number;
+}) => Promise<Usage>;
+/** Counts with a cache and queue shared by every caller in the process; use a core's instead. */
+export declare const readUsage: (env: ScanEnv, dir: string, rules: RuleInEffect[], { signal, timeLimitMs, maxCachedCalls, }?: {
+    signal?: AbortSignal;
+    timeLimitMs?: number;
+    maxCachedCalls?: number;
+}) => Promise<Usage>;

package/dist/{server → core}/scan/usage.js

@@ -1,71 +1,82 @@
-import { open, realpath, stat } from "node:fs/promises";
+import { realpath, stat } from "node:fs/promises";
 import { join, resolve, sep } from "node:path";
 import { storeDirName } from "../../shared/memory.js";
 import {} from "../../shared/types.js";
 import {} from "./env.js";
-import { isCredentials, isDir, isRecord, isWithin, listDir, wildcard, worktrees } from "./files.js";
+import { isCredentials, isDir, isWithin, listDir, openUnlessCredentials, wildcard, } from "./files.js";
+import { isRecord } from "./data.js";
+import { worktrees } from "./git.js";
 import { namesTool, parseRule } from "./tools.js";
-/**
- * Transcripts already counted, by path, so reopening a directory reads only what was added. Kept
- * in memory only, least recently counted first; once they hold more than MAX_CACHED_CALLS calls,
- * the oldest are dropped and read again when needed.
- */
-const transcripts = new Map();
 /** Roughly how many calls the cache keeps, beyond those of the directory counted last. */
-export const MAX_CACHED_CALLS = 100_000;
+const MAX_CACHED_CALLS = 100_000;
 /** A transcript is read in parts this size, so one huge file never becomes one huge string. */
 const CHUNK = 8 * 1024 * 1024;
-let queue = Promise.resolve();
-/** Requests waiting their turn, so a burst of the same request runs once. */
-const waiting = new Map();
 /** How long one count may take before it stops; what it read by then stays counted. */
 const TIME_LIMIT_MS = 60_000;
 /** A count that stopped before it finished, because it took too long or nobody wanted it. */
 export class CountStopped extends Error {
 }
 /**
- * Counts the tool calls in the sessions started in `dir`, or anywhere in its repository and its
- * worktrees, since rules at a repository's root apply there too (docs: permissions#permission-system).
- * Subagents are included. It also counts the calls you approved or refused by hand, which Claude
- * Code records on each call's result as `permissionDecision` (not documented; older transcripts
- * lack it), and how many calls each rule covers. Requests run one at a time, since they share the
- * cache. A count stops when every `signal` it was asked with aborts, or after `timeLimitMs`: it
- * rejects with CountStopped and the next one starts, even if a read of the stopped count never
- * returns.
+ * A counter with its own cache of transcripts and its own queue: counts made through it run one at
+ * a time and reuse what earlier ones read. Each core has one.
  */
-export function readUsage(env, dir, rules, { signal, timeLimitMs = TIME_LIMIT_MS, maxCachedCalls = MAX_CACHED_CALLS, } = {}) {
-    const key = JSON.stringify([env.claudeDir, resolve(dir), rules, timeLimitMs, maxCachedCalls]);
-    let run = waiting.get(key);
-    if (!run) {
-        const stop = new AbortController();
-        const promise = queue.then(() => {
-            waiting.delete(key);
-            const during = AbortSignal.any([stop.signal, AbortSignal.timeout(timeLimitMs)]);
-            // A stopped count answers right away, even while one of its reads never returns.
-            const stopped = new Promise((_, fail) => {
-                const onStop = () => fail(stoppedBecause(during));
-                if (during.aborted)
-                    onStop();
-                else
-                    during.addEventListener("abort", onStop, { once: true });
+export function usageCounter() {
+    const transcripts = new Map();
+    let queue = Promise.resolve();
+    /** Requests waiting their turn, so a burst of the same request runs once. */
+    const waiting = new Map();
+    /**
+     * Counts the tool calls in the sessions started in `dir`, or anywhere in its repository and its
+     * worktrees, since rules at a repository's root apply there too (docs: permissions#permission-system).
+     * Subagents are included. It also counts the calls you approved or refused by hand, which Claude
+     * Code records on each call's result as `permissionDecision` (not documented; older transcripts
+     * lack it), and how many calls each rule covers. Requests run one at a time, since they share the
+     * cache. A count stops when every `signal` it was asked with aborts, or after `timeLimitMs`: it
+     * rejects with CountStopped and the next one starts, even if a read of the stopped count never
+     * returns.
+     */
+    return function countUsage(env, dir, rules, { signal, timeLimitMs = TIME_LIMIT_MS, maxCachedCalls = MAX_CACHED_CALLS, } = {}) {
+        const key = JSON.stringify([env.claudeDir, resolve(dir), rules, timeLimitMs, maxCachedCalls]);
+        let run = waiting.get(key);
+        // Nobody would wait for a new count, so none starts to hold up the queue.
+        if (!run && signal?.aborted)
+            return Promise.reject(stoppedBecause(signal));
+        if (!run) {
+            const stop = new AbortController();
+            const promise = queue.then(() => {
+                waiting.delete(key);
+                const during = AbortSignal.any([stop.signal, AbortSignal.timeout(timeLimitMs)]);
+                // A stopped count answers right away, even while one of its reads never returns.
+                const stopped = new Promise((_, fail) => {
+                    const onStop = () => fail(stoppedBecause(during));
+                    if (during.aborted)
+                        onStop();
+                    else
+                        during.addEventListener("abort", onStop, { once: true });
+                });
+                return Promise.race([
+                    count(transcripts, env, resolve(dir), rules, during, maxCachedCalls),
+                    stopped,
+                ]);
             });
-            return Promise.race([count(env, resolve(dir), rules, during, maxCachedCalls), stopped]);
-        });
-        run = { promise, stop, waiters: 0 };
-        waiting.set(key, run);
-        // The queue moves on when the count settles or stops: a stopped count changes nothing more.
-        queue = promise.catch(() => undefined);
-    }
-    const current = run;
-    if (signal?.aborted)
+            run = { promise, stop, waiters: 0 };
+            waiting.set(key, run);
+            // The queue moves on when the count settles or stops: a stopped count changes nothing more.
+            queue = promise.catch(() => undefined);
+        }
+        const current = run;
+        if (signal?.aborted)
+            return current.promise;
+        current.waiters++;
+        signal?.addEventListener("abort", () => {
+            if (--current.waiters === 0)
+                current.stop.abort();
+        }, { once: true });
         return current.promise;
-    current.waiters++;
-    signal?.addEventListener("abort", () => {
-        if (--current.waiters === 0)
-            current.stop.abort();
-    }, { once: true });
-    return current.promise;
+    };
 }
+/** Counts with a cache and queue shared by every caller in the process; use a core's instead. */
+export const readUsage = usageCounter();
 function stoppedBecause(signal) {
     return new CountStopped(signal.reason instanceof DOMException && signal.reason.name === "TimeoutError"
         ? "Counting tool calls took too long and stopped; what was read is kept, so the next count continues."
@@ -76,7 +87,7 @@ function checkStopped(signal) {
     if (signal.aborted)
         throw stoppedBecause(signal);
 }
-async function count(env, dir, rules, signal, maxCachedCalls) {
+async function count(transcripts, env, dir, rules, signal, maxCachedCalls) {
     checkStopped(signal);
     const checkouts = await worktrees(dir);
     // $HOME may end in a slash or be a link, while git prints the resolved path.
@@ -90,10 +101,7 @@ async function count(env, dir, rules, signal, maxCachedCalls) {
     const folders = repository ? checkouts : [dir];
     const projects = join(env.claudeDir, "projects");
     const storeNames = await listDir(projects);
-    const taken = new Set();
-    const calls = [];
-    const counted = new Set();
-    let sessions = 0;
+    const tally = { taken: new Set(), calls: [], sessions: 0 };
     for (const folder of folders) {
         const own = storeDirName(folder);
         // Sessions started in a subfolder or a nested worktree have their own store, named with the
@@ -104,27 +112,15 @@ async function count(env, dir, rules, signal, maxCachedCalls) {
         for (const name of stores) {
             const store = join(projects, name);
             const files = await transcriptsIn(store);
-            for (const [file, session] of files) {
-                if (taken.has(file))
-                    continue;
-                // A subagent's session decides; one whose session file is gone goes by its own start.
-                const start = (await transcript(env, session, signal))?.startCwd ??
-                    (await transcript(env, file, signal))?.startCwd;
-                if (start ? !isWithin(folder, start) : name !== own)
-                    continue;
-                taken.add(file);
-                counted.add(file);
-                calls.push(...((await transcript(env, file, signal))?.calls ?? []));
-                if (file === session)
-                    sessions++;
-            }
+            await countStore(transcripts, env, signal, tally, folder, files, name === own);
             checkStopped(signal);
             for (const path of transcripts.keys())
                 if (path.startsWith(store + sep) && !files.has(path))
                     transcripts.delete(path);
         }
     }
-    trimCache(counted, maxCachedCalls);
+    const { calls, sessions } = tally;
+    trimCache(transcripts, tally.taken, maxCachedCalls);
     return {
         sessions,
         repository,
@@ -134,8 +130,27 @@ async function count(env, dir, rules, signal, maxCachedCalls) {
         matches: Object.fromEntries(rules.map((r) => [r.rule, matchCount(r, calls)])),
     };
 }
+/**
+ * Adds the transcripts in one store whose session started in `folder`. A subagent's session
+ * decides; one whose session file is gone goes by its own start, or, without one, by whether the
+ * store is the folder's own.
+ */
+async function countStore(transcripts, env, signal, tally, folder, files, ownStore) {
+    for (const [file, session] of files) {
+        if (tally.taken.has(file))
+            continue;
+        const start = (await transcript(transcripts, env, session, signal))?.startCwd ??
+            (await transcript(transcripts, env, file, signal))?.startCwd;
+        if (start ? !isWithin(folder, start) : !ownStore)
+            continue;
+        tally.taken.add(file);
+        tally.calls.push(...((await transcript(transcripts, env, file, signal))?.calls ?? []));
+        if (file === session)
+            tally.sessions++;
+    }
+}
 /** Drops the least recently counted transcripts over the limit, keeping those just counted. */
-function trimCache(counted, maxCalls) {
+function trimCache(transcripts, counted, maxCalls) {
     let total = 0;
     for (const known of transcripts.values())
         total += known.calls.length;
@@ -163,7 +178,7 @@ async function transcriptsIn(store) {
  * One transcript, read up to its end; one that cannot be read keeps what was read before, and one
  * whose count stops keeps the whole lines read so far.
  */
-async function transcript(env, file, signal) {
+async function transcript(transcripts, env, file, signal) {
     if (await isCredentials(env, file))
         return null;
     const info = await stat(file).catch(() => null);
@@ -179,7 +194,7 @@ async function transcript(env, file, signal) {
     if (known.size === info.size && known.mtimeMs === info.mtimeMs)
         return known;
     try {
-        await readFrom(file, known, info.size, signal);
+        await readFrom(env, file, known, info.size, signal);
         known.size = info.size;
         known.mtimeMs = info.mtimeMs;
     }
@@ -191,8 +206,11 @@ async function transcript(env, file, signal) {
     return known;
 }
 /** Reads whole lines from the offset up to `size`; a line still being written is read next time. */
-async function readFrom(file, known, size, signal) {
-    const handle = await open(file, "r");
+async function readFrom(env, file, known, size, signal) {
+    // Checked again on the open file, so one swapped for the credentials file after transcript()'s check is not read.
+    const handle = await openUnlessCredentials(env, file);
+    if (!handle)
+        return;
     try {
         let carried = Buffer.alloc(0);
         let position = known.offset;
@@ -217,10 +235,10 @@ async function readFrom(file, known, size, signal) {
     }
 }
 /** Takes the tool calls from an assistant line and your answers from a tool result line. */
-function read(line, transcript) {
+function read(line, into) {
     const hasCall = line.includes('"tool_use"');
     const hasDecision = line.includes('"permissionDecision"');
-    const hasStart = !transcript.startCwd && line.includes('"cwd"');
+    const hasStart = !into.startCwd && line.includes('"cwd"');
     if (!hasCall && !hasDecision && !hasStart)
         return;
     let record;
@@ -232,35 +250,42 @@ function read(line, transcript) {
     }
     if (!isRecord(record))
         return;
-    if (!transcript.startCwd && typeof record.cwd === "string")
-        transcript.startCwd = record.cwd;
+    if (!into.startCwd && typeof record.cwd === "string")
+        into.startCwd = record.cwd;
     if (!isRecord(record.message))
         return;
     const content = record.message.content;
     if (!Array.isArray(content))
         return;
+    if (record.type === "assistant")
+        readCalls(record, content, into);
+    else if (record.type === "user")
+        readDecision(record, content, into);
+}
+/** The tool calls in an assistant line. */
+function readCalls(record, content, into) {
     const at = typeof record.timestamp === "string" ? record.timestamp : "";
-    if (record.type === "assistant") {
-        for (const block of content) {
-            if (!isRecord(block) || block.type !== "tool_use")
-                continue;
-            if (typeof block.id !== "string" || typeof block.name !== "string")
-                continue;
-            const call = callOf(block.name, isRecord(block.input) ? block.input : {}, at);
-            transcript.calls.push(call);
-            transcript.byId.set(block.id, call);
-        }
-        return;
+    for (const block of content) {
+        if (!isRecord(block) || block.type !== "tool_use")
+            continue;
+        if (typeof block.id !== "string" || typeof block.name !== "string")
+            continue;
+        const call = callOf(block.name, isRecord(block.input) ? block.input : {}, at);
+        into.calls.push(call);
+        into.byId.set(block.id, call);
     }
+}
+/** Your answer to the calls a tool result line answers, when you gave it by hand. */
+function readDecision(record, content, into) {
     const decision = record.permissionDecision;
-    if (record.type !== "user" || !isRecord(decision))
+    if (!isRecord(decision))
         return;
     if (typeof decision.source !== "string" || !decision.source.startsWith("user"))
         return;
     for (const block of content) {
         if (!isRecord(block) || block.type !== "tool_result")
             continue;
-        const call = typeof block.tool_use_id === "string" && transcript.byId.get(block.tool_use_id);
+        const call = typeof block.tool_use_id === "string" && into.byId.get(block.tool_use_id);
         if (call)
             call.byYou = decision.decision === "accept";
     }

package/dist/core/schema.d.ts

@@ -0,0 +1,8 @@
+import { type Validator } from "typebox/compile";
+/**
+ * What `validator` found wrong with `value`, each led by where: `label` and the path inside it,
+ * such as `sandbox.network`.
+ */
+export declare function schemaErrors(validator: Validator, value: unknown, label: string): string[];
+/** The first thing wrong with a request body, such as "add.list must be string". */
+export declare function firstError(validator: Validator, value: unknown): string;