toolroll 0.9.93 → 0.9.95

package/dist/server/render-code-map.js

@@ -0,0 +1,137 @@
+/**
+ * The Code map page (docs/plans/code-map.md §6): read-only, from the shared reader. Every name on it came from the
+ * repository: `html` escapes it, links carry it through encodeURIComponent, and the handler looks it up exactly.
+ */
+import { githubRepoOf } from "../pull-request-flow.js";
+import { areaRows, areaView, fileView, searchMap } from "../code-map-read.js";
+import { NOT_ENOUGH, reportRows } from "../code-map-report.js";
+import { html, joinHtml, postForm } from "../html.js";
+import { relativeAge, screen } from "./chrome.js";
+import { btn, disclose, doc, docHeader, empty, facts, infoLine, input, note, notice, phoneHeader } from "./kit.js";
+const WARNING_WORDS = {
+    "symbols-truncated": "Some files have more exported names than the map keeps.",
+    "edges-truncated": "This repository has more imports than the map keeps.",
+    "read-limit": "Past the read limit, the remaining code files are listed by path only.",
+    "areas-folded": "The smallest areas are folded into “other areas”.",
+    "tsconfig-extends": "Settings inherited through tsconfig “extends” aren't read, so some imports aren't connected.",
+    "tsconfig-unreadable": "tsconfig.json couldn't be read; relative imports still work.",
+};
+export const LIMITS_WORDS = { system: "Limits enforced by the system.", checked: "Limits checked by Toolroll every 250 ms." };
+const mono = (text) => html `<code class="k-mono cm-path">${text}</code>`;
+const short = (commit) => commit.slice(0, 7);
+const plural = (n, one, many = `${one}s`) => `${n} ${n === 1 ? one : many}`;
+const hrefOf = (data, extra) => {
+    const params = new URLSearchParams(data.versionId === null ? extra : { v: String(data.versionId), ...extra });
+    return `${data.base}?${params.toString()}`;
+};
+function areaBlock(data, one, map) {
+    const named = (id) => map.areas.find(area => area.id === id)?.name ?? id;
+    const links = (list) => joinHtml(list.slice(0, 6).map(use => html `<a class="k-link" href="${hrefOf(data, { area: use.id })}">${named(use.id)}</a>`), ", ");
+    return html `<li class="cm-item"><a class="k-link cm-title" href="${hrefOf(data, { area: one.id })}">${one.name}</a>
+    <span class="cm-meta">${plural(one.files, "file")}${one.languages.length === 0 ? "" : ` · ${one.languages.join(", ")}`}${one.tests === 0 ? "" : ` · ${plural(one.tests, "test")}`}</span>
+    ${one.uses.length === 0 ? "" : html `<span class="cm-meta">Uses ${links(one.uses)}</span>`}
+    ${one.usedBy.length === 0 ? "" : html `<span class="cm-meta">Used by ${links(one.usedBy)}</span>`}</li>`;
+}
+const fileBlock = (data, file) => html `<li class="cm-item"><a class="k-link cm-title" href="${hrefOf(data, { file: file.path })}">${file.path}</a>
+  <span class="cm-meta">${file.lang} · ${plural(file.bytes, "byte")}${file.test === null ? "" : html ` · Tests: ${file.test}`}</span>
+  ${file.symbols.length === 0 ? "" : html `<span class="cm-meta">Exported names: ${file.symbols.slice(0, 12).map(one => one.name).join(", ")}${file.symbols.length > 12 ? ` and ${file.symbols.length - 12} more` : ""}</span>`}</li>`;
+function overview(data, map) {
+    return html `<section class="k-sec" aria-labelledby="cm-areas"><h3 id="cm-areas">Areas</h3>
+    ${map.areas.length === 0 ? note("This repository is empty.") : html `<ul class="cm-list">${areaRows(map).map(one => areaBlock(data, one, map))}</ul>`}</section>`;
+}
+function areaPage(data, map, id) {
+    const view = areaView(map, id);
+    if (view === null)
+        return notice("That area isn't in this version of the map.");
+    return html `<section class="k-sec" aria-labelledby="cm-area"><h3 id="cm-area">${view.area.name}</h3>
+    ${facts([
+        ["Files", String(view.area.files)], ["Tests", String(view.area.tests)],
+        ...(view.entryPoints.length === 0 ? [] : [["Entry points", joinHtml(view.entryPoints.map(one => html `<a class="k-link" href="${hrefOf(data, { file: one })}">${one}</a>`), ", ")]]),
+        ...(view.external.length === 0 ? [] : [["Packages", view.external.join(", ")]]),
+        ...(view.area.uses.length === 0 ? [] : [["Uses", joinHtml(view.area.uses.map(one => html `<a class="k-link" href="${hrefOf(data, { area: one.id })}">${one.id}</a> (${String(one.count)})`), ", ")]]),
+        ...(view.area.usedBy.length === 0 ? [] : [["Used by", joinHtml(view.area.usedBy.map(one => html `<a class="k-link" href="${hrefOf(data, { area: one.id })}">${one.id}</a> (${String(one.count)})`), ", ")]]),
+    ])}</section>
+    <section class="k-sec" aria-labelledby="cm-files"><h3 id="cm-files">Files</h3><ul class="cm-list">${view.files.slice(0, 500).map(one => fileBlock(data, one))}</ul>
+    ${view.files.length > 500 ? note(`${view.files.length - 500} more. Search to find them.`) : ""}</section>`;
+}
+function filePage(data, map, path) {
+    const view = fileView(map, path);
+    if (view === null)
+        return notice("That file isn't in this version of the map.");
+    const github = data.remoteUrl === null ? null : githubRepoOf(data.remoteUrl);
+    const list = (rows) => rows.length === 0 ? note("None.") : html `<ul class="cm-list">${rows.slice(0, 200).map(one => html `<li class="cm-item"><a class="k-link cm-title" href="${hrefOf(data, { file: one.path })}">${one.path}</a><span class="cm-meta">line ${String(one.line)}</span></li>`)}</ul>`;
+    return html `<section class="k-sec" aria-labelledby="cm-file"><h3 id="cm-file">${mono(view.file.path)}</h3>
+    ${github === null ? "" : html `<p><a class="k-link" rel="noopener noreferrer" target="_blank" href="${`https://github.com/${github}/blob/${map.commit}/${view.file.path.split("/").map(encodeURIComponent).join("/")}`}">Open on GitHub at ${short(map.commit)}</a></p>`}
+    ${facts([["Area", html `<a class="k-link" href="${hrefOf(data, { area: view.file.area })}">${view.file.area}</a>`], ["Language", view.file.lang], ...(view.file.test === null ? [] : [["Tests", html `<a class="k-link" href="${hrefOf(data, { file: view.file.test })}">${view.file.test}</a>`]])])}</section>
+    <section class="k-sec" aria-labelledby="cm-names"><h3 id="cm-names">Exported names</h3>${view.file.symbols.length === 0 ? note(view.file.state === "read" ? "None." : "Names and imports aren't read for this file.") : html `<ul class="cm-list">${view.file.symbols.map(one => html `<li class="cm-item"><span class="cm-title">${one.name}</span><span class="cm-meta">${one.kind} · line ${String(one.line)}</span></li>`)}</ul>`}</section>
+    <section class="k-sec" aria-labelledby="cm-imports"><h3 id="cm-imports">Imports</h3>${list(view.imports)}</section>
+    <section class="k-sec" aria-labelledby="cm-by"><h3 id="cm-by">Imported by</h3>${list(view.importedBy)}</section>`;
+}
+function searchPage(data, map, query) {
+    const hits = searchMap(map, query, 200);
+    return html `<section class="k-sec" aria-labelledby="cm-found"><h3 id="cm-found">${plural(hits.length, "match", "matches")}</h3>
+    ${hits.length === 0 ? note("Nothing in this version matches.") : html `<ul class="cm-list">${hits.map(one => html `<li class="cm-item"><a class="k-link cm-title" href="${hrefOf(data, { file: one.path })}">${one.name ?? one.path}</a>${one.name === null ? "" : html `<span class="cm-meta">${one.path} · line ${String(one.line)}</span>`}</li>`)}</ul>`}</section>`;
+}
+function provenance(data, map) {
+    const report = (() => { try {
+        return JSON.parse(data.status.version?.report ?? "{}");
+    }
+    catch {
+        return {};
+    } })();
+    const c = map.counts;
+    return disclose("Where this comes from", joinHtml([
+        note(map.label),
+        facts([
+            ["Remote", data.remoteUrl === null ? "None" : mono(data.remoteUrl)],
+            ["Files", `${c.files} (${c.read} read, ${c.pathOnly} by path only, ${c.tooLarge} too large to read)`],
+            ...(c.parseErrors > 0 ? [["Unreadable", plural(c.parseErrors, "file")]] : []),
+            ...(c.withheld > 0 ? [["Withheld", `${plural(c.withheld, "name")} Toolroll won't show`]] : []),
+            ...(c.links + c.submodules > 0 ? [["Not followed", `${plural(c.links, "link")}, ${plural(c.submodules, "submodule")}`]] : []),
+            ...(map.vendored.length === 0 ? [] : [["Left out", map.vendored.map(one => `${one.path} (${plural(one.files, "file")})`).join(", ")]]),
+        ]),
+        note("require() calls aren't counted. Other languages show paths and sizes only."),
+        ...map.warnings.map(code => note(WARNING_WORDS[code])),
+        ...(report.proxy ? [note(`Read through your proxy at ${report.proxy}.`)] : []),
+        ...(report.enforced === undefined ? [] : [note(LIMITS_WORDS[report.enforced])]),
+    ]));
+}
+/** "Builds with and without the map": read by people; nothing switches on it. */
+export function codeMapReportBlock(report) {
+    if (report.arms.map.families + report.arms.holdout.families === 0)
+        return null;
+    return html `<section class="k-sec" aria-labelledby="cm-report"><h3 id="cm-report">Builds with and without the map</h3>
+    ${report.enough ? "" : note(NOT_ENOUGH)}
+    ${facts(reportRows(report).map(row => [row.label, `With ${row.map} · without ${row.holdout}`]))}</section>`;
+}
+export function codeMapPage(chrome, data) {
+    const { status, map } = data;
+    const age = status.version === null ? "" : ` · ${relativeAge(status.version.builtAt, data.now)}`;
+    const meta = map === null ? status.words : `main at ${short(map.commit)}${age}`;
+    const check = data.canRefresh && status.state !== "not-available" && status.state !== "off"
+        ? postForm(`${data.base}/refresh`, btn("Check now", { sm: true, type: "submit" }), { returnTo: data.selfHref, hidden: { repo: data.repo } }) : "";
+    const stated = data.problem !== null ? notice(data.problem) : data.said !== null ? infoLine(data.said) : "";
+    const warn = status.state === "couldnt-check" || status.state === "too-large" || status.state === "remote-changed" ? notice(status.words) : status.state === "stale" ? infoLine(status.words) : "";
+    let content;
+    if (map === null) {
+        content = status.state === "making" ? empty({ title: "Making the first map.", text: "It appears here when it's ready." })
+            : status.state === "off" ? empty({ title: "The code map is off.", text: "Turn it on in this project's settings." })
+                : status.state === "not-available" ? empty({ title: "No code map.", text: status.words })
+                    : status.state === "no-main" ? empty({ title: "No main yet.", text: status.words })
+                        : "";
+    }
+    else {
+        const search = html `<form class="cm-search" method="get" action="${data.base}" role="search">
+      ${data.versionId === null ? "" : html `<input type="hidden" name="v" value="${String(data.versionId)}">`}
+      ${input({ id: "cm-q", name: "q", type: "search", value: data.q ?? "", attrs: { "aria-label": "Search files and exported names", placeholder: "Search files and exported names" } })}
+      ${btn("Search", { sm: true, type: "submit" })}</form>`;
+        const view = data.q !== null && data.q.trim() !== "" ? searchPage(data, map, data.q) : data.file !== null ? filePage(data, map, data.file) : data.area !== null ? areaPage(data, map, data.area) : overview(data, map);
+        const atTop = data.q === null && data.file === null && data.area === null;
+        content = joinHtml([search, provenance(data, map), atTop ? "" : html `<p><a class="k-link" href="${hrefOf(data, {})}">All areas</a></p>`, view, atTop ? data.report ?? "" : ""]);
+    }
+    const body = joinHtml([
+        phoneHeader("Code map", { back: data.selfHref.replace(/\/map(?:\?.*)?$/, "") }),
+        doc(docHeader({ back: [data.base.replace(/\/map$/, ""), data.name], title: "Code map", meta, ...(check === "" ? {} : { right: check }), same: true }), stated, warn, content),
+    ]);
+    return screen("Code map", body, { chrome });
+}

package/dist/server/render-flaky.d.ts

@@ -0,0 +1,20 @@
+import { type FlakyList, type FlakyObservation, type FlakyRow } from "../flaky.js";
+import { type Chrome, type Screen } from "./chrome.js";
+/** The list. */
+export declare function flakyPage(chrome: Chrome, data: {
+    name: string;
+    repo: string;
+    back: string;
+    selfHref: string;
+    list: FlakyList;
+    now: Date;
+}): Screen;
+/** One row's history. */
+export declare function flakyRowPage(chrome: Chrome, data: {
+    name: string;
+    repo: string;
+    back: string;
+    row: FlakyRow;
+    history: readonly FlakyObservation[];
+    now: Date;
+}): Screen;

package/dist/server/render-flaky.js

@@ -0,0 +1,59 @@
+/**
+ * The flaky tests list (docs/plans/learning-loops.md, "The list"): a project's tests with mixed outcomes under recorded
+ * conditions, on the kit. Reads only; the one action is "Make a task to fix it", the ordinary /tasks/add form, and a
+ * person approves that task as usual. Test names are candidate-written text, escaped at the sink like everything else.
+ */
+import { flakyCoverageWords, flakyStatusWords } from "../flaky-cli.js";
+import { fixTaskOf } from "../flaky.js";
+import { html, joinHtml, postForm } from "../html.js";
+import { relativeAge, screen } from "./chrome.js";
+import { btn, chip, disclose, doc, docHeader, empty, facts, note, phoneHeader, row } from "./kit.js";
+const KIND_WORDS = { regate: "Checks run again on the same commit", "same-tree": "Two checks of the same code", "in-check-retry": "Passed on a retry inside one check", github: "GitHub re-run" };
+/** "Make a task to fix it": the ordinary task form, filled in. */
+function fixForm(repo, data, returnTo) {
+    const task = fixTaskOf(data);
+    return postForm("/tasks/add", btn("Make a task to fix it", { sm: true, type: "submit" }), { returnTo, hidden: { title: task.title, goal: task.goal, repo } });
+}
+const statusChip = (data) => chip(flakyStatusWords(data), "", { dot: false });
+/** The list. */
+export function flakyPage(chrome, data) {
+    const { list } = data;
+    const rowHref = (key) => `${data.selfHref}${data.selfHref.includes("?") ? "&" : "?"}row=${encodeURIComponent(key)}`;
+    const rows = list.rows.map(one => row({
+        href: rowHref(one.key), chip: statusChip(one), title: one.name,
+        desc: `${one.observations} in ${list.days} days · ${one.conditions.join(", ") || "conditions not recorded"} · ${one.hardFailures} hard failure${one.hardFailures === 1 ? "" : "s"} · ${one.sources.join(", ") || "no source recorded"}`,
+        meta: html `<span class="k-num">${relativeAge(one.lastSeen, data.now)}</span>`,
+        action: fixForm(data.repo, one, data.selfHref),
+    }));
+    const shortHistory = list.complete ? "" : note(`Not enough recorded history: test results are kept for 180 days, so ${list.days} days can't be counted in full.`);
+    const body = list.rows.length === 0
+        ? (list.complete ? empty({ title: "No mixed outcomes recorded" }) : "")
+        : html `<div class="flaky-rows">${joinHtml(rows)}</div>`;
+    return screen("Flaky tests", joinHtml([
+        phoneHeader("Flaky tests", { back: data.back }),
+        doc(docHeader({ back: [data.back, data.name], title: "Flaky tests", meta: "Mixed outcomes under recorded conditions" }), shortHistory, body, disclose("What this covers", joinHtml([
+            note(flakyCoverageWords(list)),
+            list.notPaired === 0 ? "" : note(`${list.notPaired} GitHub re-run${list.notPaired === 1 ? "" : "s"} not paired.`),
+            note("Not recorded: network, other processes, time of day."),
+        ]))),
+    ], "\n"), { chrome });
+}
+/** One row's history. */
+export function flakyRowPage(chrome, data) {
+    const one = data.row;
+    const history = data.history.length === 0 ? note("No history recorded.") : joinHtml(data.history.map(entry => row({
+        chip: html ``, title: KIND_WORDS[entry.kind],
+        desc: `${entry.failed} failed · ${entry.passed} passed · ${entry.commit ?? "commit not recorded"} · ${entry.conditions}`,
+        meta: html `<span class="k-num">${relativeAge(entry.at, data.now)}</span>`,
+    })));
+    return screen(one.name, joinHtml([
+        phoneHeader("Flaky test", { back: data.back }),
+        doc(docHeader({ back: [data.back, "Flaky tests"], title: one.name, meta: flakyStatusWords(one), right: fixForm(data.repo, one, data.back) }), facts([
+            ["Seen", `${one.observations} time${one.observations === 1 ? "" : "s"}, last ${relativeAge(one.lastSeen, data.now)}`],
+            ["Hard failures", String(one.hardFailures)],
+            ["Conditions", one.conditions.join(", ") || "not recorded"],
+            ["Recorded by", one.sources.join(", ") || "not recorded"],
+            ["Test file last changed", one.fileChanged === null ? "not recorded" : relativeAge(one.fileChanged, data.now)],
+        ]), html `<section class="k-sec" aria-labelledby="f-history"><h3 id="f-history">History</h3>${history}</section>`),
+    ], "\n"), { chrome });
+}

package/dist/server/render-follow-through.d.ts

@@ -0,0 +1,11 @@
+import { type Html } from "../html.js";
+import type { Store } from "../store.js";
+export type FollowThroughView = {
+    findings: Html | "";
+    findingCount: number;
+    openFindings: number;
+    repairs: Html | "";
+    evidence: Html | "";
+    handover: Html | "";
+};
+export declare function followThroughView(store: Store, root: string, taskId: string, taskHref: string, canAct: boolean, now: Date): FollowThroughView;

package/dist/server/render-follow-through.js

@@ -0,0 +1,68 @@
+/** The task page's follow-through sections (docs/plans/fleet-follow-through.md): findings, failed checks, before and after,
+ * and the handover note. All of a finding's text is model output or repository text: it renders as text, in `html`'s
+ * escaping, and no action here is reachable from it. Every form posts to the one action in tasks.ts. */
+import { checkRepairsOfTask, checkRepairWords } from "../check-repair.js";
+import { evidencePairsOf, evidenceWords, failingFirstOf, failingFirstWords } from "../evidence-pair.js";
+import { findingLine, findingFromWords, findingsOfTask, findingStandingWords } from "../findings.js";
+import { handoverLines, handoverNoteOf } from "../handover-note.js";
+import { html, joinHtml, postForm } from "../html.js";
+import { providerCaptures } from "../provider-capture.js";
+import { btn, disclose, field, input, note, textarea } from "./kit.js";
+const act = (taskHref, name, label, hidden = {}, variant = "outline") => postForm(`${taskHref}/follow-through`, joinHtml([
+    html `<input type="hidden" name="act" value="${name}">`,
+    ...Object.entries(hidden).map(([key, value]) => html `<input type="hidden" name="${key}" value="${String(value)}">`),
+    btn(label, { variant, type: "submit" }),
+]));
+function findingRow(one, taskHref, canAct) {
+    const answered = one.state === "accepted" || one.state === "rejected";
+    const closing = canAct && one.state !== "closed" ? disclose("Close it", postForm(`${taskHref}/follow-through`, joinHtml([
+        html `<input type="hidden" name="act" value="close"><input type="hidden" name="finding" value="${String(one.id)}">`,
+        field({ id: `finding-close-${one.id}`, label: "Why it can close", control: input({ id: `finding-close-${one.id}`, name: "note" }) }),
+        btn("Close finding", { variant: "outline", type: "submit" }),
+    ]))) : "";
+    return html `<li data-finding="${one.state}"><p>${findingLine(one)}</p><p class="meta">${findingStandingWords(one)}</p><p class="meta">From ${findingFromWords(one)}. Requested: ${one.action}</p>${canAct && answered ? act(taskHref, "resend", "Send it back", { finding: one.id }) : ""}${closing}</li>`;
+}
+function sendForm(taskHref) {
+    return disclose("Send a finding", postForm(`${taskHref}/follow-through`, joinHtml([
+        html `<input type="hidden" name="act" value="send">`,
+        field({ id: "finding-note", label: "What's wrong", control: textarea({ id: "finding-note", name: "note", rows: 3 }) }),
+        field({ id: "finding-file", label: "File, if there is one", control: input({ id: "finding-file", name: "file" }) }),
+        field({ id: "finding-line", label: "Line", control: input({ id: "finding-line", name: "line", type: "number" }) }),
+        btn("Send to the agent", { variant: "outline", type: "submit" }),
+    ])));
+}
+const captureRow = (one, taskHref, canAct) => html `<li><p class="meta">${one.provider}, build #${one.run}${one.label === null ? "" : `, marked ${one.label}`}</p><p class="mono">${one.text.slice(0, 500)}</p>${canAct && one.label === null ? joinHtml([act(taskHref, "mark", "Used-up plan", { capture: one.id, label: "exhausted" }), act(taskHref, "mark", "Something else", { capture: one.id, label: "not-exhausted" })]) : ""}</li>`;
+export function followThroughView(store, root, taskId, taskHref, canAct, now) {
+    const findings = findingsOfTask(store, taskId);
+    const open = findings.filter(one => one.state === "open" || one.state === "with-person").length;
+    const repairs = checkRepairsOfTask(store, taskId).filter(one => one.state !== "closed");
+    const pairs = evidencePairsOf(store, root, taskId, now);
+    const step = failingFirstOf(store, taskId);
+    const stepWords = failingFirstWords(step);
+    const hasRun = store.lookupRef(taskId) !== null && store.runsFor(store.lookupRef(taskId).id).some(one => one.role === "builder" && one.finishedAt !== null);
+    const family = store.taskFamilyOf(taskId, null, true);
+    const familyRuns = new Set((family?.versions.map(one => one.id) ?? [taskId]).flatMap(id => { const ref = store.lookupRef(id); return ref === null ? [] : store.runsFor(ref.id).map(run => run.id); }));
+    const captures = providerCaptures(store, null, 200).filter(one => familyRuns.has(one.run)).slice(0, 5);
+    const latestFailed = repairs.find(one => one.state !== "fixed");
+    const note1 = handoverNoteOf(store, root, taskId, now);
+    return {
+        findingCount: findings.length, openFindings: open,
+        findings: findings.length === 0 && !canAct ? "" : joinHtml([
+            findings.length === 0 ? "" : html `<ul class="result-changes">${findings.map(one => findingRow(one, taskHref, canAct))}</ul>`,
+            canAct ? sendForm(taskHref) : "",
+        ]),
+        repairs: repairs.length === 0 ? "" : html `<ul class="result-changes">${repairs.map(one => html `<li data-check-repair="${one.state}"><p>${checkRepairWords(one)}</p>${one.repairTask === null ? "" : html `<p class="meta"><a class="k-link" href="/t/${encodeURIComponent(one.repairTask)}">Open the repair</a></p>`}${canAct && one.repairTask === null && (one.state === "waiting" || one.state === "parked") ? act(taskHref, "repair", "Start a repair", { run: one.sourceRun }, "primary") : ""}</li>`)}</ul>`,
+        evidence: pairs.length === 0 && stepWords === null && captures.length === 0 && !(canAct && hasRun) ? "" : joinHtml([
+            pairs.length === 0 ? "" : html `<ul class="result-changes">${pairs.map(one => html `<li data-evidence="${one.reading}"><p>${evidenceWords(one)}</p><p class="meta"><a class="k-link" href="/r/${String(one.before.run)}">Before</a>${one.after === null ? "" : html ` · <a class="k-link" href="/r/${String(one.after.run)}">After</a>`}${one.before.screenshots.length + (one.after?.screenshots.length ?? 0) === 0 ? "" : ` · ${one.before.screenshots.length + (one.after?.screenshots.length ?? 0)} screenshots`}</p></li>`)}</ul>`,
+            stepWords === null ? "" : note(stepWords),
+            step?.output == null ? "" : html `<p class="mono">${step.output}</p>`,
+            canAct && hasRun ? html `<div class="k-acts">${joinHtml([
+                ...(latestFailed === undefined ? [] : [act(taskHref, "save-evidence", "Save the failing result", { run: latestFailed.sourceRun })]),
+                ...(pairs.length === 0 ? [] : [act(taskHref, "rerun-evidence", "Run the same check again")]),
+            ])}</div>` : "",
+            canAct ? act(taskHref, step === null ? "failing-first-on" : "failing-first-off", step === null ? "Ask for a failing test first" : "Turn off failing test first") : "",
+            captures.length === 0 ? "" : disclose("What the provider said", html `<ul class="result-changes">${captures.map(one => captureRow(one, taskHref, canAct))}</ul>`),
+        ]),
+        handover: note1 === null ? "" : html `<pre class="mono handover-note">${handoverLines(note1).join("\n")}</pre>`,
+    };
+}

package/dist/server/render-history.js

@@ -22,7 +22,7 @@ export function runPage(chrome, run, taskId, artifacts, terminal = null, notes =
         ? note(html `The live transcript is off. Start serve with <span class="k-mono">--runner &lt;name&gt;</span> naming this machine's worker, and it appears here.`)
         : run.provider !== "claude"
             ? note(`The live transcript needs the claude harness for now; this build runs on ${run.provider}.`)
-            : html `${note("Display only: this is not evidence, and the machine running the agent could alter it.")}<pre id="live-transcript" class="k-mono h-pre h-live"></pre><p class="k-note" id="live-transcript-state"></p>`);
+            : html `<pre id="live-transcript" class="k-mono h-pre h-live"></pre><p class="k-note" id="live-transcript-state"></p>`);
     // The live peek region (A2): the poller fills it only on a serve that asserted its runner; otherwise the section
     // says why it is empty, so the click never lands on silence.
     const peek = !running ? "" : sec("What is changing right now", peekable

package/dist/server/render-new-task.d.ts

@@ -1,6 +1,8 @@
 import type { QualityMode } from "../quality.js";
 import type { UnattendedPermissionMode } from "../scope.js";
 import { type Chrome, type Screen } from "./chrome.js";
+import type { Scope } from "../scope.js";
+import type { Store } from "../store.js";
 export type TaskComposerPrefill = {
     title: string;
     goal: string;
@@ -26,4 +28,27 @@ draft?: string | null,
 suggestions?: ReadonlyArray<{
     label: string;
     draft: string;
-}>): Screen;
+}>, 
+/** A link the lead or a person put in the address (GET ?from=). */
+fromLink?: string | null): Screen;
+/** The terms as label and words: the lines every approval surface reads (fast-terms.ts), with nothing hidden. */
+export declare function fastTermsRows(store: Store, scope: Scope, repo: string): ReadonlyArray<readonly [string, string]>;
+/** Build (docs/plans/plain-toolroll.md P2.4): the exact terms this small task would be approved on, and the one button
+ * that approves them. The fields of "Plan it first" are the person's own words, on the ordinary road. */
+export declare function fastStartPage(chrome: Chrome, input: {
+    title: string;
+    repo: string;
+    preview: string;
+    digest: string;
+    terms: ReadonlyArray<readonly [string, string]>;
+}): Screen;
+/** An issue or pull request, read and quoted before anything is filed. Add task files it for the ordinary approval. */
+export declare function importPage(chrome: Chrome, input: {
+    repo: string;
+    url: string;
+    title: string;
+    body: string;
+    kind: "issue" | "pull";
+    number: number;
+    head: string | null;
+}): Screen;

package/dist/server/render-new-task.js

@@ -7,7 +7,8 @@
 import { html, joinHtml, postForm } from "../html.js";
 import { projectName } from "../project.js";
 import { screen } from "./chrome.js";
-import { btn, composer, disclose, doc, docHeader, dock, field, ideas, input, note, phoneHeader, radios, select, sendButton, textarea, toggleChip } from "./kit.js";
+import { btn, composer, disclose, doc, docHeader, dock, facts, field, ideas, input, note, phoneHeader, radios, select, sendButton, textarea, toggleChip } from "./kit.js";
+import { fastTermsLines } from "../fast-terms.js";
 import { TASK_TEXT_LIMITS } from "../task-text.js";
 const FORM_ID = "nt-form";
 const PLAN_ON = "The agent reads the code and asks you anything unclear, then writes the plan.";
@@ -34,9 +35,11 @@ prefill = null,
 /** Words an idea's link put in the box (GET ?text=). */
 draft = null, 
 /** Ideas for the chosen project: one tap drafts the words into the box. */
-suggestions = []) {
-    const head = html `${phoneHeader("New task", { back: "/work" })}`;
-    const header = docHeader({ title: "New task", back: ["/work", "Tasks"], meta: "Nothing is built until you approve its plan.", same: true });
+suggestions = [], 
+/** A link the lead or a person put in the address (GET ?from=). */
+fromLink = null) {
+    const head = html `${phoneHeader("New task", { back: "/tasks" })}`;
+    const header = docHeader({ title: "New task", back: ["/tasks", "Tasks"], meta: "Nothing is built until you approve its plan.", same: true });
     const items = projectItems(projects, project);
     const values = prefill?.values;
     // No project to choose from: the task names its folder (the server proves it), and adding a project is one link away.
@@ -48,7 +51,7 @@ suggestions = []) {
     const permission = values?.get("permission-mode") === "bypassPermissions" ? "bypassPermissions" : values?.get("permission-mode") === "auto" ? "auto" : permissionDefault;
     const text = prefill?.title ?? draft ?? "";
     // More options opens on a template, or when a refused filing had used any of them.
-    const optionsUsed = prefill !== null && (values === undefined || ["goal", "acceptance", "not", "touches", "id", "after"].some(name => (values.get(name) ?? "") !== "") || values.get("scout") === "1");
+    const optionsUsed = fromLink !== null || prefill !== null && (values === undefined || ["from", "goal", "acceptance", "not", "touches", "id", "after"].some(name => (values.get(name) ?? "") !== "") || values.get("scout") === "1");
     const folder = !typed ? "" : field({ id: "nt-repo", label: "Project folder", hint: "No projects yet: name the folder of a git repository.",
         control: input({ id: "nt-repo", name: "repo", value: chosen, hint: true, attrs: { required: true, placeholder: "/path/to/repository", autocapitalize: "none", spellcheck: "false" } }) });
     const bar = joinHtml([
@@ -66,6 +69,7 @@ suggestions = []) {
         textAttrs: { maxlength: TASK_TEXT_LIMITS.title, autofocus: true },
     });
     const options = html `<div class="k-form">\
+${field({ id: "nt-from", label: "From an issue or PR (optional)", hint: "A github.com link in this project. Its text becomes the plan, and you approve it.", control: input({ id: "nt-from", name: "from", value: values?.get("from") ?? fromLink ?? "", attrs: { placeholder: "https://github.com/…", autocapitalize: "none", spellcheck: "false", inputmode: "url" } }) })}\
 ${field({ id: "nt-quality", label: "Checks", control: select({ id: "nt-quality", name: "quality-mode", items: [["default", "Default checks"], ["strict", "Strict (release)"]], current: quality, wide: true }) })}\
 ${candidates.length === 0 ? "" : field({ id: "nt-after", label: "Starts", control: select({ id: "nt-after", name: "after", wide: true, current: after,
             items: [["", "Right away"], ...candidates.map(one => [one.id, `After ${one.id}: ${one.title}`])] }) })}\
@@ -98,3 +102,24 @@ ${field({ id: "nt-id", label: "Task id (optional)", control: input({ id: "nt-id"
     const recipes = note(html `Work you do often? <a class="k-link" href="/recipes">Use a saved recipe</a>.`);
     return screen("New task", html `${head}${doc(header, form, ideaList, recipes)}${dock(btn("File task", { variant: "primary", type: "submit", attrs: { form: FORM_ID } }))}`, { chrome });
 }
+/** The terms as label and words: the lines every approval surface reads (fast-terms.ts), with nothing hidden. */
+export function fastTermsRows(store, scope, repo) {
+    return fastTermsLines(store, scope, repo).map(line => [line.label, line.words]);
+}
+/** Build (docs/plans/plain-toolroll.md P2.4): the exact terms this small task would be approved on, and the one button
+ * that approves them. The fields of "Plan it first" are the person's own words, on the ordinary road. */
+export function fastStartPage(chrome, input) {
+    const head = html `${phoneHeader("Build this?", { back: "/tasks/new" })}`;
+    const header = docHeader({ title: "Build this?", back: ["/tasks/new", "New task"], meta: "Build approves exactly these terms.", same: true });
+    const build = postForm("/tasks/fast", btn("Build", { variant: "primary", type: "submit" }), { attrs: { class: "k-form", id: "fast-build" }, hidden: { preview: input.preview, digest: input.digest } });
+    const plan = postForm("/tasks/add", btn("Plan it first", { type: "submit" }), { attrs: { class: "k-form" }, hidden: { plain: "1", title: input.title, repo: input.repo, "planning-policy": "choice", "plan-first": "1" } });
+    return screen("Build this?", html `${head}${doc(header, facts(input.terms.map(([label, words]) => [label, joinHtml(words.split("\n").map(line => html `<div>${line}</div>`))])), html `<div class="k-acts">${build}${plan}</div>`)}`, { chrome });
+}
+/** An issue or pull request, read and quoted before anything is filed. Add task files it for the ordinary approval. */
+export function importPage(chrome, input) {
+    const name = input.kind === "pull" ? `Pull request #${input.number}` : `Issue #${input.number}`;
+    const head = html `${phoneHeader(name, { back: "/tasks/new" })}`;
+    const header = docHeader({ title: name, back: ["/tasks/new", "New task"], meta: "Written outside Toolroll. You'll approve its plan before anything builds.", same: true });
+    const file = postForm("/tasks/add", btn("Add task", { variant: "primary", type: "submit" }), { attrs: { class: "k-form" }, hidden: { from: input.url, repo: input.repo, title: input.title, ...(input.head === null ? {} : { "from-head": input.head }), "from-read": "1" } });
+    return screen(name, html `${head}${doc(header, html `<blockquote class="k-quote"><p><strong>${input.title}</strong></p><p class="k-pre">${input.body === "" ? "No description." : input.body}</p></blockquote>`, file)}`, { chrome });
+}

package/dist/server/render-pages.d.ts

@@ -5,12 +5,10 @@ import { type AssignmentSnapshot } from "../assignment.js";
 import { type BoardCard } from "../board.js";
 import { type BrowserLimits } from "../browser-workspace.js";
 import { type DispatchDiagnosis } from "../dispatch.js";
-import { type FirstRunStep } from "../first-run.js";
 import { type Gap } from "../gaps.js";
 import { type parseBaseTreeSnapshot } from "../peek.js";
-import { type CriterionMatrixRow } from "../proof.js";
 import { type Runner } from "../runner.js";
-import { type Decision, type Incident, type RepairChainRow, type Run, type Store, type TaskState, type WorktreeRow } from "../store.js";
+import { type Decision, type Incident, type Run, type Store, type TaskState, type WorktreeRow } from "../store.js";
 import { tally } from "../summary.js";
 import { type WorkIndexGroup, type WorkIndexItem, type WorkIndexPage } from "../work-index.js";
 import { type ChipTone } from "../design/kit.js";
@@ -23,90 +21,6 @@ export declare const TASK_STATES: readonly TaskState[];
  * auto-refresh — approval links lead to the step-up screen, and a page
  * that might hold typed input never re-renders itself.
  */
-export type InboxTab = "needs-you" | "ready" | "running" | "all";
-export declare const INBOX_TABS: readonly {
-    id: InboxTab;
-    label: string;
-}[];
-export declare function parseInboxTab(raw: string | null): InboxTab | undefined;
-/** What each tab holds, as a short fingerprint: a tab is unread when its
- * fingerprint differs from the one this browser saw there last. */
-export declare function inboxFingerprints(data: Pick<Parameters<typeof inboxPage>[1], "decisions" | "approvals" | "requeueables" | "cancelledBlockers" | "gaps" | "needsVerification" | "ready" | "running">): Record<InboxTab, string>;
-export declare function inboxPage(chrome: Chrome, data: {
-    csrf: string;
-    revision: number;
-    /** No project open in scoped mode: every admitted project at once,
-     * chips on every row, links only — acting means opening the project. */
-    rollup: boolean;
-    /** A project is OPEN: only then do decisions answer on the card. The
-     * legacy unscoped projectless inbox stays links-only too (commit-1
-     * review, finding 4) — the partial belongs to a chosen project. */
-    interactive: boolean;
-    decisions: (Decision & {
-        taskId: string;
-        repo?: string | null;
-    })[];
-    approvals: {
-        taskId: string;
-        title: string;
-        goal: string;
-        proposedAt: string;
-        repo?: string | null; /** v48 authority repair: the closed consent door's title, or null when a yes could bind. */
-        closed?: string | null;
-    }[];
-    requeueables: {
-        taskId: string;
-        title: string;
-        state: TaskState;
-        strikes: number;
-        incidentCount: number;
-        repo?: string | null;
-    }[];
-    cancelledBlockers: {
-        blockerId: string;
-        dependentCount: number;
-        exampleDependent: string;
-        repo?: string | null;
-        blockerRepo?: string | null;
-    }[];
-    gaps: Gap[];
-    /** A completed task whose proof is short or refuted and not yet accepted
-     * (Priority 2) — reads "needs verification" here too, never silently
-     * "done" just because the inbox does not otherwise look at finished work. */
-    needsVerification: {
-        taskId: string;
-        title: string;
-        verdict: "short" | "refuted";
-        repo?: string | null;
-        matrix?: CriterionMatrixRow[];
-        repairChain?: RepairChainRow | null;
-    }[];
-    /** The first-run steps; null once the installation has had its first Ready result. */
-    wizard: FirstRunStep[] | null;
-    /** Whether any worker is answering right now — said at the top when none is. */
-    worker: {
-        answering: number;
-        registered: number;
-        lastHeard: string | null;
-    };
-    now: Date;
-    /** Console v2: the tab shown, results ready to review, work running now,
-     * and the tabs holding something this browser hasn't seen (dots on a phone). */
-    tab?: InboxTab;
-    ready?: {
-        taskId: string;
-        title: string;
-        detail: string;
-        repo: string | null;
-    }[];
-    running?: {
-        taskId: string;
-        title: string;
-        detail: string;
-        repo: string | null;
-    }[];
-    unread?: readonly InboxTab[];
-}): Screen;
 /** Start a builder: the one command, as text to select (/start-builder, where every "Connect a builder" leads, and
  * the Agents page). `project`: the open project's name, when the viewer may see it; `connected`: whether a builder
  * that may build there is checking in (null: say nothing); `managed`: whether this person can start one themselves
@@ -248,94 +162,6 @@ export type WorkbenchDone = {
     outcome: string | null;
     repo: string | null;
 };
-/**
- * The control-room rail (attended A1): every state that matters while a
- * person supervises, ordered by intervention cost. The project chip is
- * deliberately repeated on every row — a title is not a workspace, and
- * switching context must never depend on remembering which repo is open.
- */
-export declare function workbenchRail(data: {
-    attention: BoardCard[];
-    building: BoardCard[];
-    waiting: BoardCard[];
-    queued: BoardCard[];
-    done: WorkbenchDone[];
-    selected: string | null;
-    saturated: boolean;
-}): Html;
-/**
- * The portfolio overview (arc slice 1a): what waits on you, what the last
- * 24 hours of run starts amounted to, what is running, and the terminal-run
- * ledger — all of it across every admitted project, a project chip on every
- * row. The caller has already applied admission and per-row visibility.
- */
-export declare function portfolioOverview(data: {
-    attention: BoardCard[];
-    building: BoardCard[];
-    waiting: BoardCard[];
-    queued: BoardCard[];
-    done: WorkbenchDone[];
-    saturated: boolean;
-    decisions: (Decision & {
-        taskId: string;
-        repo?: string | null;
-    })[];
-    approvals: {
-        taskId: string;
-        title: string;
-        goal: string;
-        proposedAt: string;
-        repo?: string | null; /** v48 authority repair: the closed consent door's title, or null when a yes could bind. */
-        closed?: string | null;
-    }[];
-    requeueables: {
-        taskId: string;
-        title: string;
-        state: TaskState;
-        strikes: number;
-        incidentCount: number;
-        repo?: string | null;
-    }[];
-    cancelledBlockers: {
-        blockerId: string;
-        dependentCount: number;
-        exampleDependent: string;
-        repo?: string | null;
-        blockerRepo?: string | null;
-    }[];
-    gaps: Gap[];
-    gapsProject: string | null;
-    runs24: (Run & {
-        taskId: string;
-    })[];
-    live: {
-        taskId: string;
-        runner: string;
-        claimedAt: string;
-        expiresAt: string;
-        model: string | null;
-        repo: string | null;
-    }[];
-    ledger: {
-        runId: number;
-        taskId: string;
-        title: string;
-        repo: string | null;
-        outcome: string;
-        role: string;
-        provider: string | null;
-        model: string | null;
-        startedAt: string;
-        ranMinutes: number | null;
-        costUsd: number | null;
-        authMode: "subscription" | "api-key" | "agent-login" | null;
-        prNumber: number | null;
-        prUrl: string | null;
-    }[];
-    /** "" when there is no session token: then no form renders. postForm adds the field itself. */
-    csrf: string;
-    now: Date;
-}): Html;
 export type OnboardCardState = {
     enabled: false;
     why: string;