toolroll 0.9.85 → 0.9.87

package/dist/server/pages.js

@@ -4,6 +4,7 @@ import { canReveal, cdCommandOf, localCheckoutOf } from "../checkout-proof.js";
 import { instanceHttpAnswer } from "../console-instance.js";
 import { handlersOf } from './handler-registry.js';
 import { html, joinHtml, postForm, reauth } from "../html.js";
+import * as kit from "./kit.js";
 /** pages handlers, moved without changing their route bodies. */
 import { createHmac, randomBytes } from "node:crypto";
 import { realpathSync } from "node:fs";
@@ -15,7 +16,6 @@ import { listFolder, localOrigins } from "../folder-look.js";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { setImmediate as yieldEventLoop } from "node:timers/promises";
-import { INSTALLATION_SCOPE, resolvePhaseAgent } from "../agentconfig.js";
 import { parseApiToken, tokenLive } from "../api-tokens.js";
 import { classify } from "../board.js";
 import { serveBrowserAsset } from '../browser-shell.js';
@@ -27,7 +27,8 @@ import { run as execRun } from "../exec.js";
 import { computeGaps } from "../gaps.js";
 import { LEDGER_CSV_HEADER, ledgerCsvRows } from "../ledger-csv.js";
 import { ledgerBody } from "../ledger-view.js";
-import { agentLanesOf, agentRowOf, agentsBoardOf, agentFactsFor, laneWindowOf, sealedDiffOf } from "../agents-board.js";
+import { agentRowOf, agentsListOf, agentFactsFor, sealedDiffOf } from "../agents-board.js";
+import { computersOf, phasesOf, systemOf } from "./agents-computers.js";
 import { markAgentSeen } from "../agent-board.js";
 import { agentsLiveOf } from "../agents-live.js";
 import { readChildWindow } from "../live-children-read.js";
@@ -48,17 +49,24 @@ import { serveInstallAsset } from "./pages-assets.js";
 import { healthz } from "./remote-hooks.js";
 import { slowRequestLines, SLOW_REQUEST_MS } from "../latency-timeline.js";
 import { leadsStillAdmitted, leadTilesFor } from './agents-live-lead.js';
-import { refuse, regionScript, screen, settingsRows, WORKSPACE_STYLE, workToolRows } from "./chrome.js";
+import { refuse, regionScript, relativeAge as relativeAgeOf, screen, settingsRows, WORKSPACE_STYLE, workToolRows } from "./chrome.js";
 import { redirect, respond, safeReturn, SAFETY, taskHref } from "./http.js";
 import { assignmentOf } from "../assignment.js";
 import { assignmentTaskStatusOf } from "../assignment-presentation.js";
-import { browsePage, fleetBody, fleetScript, githubIdentityOf, githubReposPage, homePage, portfolioOverview, projectsPage, startBuilderHtml, systemPage, workbenchRail } from "./render-pages.js";
+import { githubIdentityOf, homePage, portfolioOverview, startBuilderHtml, workbenchRail } from "./render-pages.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 {} from "./session.js";
 import { rereadBrowser } from "./live.js";
+import { homeView } from "./home.js";
+import { workIndexPage } from "../work-index.js";
 export function createPagesHandlers(runtime) {
-    const { identities, clock, lastChecks, store, visible, consoleProjects, restricted, ceiling, options, projectFamilyPeek, sendScreen, chromeFor, unscopedMode, admissionList, taskRepoOf, taskViewData, runVisible, evidenceRoot, workAccess, identify, liveCeiling, sessions, deletedRepos, authenticateApprover, authenticateCredential, projectOf, lookupSession } = runtime;
+    const { identities, clock, lastChecks, store, visible, consoleProjects, restricted, ceiling, options, projectFamilyPeek, sendScreen, chromeFor, unscopedMode, admissionList, taskRepoOf, taskViewData, runVisible, evidenceRoot, workAccess, identify, liveCeiling, sessions, deletedRepos, authenticateApprover, authenticateCredential, projectOf, lookupSession, firstRunStepsNow } = runtime;
     // The filesystem browser (operator request): pick a project folder by
     // looking, not typing. CONFINED to exactly what opening allows —
     // explicit --repo mode has an enumerable list and gets no browser at
@@ -98,14 +106,14 @@ export function createPagesHandlers(runtime) {
             .slice(0, 200);
         const root = browseRoots.find(one => canonical === one || canonical.startsWith(`${one}/`));
         const parent = canonical === root ? null : canonical.slice(0, canonical.lastIndexOf("/")) || root;
-        const csrf = who.session.csrf;
+        const registered = new Set(store.listProjects().filter(one => visible(one.path)).map(one => one.path));
         return sendScreen(response, 200, browsePage(chromeFor(who.session.project, "projects"), {
             at: canonical,
             root,
             roots: browseRoots,
             parent,
             entries,
-            csrf,
+            registered,
         }));
     }
     // The signed-in gh account's repositories, OFFERED instead of typed
@@ -155,10 +163,10 @@ export function createPagesHandlers(runtime) {
             listed,
             local: localByIdentity,
             registered,
-            csrf: who.via === "cookie" ? who.session.csrf : "",
             cloneReady: ceiling.roots.length > 0,
             openProject: who.via === "cookie" ? who.session.project ?? null : null,
             localUnanswered,
+            now: clock(),
         }));
     }
     // List repositories / Refresh list: ask the GitHub CLI signed in on this machine, then show the page.
@@ -171,17 +179,50 @@ export function createPagesHandlers(runtime) {
     }
     async function projectsIndex(ctx) {
         const { url, who, response } = ctx;
-        return void projectsScreen(response, who, url.searchParams.get("said"), 200, safeReturn(url.searchParams.get("return")));
+        return void projectsScreen(response, who, url.searchParams.get("said"), 200, safeReturn(url.searchParams.get("return")), "said");
     }
+    // Home (UI revamp wave B): what needs this person, four counts that agree with the Tasks filters, and the lead's box.
+    // A token or a restricted session keeps landing on Tasks; a first run with nothing filed yet keeps its checklist in the chat.
     async function homeRedirect(ctx) {
-        const { who, response } = ctx;
-        return redirect(response, who.via === "cookie" && !restricted() ? "/chat" : "/work");
+        const { who, response, now, project } = ctx;
+        if (who.via !== "cookie" || restricted())
+            return redirect(response, "/work");
+        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" });
+        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 } }));
+    }
+    // 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.
+    async function searchPage(ctx) {
+        const { url, response, now } = ctx;
+        const q = (url.searchParams.get("q") ?? "").replace(/[\p{Cc}\p{Cf}]/gu, " ").trim().slice(0, 200);
+        const words = q.toLowerCase().split(/\s+/).filter(Boolean);
+        const access = workAccess();
+        const live = workIndexPage(store, now, access, { view: "all", limit: 100, root: evidenceRoot });
+        const archived = workIndexPage(store, now, access, { view: "archived", limit: 40, root: evidenceRoot });
+        const multi = new Set(live.items.map(one => one.repo ?? "")).size > 1;
+        const tasks = words.length === 0 ? [] : [...live.items, ...archived.items]
+            .filter(one => words.every(word => `${one.title} ${one.rootId}`.toLowerCase().includes(word)))
+            .slice(0, 60)
+            .map(one => {
+            const waits = one.status.views.includes("needs-you");
+            const tone = one.archived !== undefined ? "" : waits ? "needs"
+                : { attention: "needs", ready: "needs", live: "live", done: "done", problem: "failed", muted: "", neutral: "" }[one.status.tone];
+            return { id: one.rootId, title: one.title, href: taskHref(one.rootId), project: multi || one.repo === null ? (one.repo === null ? "Unplaced" : projectName(one.repo)) : null,
+                age: relativeAgeOf(one.archived?.at ?? one.updatedAt, now), chip: { word: one.archived !== undefined ? "Archived" : waits ? "Needs you" : one.status.label, tone }, archived: one.archived !== undefined };
+        });
+        const view = { kind: "search", q, tasks, truncated: live.nextCursor !== null || archived.nextCursor !== null };
+        return sendScreen(response, 200, screen("Search", html `<div data-kit-page><h1>Search</h1><form action="/search"><input type="search" name="q" value="${q}" aria-label="Search"></form></div>`, { chrome: chromeFor(null, "none"), workspace: { view } }));
     }
     // The board's old name; bookmarks keep working. A GET-only alias, so a
     // plain 302 — never the shared 303 helper, which belongs to POST landings.
     async function morningAlias(ctx) {
         const { response } = ctx;
-        response.writeHead(302, { ...SAFETY, Location: "/activity" });
+        response.writeHead(302, { ...SAFETY, Location: "/" });
         response.end();
         return;
     }
@@ -309,70 +350,24 @@ export function createPagesHandlers(runtime) {
         const rows = store.actionLedger({ ...query, ...(before === null ? {} : { before: Number(before) }), limit: 51 });
         if (url.searchParams.get("format") === "json")
             return respond(response, 200, "application/json; charset=utf-8", JSON.stringify(checkResponse("ledgerPage", { chain: { ok: report.ok, entries: report.entries, through: report.through, head: report.head, problem: report.problem }, entries: rows.slice(0, 50), nextBefore: rows.length > 50 ? rows[49].id : null })));
-        return sendScreen(response, 200, screen("Action ledger", ledgerBody(rows, projects, url.searchParams, chainView), { chrome: chromeFor(chosen === "" ? null : chosen, "ledger", undefined, chosen === "" ? "all" : "project") }));
+        return sendScreen(response, 200, screen("Audit log", ledgerBody(rows, projects, url.searchParams, chainView), { chrome: chromeFor(chosen === "" ? null : chosen, "ledger", undefined, chosen === "" ? "all" : "project") }));
     }
+    // The activity summary lives on Home now (UI revamp wave B); the old address keeps answering, as a GET alias.
     async function activityPage(ctx) {
-        const { who, response, now, project } = ctx;
-        const since = new Date(now.getTime() - 24 * 60 * 60_000).toISOString();
-        return sendScreen(response, 200, homePage(chromeFor(project, "runs"), {
-            csrf: who.via === "cookie" ? who.session.csrf : "",
-            taskCount: store.listTasksScoped(project, undefined, 1, null).length,
-            repo: project,
-            summary: tally(store.runsSinceScoped(since, project)),
-            decisions: store.listDecisionsScoped(project),
-            incidents: store.openIncidents(project),
-            stranded: store.strandedTasks(project),
-            gaps: project === null ? null : computeGaps(store, project, now),
-            // Rows that want a person, plus task updates the live pairing failed to send (never quiet progress).
-            outboxPending: store.pendingForAttention().length,
-            settings: options.telegramTokenFile !== undefined,
-            building: store.liveClaims(project, now),
-            runners: store.listRunners(),
-            worktrees: store
-                .listWorktrees()
-                .filter(one => project === null || one.repo === project || identities.hot(one.repo) === identities.hot(project)),
-            episode: project === null ? null : store.latestWatchEpisode(project),
-            now,
-        }));
-    }
-    async function systemScreen(ctx) {
-        const { response, now, project } = ctx;
-        const since = new Date(now.getTime() - 24 * 60 * 60_000).toISOString();
-        void since;
-        return sendScreen(response, 200, systemPage(chromeFor(project, "system"), {
-            agents: ["plan", "build", "repair", "review"].map(phase => {
-                const answer = resolvePhaseAgent(store, phase, project, {});
-                const row = (project === null ? null : store.phaseConfig(project, phase)) ??
-                    store.phaseConfig(INSTALLATION_SCOPE, phase);
-                return {
-                    phase,
-                    ...(answer.ok
-                        ? { provider: answer.spec.provider, model: answer.spec.model, source: answer.source }
-                        : { problem: answer.problem }),
-                    setBy: row?.updatedBy ?? null,
-                };
-            }),
-            building: store.liveClaims(project, now),
-            runners: store.listRunners(),
-            worktrees: store.listWorktrees().filter(one => project === null || one.repo === project || identities.hot(one.repo) === identities.hot(project)),
-            episode: project === null ? null : store.latestWatchEpisode(project),
-            outboxPending: store.pendingForAttention().length,
-            // External work at a glance (arc 3 finding 24): every dispatch
-            // grant with its blocked state, plus any open sync episode — the
-            // page a sync-failed push deep-links to now shows the fact.
-            externalWork: store
-                .listGrants()
-                .filter(one => one.dispatch === true && one.remoteRepo != null && visible(one.repo))
-                .map(one => ({
-                remoteRepo: String(one.remoteRepo),
-                blocked: one.dispatchBlocked ?? null,
-                openEpisode: store
-                    .listNotifications("all")
-                    .find(n => n.kind === "sync-failed" && n.resolvedAt === null && n.dedupeKey.startsWith(`sync:${one.remoteRepo}:`))?.subject ?? null,
-            })),
-            now,
-        }));
+        const { response } = ctx;
+        response.writeHead(302, { ...SAFETY, Location: "/" });
+        response.end();
+        return;
     }
+    // A GET-only alias, a plain 302 (like morningAlias): an old address lands on the part of Agents that took it over.
+    const aliasTo = (location) => async (ctx) => {
+        ctx.response.writeHead(302, { ...SAFETY, Location: location });
+        ctx.response.end();
+    };
+    // System became part of Agents (UI revamp wave B): the model per phase and the computers that build.
+    const systemScreen = aliasTo("/agents#models");
+    // Terminals live on their own page (/term, its own bundle); the Agents area's address for them leads there.
+    const agentsTerminals = aliasTo("/term");
     // Peek became the Agents board: one place to check on every running agent (agents-board.ts).
     async function peekPage(ctx) {
         return redirect(ctx.response, "/agents");
@@ -431,6 +426,13 @@ export function createPagesHandlers(runtime) {
         }
         return { task, open };
     }
+    /** After a retire: fixed words naming a computer the store knows as retired (never text from the address). */
+    function retiredSaid(name) {
+        if (name === null)
+            return null;
+        const known = store.listRunners().find(one => one.name === name && one.retiredAt !== null);
+        return known === undefined ? null : { tone: "info", text: `${known.name} is retired. It takes no more work; tasks reserved for it wait until you move them.` };
+    }
     // The Agents board (one place to check on running agents): rows by state, and the opened agent's live view.
     async function agentsPage(ctx) {
         const { url, who, response, project } = ctx;
@@ -489,11 +491,21 @@ export function createPagesHandlers(runtime) {
             const view = { kind: "agents", groups: [], selected: null, lanes: null, empty: null, live: true };
             return sendScreen(response, 200, screen("Agents", html `<h1>Agents</h1><p class="meta">Live needs JavaScript.</p>`, { chrome: chromeFor(project, "runs"), workspace: { view } }));
         }
-        const groups = agentsBoardOf(store, now, access, who.name, evidenceRoot);
-        const lanes = selected === null ? agentLanesOf(store, now, access, who.name, laneWindowOf(url.searchParams.get("window"))) : null;
-        const view = { kind: "agents", groups, selected, lanes,
-            // Empty only when nothing ran at all: a planner or review on the timeline is activity too.
-            empty: groups.length === 0 && (lanes === null || lanes === undefined) ? "No agents in the last day. They show here the moment one starts." : null };
+        const groups = agentsListOf(store, now, access, who.name, evidenceRoot);
+        // The installation's parts (what /fleet and /system showed) are for a person with access to all of it, as those
+        // pages were; a project-limited person sees their own agents only.
+        const installation = !restricted();
+        const windowAsked = url.searchParams.get("window");
+        const view = { kind: "agents", groups, selected, lanes: null,
+            empty: groups.length === 0 ? "No agents in the last day. They show here the moment one starts." : null,
+            window: windowAsked === "30m" || windowAsked === "2h" ? windowAsked : "24h",
+            ...(selected !== null || !installation ? {} : {
+                computers: computersOf(store, now, visible, who.via === "cookie" && who.role === "approver" && !store.isDemo()),
+                phases: phasesOf(store, project),
+                system: systemOf(store, project, one => project === null || one.repo === project || identities.hot(one.repo) === identities.hot(project), visible),
+                computerSaid: retiredSaid(url.searchParams.get("retired")),
+            }),
+            terminals: who.via === "cookie" && who.role === "approver" && !store.isDemo() && store.isInstanceOperator(who.name) };
         const fallback = joinHtml([
             html `<h1>Agents</h1>`,
             groups.length === 0 ? html `<p class="meta">${view.empty ?? ""}</p>` : joinHtml(groups.map(group => joinHtml([
@@ -501,39 +513,13 @@ export function createPagesHandlers(runtime) {
                 ...group.rows.map(row => html `<p class="row"><a href="${row.href}"><strong>${row.title}</strong></a> <span class="meta">${[row.label, row.line].filter(Boolean).join(" \u00b7 ")}</span></p>`),
             ], "\n")), "\n"),
         ], "\n");
-        return sendScreen(response, 200, screen("Agents", fallback, { chrome: chromeFor(project, "runs"), workspace: { view } }));
+        // The list reads itself while something builds, as /system did (forms being edited are kept); an opened agent
+        // follows its own room instead.
+        const refreshSeconds = selected !== null ? undefined : store.liveClaims(null, now).length > 0 ? 10 : installation ? 60 : undefined;
+        return sendScreen(response, 200, screen("Agents", fallback, { chrome: chromeFor(project, "runs"), workspace: { view }, ...(refreshSeconds === undefined ? {} : { refreshSeconds }) }));
     }
-    async function fleetPage(ctx) {
-        const { url, response, project } = ctx;
-        // Cross-project by design: which agent is on which project is the
-        // question, so this screen is a survey — reads are still filtered
-        // through the ceiling before a card renders. No project needed.
-        const queued = store.fleetQueue(clock());
-        const building = store.liveClaims(null, clock());
-        const owned = new Set(queued.map(one => one.assignedRunner).filter((one) => one !== null));
-        const runners = store.listRunners().filter(one => one.retiredAt === null || owned.has(one.name));
-        const body = fleetBody(queued, building, runners, store.queueRevision(), visible);
-        if (url.searchParams.get("fragment") === "1") {
-            return respond(response, 200, "text/html; charset=utf-8", body);
-        }
-        const said = url.searchParams.get("said");
-        const fleetScreen = screen("fleet", joinHtml([
-            html `<h1>Fleet</h1>`,
-            html `<p class="hint">one lane per worker — drag a queued card onto another worker to re-reserve it</p>`,
-            ...(said === null ? [] : [html `<p class="meta">${said}</p>`]),
-            html `<div id="fleet-region">${body}</div>`,
-            html `<p class="meta" id="fleet-region-stamp"></p>`,
-            html `<h2>Register a worker</h2>`,
-            postForm("/fleet/runner/register", html `<label>Name<input type="text" name="name" placeholder="builder-2" maxlength="60" required></label><label>Capacity<input type="text" name="capacity" inputmode="numeric" value="1" aria-label="capacity"></label><label>Your password, typed again<input type="password" name="token" autocomplete="current-password" required></label><button type="submit">Register — its token is shown once</button>`, { attrs: { class: "card" } }),
-            html `<details class="arm-danger"><summary>Retire a worker</summary>${postForm("/fleet/runner/retire", html `<label>Which worker<input type="text" name="name" placeholder="builder-1" required></label>${reauth(html `<label>Your password, typed again<input type="password" name="token" autocomplete="current-password" required></label>`)}<button type="submit" class="danger">Retire it</button>`, { attrs: { class: "card" } })}</details>`,
-        ], "\n"), 
-        // The password fields make this screen sensitive: sendScreen strips
-        // the chrome additions and keeps the reorder poller — the named
-        // functional exception (it never reads the fields).
-        { chrome: chromeFor(project, "fleet", undefined, "all"), functional: { script: fleetScript(), fetches: true } });
-        return sendScreen(response, 200, fleetScreen);
-    }
-    // v103: every ledger entry in a date range, sealed, with an evidence pack for each task it names.
+    // Fleet became the computers on Agents (UI revamp wave B): register, retire, reserved work and notes are there.
+    const fleetPage = aliasTo("/agents#computers");
     async function ledgerExport(ctx) {
         const { url, who, request, response, now } = ctx;
         const from = exportDay(url.searchParams.get("from")), last = exportDay(url.searchParams.get("to"));
@@ -689,29 +675,29 @@ export function createPagesHandlers(runtime) {
         const decidedOn = identities.generation();
         const resolved = asked === "" ? null : await identities.resolveNow(asked);
         if (resolved === "no-answer") {
-            return void projectsScreen(response, who, "that folder didn't answer — it may be on a drive that's disconnected, or waiting on macOS; try again in a moment", 503, safeReturn(body.get("return")));
+            return void projectsScreen(response, who, "that folder didn't answer — it may be on a drive that's disconnected, or waiting on macOS; try again in a moment", 503, safeReturn(body.get("return")), "open");
         }
         const canonical = resolved;
         if (canonical === null) {
-            return void projectsScreen(response, who, "that path does not exist on this server", 400, safeReturn(body.get("return")));
+            return void projectsScreen(response, who, "that path does not exist on this server", 400, safeReturn(body.get("return")), "open");
         }
         // Authorization is the ceiling, then the path must actually be a git
         // repository — validation with direct argv and a bound, never a shell.
         // Both checks apply even to configured repos: naming a directory in
         // config authorizes it; only being a repository makes it openable.
         if (!(await authorizedProject(liveCeiling(), canonical))) {
-            return void projectsScreen(response, who, "that path is outside what this server was configured to serve", 403, safeReturn(body.get("return")));
+            return void projectsScreen(response, who, "that path is outside what this server was configured to serve", 403, safeReturn(body.get("return")), "open");
         }
         if (!(await isGitRepo(canonical))) {
-            return void projectsScreen(response, who, "that path is not a git repository", 400, safeReturn(body.get("return")));
+            return void projectsScreen(response, who, "that path is not a git repository", 400, safeReturn(body.get("return")), "open");
         }
         // An account limited to listed projects never widens its own list.
         if (!visible(canonical)) {
-            return void projectsScreen(response, who, "That project is outside your access.", 403, safeReturn(body.get("return")));
+            return void projectsScreen(response, who, "That project is outside your access.", 403, safeReturn(body.get("return")), "open");
         }
         // An identity that changed during the awaits above undoes what they proved.
         if (identities.generation() !== decidedOn)
-            return void projectsScreen(response, who, "a project folder changed while this was being checked — try again", 409, safeReturn(body.get("return")));
+            return void projectsScreen(response, who, "a project folder changed while this was being checked — try again", 409, safeReturn(body.get("return")), "open");
         // Opening an allowed repository admits it the same way `repos add` does
         // (project-admission.ts). A co-located `up` notices the durable list and
         // connects its builder; there is no separate restart or binding step.
@@ -719,11 +705,11 @@ export function createPagesHandlers(runtime) {
         const stillAllowed = (repo) => identities.generation() === decidedOn && visible(repo);
         const admitted = await admitProject(store, { registryFile: options.registryPath ?? null, path: canonical, actor: { label: who.name, origin: "console" }, now, stillAllowed });
         if (!admitted.ok) {
-            return void projectsScreen(response, who, admitted.reason === "not-git" ? "that path is not a git repository" : `that project is valid, but it could not be added — ${admitted.message}`, admitted.reason === "moved" ? 409 : 400, safeReturn(body.get("return")));
+            return void projectsScreen(response, who, admitted.reason === "not-git" ? "that path is not a git repository" : `that project is valid, but it could not be added — ${admitted.message}`, admitted.reason === "moved" ? 409 : 400, safeReturn(body.get("return")), "open");
         }
         // And once more before the session follows it.
         if (!stillAllowed(admitted.repo))
-            return void projectsScreen(response, who, "a project folder changed while this was being checked — try again", 409, safeReturn(body.get("return")));
+            return void projectsScreen(response, who, "a project folder changed while this was being checked — try again", 409, safeReturn(body.get("return")), "open");
         deletedRepos.delete(admitted.repo);
         who.session.project = admitted.repo;
         who.session.projectRevision++;
@@ -744,26 +730,25 @@ export function createPagesHandlers(runtime) {
         const token = body.get("token") ?? "";
         // A worker credential is minted here: a credential act, a password typed now even with Passwordless on.
         if (!authenticateCredential(who, token).ok) {
-            return refuse(response, who, 403, "registering a worker takes your password, typed again", "/fleet");
+            return refuse(response, who, 403, "registering a worker takes your password, typed again", "/agents#computers");
         }
         const name = (body.get("name") ?? "").trim();
         if (name === "" || name.length > 60 || /[\r\n\t]/.test(name) || hasForbiddenControls(name)) {
-            return refuse(response, who, 400, "a worker's name is one short line, no control characters", "/fleet");
+            return refuse(response, who, 400, "a worker's name is one short line, no control characters", "/agents#computers");
         }
         const capacity = Number((body.get("capacity") ?? "1").trim() || "1");
         if (!Number.isInteger(capacity) || capacity < 1 || capacity > 64) {
-            return refuse(response, who, 400, "capacity is a whole number of tasks, 1 to 64", "/fleet");
+            return refuse(response, who, 400, "capacity is a whole number of tasks, 1 to 64", "/agents#computers");
         }
         const { token: minted } = registerRunner(store, { name, host: hostname(), capacity, now });
-        const tokenScreen = screen("fleet", joinHtml([
-            html `<h1>${name} is registered</h1>`,
-            html `<div class="card">`,
-            html `<p>Its token, shown once. Only a hash is kept, so copy it now.</p>`,
-            html `<p class="mono secret-value">${minted}</p>`,
-            html `<p class="meta">Keep it beside the worker, in a file only you can read (0600) or a secrets manager. If it's lost, register the name again; its old claims are taken back.</p>`,
-            html `</div>`,
-            html `<p class="meta"><a href="/fleet">Back to Fleet</a></p>`,
-        ], "\n"), 
+        // A kit reading page (UI revamp wave B), back to the computers on Agents. The token is text to select: a Copy
+        // button would need a script, and this page carries none.
+        const tokenScreen = screen("fleet", html `<div data-kit-page>${kit.phoneHeader("Computer registered", { back: "/agents#computers" })}${kit.doc(kit.docHeader({ title: `${name} is registered`, back: ["/agents#computers", "Agents"], same: true, meta: html `Takes up to ${capacity} ${capacity === 1 ? "task" : "tasks"} at a time` }), kit.slots({
+            status: html `<h2>Its token, shown once</h2>`,
+            text: "Only a hash is kept, so copy it now.",
+            acts: html `<code class="k-code" data-runner-token>${minted}</code>`,
+            terms: "Keep it beside the computer, in a file only you can read (0600) or a secrets manager. If it's lost, register the name again; its old claims are taken back.",
+        }), kit.acts(kit.btn("Back to Agents", { href: "/agents#computers" })))}</div>`, 
         // A one-time secret on screen: no script of any kind rides along.
         { chrome: chromeFor(projectOf(who, request) ?? null, "fleet"), forceSensitive: true });
         return sendScreen(response, 200, tokenScreen);
@@ -775,13 +760,14 @@ export function createPagesHandlers(runtime) {
             return refuse(response, who, 403, "runner retirement is a browser surface");
         const token = body.get("token") ?? "";
         if (!authenticateApprover(who, token).ok) {
-            return refuse(response, who, 403, "retiring a worker takes your password, typed again", "/fleet");
+            return refuse(response, who, 403, "retiring a worker takes your password, typed again", "/agents#computers");
         }
         const name = (body.get("name") ?? "").trim();
         const retired = store.retireRunner(name, now);
         if (!retired)
-            return refuse(response, who, 404, `no worker \`${name}\``, "/fleet");
-        return redirect(response, `/fleet?said=${encodeURIComponent(`${name} is retired — its queued work is still here, drag it elsewhere`)}`);
+            return refuse(response, who, 404, `no worker \`${name}\``, "/agents#computers");
+        // Agents says it in fixed words, naming the computer only once the store knows it as retired (retiredSaid).
+        return redirect(response, `/agents?retired=${encodeURIComponent(name)}#computers`);
     }
     async function onboardPreview(ctx) {
         const { who, response, posted } = ctx;
@@ -795,24 +781,24 @@ export function createPagesHandlers(runtime) {
         if (process.platform === "win32")
             return refuse(response, who, 403, "adding from GitHub is not supported on Windows yet");
         if (ceiling.roots.length === 0)
-            return projectsScreen(response, who, "naming where repositories live takes --project-root", 400);
+            return projectsScreen(response, who, "naming where repositories live takes --project-root", 400, "/", "link");
         const shape = parseGithubRepo(body.get("repo") ?? "");
         if (!shape.ok)
-            return projectsScreen(response, who, shape.problem, 400);
+            return projectsScreen(response, who, shape.problem, 400, "/", "link");
         // Roots by INDEX (finding 13) — a posted path is never accepted.
         const rootIndex = Number(body.get("root") ?? "0");
         const rootRaw = Number.isInteger(rootIndex) ? ceiling.roots[rootIndex] : undefined;
         if (rootRaw === undefined)
-            return projectsScreen(response, who, "pick one of the configured roots", 400);
+            return projectsScreen(response, who, "pick one of the configured roots", 400, "/", "link");
         const root = await identities.resolveNow(rootRaw);
         if (root === null || root === "no-answer")
-            return projectsScreen(response, who, "that projects root does not resolve right now", 400);
+            return projectsScreen(response, who, "that projects root does not resolve right now", 400, "/", "link");
         const previewed = await (options.ghPreview ?? previewGithubRepo)(shape.owner, shape.name);
         if (!previewed.ok)
-            return projectsScreen(response, who, previewed.message, 400);
+            return projectsScreen(response, who, previewed.message, 400, "/", "link");
         const reparsed = parseGithubRepo(previewed.preview.nameWithOwner);
         if (!reparsed.ok)
-            return projectsScreen(response, who, "GitHub named a repository shape this console refuses", 400);
+            return projectsScreen(response, who, "GitHub named a repository shape this console refuses", 400, "/", "link");
         // The hook boundary is NORMALIZED like the real preview would be
         // (verification finding 2): a size that is not a nonnegative finite
         // number is unknown, and unknown is LARGE.
@@ -821,7 +807,7 @@ export function createPagesHandlers(runtime) {
             : null;
         const target = join(root, reparsed.name);
         if (dirname(target) !== root)
-            return projectsScreen(response, who, "the target escaped its root — refused", 400);
+            return projectsScreen(response, who, "the target escaped its root — refused", 400, "/", "link");
         // The session-held record (finding 14): swept at mint, capped 3.
         const session = who.session;
         session.onboard ??= new Map();
@@ -830,7 +816,7 @@ export function createPagesHandlers(runtime) {
             if (record.mintedAt < cutoff)
                 session.onboard.delete(key);
         if (session.onboard.size >= 3)
-            return projectsScreen(response, who, "three previews are already waiting — confirm or let one expire", 400);
+            return projectsScreen(response, who, "three previews are already waiting — confirm or let one expire", 400, "/", "link");
         const nonce = randomBytes(16).toString("hex");
         session.onboard.set(nonce, {
             nameWithOwner: previewed.preview.nameWithOwner,
@@ -840,7 +826,7 @@ export function createPagesHandlers(runtime) {
             large: isLargeRepo({ ...previewed.preview, diskUsageKib }),
             mintedAt: Date.now(),
         });
-        return projectsScreen(response, who, null, 200);
+        return projectsScreen(response, who, null, 200, "/", "link");
     }
     async function onboardConfirm(ctx) {
         const { who, request, response, posted, now } = ctx;
@@ -854,13 +840,13 @@ export function createPagesHandlers(runtime) {
         if (process.platform === "win32")
             return refuse(response, who, 403, "adding from GitHub is not supported on Windows yet");
         if (ceiling.roots.length === 0)
-            return projectsScreen(response, who, "naming where repositories live takes --project-root", 400);
+            return projectsScreen(response, who, "naming where repositories live takes --project-root", 400, "/", "clone");
         // CONFIRM: password, then session liveness AGAIN via lookupSession
         // (finding 22/33) — the record is consumed from the RETURNED live
         // session, synchronously, before the first await.
         const password = body.get("token") ?? "";
         if (!authenticateApprover(who, password).ok) {
-            return projectsScreen(response, who, "cloning takes your password, typed again", 403);
+            return projectsScreen(response, who, "cloning takes your password, typed again", 403, "/", "clone");
         }
         const cookieId = /(?:^|;\s*)standing-orders_session=([0-9a-f]{64})/.exec(request.headers.cookie ?? "")?.[1];
         const live = cookieId === undefined ? null : lookupSession(cookieId, false);
@@ -870,53 +856,53 @@ export function createPagesHandlers(runtime) {
         const record = live.onboard?.get(nonce);
         if (record === undefined || record.mintedAt < Date.now() - 10 * 60_000) {
             live.onboard?.delete(nonce);
-            return projectsScreen(response, who, "that preview expired or was already used — preview again", 400);
+            return projectsScreen(response, who, "that preview expired or was already used — preview again", 400, "/", "clone");
         }
         live.onboard?.delete(nonce); // consumed BEFORE the first await
         // Identities as this confirmation found them: the admission below re-checks against them (project-identity.ts).
         const decidedOn = identities.generation();
         if (record.large && body.get("big-ok") !== "1") {
-            return projectsScreen(response, who, "that repository is large (or its size is unknown) — tick the box to clone it anyway", 400);
+            return projectsScreen(response, who, "that repository is large (or its size is unknown) — tick the box to clone it anyway", 400, "/", "clone");
         }
         const rootRaw = ceiling.roots[record.rootIndex];
         if (rootRaw === undefined)
-            return projectsScreen(response, who, "the configured roots changed — preview again", 400);
+            return projectsScreen(response, who, "the configured roots changed — preview again", 400, "/", "clone");
         const root = await identities.resolveNow(rootRaw);
         if (root === null || root === "no-answer")
-            return projectsScreen(response, who, "that projects root does not resolve right now", 400);
+            return projectsScreen(response, who, "that projects root does not resolve right now", 400, "/", "clone");
         if (dirname(record.target) !== root)
-            return projectsScreen(response, who, "the configured roots changed — preview again", 400);
+            return projectsScreen(response, who, "the configured roots changed — preview again", 400, "/", "clone");
         const cloned = await (options.ghClone ?? cloneGithubRepo)(record.nameWithOwner, root, async (cwd) => {
             const answer = await execRun("git", ["rev-parse", "--show-toplevel"], { cwd, timeoutMs: 15_000 });
             return { code: answer.code, stdout: answer.stdout };
         });
         if (!cloned.ok)
-            return projectsScreen(response, who, cloned.message, 400);
+            return projectsScreen(response, who, cloned.message, 400, "/", "clone");
         // The clone answer is BOUND to the record's exact target (verification
         // finding 2): whatever produced it — the real primitive or a test
         // hook — an answer naming any other path never enrolls or opens.
         if (cloned.target !== record.target) {
-            return projectsScreen(response, who, "the clone answered with a different path than the preview promised — refused; nothing was enrolled", 400);
+            return projectsScreen(response, who, "the clone answered with a different path than the preview promised — refused; nothing was enrolled", 400, "/", "clone");
         }
         // authorizedProject AFTER the repository exists (finding 20).
         const clonedAt = await identities.resolveNow(cloned.target);
         const admitted = typeof clonedAt === "string" && clonedAt !== "no-answer" && (await authorizedProject(liveCeiling(), clonedAt)) ? clonedAt : null;
         if (admitted === null) {
-            return projectsScreen(response, who, `the clone landed at ${cloned.target} but did not prove under the ceiling — it was left in place; enroll it by hand`, 400);
+            return projectsScreen(response, who, `the clone landed at ${cloned.target} but did not prove under the ceiling — it was left in place; enroll it by hand`, 400, "/", "clone");
         }
         const stillAllowed = (repo) => identities.generation() === decidedOn && visible(repo);
         const joined = await admitProject(store, { registryFile: options.registryPath ?? null, path: admitted, actor: { label: who.name, origin: "console" }, now, stillAllowed });
         if (!joined.ok) {
-            return projectsScreen(response, who, `${cloned.target} is cloned but not added — ${joined.message}`, joined.reason === "moved" ? 409 : 400);
+            return projectsScreen(response, who, `${cloned.target} is cloned but not added — ${joined.message}`, joined.reason === "moved" ? 409 : 400, "/", "clone");
         }
         if (!stillAllowed(joined.repo))
-            return projectsScreen(response, who, `${cloned.target} is cloned but wasn't opened — a project folder changed while it was being checked; try again`, 409);
+            return projectsScreen(response, who, `${cloned.target} is cloned but wasn't opened — a project folder changed while it was being checked; try again`, 409, "/", "clone");
         deletedRepos.delete(admitted);
         who.session.project = admitted;
         who.session.projectRevision += 1;
         return projectsScreen(response, who, options.upConsole === true
             ? `${projectName(admitted)} is ready — the builder is connecting automatically`
-            : `${admitted} is ready and open`, 200);
+            : `${admitted} is ready and open`, 200, "/", "said");
     }
     /**
      * The opener: every project inside the ceiling, most recently opened
@@ -925,8 +911,9 @@ export function createPagesHandlers(runtime) {
      * registry row never confers access; this page only offers what the
      * server was configured to allow.
      */
-    async function projectsScreen(response, who, problem, status, returnTo = "/") {
-        const now = clock();
+    /** The projects this person may open: the registered ones they can see, most recently opened first, then the
+     * configured ones the queue has seen. A registry row never confers access. */
+    function visibleProjects() {
         const recent = store.listProjects().filter(one => visible(one.path));
         const recentPaths = new Set(recent.map(one => one.path));
         const candidates = new Set();
@@ -935,6 +922,20 @@ export function createPagesHandlers(runtime) {
             if (!recentPaths.has(canonical) && visible(canonical))
                 candidates.add(canonical);
         }
+        return { recent, candidates: [...candidates] };
+    }
+    /** A cheap peek per project: one small set of COUNTs, scoped to the exact repo. */
+    function peekOf(path, now) {
+        try {
+            return projectFamilyPeek(path, now);
+        }
+        catch {
+            return null;
+        }
+    }
+    async function projectsScreen(response, who, problem, status, returnTo = "/", problemAt = null) {
+        const now = clock();
+        const { recent, candidates } = visibleProjects();
         const open = who.via === "cookie" ? who.session.project : null;
         // Onboarding availability (findings 2/28/32/39): a cookie session on a
         // root-configured, non-demo, POSIX serve gets the live card; everybody
@@ -953,31 +954,66 @@ export function createPagesHandlers(runtime) {
                                 : "choose which folder this server may use with --project-root <dir>",
                         }
                         : { enabled: true, roots: ceiling.roots, record: [...(who.session.onboard?.entries() ?? [])][0] ?? null };
-        // A cheap peek per project for the switcher cards — one small set of
-        // COUNTs each, scoped to the exact repo.
-        const peekOf = (path) => {
-            try {
-                return projectFamilyPeek(path, now);
-            }
-            catch {
-                return null;
-            }
-        };
         const peeks = {};
         for (const one of recent)
-            peeks[one.path] = peekOf(one.path);
+            peeks[one.path] = peekOf(one.path, now);
         for (const path of candidates)
-            peeks[path] = peekOf(path);
-        let activity;
-        if (open !== null && !returnTo.startsWith("/tasks/new") && visible(open) && store.accountCanAccess(who.name, open)) {
+            peeks[path] = peekOf(path, now);
+        return sendScreen(response, status, projectsPage(chromeFor(open, "projects"), {
+            recent, candidates, open, problem, problemAt, onboard: onboardState, peeks, returnTo,
+            browsable: !restricted() && (ceiling.roots.length > 0 || unscopedMode),
+        }));
+    }
+    /** One project's reading page (/projects/<name>). A GET only reads (docs/plans/get-side-effects.md): it never
+     * 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;
+        let name = "";
+        try {
+            name = decodeURIComponent(url.pathname.slice("/projects/".length));
+        }
+        catch {
+            name = "";
+        }
+        const { recent, candidates } = visibleProjects();
+        const known = [...recent.map(one => ({ path: one.path, name: one.name, openedAt: one.lastOpenedAt })), ...candidates.map(path => ({ path, name: projectName(path), openedAt: null }))];
+        const named = known.filter(one => one.name === name);
+        const askedPath = url.searchParams.get("path");
+        const found = askedPath !== null ? named.find(one => one.path === askedPath) ?? null : named.length === 1 ? named[0] : null;
+        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") }));
+        }
+        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);
+        const cards = snapshot.tasks
+            .filter(facts => facts.repo === path)
+            .map(facts => classify(facts.blockerRepo !== null && !visible(facts.blockerRepo) ? { ...facts, blockerState: null } : facts, now))
+            .filter(card => card.lane === "attention" || card.lane === "building");
+        const tasks = cards.slice(0, 5).map(card => ({ href: card.href, title: card.title, reason: card.reason, needs: card.lane === "attention", since: card.stalledSince }));
+        const cookie = who.via === "cookie";
+        let activity = null;
+        if (store.accountCanAccess(who.name, path)) {
             try {
-                activity = { project: projectName(open), report: projectOutcomes(store, open, now, { principal: 'operator', repos: [open] }) };
+                activity = { report: projectOutcomes(store, path, now, { principal: 'operator', repos: [path] }) };
             }
             catch {
-                activity = { project: projectName(open), report: null };
+                activity = { report: null };
             }
         }
-        return sendScreen(response, status, projectsPage(chromeFor(open, "projects"), recent, [...candidates], open, problem, !restricted() && unscopedMode, !restricted() && (ceiling.roots.length > 0 || unscopedMode), onboardState, peeks, returnTo, who.via === "cookie" ? (path) => publishingOf(store, path).on : undefined, who.via === "cookie" ? (path) => projectCheckLevel(store, path).level : undefined, activity));
+        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,
+            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)}`,
+            settingsHref: restricted() ? null : `/settings/project?repo=${encodeURIComponent(path)}`,
+            activity, now,
+        }));
     }
     async function instanceEdge(ctx) {
         const { request, response, url } = ctx;
@@ -1108,7 +1144,9 @@ export function createPagesHandlers(runtime) {
         "projects.github": projectsGithub,
         "projects.github-list": projectsGithubList,
         "projects.page": projectsIndex,
+        "projects.project": projectPageHandler,
         "home": homeRedirect,
+        "search": searchPage,
         "morning": morningAlias,
         "workbench": workbench,
         "ledger": ledgerPage,
@@ -1119,6 +1157,7 @@ export function createPagesHandlers(runtime) {
         "agents": agentsPage,
         "agents.live": agentsLive,
         "agents.live.read": agentsLiveRead,
+        "agents.terminals": agentsTerminals,
         "fleet": fleetPage,
         "ledger.export": ledgerExport,
         "menu": menuPage,