toolroll 0.9.92 → 0.9.94

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,10 @@ 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 { 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";
@@ -44,6 +47,7 @@ import { validKeyTail } from "../live-records.js";
 import { runNotes } from "../live-notes.js";
 import { latestFinishedAttempt, retryNoteOf } from '../needs-you.js';
 import { REMOTE_MESSAGES } from "../operate-remote.js";
+import { proveRunStopped } from "../stop-proof.js";
 import { aggregateNewNames, observeWorktree, parseBaseTreeSnapshot, PEEK_LIMITS } from "../peek.js";
 import { isTaskSize, PHASES as ROUTE_PHASES } from "../phase-routing.js";
 import { applyModeToNewFiling, authorizePlanUnderMode } from "../plan-auto.js";
@@ -59,7 +63,7 @@ import { structuredHandoffView, terminalDiffView } from "../result-evidence-read
 import { fileAddTestsTask, requestFollowUpChecks } from '../result-follow-ups.js';
 import { commentSourceKey, isRevisionFeedback, parseResultTab, resultReturnTarget } from "../result-review.js";
 import { isAlive as runnerAlive } from "../runner.js";
-import { passwordlessSessionFor, acceptanceLinesToInput, acceptanceToLines, approvalOf, approve as approveScope, freshnessFor, localApprovalEligible, spendingOnlyOnSuccess, ssoNowAvailable, withFreshness, modeFilingCoverage, PLACEHOLDER_RUBRIC, proposeGuarded } from "../scope.js";
+import { passwordlessSessionFor, acceptanceLinesToInput, acceptanceToLines, approvalOf, approve as approveScope, freshnessFor, freshlyApprovable, localApprovalEligible, spendingOnlyOnSuccess, ssoNowAvailable, withFreshness, modeFilingCoverage, PLACEHOLDER_RUBRIC, proposeGuarded } from "../scope.js";
 import { subagentNames as subagentNamesOf } from "../spend.js";
 import { verifiedAuthor } from "../store.js";
 import { runCostWords } from "../summary.js";
@@ -71,13 +75,18 @@ 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";
 import { approvalFormDigest, approveRefusalWords, checkProgressHtml, consentDoorOf, nonceHashOf, PermissionsWouldChange, requirementsFromEditor, resumeDigestOf, taskOf } from "./render-tasks.js";
 import {} from "./session.js";
+import { approveReleaseCard, releaseApprovalCard, releaseSheetHref, releaseTaskOf } from "../release-approval.js";
+import { releaseSheetPage } from "./render-release.js";
+import { approvalFactsNow } from "./kit.js";
+import { localOwnerRefusal } from "../local-owner.js";
 export function createTasksHandlers(runtime) {
     const { identities, store, peekSay, peekCache, PEEK_CACHE_TTL_MS, peekInFlight, PEEK_GLOBAL_INFLIGHT, peekBySession, PEEK_SESSION_INFLIGHT, clock, peekName, PEEK_FRAGMENT_BYTES, peekEvict, evidenceRoot, sendScreen, chromeFor, visible, consumeApprovalNonce, authenticateApprover, options, mintApprovalNonce, taskScreen, unscopedMode, admissionList, planViewOf, revisionViewOf, runIsTaskResult, leadPrincipal, familyOf, armTaskResume, runIsLive, revisionLedgerOf, resultDetailOf, reviewFactsFor, taskRepoOf, runVisible, restricted, codingActorAllowed, codingProjectAllowed, managedRepos, routeViewOf, workAccess, firstRunStepsNow, revisionDocOf, failureOf, dockedConversation, planContractViewOf, familiesInView, explainAttempt, taskChatFocus, familyTasksInView, liveCeiling, projectOf, ceiling, bustBadge, revisionDestination } = runtime;
     /** A row admitted the address but its path parameter does not parse: the console's unknown page. */
@@ -89,7 +98,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;
@@ -130,7 +139,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') }));
@@ -139,82 +148,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
@@ -227,7 +160,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;
@@ -248,7 +181,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
@@ -300,179 +233,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) {
@@ -569,9 +336,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:
@@ -602,39 +369,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); })();
@@ -652,7 +439,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));
@@ -704,12 +491,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" });
@@ -855,7 +642,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 &&
@@ -1062,6 +851,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
@@ -1241,7 +1054,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);
@@ -1284,37 +1097,37 @@ export function createTasksHandlers(runtime) {
         }
         return redirect(response, decisionBack);
     }
-    async function taskConfirmStopped(ctx) {
-        const { url, who, response, now, posted } = ctx;
-        const act = matchTaskPath(url.pathname, "/confirm-stopped$");
+    async function taskRecheckStopped(ctx) {
+        const { url, who, response, posted } = ctx;
+        const act = matchTaskPath(url.pathname, "/recheck-stopped$");
         if (act === null)
             return noPage(who, response);
-        const body = readForm(posted, CONSOLE_FORMS.confirmStopped);
-        // Confirming a finished build stopped is an approver's act behind the password, typed again — the same
-        // record as `toolroll run settle`, refused while anything of the run may still be running.
+        const body = readForm(posted, CONSOLE_FORMS.recheckStopped);
+        // Check again: Toolroll looks at this computer's processes for the build once more (stop-proof.ts) and settles it
+        // when none of them is the build's. Nobody vouches that a build stopped, so there is nothing to confirm here.
         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);
         if (run === null || runTask === null || familyOf(runTask)?.root.id !== (familyOf(act.taskId)?.root.id ?? act.taskId)) {
             return taskScreen(response, who, act.taskId, "That build isn't part of this task.", 409);
         }
-        if (!authenticateApprover(who, body.get("token") ?? "", ref.repo).ok || !store.accountCanAccess(who.name, ref.repo)) {
-            return taskScreen(response, who, act.taskId, "That password didn't match. Nothing changed.", 403);
-        }
-        // When Toolroll can't check at all, the approver also says they checked: never a one-click confirmation.
-        if (store.stopQuiescenceFact(run.id)?.kind === "unknown" && body.get("checked") !== "yes") {
-            return taskScreen(response, who, act.taskId, `Make sure nothing from build #${run.id} is running, then tick the box to confirm.`, 409);
-        }
-        const settled = store.settleRunWitnessesByApprover({ runId: run.id, by: who.name, why: "Confirmed in the console that nothing from this build is running." }, now);
-        if (!settled.ok) {
-            return taskScreen(response, who, act.taskId, settled.reason === "alive" || settled.reason === "still-running"
-                ? `Something from build #${run.id} may still be running, so it can't be confirmed stopped yet.` : `Build #${run.id} can't be confirmed stopped.`, 409);
-        }
+        if (!store.accountCanAccess(who.name, ref.repo))
+            return taskScreen(response, who, act.taskId, "You can't act on this project's tasks.", 403);
+        const proved = await proveRunStopped(store, run.id, clock);
         bustBadge();
+        const left = store.stopQuiescenceFact(run.id);
+        if (left !== null) {
+            const words = proved.outcome === "blocked" ? `Build #${proved.run} ${proved.words}.`
+                : left.kind === "alive" || left.kind === "open" ? `Something from build #${left.run} may still be running. Toolroll stops what it proves is the build's on its own.`
+                    : left.kind === "elsewhere" ? `Build #${left.run} ran on another computer; only that computer can check it stopped.`
+                        : left.kind === "unknown" ? `Toolroll still can't prove build #${left.run} stopped from this computer.`
+                            : `Toolroll is still making sure build #${left.run} stopped. This clears on its own.`;
+            return taskScreen(response, who, act.taskId, words, 409);
+        }
         const to = resultReturnTarget(body.get("return"), run.id, runTasks(run.taskRef));
         return redirect(response, body.get("return") ? to : back);
     }
@@ -1330,7 +1143,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);
@@ -1692,7 +1505,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. */
@@ -1818,10 +1631,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": {
@@ -2086,7 +1899,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);
@@ -2454,11 +2267,15 @@ 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);
+                // The release sheet's Approve release (trusted-release-reports.md A7): the same door, its own page for words.
+                const sheet = body.get("sheet") === "release";
                 const approvalProblem = (message, status) => {
+                    if (sheet)
+                        return releaseSheet.sheetScreen({ who, response, project: null }, taskId, message, status);
                     if (requestedReturn !== null && requestedReturn !== "next") {
                         return redirect(response, chatReturnWithSaid(approvalBack, message));
                     }
@@ -2484,6 +2301,9 @@ export function createTasksHandlers(runtime) {
                     && !(who.authority === "local-owner" && localApprovalEligible(store, who.name, taskId).ok)) {
                     return approvalProblem("approval requires your password, typed again", 400);
                 }
+                // The sheet binds the release card's digest (the nonce was minted for it): the shared card wrapper decides.
+                if (sheet)
+                    return releaseSheet.approveFromSheet({ who, response, project: null }, taskId, digest, token);
                 const scopeRow = store.getScope(taskId);
                 if (scopeRow === null)
                     return approvalProblem("this task has no scope to approve", 409);
@@ -2948,6 +2768,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),
@@ -3078,6 +2900,7 @@ export function createTasksHandlers(runtime) {
         return live;
     }
     const tidyHandlers = createTidyHandlers(runtime);
+    const releaseSheet = createReleaseSheetHandlers(runtime);
     /** The question page, with a refusal in its box when an answer was refused (the box keeps the choice to make). */
     function decisionScreen(ctx, id, back, refusal, code, now, draft) {
         const { who, response, project } = ctx;
@@ -3095,6 +2918,7 @@ export function createTasksHandlers(runtime) {
     }
     const registrations = handlersOf("tasks", {
         ...tidyHandlers,
+        ...releaseSheet.routes,
         ...createAgentSignalHandlers(runtime),
         "code.page": showCode("workspace"),
         "code.session": showCode("session"),
@@ -3105,14 +2929,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,
@@ -3133,6 +2960,8 @@ 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,
         "queue.move": queueMove,
         "queue.note": queueNote,
         "decision.answer": answerDecision,
@@ -3155,7 +2984,7 @@ export function createTasksHandlers(runtime) {
         "task.act.retry-review": taskAct("retry-review"),
         "task.act.complete": taskAct("complete"),
         "task.act.merge": taskMerge,
-        "task.act.confirm-stopped": taskConfirmStopped,
+        "task.act.recheck-stopped": taskRecheckStopped,
         "task.act.stop": taskAct("stop"),
         "task.act.stop-carrying": taskAct("stop-carrying"),
         "task.act.pause": taskAct("pause"),
@@ -3194,7 +3023,44 @@ 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));
     }
     return { registrations, runListPane, peekFragment, taskMutation, queueRegionFor, ciFailingFor, completedRowFor, attemptRowFor, resultRowOf, reviewCockpitViewOf, decisionEvidence, runEvidence, sendArtifact, peekGuards, liveRunIds };
 }
@@ -3207,7 +3073,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,
@@ -3217,22 +3083,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"
@@ -3244,30 +3110,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;
 /**
@@ -3314,3 +3164,88 @@ export function createAgentSignalHandlers(runtime) {
     }
     return { "agents.seen": agentSeen, "agents.watch": agentWatch };
 }
+/**
+ * One-tap release approval (docs/plans/trusted-release-reports.md, slice A): the sheet (`/t/<id>/release`), the push's
+ * opaque locator (`/approve/<task ref>`, a GET that only redirects to the sheet) and the sheet's approval, which the
+ * task approval POST hands here once its shared checks (cookie session, CSRF and the browser key at admission, the
+ * single-use nonce, a password or a standing proof) passed. The approval itself is the shared card wrapper around the
+ * unchanged approve() (release-approval.ts approveReleaseCard).
+ */
+export function createReleaseSheetHandlers(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) {
+        const { who, response, project } = ctx;
+        const ref = store.lookupRef(taskId);
+        if (ref === null || !visible(ref.repo) || !store.accountCanAccess(who.name, ref.repo))
+            return missing(who, response);
+        const built = releaseApprovalCard(store, taskId);
+        if (!built.ok)
+            return missing(who, response);
+        const card = built.card;
+        const open = card.approved === null && card.refusal === null;
+        // This computer's local owner can't approve a release: the full sign-in comes first (scope.ts localApprovalEligible).
+        const local = who.via === "cookie" && who.authority === "local-owner" ? localOwnerRefusal(store.accountOf(who.name)?.passwordSet === true, releaseSheetHref(taskId)) : null;
+        const nonce = open && local === null && who.via === "cookie" && who.role === "approver" ? mintApprovalNonce(who.name, taskId, card.digest) : "";
+        const remembered = (() => {
+            if (!open || who.via !== "cookie")
+                return false;
+            const fresh = withFreshness("approve-standard", () => freshnessFor(who.name, Date.now(), true));
+            if (fresh === null)
+                return false;
+            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, held: who.role === "approver" ? autoPublishHeld(store, taskId) : null }));
+    }
+    async function showSheet(ctx) {
+        const task = matchTaskPath(ctx.url.pathname, "/release$");
+        if (task === null)
+            return missing(ctx.who, ctx.response);
+        return sheetScreen(ctx, task.taskId, null, 200);
+    }
+    /** The push's locator: proved a release in the person's projects from the plane's own state, then only redirected. */
+    async function locate(ctx) {
+        const { who, response, url } = ctx;
+        const raw = /^\/approve\/([1-9][0-9]{0,14})$/.exec(url.pathname)?.[1];
+        const ref = raw === undefined ? null : store.refForId(Number(raw));
+        if (ref === null || ref.backend !== "built-in" || !visible(ref.repo) || !store.accountCanAccess(who.name, ref.repo) || releaseTaskOf(store, ref.externalId) === null)
+            return missing(who, response);
+        return redirect(response, releaseSheetHref(ref.externalId));
+    }
+    /** The sheet's Approve release, after the approval POST's shared checks. */
+    function approveFromSheet(ctx, taskId, cardDigest, token) {
+        const { who, response } = ctx;
+        const now = clock();
+        const answer = spendingOnlyOnSuccess(() => withFreshness("approve-standard", () => approveReleaseCard(store, { taskId, cardDigest, approveNow: scopeDigest => approveScope(store, taskId, who.name, now, scopeDigest, token) })), result => !result.ok && !(result.reason === "approve" && result.result.reason === "second-approver" && !result.result.already));
+        if (answer.ok)
+            return redirect(response, releaseSheetHref(taskId));
+        if (answer.reason !== "approve")
+            return sheetScreen(ctx, taskId, answer.message, answer.reason === "not-release" ? 404 : 409);
+        const refused = answer.result;
+        if (refused.reason === "second-approver")
+            return sheetScreen(ctx, taskId, gateWords({ verdict: "vote", have: refused.have, need: 2, already: refused.already }), 200);
+        if (refused.reason === "policy")
+            return sheetScreen(ctx, taskId, refused.message, 403);
+        return sheetScreen(ctx, taskId, approveRefusalWords(refused.reason), refused.reason === "changed" || refused.reason === "unrouted" ? 409 : 403);
+    }
+    /** 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 };
+}