toolroll 0.9.103 → 0.9.105

package/dist/server/agents-computers.js

@@ -1,15 +1,8 @@
-/**
- * The Agents page's installation parts (UI revamp wave B): the computers that build (what /fleet showed), which model
- * runs each phase and the rest of what /system showed. Saved facts only, filtered through the caller's `visible`, for
- * a person with access to the whole installation; nothing here grants an act (register, retire, move and note keep
- * their own handlers and checks).
- */
 import { INSTALLATION_SCOPE, resolvePhaseAgent } from "../agentconfig.js";
 import { agentModelName } from "../model-names.js";
 import { projectName } from "../project.js";
 import { isAlive } from "../runner.js";
 import { taskHref } from "./http.js";
-/** Every registered computer that isn't retired, plus a retired one still holding reserved work, as Agents lists it. */
 export function computersOf(store, now, visible, manage) {
     const queued = store.fleetQueue(now);
     const claims = store.liveClaims(null, now);
@@ -35,7 +28,6 @@ export function computersOf(store, now, visible, manage) {
     return { list, manage, queueRevision: store.queueRevision(), shared: queued.filter(one => one.assignedRunner === null && visible(one.repo)).length };
 }
 const PHASES = ["plan", "build", "repair", "review"];
-/** Which provider and model runs each phase for the open project (or the installation), and where that choice comes from. */
 export function phasesOf(store, project) {
     return PHASES.map(phase => {
         const answer = resolvePhaseAgent(store, phase, project, {});
@@ -48,8 +40,6 @@ export function phasesOf(store, project) {
         return { phase, model: agentModelName(answer.spec.provider, answer.spec.model ?? null), problem: null, source, noDollars: answer.spec.provider !== "claude" };
     });
 }
-/** The rest of what /system showed: its workspaces, the background service on the open project, notifications waiting
- * to go out and external work. */
 export function systemOf(store, project, worktreeShown, visible) {
     const workspaces = store.listWorktrees().filter(worktreeShown).map(tree => {
         const leased = tree.leasedAt !== null && tree.releasedAt === null;

package/dist/server/agents-live-filed.js

@@ -1,6 +1,4 @@
 const BUILT_IN = "built-in";
-/** The family root of a built-in task, or null when its lineage can't be proved: the family's own proof (taskFamilyOf:
- * every revision in the root's project, each bound by its brief to its parent's own run), and the task one of it. */
 function rootOf(store, taskId) {
     const family = store.taskFamilyOf(taskId, null, false);
     return family === null || family.problem !== null || !family.versions.some(version => version.id === taskId) ? null : family.root.id;
@@ -16,11 +14,9 @@ const parse = (text) => {
         return null;
     }
 };
-/** For each run id given (the tiles already in this viewer's answer), the viewer's lead chat that filed its task. */
 export function leadFiledLinks(store, viewer, runIds) {
     const links = new Map();
     const db = store.handle;
-    // The viewer's own personal threads (never a team conversation's), by id.
     const threads = new Map();
     for (const row of db.prepare(`SELECT id, scope_kind FROM lead_thread WHERE approver = ? AND NOT EXISTS (SELECT 1 FROM team_conversation tc WHERE tc.thread = lead_thread.id)`).all(viewer)) {
         const kind = row["scope_kind"];
@@ -28,8 +24,6 @@ export function leadFiledLinks(store, viewer, runIds) {
     }
     if (threads.size === 0)
         return links;
-    // Each run's family root, proved once per task (attempts of one task share it), and only roots the viewer filed
-    // through the lead as a person go further.
     const rootOfTask = new Map();
     const runRoots = new Map();
     const repos = new Map();
@@ -46,7 +40,6 @@ export function leadFiledLinks(store, viewer, runIds) {
             continue;
         if (!repos.has(root)) {
             const ref = refRow.get(BUILT_IN, root);
-            // Filed through the lead, by the viewer, as a person.
             const filed = ref !== undefined && ref["filed_via"] === "mate" && ref["filed_by_kind"] === "person" && ref["filed_by"] === viewer && typeof ref["repo"] === "string";
             repos.set(root, filed ? String(ref["repo"]) : "");
         }
@@ -56,8 +49,6 @@ export function leadFiledLinks(store, viewer, runIds) {
     const roots = [...new Set(runRoots.values())];
     if (roots.length === 0)
         return links;
-    // Every confirmed task card in the viewer's own threads naming one of these roots: ONE read per request, through the
-    // viewer's threads (lead_thread by approver, lead_proposal by thread and state), never once per family.
     const found = new Map(roots.map(root => [root, []]));
     const spoiled = new Set();
     const cards = db.prepare(`SELECT p.thread, p.resolved_by, p.payload_json, p.outcome_json, json_extract(p.outcome_json, '$.taskId') AS task FROM lead_proposal p
@@ -66,14 +57,11 @@ export function leadFiledLinks(store, viewer, runIds) {
     for (const row of cards) {
         const root = String(row["task"]);
         const outcome = parse(row["outcome_json"]), payload = parse(row["payload_json"]);
-        // The door's own outcome (the model writes only the payload), confirmed by the viewer, for this project.
         if (outcome?.["ok"] !== true || outcome["kind"] !== "task" || outcome["taskId"] !== root || row["resolved_by"] !== viewer || payload?.["repo"] !== repos.get(root))
             spoiled.add(root);
         else
             found.get(root)?.push(Number(row["thread"]));
     }
-    // A sweep links while the card that started it is kept, as a task card does: ending a chat (or revocation) erases its
-    // cards, and with them every link it made — one retention rule for both.
     const sweeps = db.prepare(`SELECT k.root_task, s.owner, s.thread, s.repo, p.thread AS card_thread, p.state AS card_state, p.resolved_by AS card_by
     FROM lead_sweep_task k JOIN lead_sweep s ON s.id = k.sweep LEFT JOIN lead_proposal p ON p.id = s.proposal
     WHERE k.root_task IN (${roots.map(() => "?").join(",")})`).all(...roots);
@@ -85,7 +73,6 @@ export function leadFiledLinks(store, viewer, runIds) {
             found.get(root)?.push(Number(row["thread"]));
     }
     for (const [runId, root] of runRoots) {
-        // Exactly one record, nothing amiss beside it, naming one of the viewer's own personal threads.
         const named = found.get(root) ?? [];
         if (spoiled.has(root) || named.length !== 1)
             continue;

package/dist/server/agents-live-lead.js

@@ -1,22 +1,13 @@
 import { capLive, cleanLiveText, HIDDEN_KEY_BLOCK, HIDDEN_LINE, liveLine, redactLiveLines } from "../live-records.js";
 import { projectChatHref, taskChatHref } from "./http.js";
-/** A lead tile keeps at most this many lines, and this many bytes of them (the newest). */
 export const LEAD_LINES = 200, LEAD_BYTES = 32 * 1024;
-/** A tool's line: fixed copy from lead-progress.ts (labels and failure reasons), still cleaned and cut. */
 function toolLine(tool) {
     return liveLine(tool.state === "running" ? `· ${tool.label}…` : tool.state === "failed" ? `· ${tool.reason}` : `· ${tool.label}`);
 }
-/** One step's words, redacted, with only what is settled: the last word of the step's text waits for the space after
- * it unless the provider's finished answer for that step was confirmed (lead.ts sends it once, secret-checked whole).
- * A snapshot that would have completed a credential is never stored (lead.ts drops it), so the one kept can end
- * part-way through one: ending the turn or starting the next step confirms nothing. The last line is redacted on its
- * own (after the rest, with the same key state), the whole line checked for secrets first, and its unfinished word
- * found in the line as shown (invisible characters removed), so no hidden character can stand in for the space. */
 function stepLines(text, keys, confirmed) {
     const raw = text.split(/\r?\n/);
     const lastRaw = raw.pop() ?? "";
     const out = redactLiveLines(raw, keys);
-    // Empty when the last line is inside a key block (never shown).
     for (const shown of redactLiveLines([lastRaw], keys)) {
         const whole = shown === HIDDEN_LINE || shown === HIDDEN_KEY_BLOCK || confirmed || /\s$/.test(cleanLiveText(lastRaw));
         out.push((whole ? shown : shown.replace(/\S+$/, "")).trimEnd());
@@ -25,14 +16,10 @@ function stepLines(text, keys, confirmed) {
         out.pop();
     return out;
 }
-/** One turn's lines, redacted as one stream: every step's tools and words in order through ONE key state (a key block
- * opened in one step stays hidden into the next), each line cleaned and cut, then the newest kept within the caps.
- * `confirmed[i]`: step i's text is its finished answer, secret-checked whole. */
 export function leadLines(steps, confirmed = []) {
     const keys = { inKey: false };
     const all = [];
     steps.forEach((step, index) => {
-        // Tools are not the conversation's text: they never open or close a key block, and inside one they are not shown.
         for (const tool of step.toolCalls)
             if (!keys.inKey)
                 all.push(toolLine(tool));
@@ -51,7 +38,6 @@ export function leadLines(steps, confirmed = []) {
     }
     return { lines: kept, earlier: kept.length < all.length };
 }
-/** What the turn is doing now, in fixed words only. */
 function doingOf(turn) {
     if (turn.done)
         return null;
@@ -61,7 +47,6 @@ function doingOf(turn) {
         return running.label;
     return step !== undefined && step.text.trim() !== "" ? "Writing a reply" : "Thinking";
 }
-/** One thread admitted for this viewer now, as the chat room admits (server/live.ts, room "chat"); null when refused. */
 function admitLead(deps, who, id) {
     const { store, leadPrincipal, familyOf, visible, managedRepos } = deps;
     if (who.via !== "cookie" || who.role !== "approver")
@@ -72,7 +57,6 @@ function admitLead(deps, who, id) {
     const thread = store.getLeadThread(id);
     if (thread === null || thread.approver !== who.name || thread.closedAt !== null)
         return null;
-    // The owner's current thread for its scope (never a team conversation's), under the ceiling it opened with.
     if (store.liveLeadThreadFor(who.name, thread.scope)?.id !== id || thread.ceilingDigest !== principal.ceilingDigest)
         return null;
     if (thread.scope.kind === "project") {
@@ -90,7 +74,6 @@ function admitLead(deps, who, id) {
     }
     return { scope: "lead", title: "Lead chat", project: null, chatHref: "/chat", taskHref: null };
 }
-/** The viewer's own live lead turns, admitted as the chat room admits them, proved now. */
 export function leadTilesFor(deps, who) {
     const tiles = [];
     for (const [id, turn] of deps.liveTurns) {
@@ -109,8 +92,6 @@ export function leadTilesFor(deps, who) {
     }
     return tiles.sort((a, b) => a.thread - b.thread);
 }
-/** The tiles projected earlier that are still this viewer's right now (the whole admission proved again, with the
- * session as it is saved now): what is delivered is never more than what is admitted at the moment of delivery. */
 export function leadsStillAdmitted(deps, who, tiles) {
     return tiles.filter(tile => deps.liveTurns.has(tile.thread) && admitLead(deps, who, tile.thread) !== null);
 }

package/dist/server/agents-live-room.js

@@ -1,11 +1,3 @@
-/**
- * The Live grid's room (docs/plans/agents-view.md §3): one room per viewer and scope, never shared, so one viewer's
- * view is never cached for another. Every LIVE_POLL_MS it re-proves each viewer (before any read and before any send,
- * keep-alives included — createLiveRooms' own boundary), then takes the viewer's fingerprint: the tiles they may see
- * and, for this computer's runs, each live file's identity and size through the checked opener. The page hears only
- * that something it can see moved; the fingerprint is an opaque digest, never sizes or file identities. Expiry needs
- * no database write (the tiles are derived from the clock), and the room goes with its last viewer.
- */
 import { createHash } from "node:crypto";
 import { closeSync } from "node:fs";
 import { agentsLiveOf } from "../agents-live.js";
@@ -13,11 +5,8 @@ import { createLiveRooms } from "../live-bus.js";
 import { openLiveTrusted } from "../live-open.js";
 import { leadFiledLinks } from "./agents-live-filed.js";
 import { requestContext } from "./request-context.js";
-/** How often a viewer's runs and files are looked at again. */
 export const LIVE_POLL_MS = 2_000;
-/** At most this many of a viewer's runs have their files looked at (the grid streams at most this many). */
 export const LIVE_WATCHED_RUNS = 24;
-/** One file as the room sees it: its identity and size, or that it is missing or unavailable. Never its contents. */
 function fileMark(root, name) {
     const opened = openLiveTrusted(root, name);
     if (typeof opened === "string")
@@ -32,17 +21,12 @@ function fileMark(root, name) {
 export function createAgentsLiveRooms(input) {
     const { store, evidenceRoot, localRunner, clock, visible } = input;
     const keyOf = (account, scope, page = "") => JSON.stringify([account, scope, page]);
-    /** One look at a run's two files, shared by every viewer's room: at most once per LIVE_POLL_MS per run, however
-     * many viewers or bus signals there are (a burst of writes re-proves at once, but never opens files more often). */
     const looked = new Map();
     const marksOf = (runId, stillSees) => {
-        // A run's files are this viewer's to look at (or have looked at) only while the run is still theirs and this
-        // computer's, proved from its row now — a look another viewer's room took included.
         if (!stillSees())
             return null;
         const now = Date.now();
         const kept = looked.get(runId);
-        // One attempt per run per poll, whether it looked or stopped part-way: nothing makes files opened more often.
         if (kept !== undefined && now - kept.at < LIVE_POLL_MS)
             return kept.marks;
         looked.set(runId, { at: now, marks: null });
@@ -58,7 +42,6 @@ export function createAgentsLiveRooms(input) {
     };
     const rooms = createLiveRooms(key => {
         const [account] = JSON.parse(key);
-        // Read as the keyed account (its own request context), never as whoever's write woke the bus.
         return requestContext.run({ actor: account, csrf: "", returnTo: "/agents" }, () => {
             const sees = (runId) => () => {
                 const run = store.getRun(runId);
@@ -73,14 +56,12 @@ export function createAgentsLiveRooms(input) {
             for (const [runId] of [...looked])
                 if (Date.now() - looked.get(runId).at > 10 * LIVE_POLL_MS)
                     looked.delete(runId);
-            // The digest's every run proved again from its current row after the looks: one that left view isn't in it.
             const still = (runId) => {
                 const run = store.getRun(runId);
                 const repo = run === null ? null : store.refForId(run.taskRef)?.repo ?? null;
                 return repo !== null && visible(repo) && store.accountCanAccess(account, repo);
             };
             const kept = new Set(tiles.filter(tile => still(tile.runId)).map(tile => tile.runId));
-            // Which of the viewer's own lead chats filed each run (agents-live-filed.ts): a link made or erased is a change too.
             const filed = leadFiledLinks(store, account, [...kept]);
             const seen = tiles.filter(tile => kept.has(tile.runId)).map(tile => [tile.runId, tile.state, tile.why, tile.endedAt, filed.get(tile.runId)?.thread ?? null]);
             const shownMarks = marks.filter(([runId]) => kept.has(runId) && (!tiles.find(tile => tile.runId === runId)?.local || sees(runId)()));