toolroll 0.9.103 → 0.9.105

package/dist/tools-ui.js

@@ -1,6 +1,3 @@
-/** Settings → Tools: one project's MCP servers, in plain words. Secrets are
- * entered here and nowhere else, and never shown again. Built from the revamp kit (src/design/KIT.md): each tool and
- * each service is a record with one action; the password is asked only once a tool or service is picked. */
 import { html, joinHtml, postForm } from "./html.js";
 import { brandMarkHtml } from "./brand-mark.js";
 import { signedIn } from "./oauth-run-token.js";
@@ -8,9 +5,7 @@ import { credentialModeOf, toolCommandLine, toolStanding } from "./project-tools
 import { acts, btn, chip, codeLine, disclose, facts, formRow, icon, infoLine, input, note, notice, select, settingsRecord, settingsSection } from "./server/kit.js";
 import { kitSectionForm, SECRET_OPT_OUTS } from "./settings-kit.js";
 const hidden = (data) => Object.entries(data).map(([k, v]) => html `<input type="hidden" name="${k}" value="${v}">`);
-/** Kept for the console's style bundle (server/chrome.ts): the page is built from the kit and needs none of its own. */
 export const TOOLS_CSS = "";
-/** The project chooser: it opens the chosen project at once; without scripts, its button does. */
 export function toolsProjectPicker(projects, chosen, keep = {}) {
     if (projects.length < 2)
         return "";
@@ -18,10 +13,8 @@ export function toolsProjectPicker(projects, chosen, keep = {}) {
     return html `<form method="get" action="/settings/tools" class="k-acts k-picker" data-autosave>${hidden(keep)}\
 ${select({ name: "repo", label: "Project", current: chosen, items, attrs: { "data-tools-project": true } })}${btn("Show project", { sm: true, type: "submit" })}</form>`;
 }
-/** Choosing another project marks every form on the page as stale before it reloads, so a tap racing the reload is refused. */
 export const TOOLS_PROJECT_SCRIPT = `(function(){var s=document.querySelector('select[data-tools-project]');if(!s)return;s.addEventListener('change',function(){document.querySelectorAll('input[name=shown]').forEach(function(i){i.value=s.value;});});})();`;
 const slug = (text) => text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
-/** A tool secret's own field: masked, never given a value, kept out of password managers. */
 function secretField(id, label) {
     return html `<input class="k-input" id="${id}" type="password" name="value" autocomplete="off" spellcheck="false" autocapitalize="none" data-so-secret \
 data-1p-ignore data-lpignore="${SECRET_OPT_OUTS["data-lpignore"]}" data-bwignore data-form-type="other" required aria-label="${label}">`;
@@ -29,11 +22,8 @@ data-1p-ignore data-lpignore="${SECRET_OPT_OUTS["data-lpignore"]}" data-bwignore
 function toolRecord(one, base, manage, project, research = null) {
     const { tool, secretsSet } = one;
     const standing = toolStanding(tool, secretsSet);
-    // How its runs get credentials, in one line; what that means is in Details.
     const mode = credentialModeOf(tool.spec, secretsSet);
     const sub = html `${tool.spec.about}${mode === null ? "" : html ` · <span data-credential="${mode.mode}">${mode.words}</span>`}`;
-    // One form per secret: the disclosure is both where it stands and where it is set. A service connected by signing
-    // in gets its tokens only by signing in again (its Connect): no token of it is ever pasted here.
     const secrets = manage && !signedIn(tool.spec) ? tool.spec.secrets.map(secret => {
         const set = secretsSet.includes(secret.name);
         const id = `secret-${slug(tool.name)}-${slug(secret.name)}`;
@@ -51,7 +41,6 @@ function toolRecord(one, base, manage, project, research = null) {
         ...(tested === null ? [] : [["Last test", tested]]),
     ]));
     const failed = tool.lastTest !== null && !tool.lastTest.ok ? notice(tool.lastTest.problem ?? "The last test failed.") : "";
-    // Connected, but research can't use it (its grant writes): said once, with the one way to fix it.
     const reconnect = research === null || !manage ? "" : kitSectionForm({
         proof: "tools-connect", action: "/settings/tools/connect", id: `reconnect-${slug(tool.name)}`, native: true, hidden: { ...base, service: tool.name, access: "read" },
         save: { label: "Reconnect read-only", variant: "outline" }, confirm: `Reconnect ${tool.name} read-only for ${project}`, body: html ``,
@@ -65,7 +54,6 @@ function toolRecord(one, base, manage, project, research = null) {
         more: joinHtml([failed, limited, ...secrets, details, remove]),
     });
 }
-/** One service to connect by signing in on its own page: one record, one Connect. The password is asked after it is picked. */
 function connectRecord(one, view, base, problem) {
     const mark = brandMarkHtml(one.id.replace(/-desktop$/, ""), one.label, one.state === "connected");
     const attrs = { id: `connect-${one.id}`, "data-state": one.state };
@@ -82,7 +70,6 @@ function connectRecord(one, view, base, problem) {
     });
     return settingsRecord({ title: html `${mark}<span>${one.label}</span>${connected ? chip("Connected", "done") : ""}`, sub: connected ? "" : one.about, action, attrs, more: problem });
 }
-/** A service connected here, offered to the person's other projects: each act signs in again for that project (tokens are never copied). */
 function elsewhere(view, base) {
     const offers = view.connections.filter(one => one.state === "connected").flatMap(one => (view.others ?? []).filter(other => other.open.includes(one.id)).map(other => kitSectionForm({
         proof: "tools-connect", action: "/settings/tools/connect", id: `also-${slug(one.id)}-${slug(other.project)}`, native: true,
@@ -95,11 +82,9 @@ function elsewhere(view, base) {
 }
 export function toolsHtml(view, csrf, canManage, message = {}) {
     const manage = canManage && csrf !== "";
-    // `shown` is the project this page shows; the server refuses a post whose repo differs from it.
     const base = { repo: view.repo, shown: view.repo };
     const to = ` to ${view.project}`;
     const keptIn = view.storage === undefined || view.storage.filesOnly ? "Secrets stay on this computer" : view.storage.words.replace(/\.$/, "");
-    // No keychain here: said once, plainly, where it can't be missed.
     const storage = view.storage?.problem !== undefined ? notice(view.storage.problem)
         : view.storage?.filesOnly === true ? infoLine(view.storage.words) : "";
     const how = disclose("How tools work", html `<ul class="k-note"><li>A tool you add reaches work you approve from now on. Approve a task again to give it a new tool.</li><li>Removing a tool takes it away from every build right away.</li><li>${keptIn}, are never shown again, and go only to the tool that needs them.</li><li>Reviewers and the lead chat never get tools. Gemini builds don't use tools yet.</li></ul>`);
@@ -107,10 +92,8 @@ export function toolsHtml(view, csrf, canManage, message = {}) {
         : joinHtml(view.tools.map(one => toolRecord(one, base, manage, view.project, view.connections.find(c => c.id === one.tool.name && c.state === "connected")?.research ?? null)));
     const tools = settingsSection({ id: "tools", title: `Tools in ${view.project}`, lead: `Builds in ${view.project} use exactly these tools. MCP servers set up elsewhere on this computer aren't used.`, body: joinHtml([storage, records, how]) });
     const connecting = manage && view.connections.length > 0;
-    // A Connect that failed says why at its service, focused so it is heard and seen there (not only at the top).
     const atButton = connecting && view.wanted !== null && view.connections.some(one => one.id === view.wanted) && Boolean(message.problem);
     const failed = atButton ? html `<p class="k-notice" id="connect-problem" role="alert" tabindex="-1" autofocus>${icon("alert", true)}<span>${message.problem}</span></p>` : "";
-    // The service a link asked for comes first; its Connect is the page's one primary.
     const ordered = [...view.connections.filter(one => one.id === view.wanted), ...view.connections.filter(one => one.id !== view.wanted)];
     const connect = connecting ? settingsSection({ id: "connect", title: `Connect${to}`, lead: "Sign in on the service's own page. Toolroll asks for your password once you pick one.",
         body: joinHtml(ordered.map(one => connectRecord(one, view, base, one.id === view.wanted ? failed : ""))) }) : "";

package/dist/transitions-recipes.js

@@ -1,5 +1,3 @@
-// Selected portable recipes from https://github.com/Jakubantalik/transitions.dev
-// Keep recipe CSS intact; Toolroll overrides and wiring live separately.
 export const TRANSITIONS_CSS = `
 /* Transitions.dev — 05-menu-dropdown.md */
 :root {

package/dist/tree-proof.js

@@ -1,20 +1,5 @@
-/**
- * The read-only roles' clean-tree proof (planner, scout — mate arc §10,
- * v4 review finding 4). `git status --porcelain` alone is not a proof: it
- * omits IGNORED paths, so an agent could leave a generated file behind
- * and pass; and a pathname filter that exempts the protocol files
- * regardless of index status would let an agent `git add` its own
- * handoff and pass with a dirty index. So: ignored paths are snapshotted
- * BEFORE the agent runs and any new one afterwards is foreign; and a
- * protocol file is admitted only as plain untracked (`??`) — staged is
- * foreign. Ignored directories are collapsed by git (`!! build/`), so a
- * write INTO a directory that was already ignored before the agent ran
- * (a dependency tree the setup command produced) is not detected — that
- * residual is stated here rather than wished away.
- */
 const GIT = "git";
 const STATUS_ARGS = ["--no-optional-locks", "-c", "core.quotePath=false", "status", "--porcelain", "--ignored"];
-/** The ignored paths git reports right now — the "before" of a proof. */
 export async function snapshotIgnored(git, cwd) {
     const status = await git(GIT, [...STATUS_ARGS], { cwd });
     if (status.code !== 0)
@@ -26,11 +11,6 @@ export async function snapshotIgnored(git, cwd) {
     }
     return ignored;
 }
-/**
- * Everything in the tree that is not (a) an ignored path that was already
- * ignored before, (b) one of this attempt's own protocol files as PLAIN
- * untracked, or (c) the pool's untracked lease marker.
- */
 export async function proveTreeUntouched(git, cwd, args) {
     const status = await git(GIT, [...STATUS_ARGS], { cwd });
     if (status.code !== 0)
@@ -47,9 +27,6 @@ export async function proveTreeUntouched(git, cwd, args) {
             continue;
         }
         const own = args.protocolFiles.includes(path) || path === args.marker;
-        // Untracked is the only admissible state for a protocol file: a staged
-        // one would survive cleanup in the index and ride into somebody's
-        // commit.
         if (own && code === "??")
             continue;
         foreign.push(own ? `${path} (staged)` : path);

package/dist/tui-contract.js

@@ -1,9 +1 @@
-/**
- * What the terminal UI (src/tui, bundled into dist/tui.js) reads and asks for, and nothing more. The CLI side
- * (tui-source.ts) implements it with in-process reads of this installation's database and with every write sent
- * through `runOperate` as the local owner (local-owner.ts runAsLocalOwner), so the screen holds no authority of its
- * own: a write the local owner may not make is refused there, and the screen shows the refusal's words.
- *
- * Types only, with no imports: both the CLI build (tsc) and the terminal UI bundle (esbuild) read this file.
- */
 export {};

package/dist/tui-source.js

@@ -1,14 +1,9 @@
-/**
- * The terminal UI's view of this installation (tui-contract.ts TuiSource), in this process.
- *
- * Reads come straight from the database through a read-only handle (the task list and a task's own envelopes through
- * `runOperate`, live output through peek's tail reader, the store's wake sequence as the change signal). Every write
- * goes through `runOperate` inside runAsLocalOwner: the same commands, rows and refusals as the CLI, bound to local
- * mode when each command opens the database, never to anything the screen says. Every command runs with --json, so
- * nothing ever prompts on the terminal the screen owns.
- */
 import { dirname, join } from "node:path";
-import { assignmentOf } from "./assignment.js";
+import { advancedShownFor } from "./advanced.js";
+import { assignmentOf, owedAcceptance } from "./assignment.js";
+import { agentlessFirstRun, buildersFor } from "./dispatch.js";
+import { familyChangedFiles } from "./result-completion.js";
+import { checkBackingOf, receiptChecksOf, requirementWordOf } from "./task-status.js";
 import { checklistLines, mergeChecklistOf } from "./merge-checklist.js";
 import { runAsLocalOwner } from "./local-owner.js";
 import { snapshotLiveRuns } from "./peek-cli.js";
@@ -21,14 +16,14 @@ import { memoryWaiting } from "./lesson-notes.js";
 import { homeGroupOf } from "./home-groups.js";
 import { terminalText } from "./terminal-text.js";
 import { welcomeHere, welcomeLines } from "./welcome-facts.js";
+import { planSourceOf, retryPinsOf } from "./local-owner-acts.js";
 const record = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
 const words = (value, fallback = "") => typeof value === "string" ? value : fallback;
-/** Text for the screen: whatever wrote it (an agent, a person, a project's name), escapes and controls never reach the
- * terminal (terminal-text.ts). Every displayed string below goes through here; ids and digests are only acted on. */
 const shown = (value, fallback = "") => terminalText(words(value, fallback));
-/** What a refused write says, and whether it is a local-owner refusal (the screen then leads to a password). */
 function refusalOf(envelope) {
     const message = shown(envelope.message, "That was refused.");
+    if (envelope.reason === "stale")
+        return { ok: false, message, needsPassword: false, changed: true };
     return { ok: false, message, needsPassword: envelope.reason === "refused" || envelope.reason === "machine-proof" || envelope.reason === "person-required" || /password/i.test(message) };
 }
 const routeLines = (store, id) => { const words = routeChangeOf(store, id); return words === null ? [] : [words]; };
@@ -45,7 +40,6 @@ export function createTuiSource(options) {
         reader ??= openStoreReadOnly(file);
         return reader;
     };
-    /** One command as the local owner, with --json: its envelope (an unreadable answer reads as a refusal). */
     async function command(argv) {
         const [name = "", ...rest] = argv;
         let out = "";
@@ -75,7 +69,6 @@ export function createTuiSource(options) {
                 return {
                     id: words(row["id"], words(row["rootId"])), title: shown(row["title"]), status: shown(status["label"], words(row["state"])), detail: shown(status["detail"]),
                     needsYou: views.includes("needs-you"), liveRunId: typeof row["liveRunId"] === "number" ? row["liveRunId"] : null, repo: typeof row["repo"] === "string" ? row["repo"] : null,
-                    // The same rule as Home's groups, over the same work index item.
                     group: homeGroupOf({ status: { views: views.filter((one) => typeof one === "string") } }),
                 };
             });
@@ -85,7 +78,8 @@ export function createTuiSource(options) {
             const store = read();
             const mode = store === null ? null : localModeOf(store);
             const passwordSet = store !== null && mode !== null && store.accountOf(mode.owner)?.passwordSet === true;
-            return { rows, needsYou, projects: "error" in registry ? [] : registry.repos, passwordSet, learning: store === null ? null : learningLine(store, "error" in registry ? [] : registry.repos, clock()) };
+            const advanced = store === null || mode === null || advancedShownFor(store, mode.owner);
+            return { rows, needsYou, projects: "error" in registry ? [] : registry.repos, passwordSet, learning: store === null ? null : learningLine(store, "error" in registry ? [] : registry.repos, clock(), advanced) };
         },
         async task(id) {
             const answer = await command(["task", "show", id]);
@@ -104,7 +98,6 @@ export function createTuiSource(options) {
             }
             const decisions = store === null ? [] : store.listDecisions("unanswered").filter(one => one.taskId === id)
                 .map(one => ({ id: one.id, question: terminalText(one.question), options: one.options.map(option => ({ id: option.id, label: terminalText(option.label) })) }));
-            // "Can I merge?": the same checklist and lines as `toolroll task ready`, read from the same records.
             let ready = [];
             try {
                 const list = !hasResult || store === null ? null : mergeChecklistOf(store, id, clock(), { principal: "operator", repos: null }, evidenceRoot);
@@ -116,6 +109,8 @@ export function createTuiSource(options) {
             return {
                 id, title: shown(task["title"], id), status: shown(status["label"], words(work["state"])), detail: shown(status["detail"]),
                 plan, liveRunId: typeof work["liveRunId"] === "number" ? work["liveRunId"] : null, hasResult, decisions, ready,
+                planAsk: store === null ? null : planAskOf(store, id),
+                retry: (() => { const pins = store === null ? null : retryPinsOf(store, id); return pins === null ? null : { runId: pins.run, digest: pins.digest }; })(),
             };
         },
         live(id) {
@@ -143,11 +138,15 @@ export function createTuiSource(options) {
             switch (act.kind) {
                 case "new":
                     argv = ["task", "add", act.text, ...(act.repo === null ? [] : ["--repo", act.repo])];
-                    done = "Filed. Its plan will be ready for you to approve.";
+                    done = "Filed.";
+                    break;
+                case "plan":
+                    argv = ["task", "plan", act.id, "--digest", act.source];
+                    done = "Asked for a plan. You'll approve it before anything is built.";
                     break;
                 case "build":
                     argv = ["task", "new", "--build", act.preview, "--digest", act.digest];
-                    done = "Building. A builder starts it next.";
+                    done = "Building. It starts next.";
                     break;
                 case "approve":
                     argv = ["task", "approve", act.id, "--yes", "--digest", act.digest];
@@ -165,33 +164,50 @@ export function createTuiSource(options) {
                     argv = ["decide", String(act.decision), "--choose", act.option];
                     done = "Answered.";
                     break;
-                // Retry is today's requeue (the console's Retry), the same command and the same refusals.
                 case "retry":
-                    argv = ["task", "retry", act.id];
-                    done = "Queued again. A builder starts it next.";
+                    argv = ["task", "requeue", act.id, "--run", String(act.runId), "--digest", act.digest];
+                    done = "Retrying. It starts next.";
                     break;
-                case "complete": {
-                    const store = read();
-                    let digest;
-                    try {
-                        digest = store === null ? undefined : assignmentOf(store, act.id, clock(), { principal: "operator", repos: null })?.receipt?.digest;
-                    }
-                    catch {
-                        digest = undefined;
-                    }
-                    if (digest === undefined)
-                        return { ok: false, message: "This task has no finished result to accept.", needsPassword: false };
-                    argv = ["task", "complete", act.id, "--digest", digest];
-                    done = "Accepted.";
+                case "complete":
+                    argv = ["task", "complete", act.id, "--run", String(act.runId), "--digest", act.digest, ...(act.checked ? ["--checked"] : []), ...(act.reason === null ? [] : ["--reason", act.reason])];
+                    done = "Accepted. The task is done.";
                     break;
-                }
             }
             const answer = await command(argv);
             if (answer.ok !== true)
                 return refusalOf(answer);
+            if (act.kind === "complete" && answer["replayed"] === true)
+                return { ok: true, message: "Already accepted. The task is done." };
+            if (act.kind === "plan" && answer["replayed"] === true)
+                return { ok: true, message: "Already asked for a plan." };
+            if (act.kind === "retry" && answer["replayed"] === true)
+                return { ok: true, message: "Already retrying. It starts next." };
             const filed = act.kind === "new" ? words(record(answer["task"])["id"], words(answer["id"])) : act.kind === "build" ? words(answer["task"]) : "";
+            if (act.kind === "new" && filed !== "" && act.repo !== null) {
+                const store = read();
+                const ask = store === null ? null : planAskOf(store, filed);
+                const asked = ask === null ? null : await command(["task", "plan", filed, "--digest", ask.source]);
+                const filedRef = store === null ? null : store.lookupRef(filed);
+                const agentless = store === null || filedRef === null || asked?.ok !== true ? null
+                    : agentlessFirstRun(store, filedRef, true, buildersFor(store, act.repo, clock()).alive.map(one => one.name));
+                const message = asked?.ok !== true ? `Filed. It wasn't sent for a plan: ${shown(asked?.message, "it can't be planned now.")}`
+                    : agentless !== null ? `Filed. ${agentless.words}`
+                        : "Filed. Planning: you'll approve the plan before anything is built.";
+                return { ok: true, message, id: filed };
+            }
             return { ok: true, message: done, ...(filed === "" ? {} : { id: filed }) };
         },
+        async result(id) {
+            const store = read();
+            if (store === null)
+                return null;
+            try {
+                return resultOf(store, id, clock(), evidenceRoot);
+            }
+            catch {
+                return null;
+            }
+        },
         async fastTerms(text, repo) {
             if (repo === null)
                 return null;
@@ -207,7 +223,6 @@ export function createTuiSource(options) {
             const store = read();
             if (store === null)
                 return null;
-            // The screen can close while this waits on the sign-in checks: the store it holds is gone then, and so is the question.
             const here = await welcomeHere(store, file, clock(), options.check === undefined ? {} : { check: options.check }).catch((problem) => {
                 if (closed)
                     return null;
@@ -226,12 +241,12 @@ export function createTuiSource(options) {
         },
     };
 }
-/** The screen's one line about the learning loops: flaky tests and what waits in project memory, each with its command. */
-function learningLine(store, repos, now) {
+export function learningLine(store, repos, now, advanced = true) {
     let flaky = 0, memory = 0;
     try {
         for (const repo of repos) {
-            flaky += flakyCount(store, repo, now);
+            if (advanced)
+                flaky += flakyCount(store, repo, now);
             const waiting = memoryWaiting(store, repo);
             memory += waiting.notes + waiting.cleanups;
         }
@@ -242,3 +257,39 @@ function learningLine(store, repos, now) {
     const parts = [flaky === 0 ? "" : `${flaky} flaky test${flaky === 1 ? "" : "s"}: open the project's Flaky tests in the browser`, memory === 0 ? "" : `${memory} project memory suggestion${memory === 1 ? "" : "s"}: open Settings → Knowledge`].filter(Boolean);
     return parts.length === 0 ? null : parts.join(" · ");
 }
+function resultOf(store, id, now, evidenceRoot) {
+    const assignment = assignmentOf(store, id, now, { principal: "operator", repos: null }, evidenceRoot);
+    const receipt = assignment?.receipt ?? null;
+    if (assignment === null || receipt === null)
+        return null;
+    const blockers = assignment.readiness?.blockers ?? [];
+    const owed = assignment.state === "ready-to-check" ? owedAcceptance(receipt, blockers) : null;
+    const standing = blockers.filter(one => !(owed === "exception" && one.key === "criteria")).map(one => terminalText(one.message));
+    const notNow = assignment.state === "complete" ? "This result is already accepted." : assignment.state === "ready-to-check" ? null : terminalText(assignment.detail || "This result isn't ready to accept.");
+    const changed = familyChangedFiles(store, receipt.taskId, receipt.runId, evidenceRoot);
+    const backing = checkBackingOf(receiptChecksOf(receipt));
+    let checks = [];
+    try {
+        const list = mergeChecklistOf(store, id, now, { principal: "operator", repos: null }, evidenceRoot);
+        checks = list === null ? [] : checklistLines(list).map(line => terminalText(line));
+    }
+    catch {
+        checks = [];
+    }
+    return {
+        id, runId: receipt.runId, digest: receipt.digest, title: terminalText(assignment.title),
+        ready: notNow === null && standing.length === 0, blockers: notNow === null ? standing : [notNow],
+        summary: (receipt.agentReport ?? "").split("\n").map(line => terminalText(line).trimEnd()).filter(line => line.trim() !== "").slice(0, 8),
+        files: changed === null ? null : { names: changed.slice(0, 10).map(name => terminalText(name)), more: Math.max(0, changed.length - 10) },
+        requirements: (receipt.proof?.matrix ?? []).map(row => ({ word: requirementWordOf(row, receipt.proof?.verdict ?? null, backing), statement: terminalText(row.statement ?? row.id ?? "") })),
+        checks, owed,
+    };
+}
+function planAskOf(store, id) {
+    const ref = store.lookupRef(id);
+    const scope = store.getScope(id);
+    if (ref === null || ref.plan !== null || store.getTask(id)?.state !== "queued" || (scope !== null && scope.approvedAt !== null && scope.approvedDigest === scope.digest))
+        return null;
+    const source = planSourceOf(store, id);
+    return source === null ? null : { source };
+}