toolroll 0.9.93 → 0.9.95

package/dist/server/tasks.js

@@ -1,6 +1,7 @@
 import { titleWithin } from "../task-text.js";
 import { parseFeedbackImage, sameFeedbackImage } from "../result-review.js";
-import { archiveTaskFamily, dropFeedbackImage, releaseAuthorityOfTask, restoreTaskFamily, revokeRelease, runLiveCommands } from "../store.js";
+import { archiveTaskFamily, dropFeedbackImage, releaseAuthorityOfTask, restoreTaskFamily, revokeRelease, runCheckStamp, runLiveCommands } from "../store.js";
+import { ranWords } from "../check-stamp.js";
 import { applyTidy, approverStandsNow, familyRepoOf, releaseFactsOf, tidyDays, tidyDigest, tidyPreview, TIDY_DEFAULT_DAYS } from "../tidy.js";
 import { steerCapabilityOf } from "../steer-capabilities.js";
 import { canReveal, localCheckoutOf, revealInFinder } from "../checkout-proof.js";
@@ -17,7 +18,7 @@ import { DEPRECATED_PAGE } from "../deprecations.js";
 /** tasks handlers, moved without changing their route bodies. */
 import { html, htmlString, joinHtml, postForm, textHtml } from "../html.js";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
-import { lstatSync, realpathSync } from "node:fs";
+import { existsSync, lstatSync, realpathSync } from "node:fs";
 import {} from "node:http";
 import { withActor } from "../actor.js";
 import { gateWords } from "../approval-policy.js";
@@ -32,8 +33,14 @@ import { checkResponse, CONSOLE_FORMS, readForm } from "../contracts/console-api
 import { hasForbiddenControls, validateNote } from "../decision.js";
 import { builderReadyFor, diagnoseTaskDispatch, firstRunBuilderRepo } from "../dispatch.js";
 import { firstTaskSuggestions, withBuilderStep } from "../first-run.js";
-import { newTaskPage } from "./render-new-task.js";
-import { nextPage } from "./render-next.js";
+import { fastStartPage, fastTermsRows, importPage, newTaskPage } from "./render-new-task.js";
+import { fileGithubItem, readGithubItem } from "../github-import.js";
+import { allowAutoPublish, autoPublishHeld } from "../release-auto.js";
+import { startCheckRepair } from "../check-repair.js";
+import { askFailingFirst, dropFailingFirst, rerunEvidence, saveEvidencePair } from "../evidence-pair.js";
+import { closeFinding, familyInWebReach, familyRootOf, getFinding, NOT_ON_TASK, resendFinding, runOnTask, sendFinding, sendReviewFinding } from "../findings.js";
+import { labelProviderCapture, providerCapture } from "../provider-capture.js";
+import { fastStartBuild, keepGrownChange, prepareFastStart } from "../fast-start.js";
 import { evidencePack } from "../evidence-pack.js";
 import { decisionPage, evidenceRecordPage, runPage } from "./render-history.js";
 import { readVerifiedArtifact, readVerifiedReport, writeEvidenceFile } from "../evidence.js";
@@ -72,8 +79,9 @@ import { WorkIndexCursorError, workIndexPage } from "../work-index.js";
 import { buildProgressOf, parseWorkView } from "../workspace-ui.js";
 import { requestContext } from "./request-context.js";
 import { boardTickScript, oneLineOf, QUEUE_VIEW, refuse, regionScript, screen, transcriptScript, whenTime } from "./chrome.js";
+import { retiredRedirect } from "./retired-routes.js";
 import { chatReturnWithSaid, matchTaskPath, redirect, respond, reviewHref, safeChatReturn, safeReturn, SAFETY, taskChatHref, taskHref } from "./http.js";
-import { putAwayPage, boardBody, boardWorkers, inboxFingerprints, inboxPage, parseInboxTab, QUEUE_FRONT, queueBody, queueScript, TASK_STATES, workPage } from "./render-pages.js";
+import { putAwayPage, boardBody, boardWorkers, QUEUE_FRONT, queueBody, queueScript, TASK_STATES, workPage } from "./render-pages.js";
 import { runEfficiencyOf } from "../run-efficiency.js";
 import { timingFor } from "../latency-timeline.js";
 import { ACCEPT_ANYWAY_NEEDS_REASON, editorFileHref, proofBundleView, rankReviewQueue, RESULT_REFUSALS, REVIEW_QUEUE_CAP, reviewCockpitDetailParts, reviewCockpitPage, reviewPriorityOf, runFactsFragment, runOutcomeBadge, withRefusal } from "./render-results.js";
@@ -94,7 +102,7 @@ export function createTasksHandlers(runtime) {
     const showCode = (part, posted = false) => async (ctx) => {
         const { url, who, response, project } = ctx;
         if (who.via !== 'cookie' || !codingActorAllowed({ name: who.name, generation: who.session.generation }))
-            return refuse(response, who, 403, 'Coding sessions require installation-wide operator access. You can manage project tasks in Work.', '/work');
+            return refuse(response, who, 403, 'Coding sessions require installation-wide operator access. You can manage project tasks in Work.', '/tasks');
         const actor = { name: who.name, generation: who.session.generation };
         const sessionId = part === "workspace" || part === "unknown" ? null : /^\/code\/([a-f0-9]{32})/.exec(url.pathname)[1];
         const read = part === "state" || part === "changes" ? part : null;
@@ -135,7 +143,7 @@ export function createTasksHandlers(runtime) {
             if (!codingActorAllowed(actor))
                 return read !== null
                     ? respond(response, 403, 'application/json', JSON.stringify({ ok: false, error: 'Your access changed. Sign in again.' }))
-                    : refuse(response, who, 403, 'Your access changed. Sign in again.', '/work');
+                    : refuse(response, who, 403, 'Your access changed. Sign in again.', '/tasks');
             const message = error instanceof Error ? error.message : 'The coding workspace is unavailable.';
             if (part === 'ship')
                 return sendScreen(response, 409, screen('Review for shipping', html `<h1>Prepare this result</h1><p>${message}</p><a href="/code/${sessionId}">Back to coding</a>`, { chrome: chromeFor(project, 'code') }));
@@ -144,82 +152,6 @@ export function createTasksHandlers(runtime) {
             return sendScreen(response, 404, screen('Coding session unavailable', html `<h1>Session unavailable</h1><p>${message}</p><a href="/code">Open coding workspace</a>`, { chrome: chromeFor(project, 'code') }));
         }
     };
-    async function showInbox(ctx) {
-        const { url, who, request, response, now, project } = ctx;
-        // With no project open in scoped mode this is the ROLL-UP inbox:
-        // admission binds inside the bounded queries, every row's repo is
-        // re-proved here, and rows render as links only (Codex roll-up
-        // review, findings 6–8). Gaps stay per-project — they are derived
-        // against one repo's capabilities and roll up dishonestly.
-        const rollup = project === null && !unscopedMode;
-        const admission = rollup ? admissionList() : null;
-        const cancelled = store
-            .listCancelledBlockersScoped(project, 10, admission)
-            .filter(one => visible(one.repo) && visible(one.blockerRepo));
-        const inboxData = {
-            csrf: who.via === "cookie" ? who.session.csrf : "",
-            revision: who.via === "cookie" ? who.session.projectRevision : 0,
-            rollup,
-            interactive: project !== null,
-            decisions: store.listDecisionsScoped(project).filter(one => visible(one.repo)).slice(0, 10),
-            // Each waiting scope wears its consent door (v48 authority repair): a scope whose
-            // approval is closed — unreadable route, a route that cannot run,
-            // a pre-routing row whose approval lapsed — reads as needing
-            // attention, never as something to approve.
-            approvals: store.scopesAwaitingApproval(project, 10, admission).filter(one => visible(one.repo)).map(one => {
-                const ref = store.lookupRef(one.taskId);
-                const scope = store.getScope(one.taskId);
-                const door = consentDoorOf(scope, routeViewOf(one.taskId, ref, scope, now, who));
-                return { ...one, closed: door.open ? null : door.title };
-            }),
-            requeueables: store.listRequeueablesScoped(project, now, 10, admission).filter(one => visible(one.repo)),
-            needsVerification: store
-                .listCompletedWorkScoped(project, 10, admission)
-                .filter(one => visible(one.repo) && (one.proofVerdict === "short" || one.proofVerdict === "refuted") && !one.proofAccepted &&
-                assignmentOf(store, one.taskId, now, workAccess(), evidenceRoot) === null)
-                .map(one => ({
-                taskId: one.taskId,
-                title: one.title,
-                verdict: one.proofVerdict,
-                repo: one.repo,
-                matrix: one.proofMatrix,
-                repairChain: one.runId === null ? null : store.repairChainFor(one.runId),
-            })),
-            cancelledBlockers: cancelled,
-            gaps: project === null ? [] : computeGaps(store, project, now).filter(gap => gap.unblocks.length > 0).slice(0, 10),
-            // The builder step speaks for the same project as Chat's (firstRunBuilderRepo), as dispatch decides.
-            wizard: withBuilderStep(firstRunStepsNow(now), builderReadyFor(store, firstRunBuilderRepo(store, project, visible, managedRepos()), now)),
-            worker: (() => {
-                // The one fact the inbox must never hide (install review): with
-                // no worker answering, nothing here will ever build, and every
-                // approval below is a promise nobody is there to keep.
-                const runners = store.listRunners().filter(one => one.retiredAt === null && (!restricted() || one.repos.some(visible)));
-                const answering = runners.filter(one => runnerAlive(one, now));
-                const lastHeard = runners.map(one => one.heartbeatAt).sort().at(-1) ?? null;
-                return { answering: answering.length, registered: runners.length, lastHeard };
-            })(),
-            now,
-            // Console v2: results ready to review and work running now, from the same admitted work index.
-            ...(() => {
-                const row = (one) => ({ taskId: one.rootId, title: one.title, detail: one.status.detail, repo: one.repo });
-                const needsYou = workIndexPage(store, now, workAccess(), { view: "needs-you", limit: 40, project, root: evidenceRoot });
-                const runningNow = workIndexPage(store, now, workAccess(), { view: "running", limit: 40, project, root: evidenceRoot });
-                return { ready: needsYou.items.filter(one => one.assignmentState === "ready-to-check").map(row), running: runningNow.items.map(row) };
-            })(),
-        };
-        // Which tabs hold something new since this browser last looked (the dots on a phone).
-        const tab = parseInboxTab(url.searchParams.get("tab")) ?? "all";
-        const prints = inboxFingerprints(inboxData);
-        const seenWords = /(?:^|;\s*)so-inbox-seen=([0-9a-f]{8}(?:\.[0-9a-f]{8}){3})(?:;|$)/.exec(request.headers.cookie ?? "")?.[1]?.split(".") ?? null;
-        const order = ["needs-you", "ready", "running", "all"];
-        const seen = Object.fromEntries(order.map((one, index) => [one, seenWords?.[index] ?? ""]));
-        const unread = order.filter(one => seenWords !== null && seen[one] !== prints[one]);
-        for (const one of order)
-            if (tab === "all" || one === tab)
-                seen[one] = prints[one];
-        response.setHeader("Set-Cookie", `so-inbox-seen=${order.map(one => seen[one] || prints[one]).join(".")}; SameSite=Lax; Path=/; Max-Age=31536000`);
-        return sendScreen(response, 200, inboxPage(chromeFor(project, "inbox"), { ...inboxData, tab, unread }));
-    }
     async function showWork(ctx) {
         const { url, who, response, now, project } = ctx;
         // The Work destination (workspace package 1): every task in view as
@@ -232,7 +164,7 @@ export function createTasksHandlers(runtime) {
         // The stored-state filter the old task list had (`?state=`): an unknown state is refused, as it was there.
         const wantedState = url.searchParams.get("state");
         if (wantedState !== null && !TASK_STATES.includes(wantedState))
-            return refuse(response, who, 400, "no such state", "/work");
+            return refuse(response, who, 400, "no such state", "/tasks");
         const state = wantedState;
         const rollup = project === null && !unscopedMode;
         let work;
@@ -253,7 +185,7 @@ export function createTasksHandlers(runtime) {
         }
         catch (error) {
             if (error instanceof WorkIndexCursorError)
-                return refuse(response, who, 400, 'This task page has expired. Open the first page.', '/work');
+                return refuse(response, who, 400, 'This task page has expired. Open the first page.', '/tasks');
             throw error;
         }
         // A failed row says what its latest attempt missed, as its task page does (a stop reason already reads so), from
@@ -305,179 +237,13 @@ export function createTasksHandlers(runtime) {
         });
         // One project's Tasks dock that project's own conversation (v77).
         const projectThread = url.searchParams.has('project') && project !== null && managedRepos().includes(project) ? project : null;
-        const docked = projectThread === null ? null : dockedConversation(who, null, projectThread, now, `/work?project=${encodeURIComponent(projectThread)}`);
+        const docked = projectThread === null ? null : dockedConversation(who, null, projectThread, now, `/tasks?project=${encodeURIComponent(projectThread)}`);
         if (docked !== null)
             page.workspace = { ...page.workspace, conversation: docked, pageHtml: page.body };
         // Without a docked chat the list reads itself: 10 s while any of its tasks is building, else 30 s.
         page.refreshSeconds = work.totals.running > 0 ? 10 : 30;
         return sendScreen(response, 200, page);
     }
-    async function showNext(ctx) {
-        const { url, who, response, now, project } = ctx;
-        // Triage: everything waiting on a person, one at a time, hardest-
-        // blocked first — oldest question, then plans and scopes to approve,
-        // then stalled work to retry, then requirement gaps. `skip` is a
-        // bounded, session-free cursor of keys the operator set aside; every
-        // act 303s back here, which is what makes it a flow and not a list.
-        const skipped = new Set((url.searchParams.get("skip") ?? "").split(",").filter(one => /^[darg]:[A-Za-z0-9._:-]{1,80}$/.test(one)).slice(0, 20));
-        const decisions = store.listDecisionsScoped(project).filter(one => one.state !== "answered");
-        const approvals = store.scopesAwaitingApproval(project, 20);
-        const requeueables = store.listRequeueablesScoped(project, now, 20);
-        const gaps = project === null ? [] : computeGaps(store, project, now).filter(gap => gap.unblocks.length > 0);
-        const queue = [
-            ...decisions.map(decision => ({ key: `d:${decision.id}`, kind: "decision", decision })),
-            ...approvals.map(approval => ({ key: `a:${approval.taskId}`, kind: "approval", approval })),
-            ...requeueables.map(stalled => ({ key: `r:${stalled.taskId}`, kind: "requeue", stalled })),
-            ...gaps.map(gap => ({ key: `g:${gap.key.replace(/[^A-Za-z0-9._:-]/g, "_")}`, kind: "gap", gap })),
-        ];
-        const remaining = queue.filter(one => !skipped.has(one.key));
-        const item = remaining[0] ?? null;
-        const csrf = who.via === "cookie" ? who.session.csrf : "";
-        if (item !== null && item.kind === "approval") {
-            // The card restates the digest-bound terms, so the nonce may be
-            // minted here — same rule as the task screen, same binding.
-            const ref = store.lookupRef(item.approval.taskId);
-            const scope = store.getScope(item.approval.taskId);
-            const planView = ref !== null && ref.plan === "drafted" ? planViewOf(ref.id) : null;
-            const approvalDigest = approvalFormDigest(item.approval.digest, planView?.sha256 ?? null);
-            // The same agents block the task page and chat sign under (v48),
-            // and the same consent door: closed, it mints no nonce.
-            const route = routeViewOf(item.approval.taskId, ref, scope, now, who);
-            const nonce = who.via === "cookie" && consentDoorOf(scope, route).open ? mintApprovalNonce(who.name, item.approval.taskId, approvalDigest) : "";
-            return sendScreen(response, 200, nextPage(chromeFor(project, "inbox"), {
-                item, scope,
-                planDocument: planView?.document ?? null,
-                planContract: ref === null || planView === null ? null : planContractViewOf(ref.id, scope),
-                approvalDigest,
-                deliverable: ref?.deliverable ?? "branch",
-                route,
-                origin: originOf(store, item.approval.taskId, repo => store.accountCanAccess(who.name, repo)),
-                // Whether a remembered password may approve these exact terms: the task page's own preview (task-views.ts
-                // approvalFresh), read without minting a second nonce. Display only; the approve POST proves it again.
-                remembered: nonce !== "" && runtime.taskViewData(item.approval.taskId, who, null, { mintNonce: false })?.approvalFresh != null,
-                csrf, nonce, remaining: remaining.length, skipped: [...skipped], now,
-            }));
-        }
-        return sendScreen(response, 200, nextPage(chromeFor(project, "inbox"), {
-            item, scope: null, planDocument: null, planContract: null, csrf, nonce: "",
-            approvalDigest: null, route: null,
-            remaining: remaining.length, skipped: [...skipped], now,
-        }));
-    }
-    async function showBoard(ctx) {
-        const { url, who, response, now, project } = ctx;
-        // scope=all is the rolled-up view: every project this server was
-        // allowed to serve, on one board. The ceiling still rules row by row
-        // (rowVisible, the same predicate as every list) — a repo outside
-        // the server's configuration never renders a card, whatever the
-        // database holds. Unplaced work (repo NULL) appears: it dispatches
-        // anywhere, so every board honestly owns it.
-        const all = url.searchParams.get("scope") === "all";
-        // Roll-up admission happens BEFORE the query limit (Codex round 2,
-        // finding 11) — and root ceilings enumerate too, through the STORED
-        // repos that pass the ceiling (attended review, finding 3); the
-        // per-row visible() re-check below stays either way.
-        const admission = all ? admissionList() : null;
-        const snapshot = store.boardScoped(all ? null : project, now, 200, admission);
-        const admitted = all
-            ? snapshot.tasks.filter(facts => facts.repo === null || visible(facts.repo))
-            : snapshot.tasks;
-        const done = all
-            ? snapshot.done.filter(row => row.repo === null || visible(row.repo))
-            : snapshot.done;
-        // A blocker may live in a repo this server must not speak about —
-        // redact its state before the pure classifier composes a sentence
-        // from it (Codex round 2, finding 12). The dependency's NAME stays:
-        // the edge belongs to the visible task; the other project's live
-        // status does not.
-        const cards = admitted.map(facts => classify(facts.blockerRepo !== null && !visible(facts.blockerRepo)
-            ? { ...facts, blockerState: null }
-            : facts, now));
-        // "Since you last looked": what concluded between this session's
-        // previous full board read and now. Fragment polls never move the
-        // anchor — an open tab is not a person looking.
-        let delta = null;
-        if (who.via === "cookie" && url.searchParams.get("fragment") !== "1") {
-            const prev = who.session.sawBoardAt;
-            if (prev !== null && now.getTime() - prev > 5 * 60_000) {
-                const sinceIso = new Date(prev).toISOString();
-                const runs = store.runsSinceScoped(sinceIso, all ? null : project).filter(one => all ? one.taskId !== "" : true);
-                delta = {
-                    agoMinutes: Math.round((now.getTime() - prev) / 60_000),
-                    built: runs.filter(one => one.outcome === "built" || one.outcome === "no-change").length,
-                    failed: runs.filter(one => one.outcome === "failed").length,
-                    questions: store.listDecisionsScoped(all ? null : project).filter(one => one.createdAt >= sinceIso && one.state !== "answered").length,
-                };
-                if (delta.built === 0 && delta.failed === 0 && delta.questions === 0)
-                    delta = null;
-            }
-            who.session.sawBoardAt = now.getTime();
-        }
-        // A completed task whose proof is short or refuted and not yet
-        // accepted (Priority 2) reads "needs verification", not done — the
-        // board's once-and-only-once rule holds because this split is the
-        // ONE place a done row becomes either lane; the done-lane render
-        // below never sees the rows filtered out here.
-        const unverifiedDone = done.filter(row => (row.proofVerdict === "short" || row.proofVerdict === "refuted") && !row.proofAccepted);
-        const verifiedDone = done.filter(row => !unverifiedDone.includes(row));
-        const unverifiedCards = unverifiedDone.map(row => {
-            // v40: the SAME chip gains one more word when a repair chain
-            // exists for this row's own run — never a second card.
-            const chain = row.runId === null ? null : store.repairChainFor(row.runId);
-            const repairChain = chain === null
-                ? null
-                : {
-                    attempt: chain.attempt,
-                    outcome: chain.outcome,
-                    approved: chain.draftTask !== null && (store.getScope(chain.draftTask)?.approvedAt ?? null) !== null,
-                };
-            return attentionCardForUnverifiedDone({
-                taskId: row.taskId,
-                title: row.title,
-                repo: row.repo,
-                completedAt: row.completedAt,
-                proofVerdict: row.proofVerdict,
-                proofMatrix: row.proofMatrix,
-                repairChain,
-            });
-        });
-        // Project-level Needs you (evals-nightly.md, part A3): GitHub's nightly lane failures and the plane's own nightly
-        // check of main, for the projects this board shows.
-        const nightlyCards = nightlyNeedsYou(store, repo => visible(repo) && (all || project === null || repo === project)).map(need => ({
-            lane: "attention", taskId: need.key, title: need.title, repo: need.repo, reason: need.reason, href: need.href, claim: null,
-            stalledSince: need.since, attempt: null, overdue: false, priority: 0, assignedRunner: null,
-        }));
-        const laneCards = [...cards, ...unverifiedCards, ...nightlyCards];
-        // The worker strip: the workers this board's work can go to — bound to
-        // this project, or (rolled up) to any project the ceiling admits.
-        const workers = boardWorkers(store.listRunners(), { all, project, visible });
-        const body = boardBody({ cards: laneCards, workers, done: verifiedDone, saturated: snapshot.saturated, now, all, project, delta }, pr => store.ciFailureObserved(pr));
-        if (url.searchParams.get("fragment") === "1") {
-            // The live region alone — the in-page swapper's diet. Same auth,
-            // same ceiling, no shell, no scripts (finding 2).
-            return respond(response, 200, "text/html; charset=utf-8", body);
-        }
-        if (url.searchParams.get("view") === "order") {
-            // The board's ORDER view (operator request): the same screen, flipped
-            // to dispatch order with the queue's drag handles. Reordering and
-            // reserving are scheduling, not authority, so this is the one view
-            // where a drag does anything; the state view stays a view.
-            const csrf = who.via === "cookie" ? who.session.csrf : "";
-            const revision = who.via === "cookie" ? who.session.projectRevision : 0;
-            const region = queueRegionFor(project, csrf, revision, now);
-            return sendScreen(response, 200, screen("board", joinHtml([
-                html `<h1>Board</h1>`,
-                html `<p class="meta board-view"><a href="/board">state</a> \u00b7 <strong>order</strong> <span class="meta">\u2014 drag to reorder, or onto a worker to reserve; the state view is where cards move on their own</span></p>`,
-                html `<div id="queue-region">${region}</div>`,
-                html `<p class="meta" id="queue-region-stamp"></p>`,
-            ], "\n"), { chrome: chromeFor(project, "board"), functional: { script: queueScript(), fetches: true } }));
-        }
-        const regionBody = html `<div id="board-region">${body}</div><p class="meta" id="board-region-stamp"></p>`;
-        return sendScreen(response, 200, screen("board", regionBody, {
-            chrome: chromeFor(project, "board", undefined, all ? "board-all" : undefined),
-            functional: { script: regionScript("board-region", "1", undefined, { animate: true }) + boardTickScript(), fetches: true },
-        }));
-    }
     /** A completed (or attempted) row as the review list ranks it: its proof reasons, CI standing, and the assignment
      * when that assignment's receipt is this very row. */
     function reviewRowOf(row, now) {
@@ -574,9 +340,9 @@ export function createTasksHandlers(runtime) {
         const selectedRow = wantedId === null ? ranked[0] ?? null : chosen;
         // An exact link to a result this person can't see (or that never existed) reads the same either way.
         if (expectedRun !== null && wantedId !== null && chosen === null)
-            return refuse(response, who, 404, "No such result in your projects.", "/work");
+            return refuse(response, who, 404, "No such result in your projects.", "/tasks");
         if (expectedRun !== null && (!/^[1-9]\d*$/.test(expectedRun) || selectedRow?.runId !== Number(expectedRun))) {
-            return sendScreen(response, 409, screen("Result changed", html `<h1>Result changed</h1><p>This acceptance link no longer matches the current result. Review the current task before accepting.</p><p class="refusal-back"><a class="button-link" href="/review">Review results</a></p>`, { chrome: chromeFor(project, "runs") }));
+            return sendScreen(response, 409, screen("Result changed", html `<h1>Result changed</h1><p>This acceptance link no longer matches the current result. Review the current task before accepting.</p><p class="refusal-back"><a class="button-link" href="/tasks?view=ready">Review results</a></p>`, { chrome: chromeFor(project, "runs") }));
         }
         const selected = picked !== null ? picked.selected : selectedRow === null ? null : reviewCockpitViewOf(selectedRow, who, now);
         // Opening a run's own result page is viewing it: the shell says so with a keyed POST /agents/seen (easy-start N1:
@@ -607,39 +373,59 @@ export function createTasksHandlers(runtime) {
             reviewPage.workspace = { ...reviewPage.workspace, conversation: reviewDocked, pageHtml: reviewPage.body };
         return sendScreen(response, 200, reviewPage);
     }
-    /** Finished tasks live in the Tasks list's Finished view now (UI revamp wave B): the old address keeps answering, as a
-     * GET alias, with a named project carried along. */
-    async function showDone(ctx) {
-        const { url, response } = ctx;
-        const named = url.searchParams.get("project");
-        return redirectGet(response, `/work?view=completed${named === null || named === "" ? "" : `&project=${encodeURIComponent(named)}`}`);
-    }
     /** The old task list, retired into /work (docs/plans/reui-polish.md slice 7): its address keeps answering, as a
      * redirect, so links and bookmarks still land. `state` carries over (an unknown one is still refused); `template`
      * goes to the add page, which now pre-fills it. Anything else is dropped. */
+    /** Tasks (docs/plans/plain-toolroll.md P1.4): the one list, with List, Board, Ready, Archived and an every-project
+     * scope (`scope=all`). `view=board` is the Board, `view=order` the queue's order, `view=done` Finished. */
     async function showTasks(ctx) {
-        const { url, who, response } = ctx;
-        const wanted = url.searchParams.get("state");
-        if (wanted !== null && !TASK_STATES.includes(wanted))
-            return refuse(response, who, 400, "no such state", "/work");
+        const { url } = ctx;
         const template = url.searchParams.get("template");
         if (template !== null)
-            return redirect(response, `/tasks/new?template=${encodeURIComponent(template)}`);
-        return redirect(response, wanted === null ? "/work" : `/work?state=${encodeURIComponent(wanted)}`);
+            return redirect(ctx.response, `/tasks/new?template=${encodeURIComponent(template)}`);
+        const view = url.searchParams.get("view");
+        if (view === "order")
+            return showOrder(ctx);
+        // The list reads its own keys: Board is its layout, every project its roll-up, Finished its completed view.
+        const read = new URL(url.href);
+        if (view === "board") {
+            read.searchParams.delete("view");
+            read.searchParams.set("layout", "board");
+        }
+        if (view === "done")
+            read.searchParams.set("view", "completed");
+        if (read.searchParams.get("scope") === "all") {
+            read.searchParams.delete("scope");
+            read.searchParams.set("all", "1");
+        }
+        return showWork({ ...ctx, url: read });
     }
-    async function showQueue(ctx) {
+    /** The queue's order view, under Tasks: dispatch order with drag handles (scheduling, never authority). */
+    async function showOrder(ctx) {
         const { url, who, response, project } = ctx;
         const csrf = who.via === "cookie" ? who.session.csrf : "";
         const revision = who.via === "cookie" ? who.session.projectRevision : 0;
-        // Column headers read one thing beyond the queue snapshot: live claims
-        // in THIS project, per worker (the capacity is global), so the header
-        // names both and never a ratio.
-        if (url.searchParams.get("fragment") === "1") {
+        if (url.searchParams.get("fragment") === "1")
             return respond(response, 200, "text/html; charset=utf-8", queueRegionFor(project, csrf, revision, clock()));
+        const region = queueRegionFor(project, csrf, revision, clock());
+        return sendScreen(response, 200, screen("order", joinHtml([
+            html `<h1>Order the queue</h1>`,
+            html `<p class="meta board-view"><a href="/tasks?view=board">Board</a> · <strong>order</strong> <span class="meta">— drag to reorder, or onto a builder to keep it for that builder</span></p>`,
+            html `<div id="queue-region">${region}</div>`,
+            html `<p class="meta" id="queue-region-stamp"></p>`,
+        ], "\n"), { chrome: chromeFor(project, "work"), functional: { script: queueScript(), fetches: true } }));
+    }
+    /** /n/<number>: a push's task link, by the task's stored number, never its title. It opens the task's page only
+     * inside the viewer's own projects; anything else is the same not-found as an unknown number. */
+    async function showNumberedTask(ctx) {
+        const { url, who, response } = ctx;
+        const number = Number(url.pathname.slice("/n/".length));
+        const ref = Number.isSafeInteger(number) ? store.refForId(number) : null;
+        const task = ref === null || ref.backend !== "built-in" ? null : ref.externalId;
+        if (task === null || ref === null || ref.repo === null || !visible(ref.repo) || !store.accountCanAccess(who.name, ref.repo)) {
+            return refuse(response, who, 404, "There's no page at this address.", "/tasks");
         }
-        // The queue is the board's order view (reduction pass §1): the URL
-        // keeps answering, as a redirect, so nothing anyone bookmarked 404s.
-        return redirect(response, QUEUE_VIEW);
+        return redirectGet(response, taskHref(task));
     }
     async function showNewTask(ctx) {
         const picked = (() => { const name = ctx.url.searchParams.get("template"); return name === null ? null : templateByName(name); })();
@@ -657,7 +443,7 @@ export function createTasksHandlers(runtime) {
             return noPage(who, response);
         const family = familyOf(task.taskId);
         if (family === null)
-            return refuse(response, who, 404, "no such task", "/work");
+            return refuse(response, who, 404, "no such task", "/tasks");
         const version = url.searchParams.get("version");
         if (version !== null && !family.versions.some(one => one.id === version))
             return refuse(response, who, 404, "That version is not available for this task.", taskHref(family.root.id));
@@ -709,12 +495,12 @@ export function createTasksHandlers(runtime) {
         const access = workAccess();
         const family = store.taskFamilyOf(evidence.taskId, access.repos, access.includeUnplaced);
         if (family === null || !visible(family.root.repo))
-            return refuse(response, who, 404, "no such task", "/work");
+            return refuse(response, who, 404, "no such task", "/tasks");
         if (evidence.taskId !== family.root.id)
             return redirect(response, `${taskHref(family.root.id)}/evidence${url.search}`);
         const pack = evidencePack(store, family.root.id, access, who.name, now, evidenceRoot);
         if (pack === null)
-            return refuse(response, who, 404, "no such task", "/work");
+            return refuse(response, who, 404, "no such task", "/tasks");
         if (url.searchParams.get("format") === "json") {
             response.writeHead(200, { "content-type": "application/json; charset=utf-8", "content-disposition": `attachment; filename="evidence-${family.root.id.replace(/[^A-Za-z0-9._-]/g, "_")}.json"`,
                 "cache-control": "no-store", "x-content-type-options": "nosniff" });
@@ -860,7 +646,9 @@ export function createTasksHandlers(runtime) {
             who.via === "cookie" &&
             who.session.editorLinks === true &&
             // A reviewer run (v29) never had a checkout — no files to open.
-            found.worktree !== null
+            found.worktree !== null &&
+            // Idle cleanup removes the folder and a later run makes it again: no link to a folder that isn't there.
+            existsSync(found.worktree)
             ? { worktree: found.worktree }
             : null, options.editorLinks !== undefined &&
             options.localRunner !== undefined &&
@@ -1067,6 +855,30 @@ export function createTasksHandlers(runtime) {
         }
         // One filing door for every surface (Codex adoption review, finding 7).
         const after = (body.get("after") ?? "").trim();
+        // From an issue or pull request (github-import.ts): read and quoted first; filing is the second press, on what was read.
+        const fromLink = (body.get("from") ?? "").trim();
+        if (fromLink !== "") {
+            if (who.via !== "cookie" || repo === "")
+                return newTaskScreen(ctx, 400, "Choose the project this issue belongs to.", draft);
+            if (body.get("from-read") !== "1") {
+                const read = await readGithubItem(store, { url: fromLink, repo });
+                if (!read.ok)
+                    return newTaskScreen(ctx, 400, read.message, draft);
+                return sendScreen(response, 200, importPage(chromeFor(project ?? null, "tasks"), { repo, url: read.item.url, title: read.item.title, body: read.item.body, kind: read.item.kind, number: read.item.number, head: read.item.head }));
+            }
+            const filed = await fileGithubItem(store, { url: fromLink, repo, actor: who.name, shownHead: body.get("from-head") ?? null }, now);
+            if (!filed.ok)
+                return newTaskScreen(ctx, filed.reason === "head-moved" ? 409 : 400, filed.message, draft);
+            return redirect(response, taskHref(filed.taskId));
+        }
+        // Small work a person starts themselves: their words become the exact terms, and Build is their yes (fast-start.ts).
+        // Anything else, or any doubt, is the ordinary filing below. `plain` is "Plan it first" from that form.
+        if (who.via === "cookie" && body.get("plain") !== "1" && repo !== "" && goal === "" && notThis === "" && touchesGiven.length === 0 && !scout && id === "" && after === ""
+            && (qualityMode === null || qualityMode === "default") && (permissionMode === null || permissionMode === "auto")) {
+            const fast = await prepareFastStart(store, { actor: who.name, repo, title: typed.trim(), via: "console", ...(permissionMode === null ? {} : { permissionMode }), password: fastPasswordFacts(who) }, now);
+            if (fast.eligible)
+                return sendScreen(response, 200, fastStartPage(chromeFor(project ?? null, "tasks"), { title: typed.trim(), repo, preview: fast.preview, digest: fast.digest, terms: fastTermsRows(store, fast.scope, repo) }));
+        }
         let chainProblem = null;
         const made = store.transact(() => {
             // A project folder's identity changed while this request waited (a root or link now leads elsewhere): what was
@@ -1246,7 +1058,7 @@ export function createTasksHandlers(runtime) {
         const id = Number(answer[1]);
         const requestedReturn = body.get("return");
         const decisionBack = requestedReturn === "next"
-            ? "/next"
+            ? "/"
             : requestedReturn === null
                 ? `/d/${id}`
                 : safeChatReturn(requestedReturn);
@@ -1300,7 +1112,7 @@ export function createTasksHandlers(runtime) {
         const back = taskHref(act.taskId);
         const ref = store.lookupRef(act.taskId);
         if (ref === null || !visible(ref.repo))
-            return refuse(response, who, 404, "no such task", "/work");
+            return refuse(response, who, 404, "no such task", "/tasks");
         const named = (body.get("run") ?? "").trim();
         const run = /^[0-9]{1,15}$/.test(named) ? store.getRun(Number(named)) : null;
         const runTask = run === null ? null : store.externalIdFor(run.taskRef);
@@ -1335,7 +1147,7 @@ export function createTasksHandlers(runtime) {
             return taskScreen(response, who, act.taskId, "The demo merges nothing.", 403);
         const ref = store.lookupRef(act.taskId);
         if (ref === null || !visible(ref.repo))
-            return refuse(response, who, 404, "no such task", "/work");
+            return refuse(response, who, 404, "no such task", "/tasks");
         const named = (body.get("run") ?? "").trim();
         const run = /^[0-9]{1,15}$/.test(named) ? store.getRun(Number(named)) : null;
         const runTask = run === null ? null : store.externalIdFor(run.taskRef);
@@ -1697,7 +1509,7 @@ export function createTasksHandlers(runtime) {
         const resolved = store.resolveIncident(id, who.name, now);
         if (!resolved)
             return refuse(response, who, 409, "already resolved, or never open");
-        const back = body.get("return") === "inbox" ? "/inbox" : openRow === undefined ? "/" : taskHref(openRow.taskId);
+        const back = body.get("return") === "inbox" ? "/" : openRow === undefined ? "/" : taskHref(openRow.taskId);
         return redirect(response, back);
     }
     /** The compact recent-runs list for the master pane. */
@@ -1823,10 +1635,10 @@ export function createTasksHandlers(runtime) {
     function taskMutation(response, who, taskId, verb, posted, now) {
         const ref = store.lookupRef(taskId);
         if (ref === null || store.getTask(taskId) === null) {
-            return refuse(response, who, 404, "no such task", "/work");
+            return refuse(response, who, 404, "no such task", "/tasks");
         }
         if (!visible(ref.repo)) {
-            return refuse(response, who, 404, "no such task", "/work");
+            return refuse(response, who, 404, "no such task", "/tasks");
         }
         switch (verb) {
             case "steer": {
@@ -2091,7 +1903,7 @@ export function createTasksHandlers(runtime) {
                         return taskScreen(response, who, taskId, "Retried. The note wasn't saved; add it under Steering.", 409);
                 }
                 // Allow-listed return only — never an arbitrary URL from the form.
-                return redirect(response, body.get("return") === "inbox" ? "/inbox" : body.get("return") === "next" ? "/next" : taskHref(taskId));
+                return redirect(response, body.get("return") === "inbox" || body.get("return") === "next" ? "/" : taskHref(taskId));
             }
             case "follow-up": {
                 const body = readForm(posted, CONSOLE_FORMS.taskFollowUp);
@@ -2459,7 +2271,7 @@ export function createTasksHandlers(runtime) {
                 const body = readForm(posted, CONSOLE_FORMS.taskApprove);
                 const requestedReturn = body.get("return");
                 const approvalBack = requestedReturn === "next"
-                    ? "/next"
+                    ? "/"
                     : requestedReturn === null
                         ? taskHref(taskId)
                         : safeChatReturn(requestedReturn);
@@ -2960,6 +2772,8 @@ export function createTasksHandlers(runtime) {
             timing: timingFor(store, run.id, row.taskId),
             // How far its checks reached (check-access.ts), display only.
             checkAccess: store.runCheckAccess(run.id),
+            // How its checks actually ran, by what was stamped at launch: said only for a result whose checks ran.
+            checkRan: store.artifactsFor(run.id).some(one => one.kind === "check-log") ? ranWords(runCheckStamp(store, run.id)) : null,
             reviewRetry: store.reviewRetryStateOf(run.id),
             review: reviewFactsFor(run.id),
             notes: store.notesForRun(run.id),
@@ -3119,14 +2933,17 @@ export function createTasksHandlers(runtime) {
         "code.ship-preview": showCode("ship", true),
         "code.other": showCode("unknown"),
         // Retired into Tasks and the task page (src/design/KIT.md): each old address still answers, as a redirect.
-        "inbox": showInbox,
-        "work": showWork,
-        "next": showNext,
-        "board": showBoard,
-        "review": showReview,
-        "done": async (ctx) => { const to = retiredTasksAddress("done", ctx.url); return to === null ? showDone(ctx) : redirect(ctx.response, to); },
+        // Retired pages (docs/plans/plain-toolroll.md P1.4): permanent redirects, no page handler of their own.
+        "inbox": async (ctx) => retiredRedirect("inbox", ctx.url, ctx.response),
+        "work": async (ctx) => retiredRedirect("work", ctx.url, ctx.response),
+        "next": async (ctx) => retiredRedirect("next", ctx.url, ctx.response),
+        "board": async (ctx) => retiredRedirect("board", ctx.url, ctx.response),
+        // A result keeps its own page; the bare list moved to Tasks' Ready view.
+        "review": async (ctx) => ctx.url.searchParams.has("result") ? showReview(ctx) : retiredRedirect("review", ctx.url, ctx.response),
+        "done": async (ctx) => retiredRedirect("done", ctx.url, ctx.response),
         "tasks": showTasks,
-        "queue": showQueue,
+        "queue": async (ctx) => retiredRedirect("queue", ctx.url, ctx.response),
+        "n.task": showNumberedTask,
         "tasks.new": showNewTask,
         "task.page": showTask,
         "task.evidence": showTaskEvidence,
@@ -3147,6 +2964,9 @@ export function createTasksHandlers(runtime) {
         "code.answer-send": codeAct("answer"),
         "code.act-other": codeAct("unknown"),
         "tasks.add": addTask,
+        "tasks.fast": buildNow,
+        "task.act.keep-grown": keepGrown,
+        "task.act.follow-through": followThroughAct,
         "queue.move": queueMove,
         "queue.note": queueNote,
         "decision.answer": answerDecision,
@@ -3208,7 +3028,115 @@ export function createTasksHandlers(runtime) {
         const startsOn = draft?.values?.get("repo") ?? project ?? chrome.projects?.[0]?.path ?? null;
         const found = startsOn === null ? null : runtime.firstTasks.get(startsOn)?.found ?? null;
         const ideas = found ?? (runtime.firstRunStepsNow(ctx.now) !== null && !store.hasAnyWork() ? firstTaskSuggestions({ issues: [], todos: [] }) : []);
-        return sendScreen(response, status, newTaskPage(chrome, project, revision, problem, chainable, store.permissionDefault().mode, store.qualityDefault().mode, chrome.projects ?? [], draft, text, ideas));
+        return sendScreen(response, status, newTaskPage(chrome, project, revision, problem, chainable, store.permissionDefault().mode, store.qualityDefault().mode, chrome.projects ?? [], draft, text, ideas, ctx.url.searchParams.get("from")?.slice(0, 300) ?? null));
+    }
+    /** What the password rule reads for this request (approval-password.ts), the same facts the approve forms read. */
+    function fastPasswordFacts(who) {
+        return { passwordless: passwordlessSessionFor(store, who.name), localOwner: who.via === "cookie" && who.authority === "local-owner",
+            freshAt: withFreshness("approve-standard", () => freshnessFor(who.name, Date.now(), true))?.at ?? null, returnTo: "/tasks/new" };
+    }
+    /** Build: the fast start's one write. Every check is made again inside fastStartBuild's transaction. */
+    async function buildNow(ctx) {
+        const { who, response, now, posted } = ctx;
+        const body = readForm(posted, CONSOLE_FORMS.tasksFast);
+        if (who.via !== "cookie")
+            return refuse(response, who, 403, "Only a person starts a build this way.", "/tasks/new");
+        const preview = body.get("preview") ?? "";
+        const row = store.handle.prepare("SELECT repo, title FROM fast_preview WHERE id = ?").get(preview);
+        const title = row === undefined ? "" : String(row["title"]);
+        if (row !== undefined && !visible(String(row["repo"])))
+            return refuse(response, who, 403, "That project is outside your access.", "/projects");
+        const built = spendingOnlyOnSuccess(() => withFreshness("approve-standard", () => fastStartBuild(store, { preview, digest: body.get("digest") ?? "", actor: who.name, via: "console", password: fastPasswordFacts(who),
+            approveNow: (taskId, sawDigest, fast) => approveScope(store, taskId, who.name, now, sawDigest, "", {}, fast) }, now)), result => !result.ok);
+        if (!built.ok)
+            return newTaskScreen(ctx, built.reason === "changed" ? 409 : 403, built.message, { title, goal: "", not: "", touches: "", acceptance: "" });
+        const actionContext = requestContext.getStore();
+        if (actionContext !== undefined)
+            actionContext.createdTask = built.taskId;
+        return redirect(response, taskHref(built.taskId));
+    }
+    /** "Approve it to keep it": a fast start that grew gets a plan for its exact commit, on the ordinary approval. It seals nothing. */
+    async function keepGrown(ctx) {
+        const { url, who, response, now, posted } = ctx;
+        readForm(posted, CONSOLE_FORMS.keepGrown);
+        const act = matchTaskPath(url.pathname, "/keep-grown$");
+        if (act === null)
+            return noPage(who, response);
+        const kept = keepGrownChange(store, act.taskId, now);
+        if (!kept.ok)
+            return taskScreen(response, who, act.taskId, kept.message, 409);
+        return redirect(response, taskHref(act.taskId));
+    }
+    /** Findings, a failed check's repair and evidence (render-follow-through.ts). Nothing here is an approval: a repair is a
+     * draft, and its task page asks for the plan's approval as any other. */
+    async function followThroughAct(ctx) {
+        const { url, who, response, now, posted } = ctx;
+        const body = readForm(posted, CONSOLE_FORMS.followThrough);
+        const act = matchTaskPath(url.pathname, "/follow-through$");
+        if (act === null)
+            return noPage(who, response);
+        const { taskId } = act;
+        // Chat's gate, here too (findings.ts familyInReach): every project in this task's family, not only this page's.
+        if (familyInWebReach(store, who, taskId, visible) === null)
+            return refuse(response, who, 403, "That task is outside your access.", "/tasks");
+        const number = (name) => Number(body.get(name) ?? "");
+        const back = () => redirect(response, `${taskHref(taskId)}#findings`);
+        const refused = (message) => taskScreen(response, who, taskId, message, 409);
+        /** A finding or a run named by a form must belong to this task's family: this page's project was the one admitted. */
+        const ownFinding = () => { const found = getFinding(store, number("finding")); return found !== null && found.familyRoot === familyRootOf(store, taskId) ? found : null; };
+        const ownRun = () => runOnTask(store, number("run"), taskId);
+        switch (body.get("act")) {
+            case "send": {
+                const line = body.get("line") ?? "";
+                const pointer = body.get("pointer") ?? "";
+                const sent = pointer !== "" ? sendReviewFinding(store, taskId, pointer, who.name, now)
+                    : sendFinding(store, { taskId, source: "person", by: who.name, summary: body.get("note") ?? "", file: body.get("file") || null, line: line === "" ? null : Number(line) }, now);
+                return sent.ok ? back() : refused(sent.message);
+            }
+            case "resend": {
+                if (ownFinding() === null)
+                    return refused("That finding isn't on this task.");
+                const sent = resendFinding(store, number("finding"), now);
+                return sent.ok ? back() : refused(sent.message);
+            }
+            case "close": {
+                if (ownFinding() === null)
+                    return refused("That finding isn't on this task.");
+                const closed = closeFinding(store, number("finding"), who.name, body.get("note") ?? "", now);
+                return closed.ok ? back() : refused(closed.message);
+            }
+            case "repair": {
+                if (!ownRun())
+                    return refused(NOT_ON_TASK);
+                const started = startCheckRepair(store, evidenceRoot, number("run"), now);
+                return started.ok ? redirect(response, taskHref(started.draft)) : refused(started.message);
+            }
+            case "save-evidence": {
+                if (!ownRun())
+                    return refused(NOT_ON_TASK);
+                const saved = saveEvidencePair(store, evidenceRoot, { taskId, runId: number("run"), by: who.name }, now);
+                return saved.ok ? back() : refused(saved.message);
+            }
+            case "rerun-evidence": {
+                const asked = rerunEvidence(store, taskId, who.name, now);
+                return asked.ok ? back() : refused(asked.message);
+            }
+            case "failing-first-on":
+                askFailingFirst(store, taskId, who.name, now);
+                return back();
+            case "failing-first-off":
+                dropFailingFirst(store, taskId);
+                return back();
+            case "mark": {
+                const capture = providerCapture(store, number("capture"));
+                const label = body.get("label");
+                if (capture === null || !runOnTask(store, capture.run, taskId) || (label !== "exhausted" && label !== "not-exhausted"))
+                    return refused("That capture isn't on this task.");
+                labelProviderCapture(store, capture.id, label, who.name);
+                return back();
+            }
+            default: return refused("Reload the page and try again.");
+        }
     }
     return { registrations, runListPane, peekFragment, taskMutation, queueRegionFor, ciFailingFor, completedRowFor, attemptRowFor, resultRowOf, reviewCockpitViewOf, decisionEvidence, runEvidence, sendArtifact, peekGuards, liveRunIds };
 }
@@ -3221,7 +3149,7 @@ export function createTidyHandlers(runtime) {
         const { url, who, response, now, project } = ctx;
         const days = tidyDays(url.searchParams.get("days"));
         if (days === null)
-            return refuse(response, who, 400, "Choose a number of days from 1 to 365.", "/work/put-away");
+            return refuse(response, who, 400, "Choose a number of days from 1 to 365.", "/tasks/archive");
         const releases = releaseFactsOf(store);
         const items = tidyPreview(store, now, { releases, days, access: workAccess() });
         return sendScreen(response, 200, putAwayPage(chromeFor(project, "work"), { items, days, digest: tidyDigest(items, days), now,
@@ -3231,22 +3159,22 @@ export function createTidyHandlers(runtime) {
         const { who, response, now, posted } = ctx;
         const body = readForm(posted, CONSOLE_FORMS.tasksPutAway);
         const days = tidyDays(body.get("days"));
-        const back = (problem) => redirect(response, `/work/put-away?${new URLSearchParams({ ...(days === null || days === TIDY_DEFAULT_DAYS ? {} : { days: String(days) }), problem })}`);
+        const back = (problem) => redirect(response, `/tasks/archive?${new URLSearchParams({ ...(days === null || days === TIDY_DEFAULT_DAYS ? {} : { days: String(days) }), problem })}`);
         if (days === null)
             return back("Choose a number of days from 1 to 365.");
         if (!authenticateApprover(who, body.get("password") ?? "").ok)
-            return back("Enter your Toolroll password to put these away.");
+            return back("Enter your Toolroll password to archive these.");
         const done = applyTidy(store, now, { by: who.name, days, digest: body.get("digest") ?? "", only: body.getAll("task"), releases: releaseFactsOf(store), access: workAccess() });
         if (!done.ok)
             return back(done.message);
         bustBadge();
-        return redirect(response, "/work?view=archived");
+        return redirect(response, "/tasks?view=archived");
     }
     const oneTask = (kind) => async (ctx) => {
         const { url, who, response, now, posted } = ctx;
         const act = matchTaskPath(url.pathname, `/${kind}$`);
         if (act === null)
-            return refuse(response, who, 404, "There's no page at this address.", "/work");
+            return refuse(response, who, 404, "There's no page at this address.", "/tasks");
         const body = readForm(posted, kind === "archive" ? CONSOLE_FORMS.taskArchive : CONSOLE_FORMS.taskRestore);
         const standing = (refs) => approverStandsNow(store, who.name, familyRepoOf(store, refs));
         const done = kind === "archive"
@@ -3258,30 +3186,14 @@ export function createTidyHandlers(runtime) {
         const to = safeReturn(body.get("return"));
         return redirect(response, to === "/" ? taskHref(act.taskId) : to);
     };
-    return { "work.put-away": showPutAway, "work.put-away.apply": applyPutAway, "task.act.archive": oneTask("archive"), "task.act.restore": oneTask("restore") };
+    return { "tasks.archive": showPutAway, "work.put-away": async (ctx) => retiredRedirect("work.put-away", ctx.url, ctx.response),
+        "work.put-away.apply": applyPutAway, "task.act.archive": oneTask("archive"), "task.act.restore": oneTask("restore") };
 }
 /** A retired page's GET alias: a plain 302 (the shared 303 helper belongs to POST landings), as pages.ts morningAlias. */
 function redirectGet(response, to) {
     response.writeHead(302, { ...SAFETY, Location: to });
     response.end();
 }
-/**
- * Where a retired Tasks address goes now (wave A, src/design/KIT.md): Done is Finished. `board` names where the old
- * Board's state view goes once it is retired (Tasks' Board view; its Order view and its live fragment stay). Null: this
- * address still answers itself.
- */
-export function retiredTasksAddress(route, url) {
-    // (The Board keeps its own page for now: Tasks' Board view is where the app links; see the wave A report.)
-    const project = url.searchParams.get("project");
-    const keep = project === null || url.searchParams.getAll("project").length !== 1 ? "" : `project=${encodeURIComponent(project)}&`;
-    switch (route) {
-        case "done": return `/work?${keep}view=completed`;
-        case "board":
-            if (url.searchParams.get("view") === "order" || url.searchParams.get("fragment") === "1")
-                return null;
-            return url.searchParams.get("scope") === "all" ? "/work?all=1&layout=board" : `/work?${keep}layout=board`;
-    }
-}
 /** How many cards a Board column shows; the column's count covers them all and its "View all" opens the list. */
 export const BOARD_COLUMN_LIMIT = 40;
 /**
@@ -3336,7 +3248,7 @@ export function createAgentSignalHandlers(runtime) {
  * unchanged approve() (release-approval.ts approveReleaseCard).
  */
 export function createReleaseSheetHandlers(runtime) {
-    const { store, sendScreen, chromeFor, visible, mintApprovalNonce, clock } = runtime;
+    const { store, sendScreen, chromeFor, visible, mintApprovalNonce, clock, authenticateApprover } = runtime;
     const missing = (who, response) => refuse(response, who, 404, "There's no release waiting for approval at this address.", "/work");
     /** The sheet, with a problem said where it happened. */
     function sheetScreen(ctx, taskId, problem, status) {
@@ -3361,7 +3273,7 @@ export function createReleaseSheetHandlers(runtime) {
             const gate = store.approvalGate(taskId, who.name, "person");
             return freshlyApprovable(store, taskId, card.scope, gate.verdict === "seal" && !gate.protectedWork);
         })();
-        return sendScreen(response, status, releaseSheetPage(chromeFor(project ?? ref.repo, "work"), { card, nonce, facts: approvalFactsNow({ remembered }), local, problem }));
+        return sendScreen(response, status, releaseSheetPage(chromeFor(project ?? ref.repo, "work"), { card, nonce, facts: approvalFactsNow({ remembered }), local, problem, held: who.role === "approver" ? autoPublishHeld(store, taskId) : null }));
     }
     async function showSheet(ctx) {
         const task = matchTaskPath(ctx.url.pathname, "/release$");
@@ -3394,5 +3306,22 @@ export function createReleaseSheetHandlers(runtime) {
             return sheetScreen(ctx, taskId, refused.message, 403);
         return sheetScreen(ctx, taskId, approveRefusalWords(refused.reason), refused.reason === "changed" || refused.reason === "unrouted" ? 409 : 403);
     }
-    return { routes: { "task.release": showSheet, "release.locate": locate }, sheetScreen, approveFromSheet };
+    /** A held automatic release goes on: a person only, proved now. The watch then resumes it (release-next.ts). */
+    async function goOn(ctx) {
+        const { who, url, posted, now, response } = ctx;
+        const body = readForm(posted, CONSOLE_FORMS.releaseGoOn);
+        const task = matchTaskPath(url.pathname, "/release/go-on$");
+        if (task === null || who.via !== "cookie")
+            return missing(who, response);
+        const ref = store.lookupRef(task.taskId);
+        if (ref === null || !visible(ref.repo))
+            return missing(who, response);
+        if (!authenticateApprover(who, body.get("password") ?? "", ref.repo).ok)
+            return sheetScreen(ctx, task.taskId, "Enter your Toolroll password to let this release go on.", 403);
+        const allowed = allowAutoPublish(store, { taskId: task.taskId, by: who.name, now });
+        if (!allowed.ok)
+            return sheetScreen(ctx, task.taskId, allowed.why, 409);
+        return redirect(response, releaseSheetHref(task.taskId));
+    }
+    return { routes: { "task.release": showSheet, "task.release.go-on": goOn, "release.locate": locate }, sheetScreen, approveFromSheet };
 }