toolroll 0.9.92 → 0.9.94

package/dist/server/pages.js

@@ -52,14 +52,21 @@ import { refuse, regionScript, relativeAge as relativeAgeOf, screen, settingsRow
 import { redirect, respond, safeReturn, SAFETY, taskHref } from "./http.js";
 import { assignmentOf } from "../assignment.js";
 import { assignmentTaskStatusOf } from "../assignment-presentation.js";
-import { githubIdentityOf, homePage, portfolioOverview, startBuilderHtml, workbenchRail } from "./render-pages.js";
+import { githubIdentityOf, homePage, startBuilderHtml } from "./render-pages.js";
+import { retiredRedirect } from "./retired-routes.js";
+import { codeMapStatus, openMap } from "../code-map-read.js";
+import { requestRefresh } from "../code-map-store.js";
+import { codeMapReport } from "../code-map-report.js";
+import { codeMapPage, codeMapReportBlock } from "./render-code-map.js";
+import { FLAKY_WINDOW_DAYS, flakyList, flakyShow } from "../flaky.js";
+import { flakyPage, flakyRowPage } from "./render-flaky.js";
 import { browsePage, githubReposPage, projectHref, projectPage, projectsPage, unknownProject } from "./render-projects.js";
 import { notFound as kitNotFound } from "./kit.js";
 import {} from "./render-pages.js";
 import {} from "../project-outcomes.js";
 import { CHECK_LEVEL_WORDS } from "../check-levels.js";
 import { capsPage } from "./render-settings.js";
-import { decisionAnswerScript, taskBody } from "./render-tasks.js";
+import { consentDoorOf, decisionAnswerScript, taskBody } from "./render-tasks.js";
 import {} from "./session.js";
 import { rereadBrowser } from "./live.js";
 import { homeView } from "./home.js";
@@ -185,16 +192,21 @@ export function createPagesHandlers(runtime) {
     async function homeRedirect(ctx) {
         const { who, response, now, project } = ctx;
         if (who.via !== "cookie" || restricted())
-            return redirect(response, "/work");
+            return redirect(response, "/tasks");
         if (firstRunStepsNow(now) !== null && !store.hasAnyWork())
             return redirect(response, "/chat");
         // One scope for the page and the chrome around it: the project its address names (proved by the router), else all.
         const chrome = chromeFor(project, "none");
         const projects = chrome.projects ?? [];
-        const view = { ...homeView({ store, now, access: workAccess(), evidenceRoot, project, projects, chat: chrome.chat === true, canAnswer: who.role === "approver" }),
+        const closedDoor = (taskId) => {
+            const scope = store.getScope(taskId);
+            const door = consentDoorOf(scope, runtime.routeViewOf(taskId, store.lookupRef(taskId), scope, now, who));
+            return door.open ? null : door;
+        };
+        const view = { ...homeView({ store, now, access: workAccess(), evidenceRoot, project, projects, chat: chrome.chat === true, canAnswer: who.role === "approver", closedDoor }),
             // Until the first result: the welcome's three steps stay one link away.
             setup: firstRunStepsNow(now) !== null ? "/welcome" : null };
-        return sendScreen(response, 200, screen("Home", html `<div data-kit-page><h1>Home</h1><p>${view.say}</p><p><a href="/work">Tasks</a></p></div>`, { chrome, workspace: { view } }));
+        return sendScreen(response, 200, screen("Home", html `<div data-kit-page><h1>Home</h1><p>${view.say}</p><p><a href="/tasks">Tasks</a></p></div>`, { chrome, workspace: { view } }));
     }
     // Search (UI revamp wave B): the ⌘K menu's "See all results". The places come from the page; the tasks here are the
     // most recent ones in view (live and archived), matched on their title and id. Reads only.
@@ -227,76 +239,6 @@ export function createPagesHandlers(runtime) {
         response.end();
         return;
     }
-    async function workbench(ctx) {
-        const { url, who, response, now, project } = ctx;
-        // The fleet under one gaze (attended A1): the rail rolls up the whole
-        // ceiling regardless of the open project — watching is cross-project
-        // by nature; acting happens on task screens that re-prove everything.
-        const admission = admissionList();
-        const snapshot = store.boardScoped(null, now, 200, admission);
-        const rows = snapshot.tasks.filter(facts => facts.repo === null || visible(facts.repo));
-        const cards = rows.map(facts => classify(facts.blockerRepo !== null && !visible(facts.blockerRepo) ? { ...facts, blockerState: null } : facts, now));
-        const attention = cards.filter(card => card.lane === "attention").slice(0, 100);
-        const building = cards.filter(card => card.lane === "building");
-        const waiting = cards.filter(card => card.lane === "waiting");
-        const queued = cards.filter(card => card.lane === "queued");
-        const done = snapshot.done
-            .filter(one => one.repo === null || visible(one.repo))
-            .slice(0, 5)
-            .map(one => ({ taskId: one.taskId, title: one.title, outcome: one.outcome, repo: one.repo }));
-        const selected = url.searchParams.get("t");
-        const rail = workbenchRail({ attention, building, waiting, queued, done, selected, saturated: snapshot.saturated });
-        if (url.searchParams.get("fragment") === "rail") {
-            // The rail alone: same auth, same ceiling, no shell, no scripts.
-            return respond(response, 200, "text/html; charset=utf-8", rail);
-        }
-        // The portfolio overview (arc slice 1a). All-scope hygiene throughout:
-        // admission binds inside every bounded SQL read, and every unlimited
-        // feed's rows pass visible() BEFORE they render or tally — a hidden
-        // project must not leak into a row, a count, or a dollar.
-        const sinceIso = new Date(now.getTime() - 24 * 3_600_000).toISOString();
-        const decisions = store
-            .listDecisionsScoped(null)
-            .filter(one => visible(one.repo ?? null))
-            .slice(0, 10);
-        const approvals = store.scopesAwaitingApproval(null, 10, admission).filter(one => visible(one.repo ?? null));
-        const requeueables = store.listRequeueablesScoped(null, now, 10, admission).filter(one => visible(one.repo ?? null));
-        const cancelledBlockers = store
-            .listCancelledBlockersScoped(null, 10, admission)
-            .filter(one => visible(one.repo ?? null) && visible(one.blockerRepo ?? null));
-        const runs24 = store.runsSinceScoped(sinceIso, null).filter(run => visible(taskRepoOf(run.taskRef)));
-        const live = store.liveClaims(null, now).filter(one => visible(one.repo));
-        const ledger = store
-            .portfolioLedgerScoped(null, sinceIso, 30, admission)
-            .filter(row => visible(row.repo));
-        // Gaps stay project-relative (the roll-up inbox's rule): computed for
-        // the OPEN project only — there is no scope-safe road to another
-        // project's /caps.
-        const gaps = project === null ? [] : computeGaps(store, project, now).filter(gap => gap.unblocks.length > 0).slice(0, 10);
-        const csrf = who.via === "cookie" ? who.session.csrf : "";
-        let detail = html `${portfolioOverview({
-            attention, building, waiting, queued, done, saturated: snapshot.saturated,
-            decisions, approvals, requeueables, cancelledBlockers, gaps,
-            gapsProject: project, runs24, live, ledger, csrf, now,
-        })}<div class="workbench-mobile-rail">${rail}</div>`;
-        if (selected !== null) {
-            const view = taskViewData(selected, who, null);
-            detail = view === null
-                ? html `<p class="workbench-mobile-back"><a href="/workbench">← all work</a></p><div class="card"><p class="meta">No such task — it may have been outside this console's view</p></div>`
-                : html `<p class="workbench-mobile-back"><a href="/workbench">← all work</a></p>${taskBody({ ...view, degraded: "pane" })}`;
-        }
-        return sendScreen(response, 200, screen("portfolio", detail, {
-            chrome: chromeFor(project, "workbench", html `<div id="wb-rail">${rail}</div><p class="meta" id="wb-rail-stamp"></p>`, "all"),
-            functional: {
-                // The decision enhancement rides ONLY the overview: a selected
-                // task's pane may carry a password ceremony, and sensitive
-                // pages gain no new scripts (commit-1 review, finding 1).
-                script: regionScript("wb-rail", "rail") +
-                    (selected === null && decisions.length > 0 ? decisionAnswerScript() : ""),
-                fetches: true,
-            },
-        }));
-    }
     async function ledgerPage(ctx) {
         const { url, who, response, now } = ctx;
         const admitted = admissionList();
@@ -971,11 +913,12 @@ export function createPagesHandlers(runtime) {
      * switches the session's project; its Open project button posts to /projects/select, which proves it again. The
      * name is found among the projects this person may open (projectsSelect's rule: visible here and inside the
      * ceiling); a name it can't see answers exactly like one that doesn't exist. */
-    async function projectPageHandler(ctx) {
-        const { url, who, response, now } = ctx;
+    async function projectFound(ctx, page) {
+        const { url, who, response } = ctx;
         let name = "";
+        const tail = page === "" ? "" : `/${page}`;
         try {
-            name = decodeURIComponent(url.pathname.slice("/projects/".length));
+            name = decodeURIComponent(url.pathname.slice("/projects/".length, url.pathname.length - tail.length));
         }
         catch {
             name = "";
@@ -988,8 +931,37 @@ export function createPagesHandlers(runtime) {
         const open = who.via === "cookie" ? who.session.project : null;
         if (found === null || !(await authorizedProject(liveCeiling(), found.path))) {
             const words = unknownProject(name === "" ? "by that name" : name);
-            return sendScreen(response, 404, screen("Not found", kitNotFound(url.pathname, words), { chrome: chromeFor(open, "projects") }));
+            await sendScreen(response, 404, screen("Not found", kitNotFound(url.pathname, words), { chrome: chromeFor(open, "projects") }));
+            return null;
         }
+        return { ...found, ambiguous: named.length > 1 };
+    }
+    /** A project's flaky tests list and one row's history. Reads only; found exactly as the project's page is. */
+    async function projectFlakyHandler(ctx) {
+        const { url, who, response, now } = ctx;
+        const found = await projectFound(ctx, "flaky");
+        if (found === null)
+            return;
+        const open = who.via === "cookie" ? who.session.project : null;
+        const chrome = chromeFor(open, "projects");
+        const back = projectHref(found.name, found.path, found.ambiguous);
+        const selfHref = projectHref(found.name, found.path, found.ambiguous, "flaky");
+        const key = url.searchParams.get("row");
+        if (key !== null) {
+            const shown = flakyShow(store, found.path, key, now);
+            if (shown === null)
+                return sendScreen(response, 404, screen("Not found", kitNotFound(url.pathname, { title: "Nothing is recorded for that test in this project." }), { chrome }));
+            return sendScreen(response, 200, flakyRowPage(chrome, { name: found.name, repo: found.path, back: selfHref, row: shown.row, history: shown.history, now }));
+        }
+        const days = Number(url.searchParams.get("days") ?? FLAKY_WINDOW_DAYS);
+        return sendScreen(response, 200, flakyPage(chrome, { name: found.name, repo: found.path, back, selfHref, list: flakyList(store, found.path, now, days), now }));
+    }
+    async function projectPageHandler(ctx) {
+        const { who, response, now } = ctx;
+        const found = await projectFound(ctx, "");
+        if (found === null)
+            return;
+        const open = who.via === "cookie" ? who.session.project : null;
         const path = found.path;
         // The tasks that wait on this person or run, from the board's own classification, scoped to this one project.
         const snapshot = store.boardScoped(path, now, 200, null);
@@ -1009,15 +981,61 @@ export function createPagesHandlers(runtime) {
             }
         }
         return sendScreen(response, 200, projectPage(chromeFor(open, "projects"), {
-            name: found.name, path, selfHref: projectHref(found.name, path, named.length > 1), open: open === path, openedAt: found.openedAt,
+            name: found.name, path, selfHref: projectHref(found.name, path, found.ambiguous), open: open === path, openedAt: found.openedAt,
             peek: peekOf(path, now), tasks, moreTasks: Math.max(0, cards.length - tasks.length),
             checks: cookie ? { href: `/settings/checks?repo=${encodeURIComponent(path)}`, level: CHECK_LEVEL_WORDS[projectCheckLevel(store, path).level] } : null,
             pullRequests: cookie ? { href: `/settings/pull-requests?repo=${encodeURIComponent(path)}`, on: publishingOf(store, path).on } : null,
             knowledgeHref: `/settings/knowledge?repo=${encodeURIComponent(path)}`,
+            flakyHref: projectHref(found.name, path, found.ambiguous, "flaky"),
             settingsHref: restricted() ? null : `/settings/project?repo=${encodeURIComponent(path)}`,
             activity, now,
         }));
     }
+    /** The named project's code map address, for this account; null when it isn't one they can see. */
+    async function mapProject(ctx, suffix) {
+        let name = "";
+        try {
+            name = decodeURIComponent(ctx.url.pathname.slice("/projects/".length, -suffix.length));
+        }
+        catch {
+            return null;
+        }
+        const { recent, candidates } = visibleProjects();
+        const named = [...recent.map(one => ({ path: one.path, name: one.name })), ...candidates.map(path => ({ path, name: projectName(path) }))].filter(one => one.name === name);
+        const asked = ctx.url.searchParams.get("path") ?? ctx.posted.get("repo");
+        const found = asked !== null ? named.find(one => one.path === asked) ?? null : named.length === 1 ? named[0] : null;
+        if (found === null || !(await authorizedProject(liveCeiling(), found.path)))
+            return null;
+        return { name: found.name, path: found.path, base: `/projects/${encodeURIComponent(found.name)}/map`, selfHref: projectHref(found.name, found.path, named.length > 1) };
+    }
+    async function codeMapHandler(ctx) {
+        const { url, who, response, now } = ctx;
+        const open = who.via === "cookie" ? who.session.project : null;
+        const found = await mapProject(ctx, "/map");
+        if (found === null)
+            return sendScreen(response, 404, screen("Not found", kitNotFound(url.pathname, unknownProject("by that name")), { chrome: chromeFor(open, "projects") }));
+        const asked = url.searchParams.get("v");
+        const pinned = asked !== null && /^[1-9][0-9]{0,14}$/.test(asked) ? Number(asked) : undefined;
+        const status = codeMapStatus(store, found.path, now, iso => new Date(iso).toISOString().slice(11, 16));
+        const opened = status.state === "off" || status.state === "not-available" ? null : openMap(store, found.path, pinned);
+        const held = opened !== null && opened.ok ? opened : null;
+        const repoed = opened !== null && !opened.ok && pinned !== undefined ? openMap(store, found.path) : null;
+        const map = held ?? (repoed !== null && repoed.ok ? repoed : null);
+        const canRefresh = who.via === "cookie" && who.authority !== "local-owner" && store.accountOf(who.name)?.role === "approver" && store.accountCanAccess(who.name, found.path);
+        return sendScreen(response, 200, codeMapPage(chromeFor(open, "projects"), {
+            name: found.name, repo: found.path, base: found.base, selfHref: found.selfHref, status, map: map?.map ?? null, versionId: map?.version.id ?? null, remoteUrl: store.projectRemote(found.path),
+            q: url.searchParams.get("q"), area: url.searchParams.get("area"), file: url.searchParams.get("file"), canRefresh, now, report: codeMapReportBlock(codeMapReport(store, found.path, now)),
+            said: url.searchParams.get("said"), problem: repoed !== null ? "The map changed. Showing the current one." : url.searchParams.get("problem"),
+        }));
+    }
+    async function codeMapRefreshHandler(ctx) {
+        const { response, who, now } = ctx;
+        const found = await mapProject(ctx, "/map/refresh");
+        if (found === null || !store.accountCanAccess(who.name, found.path))
+            return refuse(response, who, 403, "That project is outside your access.", "/projects");
+        const said = requestRefresh(store, found.path, who.name, now);
+        return redirect(response, `${found.base}?said=${encodeURIComponent(said === "queued" ? "Queued. Main is checked on the next pass." : "Already queued.")}`);
+    }
     async function instanceEdge(ctx) {
         const { request, response, url } = ctx;
         const secret = options.instanceSecret?.() ?? null;
@@ -1135,7 +1153,7 @@ export function createPagesHandlers(runtime) {
         const taskId = url.searchParams.get("task");
         const ref = taskId === null ? null : store.lookupRef(taskId.slice(0, 200));
         if (taskId !== null && (ref === null || ref.repo === null || !visible(ref.repo)))
-            return refuse(response, who, 404, "That task is not available.", "/work");
+            return refuse(response, who, 404, "That task is not available.", "/tasks");
         const shown = ref !== null ? ref.repo : project !== null && visible(project) ? project : null;
         const connected = shown === null ? null : buildersFor(store, shown, now, ref?.assignedRunner ?? null).alive.length > 0;
         return sendScreen(response, 200, screen("Start a builder", startBuilderHtml({
@@ -1148,10 +1166,13 @@ export function createPagesHandlers(runtime) {
         "projects.github-list": projectsGithubList,
         "projects.page": projectsIndex,
         "projects.project": projectPageHandler,
+        "projects.map": codeMapHandler,
+        "projects.map-refresh": codeMapRefreshHandler,
+        "projects.flaky": projectFlakyHandler,
         "home": homeRedirect,
         "search": searchPage,
         "morning": morningAlias,
-        "workbench": workbench,
+        "workbench": async (ctx) => retiredRedirect("workbench", ctx.url, ctx.response),
         "ledger": ledgerPage,
         "activity": activityPage,
         "system": systemScreen,

package/dist/server/render-chat.js

@@ -209,7 +209,7 @@ export function chatFleetOverview(snapshot, projects, interactive) {
     const briefing = "Brief me on what needs my attention, what is building, and the highest-leverage next action across every project.";
     return html `<section class="card chat-overview" aria-label="live portfolio overview" data-card-kind="fleet-overview"><div class="chat-overview-head"><h2>${projects.length} project${projects.length === 1 ? "" : "s"}</h2>${interactive
         ? postForm("/chat", html `<button type="submit" name="message" value="${briefing}" class="quiet">Brief me</button>`, { attrs: { class: "inline" } })
-        : html `<a href="/board?scope=all" class="chat-overview-link">open board</a>`}</div><div class="chat-overview-stats"><a href="/work?view=needs-you" class="chat-overview-stat attention"><b>${needsYou}${snapshot.attentionCount?.saturated ? "+" : ""}</b><span>need you</span></a><a href="/board?scope=all" class="chat-overview-stat live"><b>${running}</b><span>building</span></a><a href="/board?scope=all&amp;view=order" class="chat-overview-stat"><b>${queued}</b><span>queued</span></a><a href="/work" class="chat-overview-stat"><b>${done}</b><span>finished today</span></a></div>${rows.length === 0 ? html `<p class="chat-overview-clear">${needsYou === 0 && running === 0 ? html `<span class="dot dot-ok"></span>No tasks are waiting and no builds are running.` : html `<a href="/work">Open Tasks to inspect current work.</a>`}</p>` : html `<div class="chat-overview-items">${rows}</div>`}${completedWorkHtml(snapshot, projects.map(project => project.label), snapshot.assignmentStates)}${saturated ? html `<p class="meta chat-overview-note">Some items aren’t shown. Open Work to see more.</p>` : ""}</section>`;
+        : html `<a href="/tasks?view=board&scope=all" class="chat-overview-link">open board</a>`}</div><div class="chat-overview-stats"><a href="/tasks?view=needs-you" class="chat-overview-stat attention"><b>${needsYou}${snapshot.attentionCount?.saturated ? "+" : ""}</b><span>need you</span></a><a href="/board?scope=all" class="chat-overview-stat live"><b>${running}</b><span>building</span></a><a href="/board?scope=all&amp;view=order" class="chat-overview-stat"><b>${queued}</b><span>queued</span></a><a href="/tasks" class="chat-overview-stat"><b>${done}</b><span>finished today</span></a></div>${rows.length === 0 ? html `<p class="chat-overview-clear">${needsYou === 0 && running === 0 ? html `<span class="dot dot-ok"></span>No tasks are waiting and no builds are running.` : html `<a href="/tasks">Open Tasks to inspect current work.</a>`}</p>` : html `<div class="chat-overview-items">${rows}</div>`}${completedWorkHtml(snapshot, projects.map(project => project.label), snapshot.assignmentStates)}${saturated ? html `<p class="meta chat-overview-note">Some items aren’t shown. Open Work to see more.</p>` : ""}</section>`;
 }
 /**
  * The lead's project rail: one bounded pulse per admitted project, plus
@@ -560,7 +560,7 @@ export function proposalCardParts(view, inert, decision, returnTo = null) {
             icon: html `<path d="M14.7 6.3a4 4 0 0 0-5 5L4 17l3 3 5.7-5.7a4 4 0 0 0 5-5l-2.4 2.4-3-3z"/>`,
         },
         agents: { label: "Agents change", action: "change agents", icon: html `<circle cx="12" cy="12" r="3"/><path d="M12 2v3"/><path d="M12 19v3"/><path d="m4.9 4.9 2.2 2.2"/><path d="m16.9 16.9 2.2 2.2"/><path d="M2 12h3"/><path d="M19 12h3"/><path d="m4.9 19.1 2.2-2.2"/><path d="m16.9 7.1 2.2-2.2"/>` },
-        review: { label: text("operation") === "revise" ? "Changes to make" : "Note for later", action: text("operation") === "revise" ? "Request changes" : "Save for later", icon: html `<path d="M4 5h16v12H8l-4 3z"/>` },
+        review: { label: text("operation") === "revise" ? "Changes to make" : "Note for later", action: text("operation") === "revise" ? "Send back" : "Save for later", icon: html `<path d="M4 5h16v12H8l-4 3z"/>` },
         control: { label: "Open control", action: "Open", icon: html `<path d="M5 12h14m-6-6 6 6-6 6"/>` },
         action: { label: text("title") || "Review action", action: sharedActionPayload(payload) ? CHAT_ACTIONS[sharedActionPayload(payload).operation].label : "Unavailable", icon: html `<path d="M5 12h14m-6-6 6 6-6 6"/>` },
         task_action: { label: payload["operation"] === "stop" ? "Stop task?" : payload["operation"] === "resume" ? "Resume task?" : "Task update", action: isChatTaskAction(payload["operation"]) ? CHAT_TASK_ACTIONS[payload["operation"]].label : "Unavailable", icon: html `<path d="M5 12h14m-6-6 6 6-6 6"/>` },

package/dist/server/render-code-map.d.ts

@@ -0,0 +1,30 @@
+import { type MapStatus } from "../code-map-read.js";
+import { type CodeMapReport } from "../code-map-report.js";
+import type { CodeMap } from "../code-map-shape.js";
+import { type Html } from "../html.js";
+import { type Chrome, type Screen } from "./chrome.js";
+export declare const LIMITS_WORDS: {
+    readonly system: "Limits enforced by the system.";
+    readonly checked: "Limits checked by Toolroll every 250 ms.";
+};
+export type CodeMapPage = {
+    name: string;
+    repo: string;
+    base: string;
+    selfHref: string;
+    status: MapStatus;
+    map: CodeMap | null;
+    versionId: number | null;
+    remoteUrl: string | null;
+    q: string | null;
+    area: string | null;
+    file: string | null;
+    canRefresh: boolean;
+    said: string | null;
+    problem: string | null;
+    now: Date;
+    report: Html | null;
+};
+/** "Builds with and without the map": read by people; nothing switches on it. */
+export declare function codeMapReportBlock(report: CodeMapReport): Html | null;
+export declare function codeMapPage(chrome: Chrome, data: CodeMapPage): Screen;

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-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;