toolroll 0.9.103 → 0.9.105

package/dist/server/render-tasks.js

@@ -1,4 +1,3 @@
-/** Task pages: approval, agents, plans, controls, decisions and the task body. */
 import { archivedWords } from "../tidy.js";
 import { btn, stepRows } from "./kit.js";
 import { whenUtc } from "../when-html.js";
@@ -24,7 +23,7 @@ import {} from "../browser-workspace.js";
 import { permissionPlainWords } from "../chat-decide.js";
 import { CHAT_TASK_ACTIONS } from "../chat-task-actions.js";
 import {} from "../contracts/console-api.js";
-import {} from "../dispatch.js";
+import { NO_AGENT_TITLE } from "../dispatch.js";
 import {} from "../evidence.js";
 import { taskRoad } from "../first-run.js";
 import { starterForWork } from "../flow-starters.js";
@@ -72,14 +71,6 @@ export function contractChangeHtml(change) {
         }
     }
 }
-/**
- * The contract panel (contract handoff, task 1): whether the drafted plan
- * reproduced the filed goal, exclusions, touches, and rubric exactly, or
- * proposes an amendment — every addition, change, and removal listed, the
- * planner's stated reason beside them, and the plain consequence that
- * approving binds the AMENDED terms. "full" is the task page's card;
- * "ceremony" is the restatement inside the approval form and /next.
- */
 export function planContractHtml(view, mode) {
     if (view === null) {
         return mode === "full" ? html `` : html `<p class="meta contract-note">No record compares this plan with your request. Check the plan above against what you asked for before approving.</p>`;
@@ -94,7 +85,6 @@ export function planContractHtml(view, mode) {
             : html `<p class="meta contract-note">Nothing was filed before planning: every part above is the planner's.</p>`;
     }
     if (view.revision === true) {
-        // A send-back: the terms were copied from the previous version, and the planner updated them with the notes.
         if (view.changes.length === 0) {
             return html `<div class="contract-panel contract-preserved"><p class="approval-label">updated plan</p><p><strong>Same plan as before</strong> <span class="meta">your notes fit the previous plan · <a href="/r/${view.run}">Planner's record</a></span></p>${stale}</div>`;
         }
@@ -121,29 +111,19 @@ export function planContractHtml(view, mode) {
         html `</div>`,
     ]);
 }
-/** The exact path limits, one per line (UI polish 2026-09-13): a long
- * comma run was the least readable term on a phone. Every path, verbatim. */
 export function approvalPathsHtml(touches) {
     if (touches.length === 0)
         return html `<p>anything</p>`;
     return html `<ul class="approval-paths">${touches.map(one => html `<li><span class="mono">${one}</span></li>`)}</ul>`;
 }
-/** The rubric, restated above the seal (v39) — the same claim the digest
- * line already makes ("approval binds to this exact wording") extended to
- * the acceptance terms: an id in Geist Mono (a machine fact the proof must
- * answer by), a statement in Geist, the signed evidence kinds after
- * it. `how` never renders here — it is advisory, never signed. Empty
- * renders nothing: a grandfathered scope's ceremony is unchanged. */
 export function acceptanceCeremonyHtml(criteria) {
     if (criteria.length === 0)
         return html ``;
     return html `<p class="meta">Acceptance</p><ul class="recap acceptance-rubric">${criteria.map(c => html `<li><code>${c.id}</code> ${c.statement} <span class="meta">[requires: ${c.evidence.join(", ")}]</span></li>`)}</ul>`;
 }
-/** "claude" + "opus" → "Claude Opus"; "claude-opus-5-5" → "Claude Opus 5.5"; anything else keeps its exact id. */
 export function agentNameWords(provider, model) {
     return agentModelName(provider, model);
 }
-/** The permission a sealed profile grants, in two or three words. */
 export function permissionWordsOf(profile) {
     if (profile === null || profile === undefined)
         return null;
@@ -154,9 +134,6 @@ export function permissionWordsOf(profile) {
             : isAcpProfile(profile) ? "Full access"
                 : profile.sandboxMode === "danger-full-access" ? "Full access" : "Workspace sandbox";
 }
-/** One plain sentence for a revision (approval critique, Oct 2):
- * "Fixes what build #9 missed: <criterion>." The notes, paths and lineage
- * stay in the Details fold. */
 export function revisionSentence(revision, acceptance) {
     const build = `build #${revision.sourceRun}`;
     if (revision.kind === "ci-repair")
@@ -171,8 +148,6 @@ export function revisionSentence(revision, acceptance) {
     const notes = revision.comments.map(one => clean(one.note)).filter(one => one !== "");
     return notes.length === 0 ? `Sends back ${build}.` : `Fixes what ${build} missed: ${notes.join("; ")}.`;
 }
-/** A planner's amendment, said plainly and kept in view: approving binds
- * the amended terms, so this is never folded away. */
 export function approvalAmendmentHtml(view) {
     if (view === null || view === undefined || "problem" in view || !view.filed && view.revision !== true || view.changes.length === 0)
         return html ``;
@@ -193,27 +168,14 @@ export function approvalAmendmentHtml(view) {
         html `</div>`,
     ]);
 }
-/** Whether a fragment renders nothing. */
 const isEmptyHtml = (fragment) => htmlString(fragment) === "";
-/** A fragment's markup for a JSON field of the browser workspace ("" when absent). */
 const fragmentString = (fragment) => fragment === "" ? "" : htmlString(fragment);
-/**
- * The approval sheet (approval critique, Oct 2): the plan open, in plain
- * rows — Goal, Changes, Won't touch, Done when — one line of who builds,
- * one Approve & start beside the password, and every remaining signed
- * term (lineage, routing, runtime limits, the seal) in one Details fold.
- * Presentation only: the same hidden fields, nonce, digest and password
- * post to the same route, and the task page and chat card share it.
- */
-/** v126: a task's origin as a line of words (the identity line). */
 function originWords(origin) {
     const flow = origin.flow === null ? null : origin.flow === "hidden" ? "from a flow" : origin.flow === "removed" ? "from a flow (removed)" : `from flow “${origin.flow.name}”`;
     const source = origin.source === null ? null : `${origin.source.label} (${origin.source.proved})`;
     const request = origin.request == null ? null : `from ${requestName(origin.request)}`;
     return [flow, source, request].filter(one => one !== null).join(" · ");
 }
-/** v126: a task's origin as a fact: the flow, linked for those who may open it, and the outside event, linked to where
- * it lives, with that link's host always shown. */
 function originParts(origin) {
     const parts = [];
     if (origin.flow !== null)
@@ -221,7 +183,6 @@ function originParts(origin) {
     if (origin.source !== null) {
         if (parts.length > 0)
             parts.push(" · ");
-        // The link shows where it goes (host and path), beside what it is.
         parts.push(origin.source.label, ` (${origin.source.proved})`);
         if (origin.source.url !== null)
             parts.push(" · ", { label: linkWords(origin.source.url), href: origin.source.url });
@@ -234,7 +195,6 @@ function originParts(origin) {
     }
     return parts;
 }
-/** The approval sheet: one form that restates every term it signs, the password, and Approve & start. */
 export function approvalSheetHtml(input) {
     const parts = approvalSheetParts(input);
     return joinHtml([
@@ -250,7 +210,6 @@ export function approvalSheetHtml(input) {
                         : html `<p class="approval-password-note" id="${parts.passwordNote}" data-approval-fresh>Your password from ${whenTime(input.freshSince)} is remembered on this computer — leave this blank to approve with it, or type it again.</p>`,
             html `<button type="submit" data-primary-action>${parts.submit}</button></div>`,
             html `<p class="approval-after">${parts.after}</p>`,
-            // Approve, Request changes, Reject (docs/plans/plain-toolroll.md P1.3): Reject is the task's own Cancel, one tap away.
             html `<div class="approval-secondary">${parts.editor ?? html `<a class="approval-link" href="${input.editHref}">Request changes</a>`}<a class="approval-link" href="${input.surface === "task" ? "#cancel-task" : input.notNowHref}">${input.surface === "task" ? "Reject" : "Not now"}</a></div>`,
             parts.details,
         ]), {
@@ -261,14 +220,8 @@ export function approvalSheetHtml(input) {
         parts.editorForm,
     ]);
 }
-/** The approval sheet's parts: what it says first, the signed rows, the in-place editor and its own form, the
- * details fold, and the words the act and its outcome use. The task page (src/design/KIT.md) shows the rows in its
- * Plan tab and the act in its approval box; the chat and /next keep the one sheet. */
 export function approvalSheetParts(input) {
     const { scope, route } = input;
-    // A machine-drafted repair appends its brief to the signed goal; the row
-    // shows the goal and one sentence says what the repair fixes. The whole
-    // signed goal stays in Details.
     const repairText = / — (repair exactly the unmet criteria named below; a comment cannot widen the scope\. Unmet: ([^.]+)\.|Collect only the missing observations for ([^.]+)\. .*|Diagnose the saved failed project check and repair within the original scope\. .*)$/s.exec(scope.goal);
     const goalShown = repairText === null ? scope.goal : scope.goal.slice(0, repairText.index);
     const statementsOf = (ids) => ids.split(",").map(id => id.trim()).map(id => scope.acceptance.find(one => one.id === id)?.statement ?? id).map(one => one.replace(/[.\s]+$/, "")).join("; ");
@@ -293,7 +246,6 @@ export function approvalSheetParts(input) {
     const doneWhen = scope.acceptance.length === 0
         ? html `<p>You decide when you review the result.</p>`
         : html `<ul class="approval-done">${scope.acceptance.map(one => html `<li>${one.statement}</li>`)}</ul>`;
-    // Who builds, in one line: the builder and planner by name, the cap, and full access when granted.
     const legs = route?.projection?.legs ?? [];
     const legOf = (phase) => legs.find(one => one.phase === phase);
     const who = [];
@@ -305,27 +257,20 @@ export function approvalSheetParts(input) {
     else if (scope.profile != null)
         who.push(`Builder ${agentNameWords(scope.profile.provider, scope.profile.model)}`);
     const planner = legOf("plan");
-    // A small change makes no plan: no planner is named (a person's chosen planner still is).
     const sized = route?.projection?.size ?? null;
     const unplanned = route?.projection != null && makesNoPlan(sized, route.projection.risk) && planner?.chosen === "recommended";
     if (planner !== undefined && !unplanned)
         who.push(`Planner ${agentNameWords(planner.provider, planner.model)}`);
-    // What the yes allows, in plain words, right above it: the agent's
-    // permissions, the per-attempt limit, and an earlier version still running.
     const allowing = [];
-    // The clauses of `allowing` the plan sheet says under Worth knowing (a paid fallback, an earlier version still
-    // running): warnings, said first, never folded.
     const warnings = [];
     const allowed = permissionPlainWords(scope.profile);
     if (allowed !== null)
         allowing.push(allowed);
     allowing.push(scope.budgetMicrousd === null ? "no attempt limit" : `up to ${money(scope.budgetMicrousd)} per attempt`);
-    // Fallback agents are terms: who takes over when an agent runs out, with any that spend money said before the yes.
     const chain = chainTermsLines(scope);
     const fallbacks = liveChainFromJson(scope.proposedChainJson ?? null)?.slice(1) ?? [];
     if (fallbacks.length > 0) {
         const paid = fallbacks.filter(one => one.authMode === "api-key" || SUBSCRIPTION_CAPABLE[one.profile.provider] !== true);
-        // Each agent named once, the paid one said where it stands in the order.
         const clause = `if it runs out of its plan, the work moves to ${fallbacks.map(one => `${agentNameWords(one.profile.provider, one.profile.model)}${paid.includes(one) ? " on an API key, which spends money" : ""}`).join(", then ")}`;
         allowing.push(clause);
         if (paid.length > 0)
@@ -348,7 +293,6 @@ export function approvalSheetParts(input) {
             ? html `An agent investigates without changing the repository. You'll hear when its report is ready.`
             : html `An agent starts in its own branch. You'll hear when it's ready to review.`;
     const submit = rebuild !== null ? html `Approve and retry` : html `Approve`;
-    // Everything else the digest binds, one tap away.
     const detail = (title, body, attrs = html ``) => isEmptyHtml(body) ? html `` : html `<section class="approval-detail"${attrs}><h3>${title}</h3>${body}</section>`;
     const revisionBody = input.revision === null ? html `` : joinHtml([
         html `<div class="revision-card" data-revision-feedback>`,
@@ -384,7 +328,6 @@ export function approvalSheetParts(input) {
         scope.budgetMicrousd === null ? "" : html `<p class="meta">Each build attempt has a ${money(scope.budgetMicrousd)} agent-reported usage cap. On a subscription this limits work; it is not an API charge.</p>`,
     ]);
     const details = joinHtml([
-        // On the task page the details are open: the page without script shows every term before the yes. Chat keeps the fold.
         html `<details class="approval-details"${input.surface === "task" ? html ` open` : ""}><summary>Plan details</summary>`,
         revisionDetail,
         repairText === null ? "" : detail("Full goal", html `<p>${scope.goal}</p>`),
@@ -397,17 +340,10 @@ export function approvalSheetParts(input) {
         html `</details>`,
     ]);
     const passwordNote = input.surface === "task" ? "approval-password-note" : "chat-approval-password-note";
-    // Edit plan, in place (task page): the rows become fields and save
-    // through the scope's own route. The fields belong to a form after this
-    // one (forms never nest), so Approve never carries them.
     const edit = input.edit;
     const draft = edit?.draft ?? null;
     const editForm = "plan-editor-form";
-    // Each field opens tall enough for what it holds (up to ten lines).
     const field = (name, value, rows, label, hint = "") => html `<label class="approval-field"><span class="approval-field-label">${label}</span>${hint === "" ? "" : html `<span class="approval-field-hint">${hint}</span>`}<textarea name="${name}" rows="${Math.min(10, Math.max(rows, value.split("\n").reduce((sum, line) => sum + Math.max(1, Math.ceil(line.length / 80)), 0)))}" form="${editForm}">${value}</textarea></label>`;
-    // Done when, one line per requirement in the signed order; the server
-    // matches them back by position (the digest guard keeps that order).
-    // Each requirement says how we'll know it is met (#19): a picker over the kinds a plan names, read back by position.
     const howPicker = (name, chosen, label, planned) => html `<select name="${name}" aria-label="${label}" form="${editForm}" class="approval-how">${planned !== null && planned.length > 1 ? html `<option value="keep"${chosen === "keep" ? html ` selected` : ""}>${`As planned: ${planned.map(kind => EVIDENCE_PLAIN[kind] ?? kind).join(", ")}`}</option>` : ""}${HOW_WE_KNOW.map(kind => html `<option value="${kind}"${chosen === kind ? html ` selected` : ""}>${HOW_WE_KNOW_WORDS[kind]}</option>`)}</select>`;
     const requirement = (name, value, label, how, placeholder = "") => html `<li><input type="text" name="${name}" value="${value}" aria-label="${label}"${placeholder === "" ? "" : html ` placeholder="${placeholder}"`} form="${editForm}">${how}</li>`;
     const requirements = draft?.getAll("requirement") ?? scope.acceptance.map(one => one.statement);
@@ -428,7 +364,6 @@ export function approvalSheetParts(input) {
         requirement("requirement-new", added, "Add a requirement", howPicker("requirement-new-how", addedHow, "How we'll know the new requirement is met", null), "Add a requirement"),
         html `</ul></fieldset>`,
         html `<div class="approval-edit-act"><button type="submit" form="${editForm}">Save plan</button>`,
-        // A plan with written steps keeps its own editor for them.
         edit.stepsHref === null ? "" : html `<a class="approval-link" href="${edit.stepsHref}">Edit steps</a>`, html `</div>`,
         html `</div></details>`,
     ]);
@@ -436,15 +371,10 @@ export function approvalSheetParts(input) {
     const editorForm = edit === null ? "" : postForm(edit.action, null, {
         attrs: { id: editForm, class: "approval-editor-form" },
         hidden: {
-            // A refused save keeps the version its draft was edited from, so a
-            // plan that changed meanwhile is never silently overwritten.
             sawDigest: draft?.get("sawDigest") ?? scope.digest,
-            // The terms the editor doesn't show ride along unchanged: a repair's
-            // brief after its goal (it stays in Details), permissions, checks, cap.
             "goal-brief": repairText === null ? null : repairText[0],
             "permission-mode": keptMode,
             "quality-mode": scope.qualityMode ?? "default",
-            // The cap rides in exact millionths ("none" keeps no limit).
             "budget-microusd": scope.budgetMicrousd === null ? "none" : String(scope.budgetMicrousd),
         },
     });
@@ -455,8 +385,6 @@ export function approvalSheetParts(input) {
         input.deliverable === "report" ? html `<p class="approval-note">Read-only: it reports back and changes nothing in the repository.</p>` : "",
         originNote(input.origin) === null ? "" : html `<p class="approval-note" data-approval-origin>${originNote(input.origin)}</p>`,
     ]);
-    // A release's terms are part of what the yes agrees to (the digest signs them): said whole on every approval
-    // surface (the plan sheet, the page without script, chat), before Approve, with nothing folded.
     const releaseBody = scope.releaseTerms == null && scope.releaseCheck == null ? "" : joinHtml([
         scope.releaseTerms == null ? "" : html `<p>${releaseTermsSentence(scope.releaseTerms)}</p>`,
         scope.releaseCheck == null ? "" : html `<p>${releaseCheckSentence(scope.releaseCheck)}</p>`,
@@ -473,15 +401,11 @@ export function approvalSheetParts(input) {
         chain.length === 0 ? "" : row("If it runs out", html `<p>${chain[0]}</p><ol class="approval-steps" data-approval-fallback>${chain.slice(1).map(one => html `<li>${one.replace(/^\d+\. /, "")}</li>`)}</ol>`),
         html `</dl>`,
         amendment,
-        // The size, said once and plainly beside who builds: "Small change: fast model, no plan".
         projection === null ? "" : sizeLineHtml(projection),
         who.length === 0 ? "" : html `<p class="approval-who">${who.join(" · ")}</p>`,
         routeEvidenceHtml(route, "approval-evidence"),
         consent,
     ]);
-    // The plan sheet (docs/plans/task-page-steps.md): the same parts, re-ordered and re-labelled to read top to bottom —
-    // one lead sentence, Steps, Done when, Will change / Won't touch, Worth knowing, the agent — with nothing a person
-    // signs inside a fold. Never a second reading of the scope: every term below is one of the parts above.
     const parsedPlan = plan !== null && plan.ok ? plan.document : null;
     const approach = parsedPlan?.approach.trim() ?? "";
     const firstSentence = (text) => /^[\s\S]+?[.!?](?=\s|$)/.exec(text)?.[0] ?? text;
@@ -490,7 +414,6 @@ export function approvalSheetParts(input) {
     const part = (title, body, attrs = html ``) => body === "" || isEmptyHtml(body) ? html `` : html `<section class="plan-sheet-part"${attrs}><h3 class="plan-sheet-h">${title}</h3>${body}</section>`;
     const statementKey = (text) => text.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
     const signedKeys = scope.acceptance.map(one => statementKey(one.statement));
-    // The plan's proof lines a requirement doesn't already say, word for word: a line that adds a condition to one stays.
     const extraProof = (parsedPlan?.proof ?? []).filter(line => { const key = statementKey(line); return key !== "" && !signedKeys.includes(key); });
     const doneWhenSheet = joinHtml([
         scope.acceptance.length === 0 ? html `<p>You decide when you review the result.</p>` : html `<ul class="plan-sheet-done">${scope.acceptance.map(one => html `<li><span>${one.statement}</span><span class="plan-sheet-how">${one.evidence.map(kind => EVIDENCE_SHEET[kind] ?? kind).join(" · ")}</span></li>`)}</ul>`,
@@ -506,7 +429,6 @@ export function approvalSheetParts(input) {
         originNote(input.origin) === null ? "" : html `<p class="approval-note" data-plan-origin>${originNote(input.origin)}</p>`,
         html `<p class="${sheetLead.length > 180 ? "plan-sheet-lead plan-sheet-lead-long" : "plan-sheet-lead"}">${sheetLead}</p>`,
         approachRest === "" ? "" : html `<p class="plan-sheet-text">${approachRest}</p>`,
-        // An older plan that doesn't parse keeps its text, as written.
         plan !== null && !plan.ok ? html `<pre class="recap plan-doc">${input.planDocument ?? ""}</pre>` : "",
         goalShown.trim() === sheetLead ? "" : part("Goal", html `<p class="approval-goal">${goalShown}</p>`),
         repairText === null ? "" : part("Full goal", html `<p>${scope.goal}</p>`),
@@ -541,29 +463,21 @@ export function approvalSheetParts(input) {
     ]);
     return { lead, rows, editor, editorForm, details, submit, label: rebuild !== null ? "Approve and retry" : "Approve", after, allowing, passwordNote, sheet, sheetLead };
 }
-/** The plan sheet: what an approval signs, read top to bottom (approvalSheetParts' own parts, re-ordered). */
 export function planSheetHtml(input) {
     return approvalSheetParts(input).sheet;
 }
-/** Evidence kinds on the plan sheet: how each requirement is proven, in plain words. */
 export const EVIDENCE_SHEET = { check: "Runs automatically", screenshot: "Shown in a screenshot", "changed-path": "Seen in the changed files", "manual-review": "You review it" };
-/** Earlier versions of a task still in flight, in plain words: queued
- * while they only wait, running once one has started; null when none. */
 export function earlierVersionsWords(active, running) {
     if (active <= 0)
         return null;
     const still = running >= active ? "running" : running <= 0 ? "queued" : "queued or running";
     return active === 1 ? `an earlier version is still ${still}` : `${active} earlier versions are still ${still}`;
 }
-/** An in-place plan edit that would change the agent's permissions: thrown to roll the save back. */
 export class PermissionsWouldChange extends Error {
 }
-/** Evidence kinds in plain words, for the signed criteria in Details. */
 export const EVIDENCE_PLAIN = { check: "the project check", screenshot: "screenshots", "changed-path": "changed files", "manual-review": "your own check" };
-/** The kinds a requirement's "How we'll know" picker offers, in the order it lists them (#19). */
 export const HOW_WE_KNOW = ["check", "screenshot", "changed-path", "manual-review"];
 export const HOW_WE_KNOW_WORDS = { check: "The project check passes", screenshot: "A screenshot shows it", "changed-path": "The changed files show it", "manual-review": "You check it yourself" };
-/** The permission choice a sealed profile carries, as the scope form names it. */
 export function permissionModeOfProfile(profile) {
     if (profile === null || profile === undefined)
         return null;
@@ -574,12 +488,6 @@ export function permissionModeOfProfile(profile) {
             : isAcpProfile(profile) ? "bypassPermissions"
                 : profile.sandboxMode === "danger-full-access" ? "bypassPermissions" : "auto";
 }
-/** Done when, from the in-place editor: each line keeps its requirement's
- * id by position, and its evidence and guidance while its words stand; a
- * rewritten one is yours to check, like an added one; an emptied one is
- * dropped. A "How we'll know" choice beside a line (#19) names its one kind
- * instead; "keep", or no choice at all (an older form), changes nothing. The
- * saved plan is a new version either way: it needs approving like any edit. */
 export function requirementsFromEditor(body, current) {
     const used = new Set(current.map(one => one.id));
     let next = 1;
@@ -608,13 +516,6 @@ export function consentDoorOf(scope, route) {
     if (scope.profileState === "unresolved") {
         return { open: false, title: "The agent setup isn’t ready yet", why: scope.unresolvedReason ?? "the plan can't say exactly what would run", road: "scope" };
     }
-    // THE SAME STRICT PROJECTION THE SEAL USES (v48 integrity): before any
-    // nonce, password field, or approve action renders, the stored scope
-    // must prove exactly — exact-key profile, chain, and route; safe and
-    // timer-safe numbers; a well-formed auth mode on every chain entry;
-    // build/repair parity; the profile as the chain's entry zero; the
-    // digest re-derived complete. What the seal would refuse, no surface
-    // offers.
     const authority = scopeAuthorityOf(scope, { authMode: provider => readAuthModeStrict(provider) });
     if (!authority.ok) {
         if (authority.reason === "auth-mode") {
@@ -638,8 +539,6 @@ export function consentDoorOf(scope, route) {
     }
     return { open: true };
 }
-/** The closed door, rendered: no nonce, no password, no approve button —
- * the reason and the one act that opens it. */
 export function consentClosedHtml(taskId, door, surface) {
     const href = `${taskHref(taskId)}#${door.road === "agents" ? "agents" : "scope"}`;
     const act = door.road === "agents" ? "Change the agents →" : "Edit the plan →";
@@ -673,12 +572,9 @@ export function profileWords(scope) {
             : isAcpProfile(profile)
                 ? html `<p class="meta">Runs on <span class="mono">${ACP_AGENTS[profile.provider].name} (via ACP) · ${profile.model}</span> — full access inside Toolroll's sandbox; the agent runs any tool it chooses and nothing asks. No turn limit: stops after ${Math.round(profile.timeoutSeconds / 60)} min, or ${Math.round(profile.idleTimeoutSeconds / 60)} min silent; repairs on ${repair}, ${Math.round(profile.repairTimeoutSeconds / 60)} min, or ${Math.round(profile.repairIdleTimeoutSeconds / 60)} min silent.</p>`
                 : html `<p class="meta">Runs on <span class="mono">${profile.provider} · ${profile.model}</span> — ${profile.sandboxMode === "danger-full-access" ? "FULL permissions via --dangerously-bypass-approvals-and-sandbox; nothing asks" : "workspace-write sandbox"}, no turn limit (${Math.round(profile.timeoutSeconds / 60)} min ${profile.timeoutKind === "idle" ? "without progress" : "per attempt"}); repairs on ${repair}, ${Math.round(profile.repairTimeoutSeconds / 60)} min</p>`;
-    // What the build may reach is part of what is approved (egress.ts): said on every approval form.
-    // Its sandbox terms (project-sandbox.ts): what it reads always, and any widening, part of what the yes agrees to.
     const terms = sandboxTermsWords(profile);
     return html `${base}<p class="meta" data-scope-network>${networkWords(profile.network ?? null)}</p><p class="meta" data-scope-writes>Writes: ${writesWords(profile.writes)}.</p>${profile.checkAccess === undefined ? "" : html `<p class="meta" data-scope-checks>Checks: ${checkAccessWords(profile.checkAccess)}.</p>`}<p class="meta" data-scope-reads>Reads: ${terms.reads}.</p>${terms.mach === null ? "" : html `<p class="meta" data-scope-mach>${terms.mach.charAt(0).toUpperCase()}${terms.mach.slice(1)}.</p>`}`;
 }
-/** The evidence line beside the agents, only when an earned rule chose the builder. */
 export function routeEvidenceHtml(view, className = "meta") {
     const words = view?.evidence ?? null;
     if (words === null)
@@ -698,14 +594,11 @@ export function agentsStandingWords(view) {
                     ? "awaiting approval"
                     : "recommended";
 }
-/** The size line an approval leads its agents with — "Small change: fast
- * model, no plan" — and, quietly, why it was sized so. */
 export function sizeLineHtml(projection) {
     if (projection.sizeWords === null)
         return html ``;
     return html `<p class="agents-size"><strong>${projection.sizeWords}.</strong>${projection.sizeReason === null ? "" : html ` <span class="meta">${projection.sizeReason}</span>`}</p>`;
 }
-/** What a size does, for a proposal card. */
 export function sizeConsequence(size, risky) {
     if (size === "small" && !risky)
         return "Small change: fast model, no plan";
@@ -713,7 +606,6 @@ export function sizeConsequence(size, risky) {
         return `${size === "large" ? "Large" : "Risky"} change: strongest agents plan and build`;
     return "Medium change: everyday agents";
 }
-/** The one plain-English line: who does what. */
 export function agentsSummaryWords(view) {
     if (view.projection !== null)
         return view.projection.summary;
@@ -721,18 +613,13 @@ export function agentsSummaryWords(view) {
         return `${view.legacy.provider} · ${view.legacy.model} builds and repairs (repair model ${view.legacy.repairModel}); the planner and reviewer come from configuration at run time`;
     return view.problem ?? "the agents cannot be read";
 }
-/** A risk badge only when there is something to say: a risky change, or an
- * older route sealed at elevated or high risk. */
 export function riskBadgeHtml(projection) {
     return projection.riskTitle === "Routine" ? html `` : html `<span class="badge">${sentenceCase(projection.riskTitle)}</span>`;
 }
-/** Neutral metadata badges: risk (when not routine), posture, and standing. */
 export function agentsBadgesHtml(view) {
     const p = view.projection;
     return html `${p === null ? "" : riskBadgeHtml(p)}${p === null ? "" : html `<span class="badge">${sentenceCase(p.postureWords)}</span>`}<span class="badge">${sentenceCase(agentsStandingWords(view))}</span>`;
 }
-/** Volatile availability, per provider on the route — shown beside the
- * agents, never inside the approval's terms. */
 export function agentsAvailabilityHtml(projection) {
     const seen = new Map();
     for (const leg of projection.legs)
@@ -745,7 +632,6 @@ export function agentsAvailabilityHtml(projection) {
     });
     return html `<p class="meta agents-availability-label">Availability right now</p><ul class="agents-availability">${items}</ul>`;
 }
-/** The closed details: one row per role, with the reasons. */
 export function agentsWhyHtml(projection, summaryLabel = "Why these agents") {
     return joinHtml([
         html `<details class="agents-why"><summary>${summaryLabel}</summary>`,
@@ -762,14 +648,10 @@ export function agentsWhyHtml(projection, summaryLabel = "Why these agents") {
         html `</dl></details>`,
     ]);
 }
-/** The ceremony's agents block: what the yes agrees to — the agents and
- * their reasons. Availability is volatile and deliberately absent here. */
 export function agentsCeremonyHtml(view) {
     if (view === null || view === undefined)
         return html ``;
     if (view.projection === null) {
-        // A proven pre-routing approval: its sealed profile is the whole
-        // agents term, said in the same place with the same label.
         if (view.legacy !== null) {
             return html `<div class="agents-ceremony"><p class="approval-label">agents</p><p class="agents-summary">${agentsSummaryWords(view)}</p></div>`;
         }
@@ -785,11 +667,6 @@ export function agentsCeremonyHtml(view) {
         html `<p class="meta">These exact agents are part of what you approve; changing any of them asks for a fresh approval.</p></div>`,
     ]);
 }
-/** The runtime limits the sealed profile binds — permissions, turn and
- * time bounds, repairs — restated on the ceremony as
- * a CLOSED disclosure (v48): a term the yes covers, one tap away, never a
- * wall of switches between the reader and the password. An unresolved
- * profile still speaks in the open: that is a refusal, not a detail. */
 export function runtimeDetailsHtml(scope) {
     if (scope.profileState === "unresolved")
         return profileWords(scope);
@@ -798,9 +675,6 @@ export function runtimeDetailsHtml(scope) {
         return html ``;
     return html `<details class="agents-runtime"><summary>Runtime limits</summary>${words}</details>`;
 }
-/** The task page's Agents card: the summary, availability, closed reasons,
- * and — for an approver — closed change controls. Every change re-files
- * the scope; an approval given under the earlier agents needs renewing. */
 export function agentsCardHtml(taskId, view, canEdit) {
     if (view === null || view === undefined)
         return html ``;
@@ -816,14 +690,7 @@ export function agentsCardHtml(taskId, view, canEdit) {
                 : "",
             html `</li>`,
         ]))}</ul>`;
-    // The controls (v48): a size choice that says what each size does, and
-    // — per role — ONLY the configured, role-valid agents the operator may
-    // pick from. Nothing is typed free-hand, no command line is quoted; the
-    // reasons above already say why the current agents were chosen.
     const roleForms = ROUTE_PHASES.filter(phase => phase !== "review").map(phase => {
-        // Selectable choices are the role's own configured agents; a current
-        // agent the configuration no longer names is DISPLAY-ONLY — said
-        // beside the control, never an option the form could re-pick.
         const options = view.choices[phase].filter(one => one.selectable);
         const stale = view.choices[phase].find(one => one.current && !one.selectable) ?? null;
         const staleNote = stale === null ? "" : html `<p class="meta agents-stale">Runs today on <span class="mono">${`${stale.provider} · ${stale.model}`}</span>, which is no longer in your configuration — pick a configured agent to replace it.</p>`;
@@ -844,7 +711,6 @@ export function agentsCardHtml(taskId, view, canEdit) {
                 html `<details class="agents-change"><summary>Change agents</summary>`,
                 postForm(route, joinHtml([
                     html `<label>Size<select name="size" aria-label="task size">${TASK_SIZES.map(one => html `<option value="${one}"${one === (p?.size?.size ?? "medium") ? html ` selected` : ""}>${sizeConsequence(one, false)}</option>`)}</select></label>`,
-                    // The hidden "no" says the form showed the box: unticked means not risky; a request without either keeps the flag.
                     html `<input type="hidden" name="risky" value="no"><label class="agents-risky"><input type="checkbox" name="risky" value="yes"${p?.size?.risky === true ? html ` checked` : ""}> Risky</label>`,
                     html `<button type="submit" class="secondary">Set size</button>`,
                 ]), { attrs: { class: "agents-form-risk" }, hidden: { sawDigest } }),
@@ -872,26 +738,20 @@ export function agentsCardHtml(taskId, view, canEdit) {
         html `</section>`,
     ]);
 }
-/** The chat's always-visible strip: the summary and a way to the details. */
 export function agentsStripHtml(view, taskId) {
     if (view === null)
         return html ``;
-    // A broken setup is not secondary detail: keep its failure visible.
     if (view.kind === "unreadable")
         return html `<p class="task-chat-agents">${agentsSummaryWords(view)} <a href="${taskHref(taskId)}#agents">Review agent setup</a></p>`;
     return html `<details class="task-chat-agents"><summary>Agent setup</summary><p>${agentsSummaryWords(view)}</p><a href="${taskHref(taskId)}#agents">View agents</a></details>`;
 }
-/** A ceremony nonce as stored: the sha256 hex of the value the form carried. */
 export function nonceHashOf(value) {
     return createHash("sha256").update(value).digest("hex");
 }
-/** The approve POST's refusal, in words a person can act on. */
-/** A release task's automatic approval, in words (docs/plans/auto-approve-green.md). */
 export function autoReleaseWords(auto) {
     return auto.kind === "approved" ? `Approved automatically: CI and release check passed on ${auto.candidate.slice(0, 7)}`
         : `Checking automatically: approves itself once CI and the release check pass on ${auto.candidate.slice(0, 7)}`;
 }
-/** " (password remembered from 10:42)" when the approval stood on a remembered password or sign-in; nothing otherwise. */
 export function approvalProofWords(proof) {
     if (proof == null)
         return "";
@@ -907,7 +767,6 @@ export function approvalProofWords(proof) {
         return " (from your paired chat)";
     if (proof.method === "carried")
         return " (from the release approval)";
-    // Easy-start C5: this computer's owner approving attended work in local mode, with no password.
     if (proof.method === "local-owner")
         return " (on this computer, no password)";
     return "";
@@ -928,17 +787,10 @@ export function approveRefusalWords(reason) {
         return "not approved: the plan can't name an exact agent for every role. Fix the agent setup, then save the plan again";
     if (reason === "password-now")
         return "not approved: this needs your password typed now — protected work, raised permissions, or a plan an agent wrote can't use a remembered one";
-    // A wrong password, someone who isn't an approver (or not for this project), a revoked login: one answer for all, so
-    // the refusal never tells a guesser which it was.
     if (reason === "not-an-approver")
         return "That password didn't match.";
     return `not approved: ${reason}`;
 }
-/** The browser's one-click approval binds not only the signed scope but the
- * exact advisory plan revision shown beside it. The scope digest remains the
- * durable authority; this composite makes a stale open tab fail when somebody
- * edits the plan before approval. The empty middle slot keeps the bytes of
- * forms already open (it once held other terms, always empty here). */
 export function approvalFormDigest(scopeDigest, planSha) {
     if (planSha === null)
         return scopeDigest;
@@ -951,17 +803,11 @@ export function approvalFormDigest(scopeDigest, planSha) {
         .update(planSha ?? "", "utf8")
         .digest("hex");
 }
-/** The one task-level road from a truthful dispatch diagnosis to its nearest
- * existing repair. This is navigation, never authority: every destination
- * still owns its original confirmation, password, CSRF, and transactional
- * checks. Keeping the map here also means the focused chat and task overview
- * cannot send a person to different fixes for the same gate. */
 export function taskRecoveryHref(taskId, diagnosis) {
     if (diagnosis?.action === null || diagnosis?.action === undefined)
         return null;
     const task = taskHref(taskId);
     switch (diagnosis.action) {
-        // The task page only repeats that no builder is connected: lead to the command that connects one.
         case "start-worker":
             return startBuilderHref(taskId);
         case "repair-dependency":
@@ -990,25 +836,12 @@ export function taskRecoveryHref(taskId, diagnosis) {
             return `${task}#task-control`;
     }
 }
-/** The resume ceremony's digest (v52): the exact run, its settlement, and
- * the scope approval as it stands — a nonce minted over one set of facts
- * cannot confirm a resume under another. */
 export function resumeDigestOf(taskId, runId, settledAt, scope) {
     return createHash("sha256")
         .update(JSON.stringify([taskId, runId, settledAt, scope?.digest ?? null, scope?.approvedDigest ?? null, scope?.approvedAt ?? null, scope?.approvedBy ?? null]))
         .digest("hex");
 }
 export const stopWhen = (iso) => iso.replace("T", " ").replace(/\.\d{3}Z$/, "Z");
-/**
- * The exact-run control (v52): ONE component on the task page, the
- * focused chat, and the status fragment, so every surface names the same
- * run and shows the same state. Stop is one guarded post naming the run;
- * Stopping… is a disabled control with who asked and when; Resume opens
- * the password ceremony; a stopped review points at Review again. Forms
- * carry the CSRF token and the exact run id, nothing else.
- */
-/** Presentation only: the same projected words and action on all task
- * surfaces. Approval keeps its action on the exact-terms disclosure. */
 export function taskStatusCard(status, taskId, dispatch, runId, approvalAction = false) {
     const task = taskHref(taskId);
     const recovery = status.token === "waiting-decision" ? `${task}#task-questions` : status.token === "stopping" || status.token === "stopped"
@@ -1036,9 +869,6 @@ export function taskControlDetailsHtml(control, taskId, csrf, surface, inert = f
     return control.kind === "paused" || control.kind === "review-stopped" || control.kind === "stopping"
         ? html `<details id="task-control-details"><summary>${control.kind === "paused" ? "Preserved work and resume" : "Stop details"}</summary>${card}</details>` : card;
 }
-/** Pause and Pause and steer beside the task page's Stop (live steering): the same exact run, each form under its own
- * request id so a repeated submit is the same request. Pause hides once asked; a paused build says until when it can
- * wait and offers Resume, or the note to continue with. */
 function pauseFormsHtml(taskId, livePause) {
     const form = (fields, button, control, extra = {}) => postForm(`${taskHref(taskId)}/pause`, html `${fields}${button}`, { attrs: { class: "inline task-control-form", "data-task-control": control }, returnTo: "task", hidden: { run: livePause.run, request: `web-${randomUUID()}`, ...extra } });
     const paused = livePause.state === "paused";
@@ -1101,12 +931,8 @@ export function taskControlHtml(control, taskId, csrf, surface, inert = false, s
     }
     return html `<details class="card task-control" id="task-control" data-task-control="review-stopped"><summary>Previous assessment stopped</summary><p>Run #${control.run} was stopped by ${control.stop.requestedBy}. The saved result is unchanged.</p></details>`;
 }
-/** The resume confirmation (v52): the exact run restated, what resuming
- * does and does not do, the gate that would still keep work from
- * starting, and the password typed again. */
 export function resumeCeremonyPage(chrome, data) {
     const control = data.control;
-    // One card, one button (docs/plans/plain-toolroll.md P1.3): the same post, nonce, run and password rule as before.
     const blocked = !data.approved ? "The plan isn't approved as it stands, so nothing builds until it is approved again."
         : data.gate === null ? null : `${data.gate.summary}: ${data.gate.detail}`;
     return screen("resume", joinHtml([
@@ -1133,7 +959,6 @@ export function publicationFactsOf(publication) {
         ? null
         : { state: publication.state, prNumber: publication.prNumber, prUrl: publication.prUrl, remoteState: publication.remoteState, lastCheckState: publication.lastCheckState };
 }
-/** Where a status's next act lives, for a row that links out. */
 export function statusActionHref(status, taskId, runId, prUrl, repo) {
     if (status.action === null)
         return null;
@@ -1147,9 +972,6 @@ export function statusActionHref(status, taskId, runId, prUrl, repo) {
         default: return taskHref(taskId);
     }
 }
-/** The one status line every surface renders: a dot in the tone, the
- * label, and the `data-work-status` token tests and CSS key off. */
-/** A not-yet-finished task's shared headline from its dispatch diagnosis (task-status.ts). */
 export function dispatchHeadline(d) {
     const read = stageOfDispatch(d);
     return taskStatusOf({ stage: read.stage, ...(read.need === undefined ? {} : { need: read.need }), ...(read.wait === undefined ? {} : { wait: read.wait }) }).headline;
@@ -1160,16 +982,6 @@ export function statusLineHtml(status, extra = "") {
 export function workDiagnosticsHtml(diagnostics) {
     return joinHtml((diagnostics ?? []).map(one => html `<p class="work-detail" data-work-diagnostic="${one.token}"><strong>${one.label}</strong> · ${one.detail}</p>`));
 }
-/**
- * The decision card everywhere a person may ANSWER (portfolio, the
- * selected-project inbox; the task page joins in slice 3): a reversible
- * option answers with one tap on the card, labeled with its own words —
- * never a letter; an irreversible option is a LINK to the decision page,
- * where the server-side confirm=yes guard lives. The roll-up inbox keeps
- * its links-only cards and never renders this partial. The recommended
- * option wears a neutral badge — recommendation is not urgency, and magenta
- * stays on the card's outline.
- */
 export function decisionAnswerCard(decision, csrf, now, chip, returnTo = null) {
     const detailsHref = `/d/${decision.id}${returnTo === null ? "" : `?return=${encodeURIComponent(returnTo)}`}`;
     const options = decision.options
@@ -1196,21 +1008,11 @@ export function decisionAnswerCard(decision, csrf, now, chip, returnTo = null) {
         html `<div class="decide-options">${joinHtml(options, "\n")}</div></div>`,
     ]);
 }
-/**
- * The inline-answer enhancement (portfolio arc §2): submits a reversible
- * option's form as the urlencoded POST the forms-only gate expects, follows
- * the redirect, and — because an answered decision leaves the open list —
- * replaces ONLY that card with the answered receipt parsed from the
- * decision page's own rendering, or removes the card. Anything unexpected
- * (auth, a page that is not the decision's) navigates instead of inserting.
- * Nothing else on the page is touched: typed input elsewhere survives.
- */
 export function decisionAnswerScript() {
     return (`document.addEventListener("submit",function(e){` +
         `var f=e.target;if(!f||!f.classList||!f.classList.contains("decide-inline"))return;` +
         `e.preventDefault();` +
         `var card=f.closest("[data-decision-id]");` +
-        // The action attribute, not f.action: a field named "action" would shadow that property (DOM clobbering).
         `var to=new URL(HTMLFormElement.prototype.getAttribute.call(f,"action")||"",location.href).href;` +
         `var page=to.replace(/\\/answer$/,"");` +
         `fetch(to,{method:"POST",credentials:"same-origin",` +
@@ -1226,9 +1028,6 @@ export function decisionAnswerScript() {
         `if(receipt){card.replaceChildren(document.importNode(receipt,true))}else{card.remove()}` +
         `},function(){location.href=page})});`);
 }
-/** A plan is stored as inert Markdown for portability into the builder
- * brief, but the console renders its known structure as a useful control
- * surface. Historical free-form plans keep their safe plain-text fallback. */
 export const MILESTONE_STATE_WORDS = {
     pending: "Pending",
     current: "In progress",
@@ -1238,11 +1037,6 @@ export const MILESTONE_STATE_WORDS = {
 export function milestoneStateWord(state) {
     return MILESTONE_STATE_WORDS[state] ?? "Pending";
 }
-/** Adaptive execution plans (v44): the live milestone projection a running
- * (or finished) build has reported. A shared render used by BOTH the task
- * page and the focused chat's live region (c2) — labeled clearly as an
- * agent's own report, since a milestone claim is never completion proof
- * (Priority 2's proof contract is the only thing that adjudicates "done"). */
 export function milestoneProgressHtml(milestones) {
     if (milestones === null || milestones === undefined || milestones.length === 0)
         return html ``;
@@ -1254,16 +1048,7 @@ export function milestoneProgressHtml(milestones) {
         html `</ul><p class="meta milestone-progress-note">Live checkpoints from the agent.</p></section>`,
     ]);
 }
-/** Adaptive execution plans (v44): the current plan revision's own reason
- * and evidence, any revision still awaiting an operator's accept/reject,
- * and the immutable history. A shared render used by BOTH the task page
- * and the focused chat's live region (c2), reading a document already
- * verified before a byte reached this function (c5). `csrf` is only a
- * guard now: an empty one renders no forms; postForm writes the field. */
 export function planRevisionLedgerHtml(ledger, taskId, csrf) {
-    // Nothing to show yet unless a plan has actually been revised: a task
-    // still on its synthetic revision-1 projection, with no pending proposal
-    // and no persisted history, is exactly what the plan card already shows.
     if (ledger === null || ledger === undefined || ledger.current === null || (ledger.pending === null && ledger.history.length === 0))
         return html ``;
     const current = ledger.current;
@@ -1329,15 +1114,6 @@ export function executionPlanHtml(document, compact = false) {
 function revisionImageLink(image) {
     return image == null ? html `` : html `<a href="/r/${image.run}/evidence/${image.artifact}">Screenshot ${image.artifact} · result #${image.run}</a> · `;
 }
-/**
- * A revision's lineage and ACTUAL terms, in the same words on the task
- * page, the approval card, and chat (contract handoff task 2): which
- * source and build it revises, the ancestry to its root, the terms the
- * child really carries (read from its own scope — never restated from the
- * brief), what is re-resolved for THIS approval, what never inherits, and
- * — when the task continues a repair chain — the attempts used against
- * the signed cap.
- */
 export function revisionLineageWords(lineage) {
     const words = [];
     if (lineage.problem !== undefined)
@@ -1373,13 +1149,6 @@ export function revisionLineageHtml(lineage) {
 export function taskBodyParts(data) {
     const { task, scope } = data;
     const stopControlsActive = data.control !== undefined && ["stopping", "paused", "review-stopped"].includes(data.control.kind);
-    // The result's shared status (workspace package 1): the same projection
-    // the Work row, the focused chat, and the review cockpit render for this
-    // run, so a done task with failed or missing proof never wears a bare
-    // "done" badge here while another surface says otherwise.
-    // The receipt re-verified the stored bytes (repair 2026-09-14), so the
-    // box wears the receipt's own status whenever a receipt exists — the
-    // two never disagree on one page about damaged evidence.
     const resultStatus = task.state !== "done"
         ? null
         : data.completion?.receipt !== null && data.completion?.receipt !== undefined
@@ -1397,19 +1166,8 @@ export function taskBodyParts(data) {
                     review: data.completion.review ?? null,
                 }, publicationFactsOf(data.publication ?? null));
     const status = data.status ?? workStatusOf({ id: task.id, title: task.title, repo: data.repo, state: task.state, updatedAt: task.updatedAt, dispatch: data.dispatch ?? null, result: null, publication: null, liveRunId: data.liveRunId ?? null, control: data.control ?? { kind: "none" } }, resultStatus ?? undefined);
-    // A review in flight leads the status box too (review fixes, finding
-    // 4): the box keeps its recorded-verdict sentence as history under the
-    // review's own words, and reads neutral rather than ok/problem while the
-    // machine is still deciding.
     const inReview = resultStatus !== null && REVIEW_TOKENS.has(resultStatus.token);
     const act = (verb, label, hidden = {}) => postForm(`${taskHref(task.id)}/${verb}`, html `<button type="submit">${label}</button>`, { attrs: { class: "inline" }, hidden });
-    // The active attempt panel (slice 1c): the run whose lease is the task's
-    // CURRENT claim, named by its one unambiguous identity — build number and
-    // worker (runsFor mixes roles newest-first, so an "attempt N" ordinal is
-    // undefined and not used). The live peek and transcript embed here,
-    // polled from the RUN's own authenticated fragments; a serve that never
-    // asserted its runner says so in the same words the run page uses; a
-    // page carrying a password ceremony degrades to the static line.
     const liveRunId = data.liveRunId ?? null;
     const liveRun = liveRunId === null ? undefined : data.runs.find(one => one.id === liveRunId);
     const liveHistoryRunId = data.control?.kind === "stop" && data.control.role === "reviewer" && data.completion?.review?.reviewerAlive === true ? data.control.run : liveRunId;
@@ -1423,25 +1181,13 @@ export function taskBodyParts(data) {
         if (data.degraded !== undefined) {
             return html `<div class="card attempt-live" data-live-run="${liveRun.id}">${head}<p class="meta">${data.degraded === "sensitive" ? "This page carries a password ceremony, so the live view stays on the build page" : "The live view is on the build page"}</p>${door}</div>`;
         }
-        // With the live file view off there is nothing live to show here: no panel (the build's own page says why).
         if (data.peekable !== true)
             return "";
         const peek = html `<p class="meta">What is changing right now</p><div id="run-peek"><p class="meta">Watching… the first look lands within 15 seconds</p></div><p class="meta" id="run-peek-stamp"></p>`;
-        // What the agent is saying is the work panel's (Watch the work): the same records, read by the workspace.
         return html `<div class="card attempt-live" data-live-run="${liveRun.id}">${head}${peek}${door}</div>`;
     })();
-    // One truthful answer to the first question on a queued task: "will this
-    // run?" The badge alone cannot distinguish approval, dependency,
-    // capability, and worker gates. This card does, in priority order, and
-    // gives the nearest concrete repair rather than making the operator infer
-    // it from the rest of the page.
     const dispatchStatus = (() => {
-        // data-work-status is the shared projection's token (package 1) —
-        // the same one the Work row, chat, and cockpit carry for this task.
         const workToken = resultStatus?.token ?? data.dispatch?.code ?? "unknown";
-        // A diagnosis under Task options: the exact technical reason, one tap
-        // away from the shared headline (task-status.ts). Red only when that
-        // headline is Failed.
         const headline = status.label;
         const box = (kind, title, detail, code, controls = "") => html `<div class="${kind === "problem" && !inReview && headline === "Failed" ? "problem" : "answered"} dispatch-status" id="run-status" data-dispatch-status="${code ?? title.toLowerCase().replace(/[^a-z0-9]+/g, "-")}" data-work-status="${workToken}"><div class="dispatch-copy"><strong>${inReview ? "Recorded checks" : title}</strong><span class="meta">${detail}</span></div>${controls}</div>`;
         if (task.state !== "done") {
@@ -1462,7 +1208,6 @@ export function taskBodyParts(data) {
                     case "approve-scope": return html ` <a href="#approve">Review the plan and approve it</a>.`;
                     case "answer-decision": return html ` <a href="#decisions">Answer the waiting question</a>.`;
                     case "unhold": return diagnosis.code === "storage-blocked" ? html ` Use <strong>Try again</strong> once it's allowed.` : html ` Use <strong>Remove hold</strong> when it can continue.`;
-                    // The reason is the detail itself; Retry is the status card's own act, said once.
                     case "retry-task": return "";
                     case "repair-capability": return html ` <a href="/caps">Repair the requirement</a>.`;
                     case "repair-dependency":
@@ -1505,7 +1250,6 @@ export function taskBodyParts(data) {
                         html `<p><a href="${startBuilderHref(task.id)}">See connection status →</a></p></div></details>`,
                     ]);
                 }
-                // Never a link to this page's own acts: Retry sits on the status card and below.
                 const href = diagnosis.action === "retry-task" ? null : taskRecoveryHref(task.id, diagnosis);
                 return href === null ? "" : html `<a class="button-link dispatch-action-link" href="${href}">${dispatchActionLabel(diagnosis)}</a>`;
             })();
@@ -1533,19 +1277,12 @@ export function taskBodyParts(data) {
                     semanticCoverageHtml(proof.proofMatrix, proof.qualityMode ?? "default"), html `</div></details>`,
                 ]);
             }
-            // v50: the independent review's own card — attempt counts, what is
-            // running or queued, the latest failure in words, and the ONE
-            // explicit act (Retry review) exactly when the allowance admits it.
             const reviewCard = reviewRetryPanel(task.id, proof.runId, proof.reviewRetry ?? null, {
                 csrf: data.csrf,
                 canAct: data.canRetryReview === true,
                 returnTo: null,
             });
             const withReview = (...parts) => joinHtml([reviewCard, ...parts]);
-            // A no-change conclusion never owes a proof — there is no diff to
-            // check acceptance criteria or a changed-path claim against — so it
-            // keeps reading on the two presence facts alone, exactly as before
-            // the proof system existed (the "attested floor" this preserves).
             if (proof.outcome === "no-change") {
                 const missing = [proof.hasHandoff ? null : "agent handoff", proof.hasTerminalDiff ? null : "terminal diff"]
                     .filter((one) => one !== null);
@@ -1553,46 +1290,27 @@ export function taskBodyParts(data) {
                     ? box("problem", resultStatus.label, html `<a href="/r/${proof.runId}">Build #${proof.runId}</a> concluded no change was needed, but its ${missing.join(" and ")} is missing.`, resultStatus.token)
                     : box("ok", resultStatus.label, html `<a href="/r/${proof.runId}">Build #${proof.runId}</a> concluded no change was needed; its handoff and machine-captured diff are on record.`, resultStatus.token));
             }
-            // A built run's verdict is the machine's own — computed once at
-            // completion by adjudicate() (Priority 2), never re-derived here.
-            // Acceptance changes the CLASS (problem → ok) and the words, never
-            // the underlying token: the surfaces still agree on what happened.
             const accepted = proof.proofAccepted;
             const humanReview = manualReviewOnly({ verdict: proof.proofVerdict ?? "", reasons: proof.proofReasons, matrix: proof.proofMatrix });
-            // Accepting contradictory or incomplete evidence is an explicit,
-            // recorded exception—not the ordinary magenta approval ceremony.
             const acceptForm = accepted || data.csrf === ""
                 ? ""
                 : html `<details class="proof-exception"><summary>${humanReview ? "Accept result" : "Accept with exception"}</summary>${postForm(`${taskHref(task.id)}/accept-proof`, html `<input type="text" name="note" maxlength="500" placeholder="${humanReview ? "What did you verify?" : "Why is this safe to accept?"}" aria-label="${humanReview ? "review note" : "exception reason"}" required><button type="submit">${humanReview ? "Accept result" : "Accept with exception"}</button>`, {
                     attrs: { class: "proof-exception-form" },
                     hidden: { run: proof.runId },
                 })}</details>`;
-            // v40: the machine's own pre-fold verdict, restated when a review
-            // moved it — "the machine attested it; reviewer:codex contradicted
-            // c2" — never pretending the machine always disagreed.
             const machineNote = !reviewConflict(proof.proofMatrix, proof.machineVerdict, proof.proofVerdict)
                 ? ""
                 : html `<p class="meta">An independent review found the report doesn't match the changes.</p>`;
             const chainHtml = repairChainHtml(proof.repairChain);
-            // v51: semantic coverage sits beside the matrix, never inside the
-            // verdict word — what the independent reviewer settled, under the
-            // signed policy, with every context gap named.
             const coverageHtml = semanticCoverageHtml(proof.proofMatrix, proof.qualityMode ?? "default");
             const proofDetails = proof.proofMatrix.length === 0 && machineNote === "" && isEmptyHtml(chainHtml)
                 ? ""
                 : html `<details class="dispatch-proof-details"><summary>${proof.proofMatrix.length === 0 ? "Verification details" : `${proof.proofMatrix.length} requirement${proof.proofMatrix.length === 1 ? "" : "s"}`} · View details</summary><div class="dispatch-proof-body">${criterionMatrixHtml(proof.proofMatrix, { compact: true, runId: proof.runId, links: proof.proofMatrixLinks, verdict: proof.proofVerdict })}${coverageHtml}${machineNote}${chainHtml}</div></details>`;
-            // The publication fact is separate from the evidence fact: a PR or
-            // an observed merge is named from its record; nothing is "deployed".
             const publicationWords = (data.publication === null || data.publication === undefined ? "" : ` ${receiptPublicationWords(publicationFactsOf(data.publication))}`) +
-                // Shortened records say so here too (repair 2026-09-14).
                 (proof.receipt === null ? "" : ` ${evidenceShortenedWords(proof.receipt.facts.evidenceHealth)}`).replace(/ $/, "");
-            // Damaged evidence (repair 2026-09-14): the box wears the receipt's
-            // own problem words — never "ok" with a verdict that predates the damage.
             if (resultStatus.token === "evidence-damaged") {
                 return withReview(box("problem", resultStatus.label, html `<a href="/r/${proof.runId}">Build #${proof.runId}</a> finished. ${resultStatus.detail}${publicationWords}`, "evidence-damaged"), html `<div class="proof-review-actions"><a class="button-link" href="/r/${proof.runId}">Review what doesn't match</a></div>`, proofDetails);
             }
-            // A recorded pass the check read now doesn't stand behind (unreadable, failed since, or not read here) never
-            // reads "passed": the box says what holds now (task-status.ts approvedCheckOf).
             if (proof.proofVerdict === "verified" && !accepted && !(proof.receipt?.checks !== undefined && ["ready-to-review", "pr-opened", "merge-observed", "pr-closed"].includes(resultStatus.token))) {
                 return withReview(box(resultStatus.tone === "problem" ? "problem" : "ok", resultStatus.label, html `<a href="/r/${proof.runId}">Build #${proof.runId}</a> finished. ${resultStatus.detail}${publicationWords}`, resultStatus.token), proofDetails);
             }
@@ -1605,16 +1323,11 @@ export function taskBodyParts(data) {
             if (proof.proofVerdict === "attested" && !accepted) {
                 return withReview(box("ok", resultStatus.label, html `<a href="/r/${proof.runId}">Build #${proof.runId}</a> finished as ${proof.outcome ?? "terminal"}. No independent project check ran: the checks listed are the agent's own report, and each item below is labeled by source.${publicationWords}`, dispatchStatusToken("attested")), proofDetails);
             }
-            // A refuted, short, or absent verdict — and an accepted one, which
-            // stays visibly an exception: the words never say checks passed.
             const machineToken = proof.proofVerdict === "refuted" ? dispatchStatusToken("refuted") : dispatchStatusToken("short");
             return withReview(box(accepted ? "ok" : "problem", resultStatus.label, html `<a href="/r/${proof.runId}">Build #${proof.runId}</a> finished. ${verificationExplanation(proof.proofVerdict, proof.proofReasons)}${accepted ? html ` An approver accepted it by hand; that acceptance leaves the machine's verdict above unchanged.` : ""}${publicationWords}`, machineToken), html `<div class="proof-review-actions"><a class="button-link" href="${reviewHref(task.id)}">${accepted ? "Review the recorded exception" : resultStatus.action?.label ?? "Review evidence"}</a>${acceptForm}</div>`, proofDetails);
         }
         return box("problem", "Can't tell yet", "Reload this task to see whether it can start.", "unknown");
     })();
-    // Operator steering (arc 1, v120): notes for the agent, each wearing the
-    // same words the CLI and the lead use — read (and when), waiting for the
-    // running agent, bound for the next attempt, or ended unread.
     const steering = data.steering ?? [];
     const steeringLive = data.steeringLive === true;
     const steerState = (one) => {
@@ -1633,17 +1346,12 @@ export function taskBodyParts(data) {
         ? ""
         : joinHtml([
             html `<h2>Holds</h2>`,
-            joinHtml(data.holds.map(
-            // The storage check's hold (dispose.ts holdForStorage) says what it waits for, in the check's own words.
-            hold => html `<p class="row">${hold.ownerKind === "backoff" && hold.reason.startsWith(STORAGE_HOLD_PREFIX) ? `waiting for macOS permission — ${hold.reason.slice(STORAGE_HOLD_PREFIX.length)}` : `${holdOwnerWords(hold.ownerKind)} — ${hold.reason}`}${hold.until === null ? "" : html ` <span class="meta">until ${whenTime(hold.until)}</span>`}</p>`), "\n"),
+            joinHtml(data.holds.map(hold => html `<p class="row">${hold.ownerKind === "backoff" && hold.reason.startsWith(STORAGE_HOLD_PREFIX) ? `waiting for macOS permission — ${hold.reason.slice(STORAGE_HOLD_PREFIX.length)}` : `${holdOwnerWords(hold.ownerKind)} — ${hold.reason}`}${hold.until === null ? "" : html ` <span class="meta">until ${whenTime(hold.until)}</span>`}</p>`), "\n"),
             html `<p class="meta">Only your hold can be lifted here. Waits for a question, repeated failures or a retry clear on their own.</p>`,
         ]);
     const approval = approvalOf(scope);
-    // A refused save from the sheet's in-place editor reopens that editor with
-    // its draft; the full scope form below stays as it was.
     const inlineScopeDraft = data.scopeDraft?.has("requirement-new") === true;
     const scopeDraft = inlineScopeDraft ? undefined : data.scopeDraft;
-    // A release's terms in the scope card (the page without script); the plan sheet says them whole (approvalSheetParts).
     const releaseTermsHtml = scope == null || (scope.releaseTerms == null && scope.releaseCheck == null) ? "" : html `<p><strong>Release</strong></p>${scope.releaseTerms == null ? "" : html `<p class="recap">${releaseTermsSentence(scope.releaseTerms)}</p>`}${scope.releaseCheck == null ? "" : html `<p class="recap">${releaseCheckSentence(scope.releaseCheck)}</p>`}${data.releaseCiRunning === true ? html `<p class="meta">${RELEASE_CI_RUNNING_WORDS}</p>` : ""}${scope.releaseTerms?.policy.carry === true ? html `<p><strong>What asks again</strong></p><ul>${joinHtml(releaseAsksAgainWords(scope.releaseTerms).map(line => html `<li>${line}</li>`), "")}</ul>` : ""}`;
     const scopeCard = scope === null
         ? html `<p class="meta">No plan yet. Nothing builds until one is approved.</p>`
@@ -1664,10 +1372,6 @@ export function taskBodyParts(data) {
                         : html `<p class="meta">${approval.reason === "changed" ? "Edited after approval" : "Not approved"}</p>${planVersionDetailsHtml(scope.digest)}`,
             html `</div>`,
         ], "\n");
-    // The scout's report (mate arc §10): title, summary, the document inert,
-    // and each follow-up as a filing the operator makes with one tap. A
-    // report that exists but cannot be verified is a named problem, never a
-    // blank — the same rule as the revision brief.
     const reportCard = data.report === null || data.report === undefined
         ? data.deliverable === "report"
             ? html `<div class="card"><p><strong>Research task</strong> <span class="meta">delivers a report, never a branch. A read-only session looks into the goal, and its report appears here when it finishes.</span></p></div>`
@@ -1694,13 +1398,6 @@ export function taskBodyParts(data) {
                     ]),
                 html `</div>`,
             ], "\n");
-    // The plan a planner drafted, when one exists: rendered inert above the
-    // approval it proposes. The scope stays the contract; this is the road.
-    // Adaptive execution plans (v44): once approved, the CURRENT revision's
-    // text displays here — the same document the builder actually reads —
-    // rather than the original artifact frozen at approval time; the edit
-    // form and its staleness guard stay bound to that original artifact,
-    // since editing is a pre-approval act this ledger does not touch.
     const currentRevisionForDisplay = data.planRevisions?.current ?? null;
     const displayedPlanDocument = currentRevisionForDisplay !== null && currentRevisionForDisplay.revision > 1
         ? currentRevisionForDisplay.document
@@ -1712,11 +1409,8 @@ export function taskBodyParts(data) {
         : approval.approved
             ? "approved"
             : "review before starting";
-    // While the approval sheet is open it states any amendment; the plan
-    // card does not repeat it (one #contract-amendment on the page).
     const sheetStatesContract = scope !== null && !approval.approved && data.plan === "drafted" && data.dispatch?.action !== "repair-dependency" &&
         !(data.revision != null && "problem" in data.revision) && scope.profileState !== "unresolved" && consentDoorOf(scope, data.route).open;
-    // The plan document's own editor (#plan-edit): the plan card holds it, and the task page's Plan row.
     const planEditorHtml = data.planDocument === null || data.csrf === "" || data.planSha == null || approval.approved
         ? ""
         : html `<details class="plan-editor" id="plan-edit"><summary>Edit plan</summary>${postForm(`${taskHref(task.id)}/plan-edit`, joinHtml([
@@ -1726,12 +1420,13 @@ export function taskBodyParts(data) {
         ]), { hidden: { "saw-plan": data.planSha } })}</details>`;
     const planCard = data.planDocument === null
         ? data.plan === "requested"
-            // A request the planner cannot be given waits on a person; the status card above already says what to shorten.
-            ? data.dispatch?.code === "planner-source"
+            ? data.dispatch?.code === "planner-source" || data.dispatch?.code === "signed-out"
                 ? ""
                 : data.revision != null && !("problem" in data.revision)
                     ? html `<div class="card planner-status"><span class="planner-orb" aria-hidden="true"></span><p><strong>Updating the plan</strong><span class="meta">Adding your notes to the plan. You approve any change before it builds.</span></p></div>`
-                    : html `<div class="card planner-status"><span class="planner-orb" aria-hidden="true"></span><p><strong>Planning requested</strong><span class="meta">${data.planAuto ? "Automatic approval is enabled for a verified plan that preserves your filed contract. Amendments and unanswered questions still pause." : "The agent is inspecting the repository and drafting the goal, acceptance criteria, and approach. It will ask only if a missing answer changes the work."}</span></p></div>`
+                    : html `<div class="card planner-status"><span class="planner-orb" aria-hidden="true"></span><p><strong>Planning requested</strong><span class="meta">${data.planAuto ? "Automatic approval is enabled for a verified plan that preserves your filed contract. Amendments and unanswered questions still pause."
+                        : data.dispatch?.code === "running" ? "The agent is inspecting the repository and drafting the goal, acceptance criteria, and approach. It will ask only if a missing answer changes the work."
+                            : "It waits for an agent to start on it."}</span></p></div>`
             : ""
         : joinHtml([
             approval.approved ? html `<details class="card planner-plan planner-plan-collapsed"><summary class="execution-plan-head">` : html `<section class="card planner-plan"><div class="execution-plan-head">`,
@@ -1745,9 +1440,6 @@ export function taskBodyParts(data) {
         ]);
     const progressCard = milestoneProgressHtml(data.milestoneProgress);
     const revisionLedgerCard = planRevisionLedgerHtml(data.planRevisions, task.id, data.csrf);
-    // The revision batch (M6.8), restated on the SAME screen as the approval
-    // it belongs to: the approver sees exactly the comments the brief carries.
-    // A brief that cannot be verified is a named problem, never a blank.
     const revisionCard = data.revision === null || data.revision === undefined
         ? ""
         : "problem" in data.revision
@@ -1759,24 +1451,12 @@ export function taskBodyParts(data) {
                 revisionLineageHtml(data.revision.lineage),
                 html `</div>`,
             ], "\n");
-    // The approval form restates every field the digest binds — an operator
-    // approves what is on this form, not what is elsewhere on the page — and
-    // requires the token typed again. The session got you here; only the
-    // token agrees. The sheet shows the plan open in plain rows with one
-    // Approve & start; the rest of the signed terms sit in its Details fold.
-    // An unapprovable scope gets the problem and the edit road instead of a
-    // password it cannot use.
     const consentDoor = consentDoorOf(scope, data.route);
     const revisionInApproval = scope !== null && !approval.approved && data.plan !== "requested" &&
         scope.profileState !== "unresolved" && consentDoor.open && data.dispatch?.action !== "repair-dependency" &&
         (data.revision == null || !("problem" in data.revision));
-    // The approval is the next step when dispatch waits on it, or when the plan was rewritten after a build (the
-    // assignment's one action): then it is shown open under the status, never folded.
     const approvalLeads = data.dispatch?.action === "approve-scope" ||
         (data.assignment?.primaryAction?.code === "approve-scope" && data.assignment.primaryAction.target.taskId === task.id);
-    // The sheet's terms, when this person can approve them here: the task page's kit approval box (its Plan tab shows
-    // the rows) and the legacy sheet both read these.
-    // A cancelled task asks for no approval: nothing would start, so its page offers no Approve (reopening asks again).
     const sheetInput = scope === null || approval.approved || task.state === "cancelled" || data.plan === "requested" || (data.revision != null && "problem" in data.revision) ||
         scope.profileState === "unresolved" || !consentDoor.open ? null : {
         surface: "task",
@@ -1854,11 +1534,7 @@ export function taskBodyParts(data) {
         ], "\n"), { attrs: { class: "scope-editor" }, hidden: { sawDigest: scopeDraft?.get("sawDigest") ?? scope?.digest ?? "" } }),
         html `</details>`,
     ], "\n");
-    // 41_237 → "41k": token counts read at a glance; exactness lives on the run page.
     const compactCount = (count) => count >= 1000 ? `${Math.round(count / 1000)}k` : String(count);
-    // The attempt ledger (M5.5): every attempt with its provider, duration,
-    // tokens, and dollars — or the honest word "unmeasured" — so a retry
-    // storm reads as the spike it is instead of hiding inside a total.
     const minutesOf = (run) => {
         if (run.finishedAt === null)
             return null;
@@ -1868,9 +1544,6 @@ export function taskBodyParts(data) {
     const tokensOf = (run) => run.tokensIn === null && run.tokensOut === null
         ? null
         : `${run.tokensIn === null ? "?" : compactCount(run.tokensIn)}/${run.tokensOut === null ? "?" : compactCount(run.tokensOut)} tok`;
-    // Ledger rows (slice 1c): the same row grammar as the portfolio's terminal
-    // ledger — identity, outcome chip, one mono meta run of provider · model ·
-    // duration · tokens · measured-or-unmeasured cost.
     const runRows = joinHtml(data.runs
         .map(run => {
         const bits = [
@@ -1884,9 +1557,6 @@ export function taskBodyParts(data) {
         return html `<p class="row"><a href="/r/${run.id}" class="mono">#${run.id}</a> ${runOutcomeBadge(run, run.id === liveHistoryRunId)}${run.reason === null ? "" : html ` <span class="meta">${reasonWords(run.reason)}</span>`} <span class="meta mono">${bits.join(" · ")}</span><span class="right meta mono">${whenTime(run.startedAt)}</span></p>`;
     }), "\n");
     const runs = data.runs.length === 0 ? "" : html `<h2>Attempts</h2>${runRows}`;
-    // ---- the right rail (slice 1c) ------------------------------------------
-    // Dollars stated per attempt set, measured or unmeasured in words — a
-    // missing figure is never summed as $0.
     const spendWords = (rows) => {
         if (rows.length === 0)
             return "no attempt yet";
@@ -1896,8 +1566,6 @@ export function taskBodyParts(data) {
         const subscriptionEquivalent = subscription.reduce((sum, one) => sum + (one.costUsd ?? 0), 0);
         const metered = measured.filter(one => one.authMode !== "subscription");
         const meteredDollars = metered.reduce((sum, one) => sum + (one.costUsd ?? 0), 0);
-        // Tokens count only where an attempt reported them; a null report is
-        // said, never summed as zero (commit-3 review, finding 2).
         const reported = rows.filter(one => one.tokensIn !== null || one.tokensOut !== null);
         const tokens = reported.reduce((sum, one) => sum + (one.tokensIn ?? 0) + (one.tokensOut ?? 0), 0);
         const tokenWords = reported.length === 0
@@ -1930,8 +1598,6 @@ export function taskBodyParts(data) {
         prop("this attempt", thisAttempt === undefined ? "no attempt yet" : spendWords([thisAttempt])),
         prop("task total", spendWords(data.runs)),
     ]);
-    // "publishes as": push, open-PR, and merge are INDEPENDENT fields on the
-    // grant — each phrased on its own; absent means exactly that.
     const publishesAs = (() => {
         const grant = data.grant ?? null;
         if (data.repo === null)
@@ -1948,9 +1614,6 @@ export function taskBodyParts(data) {
         ].filter((part) => part !== null).join(" · ");
     })();
     const publishesRow = prop("publishes as", publishesAs);
-    // The property list (task page pass): worker and attempt, queue place,
-    // the scope's standing with its seal, publication, spend — the key
-    // facts a reader scans before anything else, in one row grammar.
     const workerRow = liveRun !== undefined
         ? prop("builder", html `${liveRun.runner} · <a href="/r/${liveRun.id}">build #${liveRun.id}</a> running`)
         : data.runs[0] !== undefined
@@ -1970,7 +1633,6 @@ export function taskBodyParts(data) {
                     : prop("plan", approval.reason === "changed" ? "Edited after approval: it needs a new approval" : "not approved");
     const strikesRow = data.strikes > 0 ? prop("failed attempts", `${data.strikes} in a row`) : "";
     const propsCard = html `<div class="card props">${workerRow}${queueRow}${scopeRow}${publishesRow}${economics}${strikesRow}</div>`;
-    // The same facts for the rebuilt page, row for row.
     const facts = [];
     const lastRun = data.runs[0];
     if (liveRun !== undefined)
@@ -1989,7 +1651,6 @@ export function taskBodyParts(data) {
     if (data.release?.kind === "anchor")
         facts.push({ label: "Release", parts: [`Approved for release ${data.release.version}`, ...(data.release.landed.length === 0 ? [] : [` · later commits: ${data.release.landed.map(one => one.sha.slice(0, 7)).join(", ")}`]), ...(data.release.carrying ? [] : [` · later commits ask again`])] });
     facts.push({ label: "Publishes as", parts: [publishesAs] });
-    // v102: who asked for it, and what the project's approval rules need.
     if (data.filer != null)
         facts.push({ label: "Filed by", parts: [data.filer.name === null ? "automation" : data.filer.kind === "coordinator" ? `${data.filer.name}, through your lead` : data.filer.name] });
     if (data.approvalRules != null) {
@@ -1998,13 +1659,11 @@ export function taskBodyParts(data) {
                     ? (votes.length === 0 ? "needs two approvers" : `approved by ${votes.join(", ")} · needs one more`)
                     : data.approvalRules.words] });
     }
-    // v103: everything an auditor asks about this task, printable or as JSON.
     facts.push({ label: "Audit", parts: [{ label: "Audit record", href: `${taskHref(task.id)}/evidence` }] });
     if (data.budgetHold != null)
         facts.push({ label: "Budget", parts: [`${data.budgetHold} · `, { label: "Spend", href: "/spend" }] });
     if (data.policyHold != null)
         facts.push({ label: "Policy", parts: [`${data.policyHold} · `, { label: "Policy", href: "/settings/policy" }] });
-    // The pull-request card already says this once, with its action.
     if (data.publication !== null && data.publication !== undefined && data.pullRequest?.view == null) {
         const prHref = safePrUrl(data.publication.prUrl), pr = `PR #${data.publication.prNumber ?? "?"}`;
         facts.push({ label: "Published", parts: [prHref === null ? pr : { label: pr, href: prHref },
@@ -2014,8 +1673,6 @@ export function taskBodyParts(data) {
     facts.push({ label: "Task total", parts: [spendWords(data.runs)] });
     if (data.strikes > 0)
         facts.push({ label: "Strikes", parts: [`${data.strikes} failed attempt(s)`] });
-    // Open decisions as the shared partial — answerable inline when the
-    // page is not sensitive; link-only cards otherwise.
     const openDecisions = data.decisions.filter(one => one.state === "open" || one.state === "expired");
     const decisionRail = openDecisions.length === 0
         ? ""
@@ -2024,8 +1681,6 @@ export function taskBodyParts(data) {
             ? html `<div class="decide-card" data-decision-id="${decision.id}"><p class="q">${decision.question}</p><p class="meta">${oneLineOf(decision.recap, 160)}</p><p class="meta"><a href="/d/${decision.id}">the full question →</a></p></div>`
             : decisionAnswerCard({ ...decision, taskId: task.id, repo: data.repo }, data.csrf, data.now, false)), "\n")}`;
     const rail = joinHtml([decisionRail, propsCard].filter(part => part !== ""), "\n");
-    // Spend by provider, from the same rows — dollars only where a provider
-    // measured them, and the unmeasured said in words, never summed as $0.
     const spendCard = (() => {
         if (data.runs.length === 0)
             return "";
@@ -2072,33 +1727,21 @@ export function taskBodyParts(data) {
             : html `<p class="row meta">${incidentWords(one.kind)} — resolved by ${one.resolvedBy ?? "?"}</p>`), "\n")}`;
     const stalled = task.state === "failed" || data.incidents.some(one => one.resolvedAt === null);
     const dependencyChoiceNeeded = data.dispatch?.action === "repair-dependency";
-    // The chain: what this task waits for, editable in place. Blockers
-    // outside this console's view are named without state or link — the same
-    // redaction the board applies. Adding and removing are ordinary
-    // re-proved POSTs; the loop refusal comes back as the problem banner.
     const waitsFor = data.waitsFor ?? [];
     const candidates = (data.waitCandidates ?? []).filter(one => !waitsFor.some(existing => existing.id === one.id));
     const waitRows = waitsFor.length === 0 ? "" : joinHtml(waitsFor.map(one => html `<p class="row">${one.admitted ? html `<a href="${taskHref(one.id)}" class="mono">${one.id}</a>` : html `<span class="mono">${one.id}</span>`}${one.state === null ? "" : html ` <span class="badge badge-${one.state}">${sentenceCase(one.state)}</span>`}${postForm(`${taskHref(task.id)}/unblock`, html `<button type="submit">Don't wait for this</button>`, { attrs: { class: "inline" }, hidden: { on: one.id } })}</p>`), "\n");
     const waitAdd = data.csrf === "" || candidates.length === 0
         ? ""
         : postForm(`${taskHref(task.id)}/block`, html `<select name="on" aria-label="task to wait for">${candidates.map(one => html `<option value="${one.id}">${one.id} — ${one.title}</option>`)}</select><button type="submit">Wait for this task</button><span class="meta"> — this task starts only after it finishes</span>`, { attrs: { class: "row" } });
-    const waitsForCard = waitRows === "" && waitAdd === ""
+    const waitsForCard = task.state === "done" || task.state === "cancelled" || (waitRows === "" && waitAdd === "")
         ? ""
         : html `<h2>Waits for</h2>${waitRows === "" ? html `<p class="meta">Nothing. It starts when a builder is free.</p>` : waitRows}${waitAdd}`;
-    // The acts bar (task page pass): every verb in one row under the title,
-    // the one that resolves this task's state first and primary — retry on a
-    // stalled task, build-next in the queue, plan-first with no scope. The
-    // hold's reason sits beside its button; cancel stays armed at the foot,
-    // far from the primary. A live claim is never disturbed by an operator
-    // hold (the hold governs the NEXT start), and requeue refuses while a
-    // claim is live — so the words say exactly when each becomes real.
     const canPlan = data.plan === null && !approval.approved && !data.claimed && task.state === "queued" && (data.coordinator === null || data.coordinator === undefined);
-    // A failed task's status card carries Retry itself (the same requeue); here it would be a second ink act.
     const cardRetries = task.state === "failed" && data.assignment != null && data.csrf !== "";
     const primaryAct = stopControlsActive || cardRetries ? null : stalled && !data.claimed
-        ? { html: act("requeue", "Retry, keeping the branch and workspace"), why: "Clears the repeated failures and queues the task again. The branch and workspace are kept.", whyClass: "retry" }
+        ? { html: act("requeue", "Retry, keeping the branch and workspace", data.retryPins == null ? {} : { run: String(data.retryPins.run), digest: data.retryPins.digest }), why: "Clears the repeated failures and queues the task again. The branch and workspace are kept.", whyClass: "retry" }
         : canPlan
-            ? { html: act("plan", "plan first"), why: "plan first sends an agent to read the project, ask you questions and propose a plan. Nothing builds until you approve it.", whyClass: "plan" }
+            ? { html: act("plan", "plan first", data.planSource == null ? {} : { source: data.planSource }), why: "plan first sends an agent to read the project, ask you questions and propose a plan. Nothing builds until you approve it.", whyClass: "plan" }
             : data.plan === "requested"
                 ? null
                 : task.state === "queued" && !data.claimed && (data.position?.position ?? 1) > 1
@@ -2108,17 +1751,12 @@ export function taskBodyParts(data) {
     const canHold = task.state === "queued" || task.state === "running" || task.state === "failed";
     const actsBar = joinHtml([
         html `<span id="task-actions"></span><div class="acts-bar">`,
-        // While a ceremony leads the page, no other act competes as primary.
         primaryAct === null ? "" : approveForm === "" ? html `<span class="primary">${primaryAct.html}</span>` : primaryAct.html,
         task.state === "queued" && (data.position?.position ?? 2) === 1 && task.priority > 0
             ? act("next", "back to filing order", { undo: "1" })
             : "",
-        // A task with no scope is already unable to start. Showing a hold next
-        // to "plan first" adds a second, unnecessary decision at the exact
-        // moment the page should have one obvious action.
         stopControlsActive || canPlan || !canHold ? "" : holdAct,
         data.holds.some(hold => hold.ownerKind === "operator") ? act("unhold", "Remove hold")
-            // The storage check couldn't finish (dispose.ts holdForStorage): one tap tries again now.
             : data.holds.some(hold => hold.ownerKind === "backoff" && hold.ownerId === `storage:${hold.taskRef}`) ? act("unhold", "Try again") : "",
         html `</div>`,
         primaryAct === null ? "" : html `<p class="meta acts-why acts-why-${primaryAct.whyClass}">${primaryAct.why}</p>`,
@@ -2126,8 +1764,6 @@ export function taskBodyParts(data) {
             ? html `<p class="meta acts-why">a worker is building this right now — <em>Hold the next attempt</em> stops the one after it; cancel waits for the current build to finish${stalled ? "; retry becomes available after this attempt finishes" : ""}</p>`
             : "",
     ], "\n");
-    // Cancel gets the same ceremony as an irreversible answer: armed behind
-    // one deliberate tap, styled as the destructive act it is.
     const cancelForm = task.state === "queued" || task.state === "running" || task.state === "failed"
         ? postForm(`${taskHref(task.id)}/cancel`, joinHtml([
             data.coordinator == null ? "" : html `<label>Reason for cancellation<textarea name="reason" rows="3" maxlength="500" required>${data.cancelDraft ?? ""}</textarea></label>`,
@@ -2135,23 +1771,17 @@ export function taskBodyParts(data) {
         ]))
         : "";
     const cancelAct = cancelForm === "" ? "" : html `<details class="arm-danger"${data.cancelDraft === undefined ? "" : html ` open`}><summary>Cancel task</summary>${cancelForm}</details>`;
-    // Long sections fold, each with its count in the header: what needs
-    // reading stays open; a ledger or a form folds until asked. The rebuilt
-    // page receives the same bodies, so its folds carry the same forms.
     const sectionParts = [];
     const section = (title, body, open, count, id = title.replace(/\s+/g, "-")) => {
         if (body === "" || isEmptyHtml(body))
             return "";
         const heading = sentenceCase(title);
-        // The section's own heading moves into its summary.
         const once = (fragment, words) => replaceMarkup(fragment, new RegExp(htmlString(html `<h2>${words}</h2>`).replace(/[.*+?^${}()|[\]\\]/g, "\\$&")), () => html ``);
         const inner = once(once(body, title), heading);
         sectionParts.push({ id, title: heading, html: htmlString(inner), open, count: count ?? null });
         return html `<details class="section" id="${id}"${open ? html ` open` : ""}><summary><h2>${heading}${count === undefined ? "" : html ` <span class="lane-count">${count}</span>`}</h2></summary>${inner}</details>`;
     };
     const receiptLeads = data.assignment == null && task.state === "done" && data.completion?.receipt != null;
-    // Exact identity stays available in Task options; failures stay in the
-    // status and property rail, and approval provenance stays in the ceremony.
     const identity = html `<p class="meta task-identity">Task ID <span class="mono">${task.id}</span>${data.rootTitle !== undefined && data.rootTitle !== task.title ? ` · Execution: ${task.title}` : ""}${data.repo === null ? "" : ` · ${projectName(data.repo)}`}${data.coordinator !== null && data.coordinator !== undefined
         ? html ` · filed by <span class="mono">${data.coordinator.label}</span>${data.coordinator.filedAgo === null ? "" : ` ${data.coordinator.filedAgo}`}`
         : data.origin != null
@@ -2159,28 +1789,18 @@ export function taskBodyParts(data) {
             : data.filedVia === null || data.filedVia === undefined
                 ? ""
                 : ` · filed via ${data.filedVia}`}${data.deliverable === "report" ? html ` · <span class="badge">Research</span>` : ""}</p>`;
-    // A pull request that can be merged (or opened) owns the one primary action; the result stays in its section.
     const pullRequestActs = data.csrf !== "" && (data.pullRequest?.view?.canMerge === true || (data.pullRequest?.view == null && data.pullRequest?.offer != null));
     const pullRequestFact = data.pullRequest?.fact != null && data.pullRequest.view?.runId === data.assignment?.receipt?.runId ? data.pullRequest.fact : undefined;
     const assignmentOptions = data.assignment == null ? null : { workStatus: status, hideAction: (approveForm !== "" && approvalLeads) || pullRequestActs, problem: status.tone === "problem",
         planning: data.dispatch?.code === "running" && data.dispatch.role === "planner", ...(pullRequestFact === undefined ? {} : { pullRequest: pullRequestFact }),
         diagnostics: [...(status.diagnostics ?? []), ...(status.tone === "problem" && status.detail !== data.assignment.detail ? [status] : [])] };
-    // Say it once: a pull request that couldn't open, or merged, is the status
-    // card's own row (its reason or merge commit under Details), not a second card.
     const pullRequestCard = data.pullRequest == null || (pullRequestFact !== undefined && (data.pullRequest.view?.state === "failed" || data.pullRequest.view?.state === "merged")) ? "" : pullRequestCardHtml(data.pullRequest, data.csrf);
-    // The result takes over from the task status as soon as it is ready.
     const statusHtml = html `${data.assignment != null && assignmentOptions !== null ? assignmentSummaryHtml(data.assignment, assignmentOptions) : receiptLeads ? completionReceiptCard(data.completion.receipt, task.id, "task", status) : taskStatusCard(status, task.id, data.dispatch ?? null, liveRunId, approveForm !== "" && approvalLeads)}${checkProgressHtml(data.checkProgress ?? null)}`;
-    // The exact-run control (v52), directly under the scheduler's answer:
-    // the one place a person stops or resumes THIS attempt.
     const controlHtml = taskControlDetailsHtml(data.control ?? { kind: "none" }, task.id, data.csrf, "task", false, false, data.livePause ?? null);
     const previousResult = data.completion?.receipt == null || receiptLeads ? null : {
         title: data.assignment != null && task.state === "done" ? "Result" : "Previous result",
         html: (completionReceiptCard(data.completion.receipt, task.id, "task", data.assignment == null ? receiptStatusOf(data.completion.receipt) : assignmentStatusOf(data.assignment), data.assignment ?? null, data.assignment == null)),
     };
-    // External work wears its tracker on the page: the link, the last
-    // observed state, and — when the tracker closed it and has been seen
-    // open again — the authenticated reopen act. Done + closed is display
-    // only: completed here stays completed.
     const mirrorCard = (() => {
         const mirror = data.mirror ?? null;
         if (mirror === null)
@@ -2208,14 +1828,8 @@ export function taskBodyParts(data) {
         ]);
     })();
     const problemHtml = data.problem === null || data.scopeDraft !== undefined ? "" : html `<div class="problem">${data.problem}</div>`;
-    // The board sent them here saying "needs you" — the page must open by
-    // saying WHY and pointing at the act, not read as a fact sheet
-    // (operator finding: clicking a needs-you card landed with no context).
     const needsScopeCard = scope === null && data.plan === null && task.state === "queued" && data.dispatch?.code !== "needs-scope" && data.dispatch?.code !== "waiting-dependency" && !dependencyChoiceNeeded
         ? data.coordinator !== null && data.coordinator !== undefined
-            // The quarantine speaks here too (round-2 finding 5): the planner
-            // is as fenced as the builder on a coordinator filing, so "plan
-            // first" would recommend a road that refuses.
             ? html `<div class="card"><p><strong>This task is waiting on you: an agent filed it, and it has no plan.</strong></p><p class="meta">Filed by <span class="mono">${data.coordinator.label}</span> — nothing plans or runs until you write a plan below and approve it. Your approval runs their request.</p></div>`
             : html `<div class="card task-scope-needed"><p><strong>No approved plan yet</strong></p><p class="meta"><strong>Plan first</strong> drafts it from the repository, or <a href="#scope">write it yourself</a>.</p></div>`
         : "";
@@ -2224,17 +1838,13 @@ export function taskBodyParts(data) {
         : html `<details class="task-secondary-approval"><summary>Updated approval terms</summary>${approveForm}</details>`;
     const optionsHtml = html `${identity}${dispatchStatus}${dependencyChoiceNeeded ? "" : actsBar}`;
     const optionsOpen = data.assignment?.primaryAction?.code === "unhold" || data.assignment?.primaryAction?.code === "retry-task";
-    // The Plan section after its scope card: the release, the recipe and audit links, the agents, the edit form.
-    const scopeRest = [releaseCardHtml(task.id, data.release ?? null, data.canStopRelease === true), html `<p class="meta">${data.repo !== null && data.scope !== null ? html `<a href="/recipes/from-task?task=${encodeURIComponent(task.id)}">Reuse this plan as a recipe →</a> · ` : ""}<a href="${taskHref(data.rootId ?? task.id)}/evidence">Audit record →</a></p>`, agentsCardHtml(task.id, data.route, data.canEditRoute === true), revisionInApproval ? "" : revisionCard, data.completion != null ? "" : repairChainHtml(data.repairChain ?? null), scopeForm];
-    // The page's sections, built once and in order (each `section` also records its part for the rebuilt page).
+    const scopeRest = [releaseCardHtml(task.id, data.release ?? null, data.canStopRelease === true), html `<p class="meta">${data.repo !== null && data.scope !== null ? html `<a href="/recipes/from-task?task=${encodeURIComponent(task.id)}">Reuse this plan as a recipe →</a> · ` : ""}<a href="${taskHref(data.rootId ?? task.id)}/evidence">Audit record →</a></p>`, agentsCardHtml(task.id, agentlessRoute(data.dispatch ?? null, data.route) ? null : data.route, data.canEditRoute === true), revisionInApproval ? "" : revisionCard, data.completion != null ? "" : repairChainHtml(data.repairChain ?? null), scopeForm];
     const layoutTail = joinHtml([
         html `<div class="task-layout"><div class="task-main">`,
         attemptPanel,
         data.coordinatorProposals == null || data.coordinatorProposals.rows.length === 0
             ? ""
-            : section("proposals", 
-            // Confirm and dismiss come back to this task.
-            html `<h2>Proposed by your lead</h2>${coordinatorProposalsSection(data.coordinatorProposals.rows, data.coordinatorProposals.decisions, data.coordinatorProposals.now, false, taskHref(data.task.id))}`, true, data.coordinatorProposals.rows.length),
+            : section("proposals", html `<h2>Proposed by your lead</h2>${coordinatorProposalsSection(data.coordinatorProposals.rows, data.coordinatorProposals.decisions, data.coordinatorProposals.now, false, taskHref(data.task.id))}`, true, data.coordinatorProposals.rows.length),
         section("decisions", decisions, true, data.decisions.length),
         section("repeated failures", incidents, true, data.incidents.length, "incidents"),
         data.publication === null || data.publication === undefined
@@ -2250,26 +1860,19 @@ export function taskBodyParts(data) {
         data.followThrough == null ? "" : section("failed checks", data.followThrough.repairs, true),
         data.followThrough == null ? "" : section("before and after", data.followThrough.evidence, false),
         data.followThrough == null ? "" : section("handover note", data.followThrough.handover, false),
-        section("plan", 
-        // The recipe road rides with the scope it reuses (UI polish
-        // 2026-09-13), off the title-to-action path.
-        joinHtml([html `<h2>Plan</h2>`, scopeCard, ...scopeRest], "\n"), scopeDraft !== undefined || (data.plan !== "requested" && approveForm === "" && !(scope === null && canPlan)), undefined, "scope"),
+        section("plan", joinHtml([html `<h2>Plan</h2>`, scopeCard, ...scopeRest], "\n"), scopeDraft !== undefined || (data.plan !== "requested" && approveForm === "" && !(scope === null && canPlan)), undefined, "scope"),
         dependencyChoiceNeeded ? "" : section("waits for", waitsForCard, (data.waitsFor ?? []).length > 0, (data.waitsFor ?? []).length),
         section("holds", holds, true, data.holds.length),
         cancelAct,
         html `</div><aside class="task-rail">${rail}</aside></div>`,
     ], "\n");
-    // `rows`: the task's step rows, every one open (the page without script, docs/plans/task-page-steps.md): the status,
-    // the approval, the plan, the build's progress and the previous result move into their rows; everything else stays.
     const nativeBody = (rows) => joinHtml([
-        // The title is bare; the receipt or shared task status leads once.
         html `<div class="task-title-row"><h1 class="task-main-title">${data.rootTitle ?? task.title}</h1>${data.csrf === "" ? "" : taskViewSwitch(data.rootId ?? task.id, "overview")}</div>`,
         data.versionLabel == null ? "" : html `<p class="meta">${data.versionLabel} · <a href="${taskHref(data.rootId ?? task.id)}">Current work</a></p>`,
         data.archived == null ? "" : html `<div class="task-archived" data-archived><p>${archivedWords(data.archived)} · ${whenUtc(data.archived.at)}</p>${data.canPutAway === true && data.csrf !== ""
             ? postForm(`${taskHref(task.id)}/restore`, html `<button type="submit" class="secondary">Restore</button>`, { hidden: { return: taskHref(task.id) }, attrs: { class: "inline" } }) : ""}</div>`,
         (data.history ?? ""),
         rows ?? "",
-        // A put-away task's banner is its status: no Needs you card, no act, no approval form (each would be refused).
         rows === null && data.archived == null ? statusHtml : "",
         rows === null ? controlHtml : "",
         rows !== null || previousResult === null ? "" : html `<details class="task-previous-result"><summary>${previousResult.title}</summary>${previousResult.html}</details>`,
@@ -2281,16 +1884,8 @@ export function taskBodyParts(data) {
         needsScopeCard,
         rows === null && data.archived == null ? approvalHtml : "",
         html `<details class="task-status-details" id="task-diagnostics"${optionsOpen ? html ` open` : ""}><summary>Task options</summary>${optionsHtml}</details>`,
-        // Evidence-first (M5.5): what needs you, then what happened — decisions
-        // and incidents above the attempt ledger and spend, the mechanics
-        // (scope, holds, acts) after. Only trustworthy facts moved up. The rail
-        // (slice 1c) rides beside the main column on wide screens and above it
-        // on narrow ones.
         layoutTail,
     ], "\n");
-    // Console v2: one thread in time order (the plan, the agent's notes and
-    // results, its questions, the person's replies) and the metadata grouped
-    // for a Details panel. Every form below keeps its own route and fields.
     const familyRuns = data.family?.runs ?? data.runs.map(run => ({ ...run, taskId: task.id }));
     const versionLabelOf = (taskId) => {
         const index = data.family?.versions.findIndex(one => one.id === taskId) ?? -1;
@@ -2302,13 +1897,8 @@ export function taskBodyParts(data) {
     thread.push({ key: "filed", at: rootFiled, kind: "filed", who: "person", author: filedBy ?? "", title: "Filed the task",
         text: (() => { const goal = data.family?.root.goal ?? scope?.goal ?? null; return goal === null ? null : oneLineOf(goal, 280); })(), link: null, html: "", more: null });
     const newestBuilt = familyRuns.filter(run => run.outcome === "built" && run.role !== "planner" && run.role !== "reviewer").sort((a, b) => b.id - a.id)[0];
-    // Failed: the card says what went wrong in one line, and its one act is Retry itself (the same requeue), never a link to
-    // this page; someone who can't retry here (a viewer, a live claim) gets no act at all.
     const statusCard = data.assignment != null && assignmentOptions !== null ? assignmentCardOf(data.assignment, assignmentOptions) : null;
-    // A live build says which step it is on, or which step it is stuck on and why.
     const building = statusCard?.status.headline === "Building" && liveRun !== undefined && liveRun.role !== "planner" && liveRun.role !== "reviewer";
-    // While a build runs, the attempts that stopped before it fold into one quiet line under its Building card. Only
-    // there: with any other card (or none) they stay in the thread, never vanish.
     const earlierStopped = !building ? []
         : familyRuns.filter(run => run.id < liveRun.id && (run.role === "builder" || run.role === "scout") && run.outcome !== "built" && run.outcome !== "no-change" && run.id !== liveHistoryRunId);
     const foldedAttempts = new Set(earlierStopped.map(run => run.id));
@@ -2342,22 +1932,17 @@ export function taskBodyParts(data) {
             link: href, html: "",
             more: previousResult !== null && run.id === newestBuilt?.id && run.taskId === task.id ? { summary: STATUS_MORE, html: htmlString(previousResult.html) } : null });
     }
-    // What the agent is working through now, and how its plan changed.
     const liveAt = liveRun?.startedAt ?? task.updatedAt;
-    // The plan itself is the page's Plan row: the thread keeps one line saying it was written.
     if (planCard !== "")
         thread.push({ key: "plan", at: familyRuns.filter(run => run.role === "planner").map(run => run.finishedAt ?? run.startedAt).sort().at(-1) ?? task.updatedAt,
             kind: "plan", who: "agent", author: "", title: data.planDocument !== null ? "Plan written" : data.revision != null && !("problem" in data.revision) ? "Updating the plan" : "Planning", text: null, link: null, html: "", more: null });
     if (!isEmptyHtml(progressCard))
         thread.push({ key: "progress", at: liveAt, kind: "progress", who: "agent", author: "", title: "Progress", text: null, link: null, html: htmlString(progressCard), more: null });
-    // A plan change is decided on the page (the Build row holds its card): the thread, which the work panel shows, keeps
-    // one line and a link there. Nothing in the thread takes a decision.
     if (!isEmptyHtml(revisionLedgerCard)) {
         const waiting = data.planRevisions?.pending ?? null;
         thread.push({ key: "plan-revisions", at: liveAt, kind: "progress", who: "agent", author: "", title: waiting === null ? "Plan changes" : "Recommends a plan change",
             text: waiting === null ? null : oneLineOf(waiting.reason, 280), link: { label: waiting === null ? "See the plan changes" : "Decide on the task page", href: "#plan-revisions" }, html: "", more: null });
     }
-    // The change a person asked for: the revision's own brief.
     if (data.revision != null && !("problem" in data.revision)) {
         const feedback = data.revision;
         thread.push({ key: "revision", at: task.createdAt, kind: "reply", who: "person", author: feedback.comments[0]?.author ?? "You",
@@ -2380,8 +1965,6 @@ export function taskBodyParts(data) {
                 text: [chosen, decision.note].filter((one) => one !== null && one !== "").join(" — ") || null, link: null, html: "", more: null });
         }
     }
-    // Open questions are answered on the page (their cards sit in the step that waits, at #task-questions): the thread
-    // says what was asked and links there.
     if (decisionRail !== "")
         thread.push({ key: "questions", at: openDecisions.map(one => one.createdAt).sort()[0] ?? task.updatedAt, kind: "question", who: "agent", author: "",
             title: openDecisions.length === 1 ? "Asked you a question" : `Asked you ${openDecisions.length} questions`, text: openDecisions.map(one => oneLineOf(one.question, 280)).join("\n"),
@@ -2390,10 +1973,8 @@ export function taskBodyParts(data) {
         thread.push({ key: `steer-${note.id}`, at: note.createdAt, kind: "reply", who: "person", author: note.author, title: "Note to the agent", text: note.note, link: null, html: "", more: null });
     }
     thread.sort((a, b) => a.at === b.at ? 0 : a.at < b.at ? -1 : 1);
-    // The Details panel: the same facts, grouped and said once.
     const lastRunForAgent = liveRun ?? familyRuns.filter(run => run.role !== "reviewer").sort((a, b) => b.id - a.id)[0];
     const work = [];
-    // A put-away task's one status is Archived (its banner says by whom and why).
     work.push({ label: "Status", parts: [data.archived != null ? "Archived" : data.assignment != null && assignmentOptions !== null ? assignmentCardOf(data.assignment, assignmentOptions).status.headline : status.label] });
     if (data.repo !== null)
         work.push({ label: "Project", parts: [projectName(data.repo)] });
@@ -2436,7 +2017,6 @@ export function taskBodyParts(data) {
     const about = [];
     const filedFact = facts.find(one => one.label === "Filed by");
     about.push(filedFact ?? { label: "Filed by", parts: [filedBy ?? (data.origin != null ? "An automation" : data.filedVia == null ? "Not recorded" : `via ${data.filedVia}`)] });
-    // v126: where it came from — the flow (linked only for those who can see it) and the outside event, with its host.
     if (data.origin != null)
         about.push({ label: "From", parts: originParts(data.origin) });
     about.push({ label: "Filed", parts: [{ at: rootFiled }] });
@@ -2449,12 +2029,9 @@ export function taskBodyParts(data) {
     const details = [
         { title: "Work", facts: work }, { title: "Links", facts: links }, { title: "Review", facts: review }, { title: "About", facts: about },
     ];
-    // The rebuilt page (shadcn/ui): the same parts in a calmer order — what
-    // needs a person, then facts, then folds; the mechanics under Manage.
     const MANAGE = new Set(["steering", "waits-for", "holds"]);
     const finished = task.state === "done" || task.state === "cancelled";
     const failedCard = statusCard?.status.headline === "Failed";
-    // A link to this very page, with no section to open, goes nowhere: a card never offers one.
     const bareSelfLink = (href) => {
         if (href.includes("#"))
             return false;
@@ -2462,14 +2039,11 @@ export function taskBodyParts(data) {
         const version = new URLSearchParams(query).get("version");
         return [data.assignment?.rootId, data.rootId, task.id].some(id => id != null && path === `/t/${encodeURIComponent(id)}`) && (version === null || version === task.id);
     };
-    // Build again, in place, names its form after the card's own act.
     const rebuild = data.csrf !== "" && data.assignment?.primaryAction?.code === "retry-task" && data.assignment.need != null && "key" in data.assignment.need && data.assignment.need.key === "rebuild"
-        ? { action: `${taskHref(data.assignment.rootId)}/requeue` } : null;
+        ? { action: `${taskHref(data.assignment.rootId)}/requeue`, pins: data.retryPins ?? null } : null;
     const retry = failedCard && task.state === "failed" && !data.claimed && !stopControlsActive && data.csrf !== ""
-        ? { action: `${taskHref(task.id)}/requeue`, ...(data.failure == null ? {} : { note: retryNoteOf(data.failure.suggestion) }) } : null;
-    // Run checks happens in place: a status row's Run checks posts here and comes back; with nothing to run, the row offers nothing.
+        ? { action: `${taskHref(task.id)}/requeue`, pins: data.retryPins ?? null, ...(data.failure == null ? {} : { note: retryNoteOf(data.failure.suggestion) }) } : null;
     const runChecks = data.runChecks ?? null;
-    // A row's link to a result in Chat opens that result's own page instead: Chat would only lead back here.
     const resultPageOf = (href) => {
         const chat = href === null ? null : /^\/chat\?task=([A-Za-z0-9._~%-]{1,200})&result=([0-9]{1,15})(?:&tab=(changes|checks))?(#[A-Za-z0-9_-]{1,80})?$/.exec(href);
         return chat === null ? href : `/review?result=${chat[1]}&run=${chat[2]}${chat[3] === undefined ? "" : `&tab=${chat[3]}`}${chat[4] ?? ""}`;
@@ -2482,23 +2056,17 @@ export function taskBodyParts(data) {
     const steps = building ? buildProgressOf(data.milestoneProgress ?? null) : null;
     const progress = steps === null ? null : { line: steps.line,
         stuck: steps.stuck === null ? null : { ...steps.stuck, action: data.csrf === "" ? null : { label: "Send the agent a note", href: "#steering" } } };
-    // The Building card carries Stop for the build it describes (the same form), in place of a second card below it.
     const stop = building && data.control?.kind === "stop" && data.control.run === liveRun.id && data.csrf !== ""
         ? { action: `${taskHref(task.id)}/stop`, run: data.control.run } : null;
-    // Pause and Pause and steer sit beside that Stop, for the same run, when it is a Claude build that takes live input.
-    // Each form carries its own request id, so a repeated submit is the same request and the two never collide.
     const pause = stop !== null && data.livePause?.run === stop.run
         ? { action: `${taskHref(task.id)}/pause`, run: stop.run, state: data.livePause.state, requests: [`web-${randomUUID()}`, `web-${randomUUID()}`, `web-${randomUUID()}`],
             until: data.livePause.until ?? null, limitMs: data.livePause.limitMs ?? null } : null;
-    // The Building card keeps its way to the build's own record (/r/<id>), whatever act it shows.
     const record = building ? { label: `Build #${liveRun.id} record`, href: `/r/${liveRun.id}` } : null;
     const earlier = earlierStopped.length === 0 ? null : {
         summary: earlierAttemptsWords(earlierStopped.length),
         attempts: [...earlierStopped].sort((a, b) => a.id - b.id).map(run => ({ label: `${runNoun(run)[0].toUpperCase()}${runNoun(run).slice(1)} #${run.id}`, href: `/r/${run.id}`,
             text: run.outcome === null ? "Never finished." : run.outcome === "failed" ? failedAttemptSentence(run.reason) : run.reason === null ? null : (words => `${words.charAt(0).toUpperCase()}${words.slice(1)}.`)(reasonWords(run.reason)) })),
     };
-    // ⋯ More actions (docs/plans/one-page-task-and-agent.md): each secondary act once, in one place — Work, Share & reuse,
-    // then Danger last. A ceremony is never cloned here: its item goes to the tab that holds its one form.
     const sectionIds = new Set(sectionParts.map(one => one.id));
     const rootOf = data.rootId ?? task.id;
     const more = [
@@ -2511,9 +2079,6 @@ export function taskBodyParts(data) {
         { group: "share", label: "Copy link", kind: "copy" },
         ...(cancelForm !== "" ? [{ group: "danger", label: "Cancel task", kind: "goto", tab: "plan", target: "cancel-task" }] : []),
     ];
-    // The Plan row (docs/plans/task-page-steps.md): the plan sheet of the terms on file, built from the same parts as
-    // the approval's (approvalSheetParts), and the plan's own editor. While the approval waits here the sheet is the
-    // approval's own (`approve.planHtml`), so this row carries only the editor: the plan is shown once.
     const plannerRun = familyRuns.filter(run => run.role === "planner" && run.outcome !== null).sort((a, b) => b.id - a.id)[0];
     const sheetShown = scope === null ? null : sheetInput ?? {
         surface: "task", action: "", csrf: "", nonce: "", digest: scope.digest, returnTo: null, scope,
@@ -2526,7 +2091,6 @@ export function taskBodyParts(data) {
     };
     const sheetParts = sheetShown === null ? null : approvalSheetParts(sheetShown);
     const approvalWaitsHere = data.archived == null && sheetInput !== null && !dependencyChoiceNeeded && data.csrf !== "";
-    // A revision's plan being updated with the notes: the planner's card says so above the plan it starts from.
     const planUpdating = data.planDocument === null && data.plan === "requested" && data.revision != null && !("problem" in data.revision) && planCard !== "";
     const planView = scope === null
         ? (planCard === "" ? null : { lead: null, by: null, at: null, html: htmlString(planCard), planning: data.plan === "requested", updating: planUpdating, key: "card" })
@@ -2556,14 +2120,9 @@ export function taskBodyParts(data) {
         runChecks,
         progress: progress === null ? null : { ...progress, steps: (data.milestoneProgress ?? []).map(one => ({ title: one.description, state: one.state })) },
         plan: planView,
-        // One quiet line under the step: what the agent did last, and when.
         activity: liveRun === undefined ? null : data.activity ?? null,
-        // The work panel's run: the live build, else this version's latest build or report. Its records are read through the
-        // run page's own guarded window; a page asking for a password names no window at all.
         work: (() => {
             const recorded = (run) => run.role === "builder" || run.role === "scout";
-            // Running: unfinished under the task's current claim (liveRun is the one run proved live; a builder whose repair
-            // child is the live run shares that claim and is still this attempt).
             const running = (run) => liveRun !== undefined && run.outcome === null && run.finishedAt === null && run.leaseId === liveRun.leaseId;
             const builds = data.runs.filter(recorded).sort((a, b) => b.id - a.id);
             const run = builds.find(running) ?? builds[0];
@@ -2580,7 +2139,6 @@ export function taskBodyParts(data) {
         earlier,
         approval: data.archived != null ? "" : fragmentString(approvalHtml),
         approvalPlacement: approvalLeads ? "lead" : "plan",
-        // The kit's approval box (src/design/KIT.md): the act, by the real rules, with the rows in the Plan tab.
         approve: data.archived != null || sheetInput === null || dependencyChoiceNeeded || data.csrf === "" ? null : approveKitOf(sheetInput, data.approvalFresh ?? null),
         approved: scope !== null && approval.approved ? approvedKitOf(scope, approval, data.approvalProof ?? null) : null,
         more,
@@ -2588,8 +2146,6 @@ export function taskBodyParts(data) {
         recheckStopped: data.csrf !== "" && data.assignment?.primaryAction?.code === "recheck-stopped" && data.assignment.primaryAction.target.runId !== null
             ? { action: `${taskHref(data.assignment.rootId)}/recheck-stopped`, run: data.assignment.primaryAction.target.runId } : null,
         rebuild,
-        // What needs a person on the page itself. Open questions and a plan change are answered here, in their step's row:
-        // the thread (the work panel) only links to them.
         lead: [
             { key: "history", html: data.history === undefined ? "" : htmlString(data.history) }, { key: "control", html: htmlString(stop === null ? controlHtml : taskControlDetailsHtml(data.control, task.id, data.csrf, "task", false, true)) }, { key: "problem", html: fragmentString(problemHtml) },
             { key: "questions", html: decisionRail === "" ? "" : htmlString(decisionRail) }, { key: "plan-revisions", html: isEmptyHtml(revisionLedgerCard) ? "" : htmlString(revisionLedgerCard) },
@@ -2599,14 +2155,10 @@ export function taskBodyParts(data) {
             { key: "needs-scope", html: fragmentString(needsScopeCard) },
             { key: "mirror", html: fragmentString(mirrorCard) }, { key: "attempt", html: fragmentString(attemptPanel), ...(liveRunId === null ? {} : { instance: String(liveRunId) }) },
         ].filter(one => one.html !== ""),
-        // Open questions are a lead block (key "questions"), so they sit in the step that waits.
         questions: "",
         facts,
         sections: [
             ...(previousResult === null || thread.some(one => one.more !== null) ? [] : [{ id: "result", title: previousResult.title, html: htmlString(previousResult.html), open: false, count: null }]),
-            // Questions are in the thread; the scope and the ledgers fold here until asked.
-            // The Plan and Approval rows hold the plan sheet (a release's terms included), so this page's Plan section keeps
-            // only what the sheet leaves out (the links, the agents, the edit form): the plan is never printed a second time.
             ...sectionParts.filter(one => !MANAGE.has(one.id) && one.id !== "decisions").map(one => one.id !== "scope" ? one : {
                 ...one,
                 ...(scope === null ? {} : { html: htmlString(joinHtml(scopeRest, "\n")) }),
@@ -2618,17 +2170,13 @@ export function taskBodyParts(data) {
             { id: "task-diagnostics", title: "Task options", html: htmlString(optionsHtml), open: optionsOpen, count: null },
         ],
         cancel: cancelForm === "" ? null : { html: htmlString(cancelForm), open: data.cancelDraft !== undefined },
-        // Every task's road (the first task's guide used to be the only one): facts only, so the checks step says when
-        // checks didn't run, and a research report has none.
         journey: task.state === "cancelled" || data.status === undefined ? null : (() => {
             const planning = data.plan === "requested" && approveForm === "";
             const read = data.assignment != null ? assignmentStageOf(data.assignment, { token: data.status.token }, planning) : stageOfCode(data.status.token, { planning });
-            // The one answer the status card's headline and Project checks row read (task-status.ts approvedCheckOf).
             const checks = statusCard?.status.check ?? null;
             const report = data.deliverable === "report" || data.report != null;
             return taskRoad(read, scope !== null && approvalOf(scope).approved, task.state === "done", { checks, report });
         })(),
-        // "Do this every time…": the starter flow that does this kind of work on its own, one yes away.
         thread,
         details,
         chatHref: data.csrf === "" ? null : taskChatHref(data.rootId ?? task.id),
@@ -2637,14 +2185,12 @@ export function taskBodyParts(data) {
             return { href: `/settings/flows?repo=${encodeURIComponent(data.repo)}&starter=${starter.id}#starter-${starter.id}`, starter: starter.name };
         })(),
     };
-    // Without script the steps are the page too: every row open, in order, each holding its own part.
     const rowFacts = data.archived != null ? null : stepRowsOf(view);
     const rowsHtml = rowFacts === null ? null : (() => {
         const here = rowFacts.find(row => row.state === "current" || row.state === "stuck") ?? rowFacts.find(row => row.open) ?? rowFacts.at(-1);
         const bodyOf = (key) => joinHtml([
             key === here.key ? statusHtml : "",
             key === "plan" ? planCard : "",
-            // The shared approval sheet, its Plan details open here: nothing the yes agrees to is folded on this page.
             key === "approve" ? (approvalHtml !== "" ? approvalHtml : view.approved == null ? "" : html `<p class="meta">${view.approved.automatic ? `Approved automatically by ${view.approved.rule ?? "a rule"}` : `Approved by ${view.approved.by}`} · ${whenTime(view.approved.at)}</p>`) : "",
             key === "build" ? joinHtml([controlHtml, progressCard, revisionLedgerCard]) : "",
             key === "ready" && previousResult !== null ? html `<section class="task-previous-result" aria-label="${previousResult.title}">${previousResult.html}</section>` : "",
@@ -2658,12 +2204,6 @@ export function taskBody(data) {
     return taskBodyParts(data).html;
 }
 export function taskPage(chrome, data) {
-    // The sensitive-page composition guard (slice 1c): this page may carry a
-    // password ceremony. sendScreen() would keep a functional script on such
-    // a page — so the decision is made HERE, from the rendered body itself:
-    // when the body (or the chrome's list pane) shows a password input, the
-    // page re-renders degraded — no poller, static attempt line, link-only
-    // decisions — and ships no functional script at all.
     const first = taskBodyParts(data);
     const sensitive = SENSITIVE_INPUT.test(htmlString(first.html)) || (chrome.listPane !== undefined && SENSITIVE_INPUT.test(htmlString(chrome.listPane)));
     if (sensitive) {
@@ -2676,7 +2216,6 @@ export function taskPage(chrome, data) {
     const script = (liveRun === undefined ? "" : regionScript("check-progress", "check", `/r/${liveRun.id}`)) +
         (liveRun !== undefined && data.peekable === true ? regionScript("run-peek", "peek", `/r/${liveRun.id}`) : "") +
         (answers ? decisionAnswerScript() : "");
-    // The same three, named for the app (task-page-in-app.md): it runs its own version of each where it can.
     const app = [];
     if (liveRun !== undefined)
         app.push({ kind: "region", region: "check-progress", run: liveRun.id });
@@ -2690,8 +2229,6 @@ export function taskPage(chrome, data) {
         ...(script === "" ? {} : { functional: { script, fetches: true, app } }),
     });
 }
-/** One accessible two-choice control everywhere permissions are selected.
- * The words describe behavior; the raw flag stays secondary detail. */
 export function permissionModeChoices(name, selected) {
     const choice = (value, title, detail) => html `<label class="permission-choice"><input type="radio" name="${name}" value="${value}"${value === selected ? html ` checked` : ""}><span><strong>${title}</strong><small>${detail}</small></span></label>`;
     return joinHtml([
@@ -2701,7 +2238,6 @@ export function permissionModeChoices(name, selected) {
         html `</div>`,
     ]);
 }
-/** Quality selects the configured agent route; permissions remain separate. */
 export function qualityModeChoices(name, selected) {
     const choice = (value, title, detail) => html `<label class="permission-choice"><input type="radio" name="${name}" value="${value}"${value === selected ? html ` checked` : ""}><span><strong>${title}</strong><small>${detail}</small></span></label>`;
     return joinHtml([
@@ -2711,14 +2247,6 @@ export function qualityModeChoices(name, selected) {
         html `</div>`,
     ]);
 }
-/**
- * A decision's answer forms — one source of truth for the decision screen
- * and the triage flow. The consequence reads BEFORE the button that buys
- * it; irreversible options arm behind one deliberate tap AND the server
- * independently requires the confirm field. `returnTo` is allow-listed by
- * the answer handler, never an arbitrary URL. `csrf` is unused (postForm
- * writes the field); kept for callers.
- */
 export function decisionOptionForms(decision, returnTo) {
     return joinHtml(decision.options
         .map(option => {
@@ -2744,9 +2272,6 @@ export function taskOf(store, decision) {
     const run = store.getRun(decision.run);
     return run === null ? "?" : store.externalIdFor(run.taskRef) ?? "?";
 }
-/** A release task's own card (release-once.md, "What people see"): the release it's approved for, the later commits
- * carried under it (on demand), what a later check must run again, the last nightly check of main, and one action to
- * stop carrying. A carried task says whose approval it was carried from. */
 export function releaseCardHtml(taskId, release, canStop) {
     if (release === null)
         return html ``;
@@ -2767,9 +2292,6 @@ export function releaseCardHtml(taskId, release, canStop) {
         html `</div>`,
     ], "\n");
 }
-/** The task page's approval box (src/design/KIT.md): what it asks, the act's own form fields, and the facts the
- * approve control reads to show a password, one click, or nothing. The rows it signs go to the Plan tab (`planHtml`).
- * These decide only what the page shows: the approve route proves the person, the freshness and the digest again. */
 export function approveKitOf(input, freshSince) {
     const parts = approvalSheetParts(input);
     const rebuild = input.rebuild ?? null;
@@ -2785,15 +2307,11 @@ export function approveKitOf(input, freshSince) {
         kind: "standard",
         facts: { passwordless: passwordlessRendering() || input.localOwner?.eligible === true, remembered: until !== null },
         rememberedUntil: until,
-        // Easy-start C5: the owner approving on this computer needs no password, and the line says so (not "Passwordless").
         ...(input.localOwner?.eligible === true ? { termsWords: "No password needed on this computer." } : {}),
-        // What it signs: the plan sheet (the same parts as the chat's sheet, re-ordered), then the in-place editor.
         planHtml: htmlString(joinHtml([parts.sheet, parts.editor ?? "", parts.editorForm])),
-        // The plan sheet alone, with no editor and no form: what Home shows beside its one-click Approve (B2.1).
         sheetHtml: htmlString(parts.sheet),
     };
 }
-/** How an approved plan was approved, for the status box's terms line: by whom and how, or the rule that approved it. */
 export function approvedKitOf(scope, approval, proof) {
     if (!approval.approved)
         return null;
@@ -2803,7 +2321,9 @@ export function approvedKitOf(scope, approval, proof) {
     const how = approvalProofWords(proof).replace(/^ \(|\)$/g, "");
     return { by: approval.by, at: approval.at, automatic: rule !== null, rule, how: how === "" ? (rule === null ? "password typed" : "") : how, version: scope.digest.slice(0, 12) };
 }
-/** The plan version, in Details: a short handle a person can compare, never on the approval line itself. */
 export function planVersionDetailsHtml(digest) {
     return html `<details class="scope-version"><summary class="meta">Details</summary><p class="meta"><span class="mono">${planVersionWords(digest)}</span></p></details>`;
 }
+function agentlessRoute(dispatch, route) {
+    return dispatch?.summary === NO_AGENT_TITLE && route?.kind === "unreadable" && (route.problem ?? "").includes("has no exact model");
+}