toolroll 0.9.104 → 0.9.105

package/dist/browser-crew.js

@@ -1,7 +1,5 @@
 import { chatControlHref, chatResultHref } from './chat-controls.js';
 import { startBuilderHref } from './needs-you.js';
-/** The index is navigation only. Controls retain their exact owning task, run,
- * decision and approval ceremony; opening a result keeps its saved execution. */
 export function browserWorkActionHref(item) {
     const action = item.primaryAction;
     if (action === null)
@@ -28,25 +26,20 @@ export function browserWorkActionHref(item) {
     }
     if (runId !== null && (action.code === 'inspect-run' || action.code === 'reconcile-run'))
         return `/r/${runId}`;
-    // The task page only repeats that no builder is connected: lead to the command that connects one.
     if (action.code === 'start-worker')
         return startBuilderHref(taskId);
     const anchor = action.code === 'approve-scope' ? '#approve'
         : action.code === 'inspect-stop' || action.code === 'resume-run' ? '#task-control'
-            // Retry (and Build again) is the task's status card itself, at the top: no anchor to its options.
             : action.code === 'unhold' ? '#task-actions'
                 : action.code === 'write-scope' || action.code === 'select-agent' ? '#scope'
                     : action.code === 'inspect-hold' ? '#holds'
                         : action.code === 'repair-dependency' ? '#run-status' : '';
     return `/t/${encodeURIComponent(item.rootId)}?version=${encodeURIComponent(taskId)}` + anchor;
 }
-/** Render an already-admitted page without repeating its database query. Every task reads its one headline, the
- * same words as the Tasks list, task page and result page. */
 export function browserCrewFromIndex(page, conversationId) {
     const link = (href) => conversationId && href.startsWith('/chat?') ? href + '&conversation=' + encodeURIComponent(conversationId) : href;
     const rows = page.items.map(summary => {
         const status = summary.status;
-        // Keep the server's sentence intact; ignore only empty or repeated badge words.
         const words = (text) => text.trim().replace(/\s+/g, ' ').replace(/[.!?]+$/, '').toLowerCase();
         const detail = ['Waiting', 'Failed', 'Needs you'].includes(status.label)
             && words(status.detail) !== '' && words(status.detail) !== words(status.label) ? status.detail : undefined;
@@ -65,7 +58,6 @@ export function browserCrewFromIndex(page, conversationId) {
         };
         return { item, rank: status.rank };
     });
-    // Stable ordering retains recency within each shared presentation rank.
     rows.sort((a, b) => a.rank - b.rank);
     return { crew: rows.map(row => row.item), crewTruncated: page.nextCursor !== null };
 }

package/dist/browser-shell.js

@@ -1,20 +1,15 @@
-/** The browser bundle is a presentation client. Only these fixed public assets
- * are readable here; authenticated data stays in the existing page handlers. */
 import { readFileSync } from 'node:fs';
 import {} from './browser-workspace.js';
 import { html, jsonScript, replaceMarkup, scriptElement } from './html.js';
 const assets = new Map();
-/** The fixed public assets: the workspace, Live mode's own small bundle, and the notices. */
 const BROWSER_ASSETS = [['workspace.js', 'text/javascript; charset=utf-8'], ['workspace.css', 'text/css; charset=utf-8'], ['terminal.js', 'text/javascript; charset=utf-8'],
     ['terminal.css', 'text/css; charset=utf-8'], ['THIRD_PARTY_NOTICES.txt', 'text/plain; charset=utf-8']];
 function readAsset(name) {
-    // Compiled installation first; the second location supports source-based
-    // development/tests after the browser build. No request supplies a file path.
     for (const location of [new URL(`./browser/${name}`, import.meta.url), new URL(`../dist/browser/${name}`, import.meta.url)]) {
         try {
             return readFileSync(location);
         }
-        catch { /* An unbuilt checkout retains the HTML surface. */ }
+        catch { }
     }
     return null;
 }
@@ -48,18 +43,10 @@ export function serveBrowserAsset(request, response, path) {
     response.end(request.method === 'HEAD' ? undefined : asset?.body ?? 'Browser assets are not built.');
     return true;
 }
-/** Retain the complete native document as the no-JavaScript/unloaded-bundle
- * fallback. React replaces its root only once the local module has loaded.
- * The data script is escaped for HTML parsing, not merely valid JSON. */
 export function browserWorkspaceDocument(document, workspace, nonce, functionalScript, beside = html ``) {
     const initialize = `window.addEventListener('standing-orders:workspace-rendered',function initializeWorkspace(){window.removeEventListener('standing-orders:workspace-rendered',initializeWorkspace);${functionalScript}});`;
-    // A cross-page fade the browser gives up on rejects its promises; settle them from the head, before the
-    // first frame (the app's own listener arrives too late when a page is revealed before the bundle runs).
     const settleFades = `(function(){function s(e){var f=e.viewTransition;if(f)[f.finished,f.ready,f.updateCallbackDone].forEach(function(p){if(p)p.catch(function(){})})}addEventListener('pageswap',s);addEventListener('pagereveal',s)})();`;
-    // Each insertion is markup built here; the page's own markup (and its data) is never re-read as a pattern.
-    let out = replaceMarkup(document, /<\/head>/, () => 
-    // A page showing a password keeps to its one script (the sensitivity contract), so it goes without.
-    html `<link rel="stylesheet" href="/assets/workspace.css">${workspace.sensitive ? "" : scriptElement(settleFades, { nonce })}</head>`);
+    let out = replaceMarkup(document, /<\/head>/, () => html `<link rel="stylesheet" href="/assets/workspace.css">${workspace.sensitive ? "" : scriptElement(settleFades, { nonce })}</head>`);
     out = replaceMarkup(out, /<body>/, () => html `<body><div id="standing-orders-workspace">`);
     return replaceMarkup(out, /<\/body>/, () => html `</div>${beside}${jsonScript(workspace, { id: "standing-orders-workspace-data", nonce })}${scriptElement(initialize, { nonce })}<script type="module" src="/assets/workspace.js" nonce="${nonce}"></script></body>`);
 }

package/dist/browser-workspace.js

@@ -1,26 +1,14 @@
-/** The browser consumes this contract with a type-only import. All HTML is
- * produced by the existing trusted server renderers, never by a model-supplied
- * fragment. These projections do not authenticate, mutate or grant authority. */
 import { DISPLAY_STATES as DISPLAY_ORDER } from './agent-state-words.js';
 import { browserCrewFromIndex } from './browser-crew.js';
 export { browserCrewFromIndex, browserWorkActionHref } from './browser-crew.js';
 import { workIndexPage } from './work-index.js';
-/** The most a summary snapshot may take in UTF-8 bytes, as the summary room sends it (JSON inside JSON, plus the
- * frame's envelope), well inside one live frame (live-bus.ts STREAM_LIMIT_BYTES). */
 export const SUMMARY_BUDGET = 24_000;
-/** The frame around a snapshot: its event line, room, revision and the JSON around `at`. Generous on purpose. */
 const SUMMARY_ENVELOPE_BYTES = 512;
 const utf8 = new TextEncoder();
-/** A snapshot's size on the wire: UTF-8 bytes of the JSON string the frame carries, plus its envelope. */
 export function summaryFrameBytes(value) {
     return utf8.encode(JSON.stringify({ at: JSON.stringify(value) })).length + SUMMARY_ENVELOPE_BYTES;
 }
 const clip = (text, max) => text.length <= max ? text : `${text.slice(0, max - 1)}…`;
-/**
- * A summary snapshot that fits one live frame, with every count kept: long words are clipped, then rail tasks become
- * `more` (from the project listing most), then the quietest projects fold into one `others` entry with their counts
- * summed. Nothing is dropped silently: whatever is not listed is counted.
- */
 export function boundProjectSummary(rows, budget = SUMMARY_BUDGET) {
     const size = summaryFrameBytes;
     let out = rows.map(one => ({ ...one, name: clip(one.name, 80), tasks: one.tasks.map(task => ({ ...task, title: clip(task.title, 120), line: clip(task.line, 120) })) }));
@@ -33,7 +21,6 @@ export function boundProjectSummary(rows, budget = SUMMARY_BUDGET) {
     }
     if (size(out) <= budget)
         return out;
-    // Fold the quietest projects (weakest state last in the list) into one entry until it fits.
     const strength = (one) => DISPLAY_ORDER.indexOf(one.state);
     const order = out.map((one, index) => ({ one, index })).sort((a, b) => strength(b.one) - strength(a.one) || b.index - a.index);
     const folded = new Set();
@@ -51,7 +38,6 @@ export function boundProjectSummary(rows, budget = SUMMARY_BUDGET) {
             break;
         folded.add(index);
     }
-    // Still too large: the oldest asks go last (their counts stay; only their chimes are lost).
     let assembled = assemble();
     while (size(assembled) > budget) {
         const fullest = assembled.reduce((best, one, index) => one.asks.length > (assembled[best]?.asks.length ?? -1) ? index : best, -1);
@@ -61,18 +47,11 @@ export function boundProjectSummary(rows, budget = SUMMARY_BUDGET) {
     }
     return assembled;
 }
-/** The Tasks badge's words: the count and the projects it covers
- * ("3 need you in shop", "1 needs you across all your projects"). */
 export function needsYouLabelOf(count, projectName, saturated = false) {
     const where = projectName === null ? 'across all your projects' : `in ${projectName}`;
     return `${count}${saturated ? '+' : ''} ${count === 1 && !saturated ? 'needs' : 'need'} you ${where}`;
 }
-/** Safe inside a script[type=application/json] element. JSON escaping alone
- * does not stop the HTML parser from closing that element at </script>. */
 export const BROWSER_CREW_LIMIT = 40;
-/** A bounded recent family list. The caller supplies its already admitted
- * access; an optional project can only narrow it. Admission and family grouping
- * happen before the SQL limit and before reading questions or saved evidence. */
 export function browserCrewOf(store, now, access, options = {}) {
     const project = options.project ?? null;
     if (project !== null && access.repos !== null && !access.repos.includes(project))
@@ -82,8 +61,6 @@ export function browserCrewOf(store, now, access, options = {}) {
     const page = workIndexPage(store, now, access, { limit, project, ...(options.evidenceRoot === undefined ? {} : { root: options.evidenceRoot }) });
     return browserCrewFromIndex(page);
 }
-/** Navigation input must already be admitted by the caller. No extra project
- * discovery belongs in a browser projection. Keep exact paths in every link. */
 export function browserProjectsOf(projects) {
     const seen = new Set();
     return projects.flatMap(project => {
@@ -94,21 +71,20 @@ export function browserProjectsOf(projects) {
                 knowledgeHref: `/settings/knowledge?repo=${encodeURIComponent(project.path)}` }];
     });
 }
-export function browserNavigationOf(path, project = null, needsYou = 0, tasksProject = project, needsYouLabel) {
+export function browserNavigationOf(path, project = null, needsYou = 0, tasksProject = project, needsYouLabel, advanced = true) {
     const pathname = path.split('?')[0].split('#')[0];
     const under = (...roots) => roots.some(root => pathname === root || pathname.startsWith(`${root}/`));
-    // The rail (UI revamp, wave B; Chat under Home, live-pages-and-home.md B1): Home carries the one Needs-you count and
-    // an agent's question lives under it; the lead chat is its own item; a task's pages under Tasks, every computer and
-    // terminal under Agents, every setting under Settings.
     return [
         { label: 'Home', href: '/', active: pathname === '/' || under('/d', '/activity', '/morning'),
             ...(needsYou > 0 ? { count: needsYou, ...(needsYouLabel === undefined ? {} : { countLabel: needsYouLabel }) } : {}) },
         { label: 'Chat', href: '/chat', active: under('/chat') },
         { label: 'Tasks', href: `/tasks${tasksProject === null ? '' : `?project=${encodeURIComponent(tasksProject)}`}`,
             active: under('/tasks', '/t', '/r', '/review') },
-        { label: 'Flows', href: '/flows', active: under('/flows', '/recipes', '/kits', '/routines') },
-        { label: 'Agents', href: '/agents', active: under('/agents', '/peek', '/term', '/fleet', '/system', '/runs') },
+        ...(advanced ? [
+            { label: 'Flows', href: '/flows', active: under('/flows', '/recipes', '/kits', '/routines') },
+            { label: 'Agents', href: '/agents', active: under('/agents', '/peek', '/term', '/fleet', '/system', '/runs') },
+        ] : []),
         { label: 'Projects', href: '/projects', active: under('/projects') },
-        { label: 'Settings', href: '/settings', active: under('/settings', '/spend', '/mode', '/people', '/ledger', '/menu') },
+        { label: 'Settings', href: '/settings', active: under('/settings', '/spend', '/mode', '/people', '/ledger', '/menu', ...(advanced ? [] : ['/flows', '/recipes', '/kits', '/routines', '/agents', '/peek', '/term', '/fleet', '/system', '/runs'])) },
     ];
 }

package/dist/budget-alerts.js

@@ -8,9 +8,7 @@ export function budgetAlertPass(store, now) {
         const mark = MARKS.find(one => budget.percent >= one);
         if (mark === undefined)
             continue;
-        // Keyed by the limit too: a budget raised (or lowered) this month alerts afresh at its new marks.
         const key = (one) => `budget:${budget.id}:${budget.limitMicrousd}:${month}:${one}`;
-        // A higher mark already sent this month covers this one.
         if (MARKS.filter(one => one >= mark).some(one => store.handle.prepare("SELECT 1 AS hit FROM notification WHERE dedupe_key = ?").get(key(one)) !== undefined))
             continue;
         const label = budgetLabel(budget, budget.scope === "subagent" ? names.get(Number(budget.key)) : undefined);
@@ -30,14 +28,13 @@ export function budgetAlertPass(store, now) {
     }
     return { sent };
 }
-/** The loop beside the console: a pass a minute. */
 export function startBudgetAlerts(store, everyMs = 60_000) {
     let stopped = false;
     const tick = () => { if (stopped)
         return; try {
         budgetAlertPass(store, new Date());
     }
-    catch { /* the next pass tries again */ } };
+    catch { } };
     const timer = setInterval(tick, everyMs);
     timer.unref?.();
     const first = setTimeout(tick, 5_000);

package/dist/build-review.js

@@ -1,20 +1,3 @@
-/**
- * One automatic review for a finished build. When a build's approved check
- * passes (or it finishes with checks Off) in a project whose review switch is on, the project's review phase
- * agent reads the scope, acceptance criteria and diff in a fresh read-only
- * session and returns findings graded HIGH, MEDIUM or LOW.
- *
- * - Any HIGH sends the task back ONCE, through the ordinary revision path,
- *   with the HIGH findings as its note. A HIGH on that revision goes to the
- *   person with the findings.
- * - MEDIUM and LOW never block; they ride the result as suggested follow-ups.
- * - A review that errors or times out never blocks: the result reaches the
- *   person marked "not reviewed".
- *
- * Admission reuses the existing review request queue and admitReview, whose
- * automatic one-shot rule is what keeps it to exactly one reviewer run per
- * build. Nothing here retries.
- */
 import { TASK_TEXT_LIMITS } from "./task-text.js";
 import { createHash } from "node:crypto";
 import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
@@ -40,7 +23,6 @@ const DEFAULT_IDLE_TIMEOUT_MS = 10 * 60_000;
 const DEFAULT_TIMEOUT_MS = 30 * 60_000;
 const INLINE_DIFF_BYTES = 256 * 1024;
 const NOTE_LIMIT = 500;
-/** The build's approved check passed, or the build used checks Off (check-levels.ts) and finished. */
 function checkPassed(store, root, runId) {
     if (runCheckLevel(store, runId) === "off")
         return true;
@@ -55,19 +37,11 @@ function checkPassed(store, root, runId) {
         return false;
     }
 }
-/**
- * Called when a build is accepted as done, inside its disposition. Queues the
- * one review when the switch is on and the approved check passed; a request
- * the queue refuses is recorded as not reviewed so the result still reaches
- * the person. Idempotent per run.
- */
 export function queueBuildReview(store, repo, runId, root, now) {
-    // Never at the build's expense: a queueing problem rolls back only itself,
-    // and the finished result goes to the person unreviewed.
     try {
         store.transact(() => store.savepoint(() => queueLocked(store, repo, runId, root, now)));
     }
-    catch { /* nothing queued */ }
+    catch { }
 }
 function queueLocked(store, repo, runId, root, now) {
     const run = store.getRun(runId);
@@ -82,7 +56,6 @@ function queueLocked(store, repo, runId, root, now) {
     const taskId = store.externalIdFor(run.taskRef);
     if (taskId === null)
         return;
-    // A release candidate check only verifies an existing commit: no diff of its own to review.
     if ((store.getScope(taskId)?.candidate ?? null) !== null)
         return;
     const asked = store.requestReview(runId, AUTOMATIC_REVIEWER, now, undefined, "automatic");
@@ -95,7 +68,6 @@ function settle(store, runId, state, fields, now) {
         .run(state, fields.findings === undefined ? null : JSON.stringify({ version: FINDINGS_VERSION, findings: fields.findings }), fields.reason ?? null, fields.sentBackAs ?? null, now.toISOString(), runId);
     store.bumpWake();
 }
-/** Only the first automatic send-back in a task family: its revision's HIGH goes to the person. */
 function mayResend(store, taskId) {
     const family = store.taskFamilyOf(taskId, null, true);
     if (family === null || family.problem !== null || family.current.id !== taskId)
@@ -103,7 +75,6 @@ function mayResend(store, taskId) {
     const ids = [family.root.id, ...family.versions.map(one => one.id)];
     return store.handle.prepare("SELECT 1 FROM build_review WHERE sent_back_as IN (SELECT value FROM json_each(?)) LIMIT 1").get(JSON.stringify(ids)) === undefined;
 }
-/** The HIGH findings as one revision note, within the revise path's limit. */
 export function revisionNoteOf(high) {
     const note = `Automatic review found ${high.length} high finding${high.length === 1 ? "" : "s"}: ${high.map(one => `${one.file}:${one.line} — ${one.scenario}`).join(" · ")}`;
     if (note.length <= NOTE_LIMIT)
@@ -118,16 +89,12 @@ export function revisionNoteOf(high) {
     return `${cut.trimEnd()}…`;
 }
 function sendBack(store, root, runId, taskId, repo, high, now) {
-    // A hands-off mode's signer auto-approves their own filings; the revision is
-    // filed under that mode exactly as if they had asked for it. Otherwise it
-    // waits for its normal plan and approval.
     const mode = store.activeMode(repo, now);
     const actor = mode?.name === "hands-off" ? mode.signedBy : AUTOMATIC_REVIEWER;
     const revised = requestResultChanges(store, root, {
         run: runId, source: revisionSourceOf(store.getScope(taskId)?.digest ?? null), actor, repos: [repo], batch: "",
         note: revisionNoteOf(high), path: "", line: "",
         request: createHash("sha256").update(`build-review:${runId}`).digest("hex").slice(0, 32), allowMode: true,
-        // The automatic review's send-back, even when the mode's signer is its actor: never a person's act.
         origin: "automatic-review",
     }, now);
     return revised.ok ? { ok: true, id: revised.id } : { ok: false, problem: revised.message };
@@ -177,11 +144,10 @@ async function runReviewer(store, options) {
     const cut = read.content.length > INLINE_DIFF_BYTES;
     const brief = reviewBrief(title, scope, cut ? read.content.subarray(0, INLINE_DIFF_BYTES).toString("utf8") : whole, cut);
     const scratch = mkdtempSync(join(tmpdir(), "toolroll-review-"));
-    // Keep the worker visibly alive while its reviewer runs.
     const pulse = setInterval(() => { try {
         runnerHeartbeat(store, options.runner, options.token, options.clock());
     }
-    catch { /* the next pass settles it */ } }, 60_000);
+    catch { } }, 60_000);
     pulse.unref?.();
     try {
         writeFileSync(join(scratch, REVIEW_PATCH_NAME), read.content, { mode: 0o600 });
@@ -214,18 +180,10 @@ async function runReviewer(store, options) {
         rmSync(scratch, { recursive: true, force: true });
     }
 }
-/**
- * The worker's review pass, after its builds: every open automatic review in
- * this worker's projects gets its one reviewer run. Other open review asks are
- * closed unrun, as before. A review that cannot finish settles as not
- * reviewed; nothing waits on it.
- */
 export async function buildReviewPass(store, options) {
     const { clock } = options;
     const reports = [];
     const mine = (repo) => repo !== null && options.repos.includes(repo);
-    // A pending review whose reviewer ended without settling it (a crash, a
-    // recovered dead worker) is over: not reviewed, never run again.
     store.transact(() => {
         const stale = store.handle.prepare(`SELECT b.run, b.repo FROM build_review b JOIN review_request rr ON rr.id = b.request
       LEFT JOIN run r ON r.id = b.reviewer_run
@@ -250,8 +208,6 @@ export async function buildReviewPass(store, options) {
             });
             reports.push({ run: request.run, outcome: "not-reviewed", detail: words });
         };
-        // The task's sealed review leg when it has one; otherwise the project's
-        // review phase agent (`config show`).
         const sealed = store.sealedRouteOf(request.taskId);
         let spec;
         if (sealed.ok) {
@@ -280,8 +236,6 @@ export async function buildReviewPass(store, options) {
             return outcome;
         });
         if (!admitted.ok) {
-            // Another worker's custody or credential problem is not this review's
-            // failure; everything else settles now rather than holding the result.
             if (admitted.reason === "gone" || admitted.reason === "unauthenticated" || admitted.reason === "watch-custody")
                 return "next";
             notReviewed(`the review could not start (${admitted.detail ?? admitted.rail ?? admitted.reason})`);
@@ -305,7 +259,6 @@ export async function buildReviewPass(store, options) {
         }
         const high = reviewed.findings.filter(one => one.severity === "HIGH");
         const findings = reviewed.findings;
-        // The reviewer's ending, the send-back and the settled row commit together.
         const settled = store.transact(() => {
             store.finishRun(admitted.reviewerRunId, { outcome: "no-change", reason: "reviewed", now: clock() });
             const sent = high.length > 0 && mayResend(store, request.taskId) ? sendBack(store, options.root, request.run, request.taskId, repo, high, clock()) : null;
@@ -328,7 +281,6 @@ export async function buildReviewPass(store, options) {
                 break;
         }
         catch (error) {
-            // Never a broken worker pass, never a held result: settle what is left.
             const words = `the review failed (${error instanceof Error ? error.message.slice(0, 200) : "unknown error"})`;
             store.transact(() => {
                 const row = store.handle.prepare("SELECT reviewer_run FROM build_review WHERE run = ? AND state = 'pending'").get(request.run);

package/dist/builder-restart.js

@@ -1,15 +1,6 @@
-/**
- * Restarting this computer's own builder (docs/plans/plain-toolroll.md P2.3): the record of what a person wants, and the
- * one transaction that admits an automatic restart. The supervisor work is laptop-background.ts restartOwnBuilder.
- *
- * `background on` and `up` record that the builder should run, with the build and database format they ran; `background
- * off` and `stop` record that it should not, before they stop it. Nothing else writes that wish, and only a recorded
- * wish to run is ever acted on.
- */
 import { updateAdmissionPaused } from "./desktop-update-gate.js";
 import { drainOf } from "./runner.js";
 import { readSchemaVersion } from "./store.js";
-/** At most this many automatic restarts in this window (tried, whatever came of them). */
 export const RESTART_LIMIT = 3;
 export const RESTART_WINDOW_MS = 30 * 60_000;
 export function builderWish(store) {
@@ -20,20 +11,16 @@ export function databaseFormat(store) {
     const read = readSchemaVersion(store.handle);
     return read.ok ? read.version : null;
 }
-/** Record what a person asked for. A `stopped` keeps the last known build. */
 export function recordBuilderWish(store, desired, by, build, now) {
     store.handle.prepare(`INSERT INTO builder_service (id, desired, build, schema_version, set_by, set_at) VALUES (1, ?, ?, ?, ?, ?)
     ON CONFLICT (id) DO UPDATE SET desired = excluded.desired, build = excluded.build, schema_version = excluded.schema_version, set_by = excluded.set_by, set_at = excluded.set_at`)
         .run(desired, build, databaseFormat(store) ?? 0, by, now.toISOString());
 }
-/** An update, a deploy's drain or a stop in progress: this is someone else's restart to make. */
 export function restartPaused(store, now) {
     if (updateAdmissionPaused(store.raw()))
         return true;
     return store.listRunners().some(runner => drainOf(store, runner, now) !== null);
 }
-/** The wish, the pause and the count, read again and the attempt written in one transaction: two callers can't both
- * take the last attempt, and a crash after this still counted. */
 export function admitBuilderRestart(store, now) {
     return store.transact(() => {
         if (builderWish(store)?.desired !== "running")