toolroll 0.9.46 → 0.9.48

package/dist/planner.js

@@ -31,6 +31,7 @@ import { TOKEN_ENVS as TELEGRAM_TOKEN_ENVS } from "./telegram.js";
 import { evidenceRoot, mailboxName, planFileName, quarantineMailboxes, readMailbox, storeEvidence, writeEvidenceFile, } from "./evidence.js";
 import { MARKER as LEASE_MARKER } from "./worktree.js";
 import { openLiveLog } from "./live.js";
+import { withRunActivity } from "./task-activity.js";
 import { proveTreeUntouched, snapshotIgnored } from "./tree-proof.js";
 import { CLAUDE_LIMITS, ACCEPTANCE_LIMITS } from "./scope.js";
 import { normalizeStructuredJson, storeStructuredAttempt, validationErrorsJson, STRUCTURED_REPAIR_ATTEMPTS, STRUCTURED_REPAIR_MAX_TURNS, STRUCTURED_REPAIR_TIMEOUT_MS, } from "./structured-output.js";
@@ -590,7 +591,7 @@ export async function plan(store, request) {
     }
     // The live window (peek): the same transcript file the builder keeps,
     // so `toolroll peek` and the run page can watch this session too.
-    const liveLog = openLiveLog(root, request.runId);
+    const liveLog = withRunActivity(openLiveLog(root, request.runId), store, request.runId, clock);
     // The durable run row, not a caller's duplicate options, is the route
     // every correction inherits.
     const provider = logicalRun.provider;
@@ -730,7 +731,7 @@ export async function plan(store, request) {
             ...(agent === undefined ? {} : { runner: agent }),
             ...(request.onProviderSpawn === undefined ? {} : { onSpawn: request.onProviderSpawn }),
             clock,
-            ...(liveLog === null ? {} : { onStreamEvent: (event) => liveLog.observe(event) }),
+            onStreamEvent: (event) => liveLog.observe(event),
         });
         const firstProof = await proveAfterInvocation();
         if (firstProof !== null)
@@ -883,7 +884,7 @@ export async function plan(store, request) {
                     ...(agent === undefined ? {} : { runner: agent }),
                     ...(request.onProviderSpawn === undefined ? {} : { onSpawn: request.onProviderSpawn }),
                     clock,
-                    ...(liveLog === null ? {} : { onStreamEvent: (event) => liveLog.observe(event) }),
+                    onStreamEvent: (event) => liveLog.observe(event),
                 });
             }
             catch (error) {

package/dist/read-executor-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/read-executor-worker.js

@@ -0,0 +1,26 @@
+import { parentPort, workerData } from 'node:worker_threads';
+import { openStoreReadOnly } from './store.js';
+import { workIndexPage } from './work-index.js';
+/** One read-only, query-only connection per worker (read-executor.ts). Jobs arrive one at a time. */
+let store = null;
+function connection() {
+    if (store !== null)
+        return store;
+    const opened = openStoreReadOnly(String(workerData.file));
+    if (opened === null)
+        throw new Error('The read worker could not open the database read-only at the current schema.');
+    opened.handle.exec('PRAGMA query_only=1');
+    return store = opened;
+}
+parentPort.on('message', ({ id, job }) => {
+    let reply;
+    try {
+        if (job.kind !== 'work-index-page')
+            throw new Error('Unknown read.');
+        reply = { id, ok: true, value: workIndexPage(connection(), new Date(job.now), job.access, job.options) };
+    }
+    catch (error) {
+        reply = { id, ok: false, error: { name: error instanceof Error ? error.name : 'Error', message: error instanceof Error ? error.message : String(error) } };
+    }
+    parentPort.postMessage(reply);
+});

package/dist/read-executor.d.ts

@@ -0,0 +1,49 @@
+import type { Store } from './store.js';
+import { type WorkIndexOptions, type WorkIndexPage } from './work-index.js';
+import type { WorkSummaryAccess } from './work-summary.js';
+/**
+ * Heavy, read-only database work for the server, run on worker threads (docs/server-performance.md).
+ * Each worker owns one read-only, query-only connection to the server's own database file, so the
+ * measured hot read (the work index behind `task list`) never holds the HTTP event loop. Callers
+ * authorize first and send only the already-admitted access; a worker never widens it, writes, or
+ * retries. Without a file-backed database (tests, the demo) nothing is attached and callers keep
+ * running the same builder in-process.
+ */
+export type ReadJob = {
+    kind: 'work-index-page';
+    now: string;
+    access: WorkSummaryAccess;
+    options: WorkIndexOptions;
+};
+export type ReadReply = {
+    id: number;
+    ok: true;
+    value: unknown;
+} | {
+    id: number;
+    ok: false;
+    error: {
+        name: string;
+        message: string;
+    };
+};
+/** More queued reads than this fail at once instead of growing without bound. */
+export declare const READ_QUEUE_MAX = 1000;
+export declare class ReadExecutorError extends Error {
+    constructor(message: string);
+}
+export declare class ReadExecutor {
+    #private;
+    constructor(file: string, size?: number);
+    get size(): number;
+    /** workIndexPage(store, now, access, options) on a worker's read-only connection: same rows, same errors. */
+    workIndexPage(now: Date, access: WorkSummaryAccess, options: WorkIndexOptions): Promise<WorkIndexPage>;
+    /** Fails every queued and running read once, then stops the workers. */
+    close(): Promise<void>;
+}
+/** Half the cores, at most eight: the measured 20-engineer load needs over four (docs/server-performance.md),
+ * and the rest stay with the event loop and local agents. Workers start only when reads arrive. */
+export declare function defaultReadWorkers(): number;
+/** The server attaches its executor to its own Store; a command run on that Store reads through it. */
+export declare function attachReadExecutor(store: Store, executor: ReadExecutor): () => void;
+export declare function readExecutorOf(store: Store): ReadExecutor | null;

package/dist/read-executor.js

@@ -0,0 +1,119 @@
+import { Worker } from 'node:worker_threads';
+import { availableParallelism } from 'node:os';
+import { WorkIndexCursorError } from './work-index.js';
+/** More queued reads than this fail at once instead of growing without bound. */
+export const READ_QUEUE_MAX = 1_000;
+export class ReadExecutorError extends Error {
+    constructor(message) { super(message); this.name = 'ReadExecutorError'; }
+}
+export class ReadExecutor {
+    #file;
+    #size;
+    #slots = [];
+    #queue = [];
+    #next = 1;
+    #closed = false;
+    constructor(file, size = defaultReadWorkers()) {
+        this.#file = file;
+        this.#size = Math.max(1, Math.floor(size));
+    }
+    get size() { return this.#size; }
+    /** workIndexPage(store, now, access, options) on a worker's read-only connection: same rows, same errors. */
+    async workIndexPage(now, access, options) {
+        try {
+            return await this.#run({ kind: 'work-index-page', now: now.toISOString(), access, options });
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === 'WorkIndexCursorError')
+                throw new WorkIndexCursorError();
+            throw error;
+        }
+    }
+    #run(job) {
+        if (this.#closed)
+            return Promise.reject(new ReadExecutorError('The server is closing.'));
+        if (this.#queue.length >= READ_QUEUE_MAX)
+            return Promise.reject(new ReadExecutorError('The server is too busy to read this now; try again shortly.'));
+        return new Promise((resolve, reject) => {
+            this.#queue.push({ id: this.#next++, job, resolve, reject });
+            this.#pump();
+        });
+    }
+    #pump() {
+        while (this.#queue.length > 0) {
+            let slot = this.#slots.find(one => one.busy === null);
+            if (slot === undefined && this.#slots.length < this.#size)
+                slot = this.#spawn();
+            if (slot === undefined)
+                return;
+            const pending = this.#queue.shift();
+            slot.busy = pending;
+            slot.worker.postMessage({ id: pending.id, job: pending.job });
+        }
+    }
+    #spawn() {
+        // The installed server runs the built sibling; tests run the TypeScript source through tsx.
+        const worker = import.meta.url.endsWith('.ts')
+            ? new Worker(`import('tsx/esm/api').then(tsx => { tsx.register(); return import(${JSON.stringify(new URL('./read-executor-worker.ts', import.meta.url).href)}); });`, { eval: true, workerData: { file: this.#file } })
+            : new Worker(new URL('./read-executor-worker.js', import.meta.url), { workerData: { file: this.#file } });
+        const slot = { worker, busy: null };
+        this.#slots.push(slot);
+        worker.on('message', (reply) => {
+            const pending = slot.busy;
+            if (pending === null || pending.id !== reply.id)
+                return;
+            slot.busy = null;
+            if (reply.ok)
+                pending.resolve(reply.value);
+            else
+                pending.reject(Object.assign(new Error(reply.error.message), { name: reply.error.name }));
+            this.#pump();
+        });
+        // A crashed worker fails only the read it held; the next read starts a fresh one.
+        const lost = (error) => {
+            const at = this.#slots.indexOf(slot);
+            if (at < 0)
+                return;
+            this.#slots.splice(at, 1);
+            const pending = slot.busy;
+            slot.busy = null;
+            pending?.reject(error);
+            if (!this.#closed)
+                this.#pump();
+        };
+        worker.on('error', error => lost(error instanceof Error ? error : new ReadExecutorError(String(error))));
+        worker.on('exit', code => lost(new ReadExecutorError(`The read worker stopped (exit ${code}).`)));
+        worker.unref();
+        return slot;
+    }
+    /** Fails every queued and running read once, then stops the workers. */
+    async close() {
+        if (this.#closed)
+            return;
+        this.#closed = true;
+        const stopped = new ReadExecutorError('The server is closing.');
+        for (const pending of this.#queue.splice(0))
+            pending.reject(stopped);
+        const slots = this.#slots.splice(0);
+        for (const slot of slots) {
+            slot.busy?.reject(stopped);
+            slot.busy = null;
+        }
+        await Promise.all(slots.map(slot => slot.worker.terminate().catch(() => 0)));
+    }
+}
+/** Half the cores, at most eight: the measured 20-engineer load needs over four (docs/server-performance.md),
+ * and the rest stay with the event loop and local agents. Workers start only when reads arrive. */
+export function defaultReadWorkers() {
+    return Math.max(1, Math.min(8, Math.floor(availableParallelism() / 2)));
+}
+const attached = new WeakMap();
+/** The server attaches its executor to its own Store; a command run on that Store reads through it. */
+export function attachReadExecutor(store, executor) {
+    attached.set(store, executor);
+    return () => { if (attached.get(store) === executor)
+        attached.delete(store); };
+}
+export function readExecutorOf(store) {
+    return attached.get(store) ?? null;
+}

package/dist/request-budget.d.ts

@@ -88,6 +88,7 @@ export declare class RequestBudget {
      * read. Anything unreadable refuses with 503 and nothing runs.
      */
     admit(tokenId: string, route: BudgetRoute): Admission;
+    private check;
     /** Save every changed entry. A server calls this on a timer and when it closes. */
     flush(): void;
     private save;

package/dist/request-budget.js

@@ -123,6 +123,12 @@ export class RequestBudget {
      * read. Anything unreadable refuses with 503 and nothing runs.
      */
     admit(tokenId, route) {
+        const result = this.check(tokenId, route);
+        if (!result.ok)
+            this.store.telemetry.budgetRefused(route, result.status === 429 ? result.limit : 'unavailable');
+        return result;
+    }
+    check(tokenId, route) {
         try {
             const now = this.clock();
             const token = this.store.apiTokenSecret(tokenId)?.row;

package/dist/serve.d.ts

@@ -33,6 +33,8 @@ export type ServeOptions = {
     installBin?: string;
     /** Native coding workspace injection for isolated integration tests. */
     codingWorkspace?: CodingWorkspace;
+    /** Read-only worker connections for heavy reads (read-executor.ts); 0 reads in-process. Default: off under tests. */
+    readWorkers?: number;
     store: Store;
     evidenceRoot: string;
     clock?: () => Date;
@@ -274,6 +276,11 @@ type Chrome = {
     scope?: "all" | "project" | "board-all";
     /** The saturated inbox count — never a sum of unbounded list reads. */
     inboxCount: number;
+    /** The project the Tasks count covers: the request's own project view
+     * (the open project, or /work's ?project=), null for every admitted project. */
+    inboxProject?: string | null;
+    /** The Tasks badge's words, naming what it covers: "3 need you in shop". */
+    inboxLabel?: string;
     inboxSaturated: boolean;
     settings: boolean;
     /** This database is a demo sandbox: banner every page, spend fenced. */