toolroll 0.9.86 → 0.9.87

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

@@ -0,0 +1,96 @@
+/**
+ * New task (Wave E, src/design/KIT.md): one describe box, the project it lands in and "Read code before planning" in
+ * the box's bottom row, the round send; every other choice behind More options; ideas under it. The form posts the
+ * same fields /tasks/add has always read (title, repo, plan-first with planning-policy=choice, quality-mode, after,
+ * goal, acceptance, not, touches, scout, id, permission-mode, projectRevision), so every server check is unchanged.
+ */
+import { html, joinHtml, postForm } from "../html.js";
+import { projectName } from "../project.js";
+import { screen } from "./chrome.js";
+import { btn, composer, disclose, doc, docHeader, dock, field, ideas, input, note, phoneHeader, radios, select, sendButton, switchInput, textarea } from "./kit.js";
+const FORM_ID = "nt-form";
+const PLAN_ON = "The agent reads the code and asks you anything unclear, then writes the plan.";
+const PLAN_OFF = "The agent writes the plan straight from your words. Faster for small, obvious changes.";
+/** The projects as the select offers them: names, with the parent folder when two share a name; the open one first
+ * picked. Values are the paths the server proves. */
+function projectItems(projects, open) {
+    const all = open !== null && !projects.some(one => one.path === open) ? [{ path: open, name: projectName(open) }, ...projects] : [...projects];
+    const counts = new Map();
+    for (const one of all)
+        counts.set(one.name, (counts.get(one.name) ?? 0) + 1);
+    return all.map(one => {
+        if ((counts.get(one.name) ?? 0) < 2)
+            return [one.path, one.name];
+        const parent = one.path.split(/[\\/]/).filter(Boolean).slice(-2, -1)[0] ?? one.path;
+        return [one.path, `${one.name} (${parent})`];
+    });
+}
+export function newTaskPage(chrome, project, 
+/** undefined: keep the revision the refused form posted (its draft), so a project switch since still refuses. */
+projectRevision, problem, candidates = [], permissionDefault = "auto", qualityDefault = "default", projects = [], 
+/** A shipped template's fields, or a refused filing's own words, back in the form. */
+prefill = null, 
+/** Words an idea's link put in the box (GET ?text=). */
+draft = null, 
+/** Ideas for the chosen project: one tap drafts the words into the box. */
+suggestions = []) {
+    const head = html `${phoneHeader("New task", { back: "/work" })}`;
+    const header = docHeader({ title: "New task", back: ["/work", "Tasks"], meta: "Nothing is built until you approve its plan.", same: true });
+    const items = projectItems(projects, project);
+    const values = prefill?.values;
+    // No project to choose from: the task names its folder (the server proves it), and adding a project is one link away.
+    const typed = items.length === 0;
+    const chosen = values?.get("repo") ?? project ?? items[0]?.[0] ?? "";
+    const planOn = values === undefined || values.get("plan-first") === "1";
+    const quality = values?.get("quality-mode") ?? qualityDefault;
+    const after = values?.get("after") ?? "";
+    const permission = values?.get("permission-mode") === "bypassPermissions" ? "bypassPermissions" : values?.get("permission-mode") === "auto" ? "auto" : permissionDefault;
+    const text = prefill?.title ?? draft ?? "";
+    // More options opens on a template, or when a refused filing had used any of them.
+    const optionsUsed = prefill !== null && (values === undefined || ["goal", "acceptance", "not", "touches", "id", "after"].some(name => (values.get(name) ?? "") !== "") || values.get("scout") === "1");
+    const folder = !typed ? "" : field({ id: "nt-repo", label: "Project folder", hint: "No projects yet: name the folder of a git repository.",
+        control: input({ id: "nt-repo", name: "repo", value: chosen, hint: true, attrs: { required: true, placeholder: "/path/to/repository", autocapitalize: "none", spellcheck: "false" } }) });
+    const bar = joinHtml([
+        typed ? "" : select({ id: "nt-project", name: "repo", label: "Project", items, current: chosen, sm: true }),
+        switchInput({ id: "nt-plan", name: "plan-first", label: "Read code before planning", on: planOn, attrs: { value: "1" } }),
+    ]);
+    const box = composer({
+        id: "nt", name: "title", label: "What should change?", placeholder: "What should change? One or two sentences is enough.",
+        value: text, rows: 4, maxRows: 10, before: bar, error: problem,
+        send: sendButton({ label: "File task" }),
+        note: html `<span class="k-on-note">${PLAN_ON}</span><span class="k-off-note">${PLAN_OFF}</span>`,
+        textAttrs: { maxlength: 200, autofocus: true },
+    });
+    const options = html `<div class="k-form">\
+${field({ id: "nt-quality", label: "Checks", control: select({ id: "nt-quality", name: "quality-mode", items: [["default", "Default checks"], ["strict", "Strict (release)"]], current: quality, wide: true }) })}\
+${candidates.length === 0 ? "" : field({ id: "nt-after", label: "Starts", control: select({ id: "nt-after", name: "after", wide: true, current: after,
+            items: [["", "Right away"], ...candidates.map(one => [one.id, `After ${one.id}: ${one.title}`])] }) })}\
+${field({ id: "nt-goal", label: "Goal (optional)", hint: "With acceptance below, automatic approval can sign an unchanged plan.", control: textarea({ id: "nt-goal", name: "goal", rows: 2, value: prefill?.goal ?? "", attrs: { placeholder: "What success looks like" } }) })}\
+${field({ id: "nt-acceptance", label: "Acceptance", hint: "Needed with a goal. One per line: statement | evidence,kinds | how", control: textarea({ id: "nt-acceptance", name: "acceptance", rows: 2, value: prefill?.acceptance ?? "", attrs: { placeholder: "Requests over the limit return 429 | check" } }) })}\
+${field({ id: "nt-not", label: "Not this (optional)", control: input({ id: "nt-not", name: "not", value: prefill?.not ?? "" }) })}\
+${field({ id: "nt-touches", label: "Likely touches (optional)", hint: "Paths, separated by commas.", control: input({ id: "nt-touches", name: "touches", value: prefill?.touches ?? "", hint: true }) })}\
+<div class="k-checks"><label><input type="checkbox" name="scout" value="1"${values?.get("scout") === "1" ? html ` checked` : ""}>Research only: a read-only report, no code changes</label></div>\
+${field({ id: "nt-id", label: "Task id (optional)", control: input({ id: "nt-id", name: "id", value: values?.get("id") ?? "", attrs: { placeholder: "Made from the request" } }) })}\
+<div class="k-field"><span class="k-label">Agent permissions</span>${radios({ name: "permission-mode", legend: "Agent permissions", current: permission, items: [
+            { value: "auto", label: "Auto", text: "Asks before risky actions." },
+            { value: "bypassPermissions", label: "Full access", text: "Never asks and can change files anywhere on this computer. Trusted repositories only." },
+        ] })}<p class="k-hint">From Settings. You can still change it on the plan before you approve.</p></div></div>`;
+    const form = postForm("/tasks/add", joinHtml([
+        prefill !== null && values === undefined ? note("Filled in from a template. Change anything; it still waits for your approval.") : "",
+        folder,
+        typed ? note(html `<a class="k-link" href="/projects?return=%2Ftasks%2Fnew">Add a project</a> to choose it here next time.`) : "",
+        box,
+        disclose("More options", options, optionsUsed),
+    ]), {
+        attrs: { class: "k-form k-dock-send", id: FORM_ID },
+        projectRevision: projectRevision === undefined && values?.get("projectRevision") == null ? null : String(projectRevision ?? values?.get("projectRevision") ?? ""),
+        hidden: { "planning-policy": "choice" },
+    });
+    const chosenName = items.find(([path]) => path === chosen)?.[1] ?? (chosen === "" ? "your project" : projectName(chosen));
+    const ideaList = ideas({
+        label: `Ideas for ${chosenName}`, into: "nt",
+        items: suggestions.map(one => ({ label: one.label, draft: one.draft, href: `/tasks/new?text=${encodeURIComponent(one.draft)}` })),
+    });
+    const recipes = note(html `Work you do often? <a class="k-link" href="/recipes">Use a saved recipe</a>.`);
+    return screen("New task", html `${head}${doc(header, form, ideaList, recipes)}${dock(btn("File task", { variant: "primary", type: "submit", attrs: { form: FORM_ID } }))}`, { chrome });
+}

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

@@ -0,0 +1,63 @@
+/**
+ * /next (Wave E, src/design/KIT.md): everything waiting on a person, one at a time, each in the approval slots with
+ * its one act, every act landing back here. The forms post exactly what they always have (the approve form's nonce,
+ * digest and password; a decision's choice, confirm and note; a requeue), so every server check is unchanged. The
+ * approval shows the password only when the rules ask (approveForm, standard): none with Passwordless or a remembered
+ * password the task page's own preview says may approve these exact terms; otherwise the password, required.
+ */
+import { type TaskOrigin } from "../task-source.js";
+import type { Gap } from "../gaps.js";
+import type { Scope } from "../scope.js";
+import type { Decision } from "../store.js";
+import { type Chrome, type Screen } from "./chrome.js";
+import { type PlanContractView, type RouteView } from "./render-tasks.js";
+export type NextItem = {
+    key: string;
+    kind: "decision";
+    decision: Decision & {
+        taskId: string;
+    };
+} | {
+    key: string;
+    kind: "approval";
+    approval: {
+        taskId: string;
+        title: string;
+        goal: string;
+        digest: string;
+        proposedAt: string;
+    };
+} | {
+    key: string;
+    kind: "requeue";
+    stalled: {
+        taskId: string;
+        title: string;
+        strikes: number;
+        incidentCount: number;
+    };
+} | {
+    key: string;
+    kind: "gap";
+    gap: Gap;
+} | null;
+export declare function nextPage(chrome: Chrome, data: {
+    item: NextItem;
+    scope: Scope | null;
+    planDocument: string | null;
+    planContract?: PlanContractView | null;
+    approvalDigest: string | null;
+    /** v34: said inside the ceremony when the yes buys a report, not a branch. */
+    deliverable?: "branch" | "report";
+    /** v48: the agents the yes freezes — the one block every ceremony shows. */
+    route: RouteView | null;
+    /** v126: where the work came from (an outside event's line of context, never a term agreed to). */
+    origin?: TaskOrigin | null;
+    /** A remembered password stands in for these exact terms (the task page's preview): one click, no field. */
+    remembered?: boolean;
+    csrf: string;
+    nonce: string;
+    remaining: number;
+    skipped: string[];
+    now: Date;
+}): Screen;

package/dist/server/render-next.js

@@ -0,0 +1,109 @@
+/**
+ * /next (Wave E, src/design/KIT.md): everything waiting on a person, one at a time, each in the approval slots with
+ * its one act, every act landing back here. The forms post exactly what they always have (the approve form's nonce,
+ * digest and password; a decision's choice, confirm and note; a requeue), so every server check is unchanged. The
+ * approval shows the password only when the rules ask (approveForm, standard): none with Passwordless or a remembered
+ * password the task page's own preview says may approve these exact terms; otherwise the password, required.
+ */
+import { originNote } from "../task-source.js";
+import { html, joinHtml, postForm } from "../html.js";
+import { screen, when } from "./chrome.js";
+import { taskHref } from "./http.js";
+import { acceptanceCeremonyHtml, agentsCeremonyHtml, consentClosedHtml, consentDoorOf, executionPlanHtml, planContractHtml, profileWords, runtimeDetailsHtml, } from "./render-tasks.js";
+import { approvalFactsNow, approvalTerms, approveForm, btn, chip, disclose, doc, docHeader, empty, facts, note, phoneHeader, slots } from "./kit.js";
+/** One decision option: a one-click answer (an irreversible one behind its own disclosure, with the confirm the server
+ * requires) and its consequence. A note travels from the task's own page. */
+function optionForm(decision, option) {
+    const recommended = option.id === decision.recommendation;
+    const form = postForm(`/d/${decision.id}/answer`, html `<div class="k-acts">${btn(option.label, { variant: option.reversible ? (recommended ? "primary" : "outline") : "danger", type: "submit" })}</div>\
+<p class="k-note">${recommended ? html `${chip("Recommended", "", { dot: false })} ` : ""}${option.consequence}</p>`, { attrs: { class: "k-form" }, returnTo: "next", hidden: { choice: option.id, confirm: option.reversible ? null : "yes" } });
+    return option.reversible ? form : disclose(`${option.label} (can't be undone)`, form);
+}
+export function nextPage(chrome, data) {
+    const { item } = data;
+    const title = "Needs you";
+    if (item === null) {
+        const held = data.skipped.length;
+        return screen(title, html `${phoneHeader(title)}${doc(docHeader({ title, same: true }), held > 0
+            ? empty({ title: `Only the ${held} you set aside ${held === 1 ? "is" : "are"} left.`, text: "Look at them again now, or come back later.", action: btn("Look at them again", { sm: true, href: "/next" }) })
+            : empty({ title: "Nothing needs you.", text: "Everything is either working or waiting on its own clock.", action: btn("Open Tasks", { sm: true, href: "/work" }) }))}`, { chrome });
+    }
+    const skipHref = `/next?skip=${encodeURIComponent([...data.skipped, item.key].join(","))}`;
+    const header = docHeader({
+        title, same: true,
+        meta: data.remaining === 1 ? "The last thing waiting on you" : `1 of ${data.remaining} waiting on you`,
+        right: btn("Not now", { variant: "ghost", sm: true, href: skipHref }),
+    });
+    const openTask = (taskId, words = "Open the task") => html `<a class="k-link" href="${taskHref(taskId)}">${words}</a>`;
+    let card;
+    if (item.kind === "decision") {
+        const { decision } = item;
+        card = slots({
+            wait: true, attrs: { "data-decision": String(decision.id) },
+            status: html `${chip("Question", "ask")}<h2>${decision.question}</h2>`,
+            text: decision.recap,
+            acts: joinHtml(decision.options.map(option => optionForm(decision, option))),
+            terms: html `${decision.taskId} · asked ${when(decision.createdAt)} · ${openTask(decision.taskId, "Answer with a note on the task")}`,
+        });
+    }
+    else if (item.kind === "approval" && !consentDoorOf(data.scope, data.route).open) {
+        const door = consentDoorOf(data.scope, data.route);
+        card = slots({
+            wait: true,
+            status: html `${chip("Plan", "ask")}<h2>${item.approval.title}</h2>`,
+            text: item.approval.taskId,
+            acts: consentClosedHtml(item.approval.taskId, door, "next"),
+            terms: openTask(item.approval.taskId),
+        });
+    }
+    else if (item.kind === "approval") {
+        const scope = data.scope;
+        const facts_ = approvalFactsNow({ remembered: data.remembered === true });
+        const terms = joinHtml([
+            data.deliverable === "report" ? note("Research only: a read-only session investigates this goal and delivers a report. No branch; nothing in the repository changes.") : "",
+            scope === null || scope.profileState !== "unresolved" ? "" : profileWords(scope),
+            originNote(data.origin) === null ? "" : html `<p class="k-note" data-approval-origin>${originNote(data.origin)}</p>`,
+            facts([
+                ["Goal", scope?.goal ?? item.approval.goal],
+                ["Not this", scope?.outOfScope == null ? "No exclusions" : scope.outOfScope],
+                ["Touches", scope === null || scope.touches.length === 0 ? "Anything" : scope.touches.join(", ")],
+            ]),
+            scope === null ? "" : acceptanceCeremonyHtml(scope.acceptance),
+            // The agents the yes freezes (v48): the same block the task page and chat sign under, before the password.
+            agentsCeremonyHtml(data.route),
+            scope === null ? "" : runtimeDetailsHtml(scope),
+        ]);
+        const plan = data.planDocument === null ? "" : html `<section class="k-sec"><h3>The plan</h3>${executionPlanHtml(data.planDocument, true)}${planContractHtml(data.planContract ?? null, "ceremony")}</section>`;
+        const digest = data.approvalDigest ?? item.approval.digest;
+        // The terms ride inside the form, before the password: what the yes covers is on the form that says it.
+        card = html `${plan}${slots({
+            wait: true, attrs: { "data-approval": digest },
+            status: html `${chip("Plan", "ask")}<h2>${item.approval.title}</h2>`,
+            text: html `${item.approval.taskId} · ${openTask(item.approval.taskId, "Open the task to change the scope first")}`,
+            acts: approveForm({ action: `${taskHref(item.approval.taskId)}/approve`, kind: "standard", facts: facts_, label: "Approve and start", primary: true,
+                before: html `<section class="k-sec"><h3>Approve exactly this</h3>${terms}</section>`,
+                form: { returnTo: "next", hidden: { nonce: data.nonce, digest }, attrs: { class: "k-form" } } }),
+            terms: approvalTerms("standard", facts_),
+        })}`;
+    }
+    else if (item.kind === "requeue") {
+        card = slots({
+            wait: true,
+            status: html `${chip("Stopped", "ask")}<h2>${item.stalled.title}</h2>`,
+            text: `Stopped with ${item.stalled.incidentCount} incident${item.stalled.incidentCount === 1 ? "" : "s"}${item.stalled.strikes > 0 ? ` after ${item.stalled.strikes} attempt${item.stalled.strikes === 1 ? "" : "s"}` : ""}. Retrying resolves the incidents, clears the failed attempts and puts it back in line.`,
+            acts: postForm(`${taskHref(item.stalled.taskId)}/requeue`, btn("Retry this work", { variant: "primary", type: "submit" }), { returnTo: "next" }),
+            terms: html `${item.stalled.taskId} · ${openTask(item.stalled.taskId, "Read the attempts first")}`,
+        });
+    }
+    else {
+        const { gap } = item;
+        card = slots({
+            wait: true,
+            status: html `${chip("Missing", "ask")}<h2>Supply ${gap.key}</h2>`,
+            text: html `${gap.state}. Filling it starts ${gap.unblocks.length} task${gap.unblocks.length === 1 ? "" : "s"}: ${joinHtml(gap.unblocks.map(one => html `<span class="k-mono">${one}</span>`), ", ")}.`,
+            acts: "",
+            terms: html `Prove it is filled from a terminal: <code class="k-mono">${gap.verify}</code>`,
+        });
+    }
+    return screen(title, html `${phoneHeader(title)}${doc(header, card)}`, { chrome });
+}

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

@@ -1,26 +1,21 @@
 /** Everyday console pages: home, inbox, board, work, projects, fleet and the queue. */
 import { type TidyItem } from "../tidy.js";
-import { type TaskOrigin } from "../task-source.js";
 import { type Html } from "../html.js";
 import { type AssignmentSnapshot } from "../assignment.js";
 import { type BoardCard } from "../board.js";
-import { type BrowserLimits, type BrowserProjectsView } from "../browser-workspace.js";
-import { type CheckLevel } from "../check-levels.js";
+import { type BrowserLimits } from "../browser-workspace.js";
 import { type DispatchDiagnosis } from "../dispatch.js";
 import { type FirstRunStep } from "../first-run.js";
 import { type Gap } from "../gaps.js";
-import { type ListOutcome } from "../onboard.js";
 import { type parseBaseTreeSnapshot } from "../peek.js";
 import { type CriterionMatrixRow } from "../proof.js";
-import { type QualityMode } from "../quality.js";
 import { type Runner } from "../runner.js";
-import { type Scope, type UnattendedPermissionMode } from "../scope.js";
 import { type Decision, type Incident, type RepairChainRow, type Run, type Store, type TaskState, type WorktreeRow } from "../store.js";
 import { tally } from "../summary.js";
-import { type WorkIndexGroup, type WorkIndexPage } from "../work-index.js";
+import { type WorkIndexGroup, type WorkIndexItem, type WorkIndexPage } from "../work-index.js";
+import { type ChipTone } from "../design/kit.js";
 import { type WorkFacts, type WorkStatus, type WorkView } from "../workspace-ui.js";
 import { type Chrome, type Screen } from "./chrome.js";
-import { type PlanContractView, type RouteView } from "./render-tasks.js";
 export declare const TASK_STATES: readonly TaskState[];
 /**
  * The inbox (v3): only things stalling progress without a person, one card
@@ -112,9 +107,8 @@ export declare function inboxPage(chrome: Chrome, data: {
     }[];
     unread?: readonly InboxTab[];
 }): Screen;
-/** System: the machinery — workers, background service, workspaces. */
 /** Start a builder: the one command, as text to select (/start-builder, where every "Connect a builder" leads, and
- * /system#builder). `project`: the open project's name, when the viewer may see it; `connected`: whether a builder
+ * the Agents page). `project`: the open project's name, when the viewer may see it; `connected`: whether a builder
  * that may build there is checking in (null: say nothing); `managed`: whether this person can start one themselves
  * (registering a builder takes an instance operator), else who to ask. */
 export declare function startBuilderHtml(data: {
@@ -123,40 +117,6 @@ export declare function startBuilderHtml(data: {
     connected: boolean | null;
     managed: boolean;
 }): Html;
-export declare function systemPage(chrome: Chrome, data: {
-    agents: {
-        phase: "plan" | "build" | "repair" | "review";
-        provider?: string;
-        model?: string | null;
-        source?: "pinned" | "flag" | "project" | "installation" | "default";
-        problem?: string;
-        setBy: string | null;
-    }[];
-    building: {
-        taskId: string;
-        runner: string;
-        claimedAt: string;
-        expiresAt: string;
-        model: string | null;
-    }[];
-    runners: Runner[];
-    worktrees: WorktreeRow[];
-    episode: {
-        id: number;
-        startedAt: string;
-        endedAt: string | null;
-        ticks: number;
-        built: number;
-        broke: number;
-    } | null;
-    outboxPending: number;
-    externalWork?: {
-        remoteRepo: string;
-        blocked: string | null;
-        openEpisode: string | null;
-    }[];
-    now: Date;
-}): Screen;
 /**
  * A build's stage as one of three steps — set up, writing, checking and
  * committing — read from the machine's own phase, never a percent. The
@@ -203,8 +163,6 @@ export declare function boardBody(data: {
         questions: number;
     } | null;
 }, ciRed: (pr: number) => boolean): Html;
-/** Completed work: one row per done task, its final run and PR attached. */
-export declare function donePage(chrome: Chrome, rows: ReturnType<Store["listCompletedWorkScoped"]>, ciRed: (pr: number) => boolean): Screen;
 export declare function homePage(chrome: Chrome, data: {
     csrf: string;
     taskCount: number;
@@ -244,40 +202,6 @@ export declare function homePage(chrome: Chrome, data: {
     settings: boolean;
     now: Date;
 }): Screen;
-export type TaskComposerPrefill = {
-    title: string;
-    goal: string;
-    not: string;
-    touches: string;
-    acceptance: string;
-    values?: URLSearchParams;
-};
-/** The one front door for new work. The common path is one prompt and one
- * button; the detailed contract remains available in-place for templates,
- * experts, and the rare task that should skip repository-aware planning. */
-/** Where new work goes when no project is open: a choice from the projects
- * this person already has, never a typed path; a new project is one link
- * away. Same-named checkouts show their parent folder to tell them apart. */
-export declare function projectPickerHtml(projects: {
-    path: string;
-    name: string;
-}[], chosen: string): Html;
-export declare function taskComposerHtml(data: {
-    project: string | null;
-    projectRevision?: number;
-    prefill?: TaskComposerPrefill | null;
-    candidates?: {
-        id: string;
-        title: string;
-    }[];
-    permissionDefault: UnattendedPermissionMode;
-    qualityDefault: QualityMode;
-    /** Projects this person may place work in, most recently opened first. */
-    projects?: {
-        path: string;
-        name: string;
-    }[];
-}): Html;
 export type WorkRow = WorkFacts & {
     assignment?: AssignmentSnapshot | null;
     assignmentProblem?: boolean;
@@ -287,6 +211,19 @@ export type WorkRow = WorkFacts & {
     resultRunId: number | null;
 };
 export declare const TASK_GROUP_LABEL: Readonly<Record<WorkIndexGroup, string>>;
+/** A list row's chip (src/design/KIT.md): a waiting row names its ask ("Plan", "Result") in the ask tone, or says
+ * Needs you; every other row wears its headline in the tone of the status it belongs to. */
+export declare function workRowChip(row: Pick<WorkIndexItem, 'ask' | 'chip' | 'status' | 'archived'>): {
+    word: string;
+    tone: ChipTone;
+};
+/** The board's four columns: what needs you, what will start on its own, what runs, what finished. */
+export type WorkBoard = {
+    needs: WorkIndexPage;
+    queued: WorkIndexPage;
+    running: WorkIndexPage;
+    finished: WorkIndexPage;
+};
 export declare function workPage(chrome: Chrome, data: {
     view: WorkView;
     projectFilter?: string;
@@ -298,19 +235,11 @@ export declare function workPage(chrome: Chrome, data: {
     state?: TaskState | null;
     /** An approver in a browser session: rows offer Put away (or Restore, archived), and the page offers Put away old tasks. */
     canPutAway?: boolean;
-}): Screen;
-export declare function browsePage(chrome: Chrome, data: {
-    at: string;
-    root: string;
-    roots: string[];
-    parent: string | null;
-    entries: {
-        name: string;
-        path: string;
-        git: boolean;
-    }[];
-    /** Unused: postForm adds the request's CSRF field. Kept for callers. */
-    csrf: string;
+    /** The project this list shows (null: every project in view) and whether All was asked for by name (`all=1`). */
+    lens?: string | null;
+    all?: boolean;
+    /** The Board view's columns, read from the same index as the list; absent for the List view. */
+    board?: WorkBoard | null;
 }): Screen;
 /** The compact completed row shared by both halves of the control room. */
 export type WorkbenchDone = {
@@ -435,26 +364,6 @@ export type ProjectPeek = {
  * GitHub identity. Everything else is null.
  */
 export declare function githubIdentityOf(remoteUrl: string): string | null;
-/** The GitHub listing page: the account's repositories with ONE honest
- * action each. Names, descriptions, and paths are gh/filesystem DATA —
- * escaped at the sink like everything else. */
-export declare function githubReposPage(chrome: Chrome, data: {
-    /** The last listing; null until someone lists (a POST: listing asks GitHub, so a page visit never does). */
-    listed: ListOutcome | null;
-    local: Map<string, string>;
-    registered: Set<string>;
-    /** Unused: postForm adds the request's CSRF field. Kept for callers. */
-    csrf: string;
-    cloneReady: boolean;
-    openProject: string | null;
-    /** A projects folder didn't answer in time: local copies weren't matched this time. */
-    localUnanswered?: boolean;
-}): Screen;
-export declare function projectsPage(chrome: Chrome, recent: {
-    path: string;
-    name: string;
-    lastOpenedAt: string;
-}[], candidates: string[], open: string | null, problem: string | null, _unscopedMode: boolean, browsable?: boolean, onboard?: OnboardCardState | null, peeks?: Record<string, ProjectPeek | null>, returnTo?: string, pullRequestsOn?: (path: string) => boolean, checkLevelOf?: (path: string) => CheckLevel, activity?: BrowserProjectsView["activity"]): Screen;
 /** The no-script "move to the front" sentinel: the form cannot name the
  * front of a partition, so the handler resolves it (slice 1b, fix 1). */
 export declare const QUEUE_FRONT = "__TOP__";
@@ -473,18 +382,6 @@ export declare function queueBody(tasks: QueueCardTask[], workers: {
     capacity: number;
     building: number;
 }[], revision: number, queueRevision: number): Html;
-/**
- * The fleet screen — one lane per runner, and the work in front of it.
- * Building claims pin to the top of their worker's lane (live — never
- * draggable); queued reservations sit below it (draggable to another
- * worker, re-reserving them). Every card wears its project chip, which is
- * the whole point: which agent is on which project is the page's answer.
- * Form-free like the board, except the per-worker note, so the lane stack
- * can re-render itself while somebody watches.
- */
-export declare function fleetBody(queued: ReturnType<Store["fleetQueue"]>, building: ReturnType<Store["liveClaims"]>, runners: Runner[], queueRevision: number, visibleRepo: (repo: string | null) => boolean): Html;
-/** Identical drag mechanics to the queue — the pointer events land on the worker's column. */
-export declare function fleetScript(): string;
 /** The /queue page's one nonce'd script: delegated pointer-event drag (it
  * survives every fragment swap — finding 17) plus a poller that re-checks
  * focus, dirty inputs, and an in-flight drag AT SWAP TIME, never only
@@ -492,71 +389,6 @@ export declare function fleetScript(): string;
  * (finding 18); missing that, a select counts clean.
  */
 export declare function queueScript(): string;
-export declare function newTaskPage(chrome: Chrome, project: string | null, 
-/** undefined: keep the revision the refused form posted (its draft), so a project switch since still refuses. */
-projectRevision: number | undefined, problem: string | null, candidates?: {
-    id: string;
-    title: string;
-}[], permissionDefault?: UnattendedPermissionMode, qualityDefault?: QualityMode, projects?: {
-    path: string;
-    name: string;
-}[], 
-/** A shipped template's fields, or a refused filing's own words, back in the form. */
-prefill?: TaskComposerPrefill | null): Screen;
-/**
- * The triage flow: everything waiting on a person, one card at a time.
- * Full context ON the card, the act inline, and every act lands back here
- * — clearing the queue is taps, not navigation. Read state travels in the
- * URL (the bounded skip cursor), never in the session: two tabs cannot
- * fight, and a shared link shows the same queue.
- */
-export declare function nextPage(chrome: Chrome, data: {
-    item: {
-        key: string;
-        kind: "decision";
-        decision: Decision & {
-            taskId: string;
-        };
-    } | {
-        key: string;
-        kind: "approval";
-        approval: {
-            taskId: string;
-            title: string;
-            goal: string;
-            digest: string;
-            proposedAt: string;
-        };
-    } | {
-        key: string;
-        kind: "requeue";
-        stalled: {
-            taskId: string;
-            title: string;
-            strikes: number;
-            incidentCount: number;
-        };
-    } | {
-        key: string;
-        kind: "gap";
-        gap: Gap;
-    } | null;
-    scope: Scope | null;
-    planDocument: string | null;
-    planContract?: PlanContractView | null;
-    approvalDigest: string | null;
-    /** v34: said inside the ceremony when the yes buys a report, not a branch. */
-    deliverable?: "branch" | "report";
-    /** v48: the agents the yes freezes — the one block every ceremony shows. */
-    route: RouteView | null;
-    /** v126: where the work came from (an outside event's line of context, never a term agreed to). */
-    origin?: TaskOrigin | null;
-    csrf: string;
-    nonce: string;
-    remaining: number;
-    skipped: string[];
-    now: Date;
-}): Screen;
 export type PeekAdmission = {
     run: Run;
     /** The run's checkout, PROVEN non-null by the guards: a reviewer run