toolroll 0.9.85 → 0.9.87

package/dist/server/task-views.d.ts

@@ -1,3 +1,4 @@
+import { releaseProgressFor, type ShipChecks } from "../store.js";
 import { type Html } from "../html.js";
 import { type AssignmentSnapshot } from '../assignment.js';
 import { type FailureExplanation } from '../needs-you.js';
@@ -12,6 +13,7 @@ import { type CompletionReceiptView, type ResultDetail, type TaskPullRequest } f
 import { taskBody, type MilestoneProgressView, type PlanContractView, type PlanRevisionLedgerView, type RevisionDocView, type RevisionView, type RouteView } from "./render-tasks.js";
 import { type Who } from "./session.js";
 import type { TaskPageExtras } from "./runtime.js";
+import type { BrowserTaskView } from "../browser-workspace.js";
 import type { PlanRevision, TaskRef } from "../store.js";
 import { type Run, type Store, type Task, type TaskState } from "../store.js";
 import { type ReviewFacts } from "../workspace-ui.js";
@@ -88,3 +90,9 @@ export declare function createTaskViews(runtime: TaskViewsRuntime): {
     progressOf: (taskRef: number, currentDocument: string | null) => MilestoneProgressView[] | null;
     resultDetailOf: (run: Run, who: Who, now: Date) => ResultDetail;
 };
+/** A pull request's checks as Ship shows them (src/design/KIT.md timing rows): each check on one elapsed-time axis
+ * from the first one's start, its state in the five words' tones, and one line for the whole. Null: no checks read. */
+export declare function shipViewOf(ship: ShipChecks | null, now: Date): NonNullable<BrowserTaskView["ship"]> | null;
+/** A release's steps as its progress view shows them: every step in order on one time axis, the ones not reached
+ * queued, and where it stands in one line. Null: this task is no release. */
+export declare function releaseStepsViewOf(progress: ReturnType<typeof releaseProgressFor>, now: Date): NonNullable<BrowserTaskView["release"]> | null;

package/dist/server/task-views.js

@@ -1,6 +1,8 @@
 import { feedbackImageProblem } from "../result-actions.js";
 import { parseFeedbackImage } from "../result-review.js";
 import { releaseViewOf } from "../release-view.js";
+import { RELEASE_STEPS } from "../release.js";
+import { releaseProgressFor, shipChecksForTask } from "../store.js";
 import { releaseCiRunningOf } from "../release-ci-hold.js";
 import { releaseObligationsOf } from "../release-recheck.js";
 import { approvalProofOf, freshlyApprovable, freshnessFor, withFreshness } from "../scope.js";
@@ -21,6 +23,7 @@ import { newestPullRequestOf, publishingOf, pullRequestBlocker } from '../pull-r
 import { structuredHandoffView, terminalDiffView } from "../result-evidence-readers.js";
 import { resultCheckLevel } from '../result-follow-ups.js';
 import { skillsSnapshotHtml, skillTestFeedbackHtml } from "../skills-ui.js";
+import { archiveOf } from "../store.js";
 import { runActivityOf } from "../task-activity.js";
 import { taskFingerprint } from "../task-live.js";
 import { pullRequestFactOf } from '../task-status.js';
@@ -792,6 +795,10 @@ export function createTaskViews(runtime) {
         const presentedData = { ...data, rootId: family?.root.id ?? taskId, rootTitle: family?.root.title ?? data.task.title,
             ...(family === null || data.assignment != null ? {} : { history: familyHistory(family) }),
             versionLabel: family !== null && family.current.id !== taskId ? `Viewing ${family.versions.findIndex(one => one.id === taskId) === 0 ? "Original" : `Revision ${family.versions.findIndex(one => one.id === taskId)}`} · ${family.current.state === "running" ? "A newer revision is running" : "A newer revision is current"}` : null };
+        // Put away (v145, task-tidy.md): who or what put it away and why, and whether this person can put it away or restore it.
+        const archived = archiveOf(runtime.store, taskId);
+        presentedData.archived = archived;
+        presentedData.canPutAway = who.via === "cookie" && who.role === "approver";
         if (scopeDraft !== undefined)
             presentedData.scopeDraft = scopeDraft;
         if (cancelDraft !== undefined)
@@ -831,8 +838,12 @@ export function createTaskViews(runtime) {
                     } })() } } : {}) } : page.workspace?.view;
         // A refusal that keeps a draft (a scope edit, an armed cancel) or asks for the plan editor reopens on Plan, where the
         // draft and its error are; anything else on Activity unless the address named a tab.
-        const tab = extras.tab ?? (scopeDraft !== undefined || cancelDraft !== undefined || editPlan ? "plan" : "activity");
-        const oneTaskView = taskView?.kind === "task" ? onePageView(taskView, family, presentedData.family?.runs ?? data.runs.map(run => ({ ...run, taskId: data.task.id })), { ...extras, tab }) : taskView;
+        const tab = extras.tab ?? "plan";
+        const onePage = taskView?.kind === "task" ? onePageView(taskView, family, presentedData.family?.runs ?? data.runs.map(run => ({ ...run, taskId: data.task.id })), { ...extras, tab }) : taskView;
+        // Ship (its pull request's checks, each on one time axis) and a release's own steps, read from the store now.
+        const rootId = family?.root.id ?? taskId;
+        const oneTaskView = onePage?.kind === "task" ? { ...onePage, ship: shipViewOf(shipChecksForTask(runtime.store, rootId), runtime.clock()),
+            release: releaseStepsViewOf(releaseProgressFor(runtime.store, rootId), runtime.clock()) } : onePage;
         // The Result tab's no-script page, under the task's own (the same HTML its result page serves), and its script.
         if (extras.result != null) {
             page.body = html `${page.body}<section class="task-result-tab" id="task-result" aria-label="Result">${extras.result.html}</section>`;
@@ -1158,3 +1169,80 @@ function autoReleaseOf(scope) {
     return scope.approvalBasis === "auto-green" ? { kind: "approved", candidate: scope.candidate }
         : scope.approvalBasis === "auto-check" ? { kind: "checking", candidate: scope.candidate } : null;
 }
+/** A pull request's checks as Ship shows them (src/design/KIT.md timing rows): each check on one elapsed-time axis
+ * from the first one's start, its state in the five words' tones, and one line for the whole. Null: no checks read. */
+export function shipViewOf(ship, now) {
+    if (ship === null || ship.checks.length === 0)
+        return null;
+    const at = (iso) => iso === null ? null : Date.parse(iso);
+    const observed = Date.parse(ship.observedAt);
+    const end = Number.isFinite(observed) ? observed : now.getTime();
+    const starts = ship.checks.map(one => at(one.startedAt)).filter((one) => one !== null && Number.isFinite(one));
+    const origin = starts.length === 0 ? end : Math.min(...starts);
+    const st = (state) => state === "passed" ? "ok" : state === "failed" || state === "cancelled" ? "bad" : state === "running" ? "run" : state === "queued" ? "q" : "ok";
+    const rows = ship.checks.map(one => {
+        const start = at(one.startedAt), done = at(one.completedAt);
+        const from = start ?? origin;
+        return { name: one.name, ...(one.workflow === null || one.workflow === one.name ? {} : { sub: one.workflow }),
+            ...(one.state === "skipped" ? { sub: "skipped" } : one.state === "neutral" ? { sub: "neutral" } : {}),
+            st: st(one.state), start: Math.max(0, (from - origin) / 1000), dur: start === null ? 0 : Math.max(0, ((done ?? end) - start) / 1000) };
+    });
+    const passed = ship.checks.filter(one => one.state === "passed" || one.state === "skipped" || one.state === "neutral").length;
+    const failed = ship.checks.filter(one => one.state === "failed" || one.state === "cancelled").length;
+    const running = ship.checks.length - passed - failed;
+    // The overall status is the observation's own (the one merges read); the rows only time each check.
+    // `none` (the pull request closed or merged, or GitHub reported no checks) is never painted as passed.
+    const state = ship.observed === "failing" ? "failed" : ship.observed === "passing" ? "passed" : ship.observed === "running" ? "running" : "none";
+    return {
+        pr: ship.prNumber, head: ship.headSha.slice(0, 7), state, rows,
+        summary: state === "failed" ? (failed > 0 ? `${failed} of ${ship.checks.length} ${ship.checks.length === 1 ? "check" : "checks"} failed` : "Checks are failing on GitHub")
+            : state === "running" ? `${passed} of ${ship.checks.length} checks passed` : state === "passed" ? `All ${ship.checks.length} ${ship.checks.length === 1 ? "check" : "checks"} passed`
+                : "No current checks: the pull request is closed or merged, or GitHub reported none",
+        observedAt: ship.observedAt,
+    };
+}
+/** A release step's name in words (release.ts RELEASE_STEPS). */
+const RELEASE_STEP_WORDS = {
+    gate: "Release gate", approval: "Approval", check: "Release check", complete: "Complete the task", quiet: "Wait for quiet", deploy: "Deploy to this Mac",
+    link: "Point the CLI at it", ci: "Pull request checks", merge: "Merge into main", tree: "Verify the merged tree", tag: "Tag", publish: "Publish to npm", homebrew: "Homebrew",
+};
+/** A release's steps as its progress view shows them: every step in order on one time axis, the ones not reached
+ * queued, and where it stands in one line. Null: this task is no release. */
+export function releaseStepsViewOf(progress, now) {
+    if (progress === null)
+        return null;
+    const origin = Date.parse(progress.startedAt);
+    const recorded = new Map(progress.steps.map(one => [one.step, one]));
+    const all = RELEASE_STEPS.filter(step => step !== "done");
+    // A release that started part way (one carried under an earlier approval, or resumed from an older journal) shows
+    // the steps from where its own record starts; a step missing between two recorded ones is a write that was lost.
+    const firstAt = all.findIndex(step => recorded.has(step));
+    const lastAt = all.reduce((at, step, index) => recorded.has(step) ? index : at, -1);
+    const steps = firstAt <= 0 ? all : all.slice(firstAt);
+    const rows = steps.map(step => {
+        const one = recorded.get(step);
+        // A step with no record is never painted as done: between recorded ones it says so, after them it is queued.
+        if (one === undefined)
+            return all.indexOf(step) < lastAt ? { name: RELEASE_STEP_WORDS[step] ?? step, sub: "not recorded", st: "q", start: 0, dur: 0 }
+                : { name: RELEASE_STEP_WORDS[step] ?? step, st: "q", start: 0, dur: 0 };
+        const start = Date.parse(one.startedAt), end = one.endedAt === null ? now.getTime() : Date.parse(one.endedAt);
+        const st = one.state === "done" ? "ok" : one.state === "failed" ? "bad" : one.state === "waiting" ? "wait" : "run";
+        return { name: RELEASE_STEP_WORDS[step] ?? step, ...(one.detail === null || one.state === "done" ? {} : { sub: one.detail.slice(0, 160) }), st,
+            start: Number.isFinite(start) && Number.isFinite(origin) ? Math.max(0, (start - origin) / 1000) : 0, dur: Number.isFinite(start) && Number.isFinite(end) ? Math.max(0, (end - start) / 1000) : 0 };
+    });
+    const current = rows.findIndex(row => row.st === "run" || row.st === "wait" || row.st === "bad");
+    // Released only on its own evidence: the last step (Homebrew, after publication) recorded done. A merge (authority
+    // `merged`) is not a release: verifying the tree, the tag and publication still follow it.
+    const done = progress.stopped === null && recorded.get("homebrew")?.state === "done";
+    const at = current === -1 ? null : rows[current];
+    const last = lastAt === -1 ? null : RELEASE_STEP_WORDS[all[lastAt]] ?? all[lastAt];
+    return {
+        tag: progress.tag, version: progress.version, pr: progress.pr,
+        rows,
+        state: progress.stopped !== null ? "failed" : done ? "done" : at?.st === "wait" ? "waiting" : "running",
+        headline: done ? `Released ${progress.version}` : progress.stopped !== null ? `Stopped at ${RELEASE_STEP_WORDS[progress.stopped.step] ?? progress.stopped.step}`
+            : at !== null ? `${at.name} · Step ${current + 1} of ${rows.length}` : last === null ? "Starting" : `${last} done · the next step starts on its own`,
+        stopped: progress.stopped === null ? null : { step: RELEASE_STEP_WORDS[progress.stopped.step] ?? progress.stopped.step, message: progress.stopped.message, at: progress.stopped.at },
+        startedAt: progress.startedAt,
+    };
+}

package/dist/server/tasks.d.ts

@@ -2,6 +2,7 @@
 import { type Html } from "../html.js";
 import { type ServerResponse } from "node:http";
 import { type Artifact, type Run, type Store } from "../store.js";
+import type { HandlerContext } from './handler-context.js';
 import type { ServerRuntime } from './runtime.js';
 import { type PeekAdmission } from "./render-pages.js";
 import { type CompletedWorkRow, type RankedReviewRow, type ReviewCockpitView } from "./render-results.js";
@@ -36,3 +37,20 @@ export declare function createTasksHandlers(runtime: ServerRuntime): {
     };
     liveRunIds: (rows: readonly (Pick<Run, "id" | "outcome" | "leaseId" | "taskRef">)[]) => Set<number>;
 };
+/** Put away and Restore one task, and Put away old tasks (docs/plans/task-tidy.md): the preview reads only (GET-quiet);
+ * putting away many is an approver's step-up bound to the digest of exactly what the preview showed. Each write
+ * re-proves the person's standing inside its own transaction. */
+export declare function createTidyHandlers(runtime: ServerRuntime): {
+    "work.put-away": (ctx: HandlerContext) => Promise<void>;
+    "work.put-away.apply": (ctx: HandlerContext) => Promise<void>;
+    "task.act.archive": (ctx: HandlerContext) => Promise<void>;
+    "task.act.restore": (ctx: HandlerContext) => Promise<void>;
+};
+/**
+ * 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 declare function retiredTasksAddress(route: "board" | "done", url: URL): string | null;
+/** How many cards a Board column shows; the column's count covers them all and its "View all" opens the list. */
+export declare const BOARD_COLUMN_LIMIT = 40;

package/dist/server/tasks.js

@@ -1,5 +1,6 @@
 import { parseFeedbackImage, sameFeedbackImage } from "../result-review.js";
-import { dropFeedbackImage, releaseAuthorityOfTask, revokeRelease, runLiveCommands } from "../store.js";
+import { archiveTaskFamily, dropFeedbackImage, releaseAuthorityOfTask, restoreTaskFamily, revokeRelease, runLiveCommands } from "../store.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";
 /** A form's way back to a flow card ("flow:<flow>:<card>"), read strictly: numbers only, never a path. */
@@ -10,7 +11,7 @@ function returnedFlow(value) {
 import { originOf } from "../task-source.js";
 import { ACP_AGENTS, isAcpProvider } from "../acp-agents.js";
 import { handlersOf } from './handler-registry.js';
-import { closedQuestionWords } from "../decision.js";
+import { closedQuestionWords, LIMITS } from "../decision.js";
 import { DEPRECATED_PAGE } from "../deprecations.js";
 /** tasks handlers, moved without changing their route bodies. */
 import { html, htmlString, joinHtml, postForm, textHtml } from "../html.js";
@@ -29,8 +30,11 @@ import { CodingActionError } from '../coding-workspace.js';
 import { checkResponse, CONSOLE_FORMS, readForm } from "../contracts/console-api.js";
 import { hasForbiddenControls, validateNote } from "../decision.js";
 import { builderReadyFor, diagnoseTaskDispatch, firstRunBuilderRepo } from "../dispatch.js";
-import { withBuilderStep } from "../first-run.js";
-import { evidencePack, evidencePackHtml } from "../evidence-pack.js";
+import { firstTaskSuggestions, withBuilderStep } from "../first-run.js";
+import { newTaskPage } from "./render-new-task.js";
+import { nextPage } from "./render-next.js";
+import { evidencePack } from "../evidence-pack.js";
+import { decisionPage, evidenceRecordPage, runPage } from "./render-history.js";
 import { readVerifiedArtifact, readVerifiedReport, writeEvidenceFile } from "../evidence.js";
 import { computeGaps } from "../gaps.js";
 import { limitsView } from "../limits-ui.js";
@@ -67,11 +71,11 @@ 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 { chatReturnWithSaid, matchTaskPath, redirect, respond, reviewHref, safeChatReturn, safeReturn, SAFETY, taskChatHref, taskHref } from "./http.js";
-import { boardBody, boardWorkers, donePage, inboxFingerprints, inboxPage, newTaskPage, nextPage, parseInboxTab, QUEUE_FRONT, queueBody, queueScript, TASK_STATES, workPage } from "./render-pages.js";
+import { putAwayPage, boardBody, boardWorkers, inboxFingerprints, inboxPage, parseInboxTab, 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, runPage, RUNS_PAGE, runsPage, withRefusal } from "./render-results.js";
-import { approvalFormDigest, approveRefusalWords, checkProgressHtml, consentDoorOf, decisionPage, nonceHashOf, PermissionsWouldChange, requirementsFromEditor, resumeDigestOf, taskOf } from "./render-tasks.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";
 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;
@@ -250,7 +254,7 @@ export function createTasksHandlers(runtime) {
         // the database alone: a row reads no check log. A live build's row says which step it is on, or the step it is
         // stuck on, from that live attempt's own progress only, never a stopped attempt's; the step's words come from its
         // current plan (one saved file, for live rows only), and without it the row names the step by number.
-        work = { ...work, items: work.items.map((item) => {
+        const enrich = (page) => ({ ...page, items: page.items.map((item) => {
                 if (item.liveRunId !== null) {
                     const ref = store.lookupRef(item.activeTaskId);
                     const recorded = ref === null ? null : store.latestCheckpointForRun(item.liveRunId);
@@ -269,15 +273,25 @@ export function createTasksHandlers(runtime) {
                     return item;
                 const failure = failureOf(family.versions.flatMap(version => store.runsFor(version.refId)), null, false);
                 return failure.kind === "reason" ? item : { ...item, status: { ...item.status, detail: failure.line } };
-            }) };
+            }) });
+        work = enrich(work);
+        // The Board view: the same index as four columns (needs you, queued, running, finished), never a second classifier.
+        const board = url.searchParams.get("layout") !== "board" ? null : (() => {
+            const column = (view) => enrich(workIndexPage(store, now, workAccess(), { view, limit: BOARD_COLUMN_LIMIT, project, root: evidenceRoot, ...(state === null ? {} : { state }) }));
+            return { needs: column("needs-you"), queued: column("queued"), running: column("running"), finished: column("completed") };
+        })();
         const page = workPage(chromeFor(project, "work", undefined, rollup ? "all" : undefined), {
             view,
+            lens: project,
+            all: url.searchParams.get("all") === "1",
+            board,
             ...(url.searchParams.has('project') && project !== null ? { projectFilter: project } : {}),
             work,
             previous: url.searchParams.has('cursor'),
             multiProject: new Set(work.items.map(task => task.repo ?? "")).size > 1,
             now,
             state,
+            canPutAway: who.via === "cookie" && who.role === "approver",
             // v105: subscription windows and monthly budgets, for whoever runs the installation.
             limits: store.isInstanceOperator(who.name)
                 ? limitsView(store.providerLimits(), store.budgets().length === 0 ? [] : store.monthSpendCached(now).budgets, { project: projectName, subagent: id => subagentNamesOf(store.handle).get(id) ?? `Subagent ${id}` }, now)
@@ -332,6 +346,9 @@ export function createTasksHandlers(runtime) {
                 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,
             }));
         }
@@ -586,9 +603,12 @@ 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 { response, project } = ctx;
-        return sendScreen(response, 200, donePage(chromeFor(project, "runs"), store.listCompletedWorkScoped(project, 50), pr => store.ciFailureObserved(pr)));
+        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`
@@ -622,7 +642,9 @@ export function createTasksHandlers(runtime) {
         const prefill = picked !== null && picked.kind === "task"
             ? { title: picked.title, goal: picked.goal, not: picked.outOfScope ?? "", touches: picked.touches.join(", "), acceptance: acceptanceToLines(picked.acceptance).join("\n") }
             : null;
-        return newTaskScreen(ctx, 200, null, prefill);
+        // An idea's link (or any ?text=) puts words in the box: bounded to what the box takes, nothing filed.
+        const text = ctx.url.searchParams.get("text");
+        return newTaskScreen(ctx, 200, null, prefill, text === null ? null : text.slice(0, 200));
     }
     async function showTask(ctx) {
         const { url, who, response } = ctx;
@@ -645,7 +667,8 @@ export function createTasksHandlers(runtime) {
         // One page per task (docs/plans/one-page-task-and-agent.md): the tab named, and the Result tab's result — the shown
         // version's own, or the exact run `run=` names, which must be a result of that very version.
         const tabWord = url.searchParams.get("tab");
-        const tab = tabWord === "result" || tabWord === "plan" ? tabWord : "activity";
+        // The first tab (Plan, or Result once there is one) unless the address names Activity or Attempts.
+        const tab = tabWord === "result" || tabWord === "activity" || tabWord === "attempts" ? tabWord : "plan";
         const runWord = url.searchParams.get("run");
         const named = runWord === null ? null : /^[1-9][0-9]{0,14}$/.test(runWord) ? Number(runWord) : -1;
         if (named === -1)
@@ -693,22 +716,12 @@ export function createTasksHandlers(runtime) {
                 "cache-control": "no-store", "x-content-type-options": "nosniff" });
             return void response.end(JSON.stringify(checkResponse("evidencePack", pack), null, 2));
         }
-        return sendScreen(response, 200, screen(`Evidence pack · ${family.root.id}`, evidencePackHtml(pack), { chrome: chromeFor(family.root.repo, "tasks") }));
+        return sendScreen(response, 200, evidenceRecordPage(chromeFor(family.root.repo, "tasks"), pack));
     }
+    /** Build history lives on Agents now ("Finished in the last …"), and each task keeps its own attempts: the old address
+     * keeps answering, as a GET alias. */
     async function showRuns(ctx) {
-        const { url, who, response, project } = ctx;
-        const raw = url.searchParams.get("before");
-        let before = null;
-        if (raw !== null) {
-            if (!/^[1-9][0-9]{0,14}$/.test(raw) || !Number.isSafeInteger(Number(raw))) {
-                return refuse(response, who, 400, "that cursor is not a page", "/runs");
-            }
-            before = Number(raw);
-        }
-        const rows = store.listRunsBefore(before, RUNS_PAGE, project);
-        const verdicts = store.proofVerdictsFor(rows.map(one => one.id));
-        const accepted = new Set(rows.filter(one => store.proofAcceptance(one.id) !== null).map(one => one.id));
-        return sendScreen(response, 200, runsPage(chromeFor(project, "runs"), rows, liveRunIds(rows), rows.length === RUNS_PAGE ? rows[rows.length - 1]?.id ?? null : null, verdicts, accepted));
+        return redirectGet(ctx.response, "/agents");
     }
     async function showRun(ctx) {
         const { url, who, response, now, project } = ctx;
@@ -871,21 +884,12 @@ export function createTasksHandlers(runtime) {
         return redirect(ctx.response, "/flows");
     }
     async function showDecision(ctx) {
-        const { url, who, response, now, project } = ctx;
+        const { url, who, response, now } = ctx;
         const one = /^\/d\/([0-9]{1,15})$/.exec(url.pathname);
         if (one === null)
             return noPage(who, response);
-        const decision = store.getDecision(Number(one[1]));
-        if (decision === null)
-            return refuse(response, who, 404, "no such decision");
-        const run = store.getRun(decision.run);
-        if (run !== null && !visible(taskRepoOf(run.taskRef))) {
-            return refuse(response, who, 404, "no such decision");
-        }
-        const taskId = taskOf(store, decision);
         const decisionReturn = url.searchParams.get("return");
-        const back = decisionReturn === null ? null : safeChatReturn(decisionReturn);
-        return sendScreen(response, 200, decisionPage(chromeFor(project, "none"), decision, taskId, store.evidenceFor(decision.id), who, now, back));
+        return decisionScreen(ctx, Number(one[1]), decisionReturn === null ? null : safeChatReturn(decisionReturn), null, 200, now, null);
     }
     async function showDecisionEvidence(ctx) {
         const { url, who, response } = ctx;
@@ -1250,7 +1254,12 @@ export function createTasksHandlers(runtime) {
         // Irreversible options never ride one accidental tap: the form arms
         // them behind an explicit confirmation field, and the server checks —
         // the client rendering is convenience, this is the rule.
+        // The question page's own form hears a refusal in its box, with nothing changed; /next keeps its refusal page.
+        const inPlace = requestedReturn !== "next";
+        const pageBack = requestedReturn === null ? null : decisionBack;
         if (chosen !== undefined && !chosen.reversible && body.get("confirm") !== "yes") {
+            if (inPlace)
+                return decisionScreen(ctx, id, pageBack, `“${chosen.label}” can't be undone: tick the box to confirm it`, 400, now, { choice, note: body.get("note") });
             return refuse(response, who, 400, "an irreversible choice must be confirmed", requestedReturn === null ? `/d/${id}` : `/d/${id}?return=${encodeURIComponent(decisionBack)}`);
         }
         const note = body.get("note");
@@ -1265,6 +1274,9 @@ export function createTasksHandlers(runtime) {
             const status = answered.reason === "bad-option" || answered.reason === "bad-note" ? 400 : 409;
             const closed = answered.reason === "closed" ? store.getDecision(id)?.supersededReason ?? null : null;
             const why = closed !== null ? closedQuestionWords(closed) : answered.reason === "already-answered" ? "already answered — somebody got there first" : answered.reason;
+            if (inPlace && answered.reason !== "closed" && answered.reason !== "already-answered") {
+                return decisionScreen(ctx, id, pageBack, answered.reason === "bad-option" ? "Choose one of the options" : answered.reason === "bad-note" ? `The note is too long or can't be sent (up to ${LIMITS.note} characters)` : why, status, now, { choice, note });
+            }
             return refuse(response, who, status, why, requestedReturn === null ? `/d/${id}` : decisionBack);
         }
         return redirect(response, decisionBack);
@@ -3057,7 +3069,24 @@ export function createTasksHandlers(runtime) {
                 live.add(run.id);
         return live;
     }
+    const tidyHandlers = createTidyHandlers(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;
+        const decision = store.getDecision(id);
+        if (decision === null)
+            return refuse(response, who, 404, "no such decision");
+        const run = store.getRun(decision.run);
+        if (run !== null && !visible(taskRepoOf(run.taskRef))) {
+            return refuse(response, who, 404, "no such decision");
+        }
+        const taskId = taskOf(store, decision);
+        const ref = taskId === "?" ? null : store.lookupRef(taskId);
+        const place = { title: ref === null ? null : store.getTask(taskId)?.title ?? null, repo: ref?.repo ?? null, run: run === null ? null : { id: run.id, role: run.role } };
+        return sendScreen(response, code, decisionPage(chromeFor(project, "none"), decision, taskId, store.evidenceFor(decision.id), now, place, back, refusal, draft));
+    }
     const registrations = handlersOf("tasks", {
+        ...tidyHandlers,
         "code.page": showCode("workspace"),
         "code.session": showCode("session"),
         "code.state": showCode("state"),
@@ -3066,12 +3095,13 @@ export function createTasksHandlers(runtime) {
         "code.changes-read": showCode("changes", true),
         "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": showDone,
+        "done": async (ctx) => { const to = retiredTasksAddress("done", ctx.url); return to === null ? showDone(ctx) : redirect(ctx.response, to); },
         "tasks": showTasks,
         "queue": showQueue,
         "tasks.new": showNewTask,
@@ -3138,7 +3168,7 @@ export function createTasksHandlers(runtime) {
     });
     /** The add page, once more: blank, from a shipped template (`?template=`, as the old task list did), or with a refused
      * filing's own words and status (the draft keeps the project revision it was written against). */
-    function newTaskScreen(ctx, status, problem, draft) {
+    function newTaskScreen(ctx, status, problem, draft, text = null) {
         const { who, response, project } = ctx;
         const chainable = store
             .listTasksScoped(project, undefined, 100, null)
@@ -3150,7 +3180,84 @@ export function createTasksHandlers(runtime) {
             chainable.unshift({ id: after, title: "(as submitted)" });
         const chrome = chromeFor(project, "tasks");
         const revision = draft?.values !== undefined ? undefined : who.via === "cookie" ? who.session.projectRevision : 0;
-        return sendScreen(response, status, newTaskPage(chrome, project, revision, problem, chainable, store.permissionDefault().mode, store.qualityDefault().mode, chrome.projects ?? [], draft));
+        // Ideas for the project the box starts on: what the first run found there (issues, TODOs), else the safe generic
+        // ones while the first run is open; none once someone has filed work and nothing was found.
+        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 { registrations, runListPane, peekFragment, taskMutation, queueRegionFor, ciFailingFor, completedRowFor, attemptRowFor, resultRowOf, reviewCockpitViewOf, decisionEvidence, runEvidence, sendArtifact, peekGuards, liveRunIds };
 }
+/** Put away and Restore one task, and Put away old tasks (docs/plans/task-tidy.md): the preview reads only (GET-quiet);
+ * putting away many is an approver's step-up bound to the digest of exactly what the preview showed. Each write
+ * re-proves the person's standing inside its own transaction. */
+export function createTidyHandlers(runtime) {
+    const { store, sendScreen, chromeFor, authenticateApprover, workAccess, bustBadge } = runtime;
+    async function showPutAway(ctx) {
+        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");
+        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,
+            problem: url.searchParams.get("problem"), releasesSkipped: releases.problem }));
+    }
+    async function applyPutAway(ctx) {
+        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 })}`);
+        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.");
+        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");
+    }
+    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");
+        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"
+            ? archiveTaskFamily(store, act.taskId, { by: who.name, byKind: "person", rule: null, reason: (body.get("reason") ?? "").trim() || "Put away by hand" }, now, { guard: standing })
+            : restoreTaskFamily(store, act.taskId, who.name, now, standing);
+        if (!done.ok)
+            return refuse(response, who, done.reason === "unknown-task" ? 404 : 409, done.message, taskHref(act.taskId));
+        bustBadge();
+        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") };
+}
+/** 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;

package/dist/server/terminals.js

@@ -78,7 +78,7 @@ export function createTerminalHandlers(runtime, deps) {
         const id = TERMINAL_ID.exec(url.pathname)?.[1] ?? "";
         const nonce = randomBytes(16).toString("base64");
         const host = request.headers.host ?? "";
-        const document = html `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover, interactive-widget=resizes-content"><meta name="theme-color" content="#0C0E12"><meta name="apple-mobile-web-app-capable" content="yes"><title>Live — Toolroll</title><link rel="icon" href="/icon.svg"><link rel="manifest" href="/manifest.webmanifest"><link rel="stylesheet" href="/assets/terminal.css"></head><body><div id="so-term"></div><div id="so-term-boot" hidden data-csrf="${who.session.csrf}" data-session="${id}" data-passwordless="${passwordlessOn(store) ? "1" : ""}"></div><script type="module" src="/assets/terminal.js" nonce="${nonce}"></script></body></html>`;
+        const document = html `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover, interactive-widget=resizes-content"><meta name="theme-color" content="#0C0E12"><meta name="apple-mobile-web-app-capable" content="yes"><title>Terminals — Toolroll</title><link rel="icon" href="/icon.svg"><link rel="manifest" href="/manifest.webmanifest"><link rel="stylesheet" href="/assets/terminal.css"></head><body><div id="so-term"></div><div id="so-term-boot" hidden data-csrf="${who.session.csrf}" data-session="${id}" data-passwordless="${passwordlessOn(store) ? "1" : ""}"></div><script type="module" src="/assets/terminal.js" nonce="${nonce}"></script></body></html>`;
         response.writeHead(200, {
             "Content-Type": "text/html; charset=utf-8", "Cache-Control": "no-store", "X-Content-Type-Options": "nosniff", "Referrer-Policy": "no-referrer",
             // The socket is this page's own host: named outright, since older WebKit doesn't read 'self' as ws:/wss:.

package/dist/server/welcome.d.ts

@@ -0,0 +1,22 @@
+import { type FirstRunStep } from "../first-run.js";
+import { type CheckStep } from "./kit.js";
+import type { ServerRuntime } from "./runtime.js";
+import { type Chrome, type Screen } from "./chrome.js";
+export type WelcomeFacts = {
+    steps: readonly FirstRunStep[];
+    projects: number;
+    /** This person has a live push enrollment on some device. */
+    alerts: boolean;
+};
+/** The five steps as the page shows them, and which one leads. */
+export declare function welcomeSteps(facts: WelcomeFacts): {
+    steps: CheckStep[];
+    primary: {
+        label: string;
+        href: string;
+    } | null;
+};
+export declare function welcomePage(chrome: Chrome, facts: WelcomeFacts): Screen;
+export declare function createWelcomeHandlers(runtime: ServerRuntime): {
+    registrations: import("./handler-registry.js").Registration[];
+};

package/dist/server/welcome.js

@@ -0,0 +1,69 @@
+/**
+ * The first run's own page, /welcome (Wave E, src/design/KIT.md): five guided steps to a first result, each derived
+ * from live facts on every render (never a stored cursor), each with the one action that does it. The next required
+ * step's action is the screen's one primary (on a fresh install: Add a project); alerts on the phone are optional and
+ * never lead. It only reads: every step's action is a link to the page that does it. Once the first result has
+ * arrived (or for a project-limited account, or in the demo) the first run is over and the address leads Home.
+ */
+import { builderReadyFor, firstRunBuilderRepo } from "../dispatch.js";
+import { withBuilderStep } from "../first-run.js";
+import { html } from "../html.js";
+import { START_BUILDER_HREF } from "../needs-you.js";
+import { handlersOf } from "./handler-registry.js";
+import { redirect } from "./http.js";
+import { btn, checklist, dock, pageHeader } from "./kit.js";
+import { screen } from "./chrome.js";
+const plural = (n, one, many) => `${n} ${n === 1 ? one : many}`;
+/** The five steps as the page shows them, and which one leads. */
+export function welcomeSteps(facts) {
+    const step = (key) => facts.steps.find(one => one.key === key);
+    const agent = step("agent"), builder = step("builder"), task = step("task");
+    const projectDone = facts.projects > 0;
+    const agentDone = (agent?.done ?? false) && (builder?.done ?? true);
+    const command = agent?.action?.kind === "command" ? agent.action.command : null;
+    const agentState = agentDone ? "done" : agent?.checking === true ? "checking" : "open";
+    const agentText = agentDone ? "An agent is signed in and a builder is ready."
+        : agent?.checking === true ? "Checking for a signed-in agent on this computer…"
+            : agent !== undefined && !agent.done && command !== null ? html `On the computer running Toolroll, run <code class="k-mono">${command}</code>.`
+                : "Start a builder so tasks can run.";
+    const agentLink = agentDone || agent?.checking === true ? null
+        : agent !== undefined && !agent.done ? { label: "Agent settings", href: "/settings/models" } : { label: "Start a builder", href: START_BUILDER_HREF };
+    const taskDone = task?.done ?? false;
+    // The next required step leads (alerts are optional and never do).
+    const order = [
+        { key: "project", open: !projectDone, link: { label: "Add a project", href: "/projects" } },
+        { key: "agent", open: agentState === "open", link: agentLink },
+        { key: "task", open: !taskDone && projectDone, link: { label: "New task", href: "/tasks/new" } },
+    ];
+    const lead = order.find(one => one.open && one.link !== null) ?? null;
+    const action = (key, link) => link === null ? null : btn(link.label, { sm: true, href: link.href, ...(lead?.key === key ? { variant: "primary", docked: true } : {}) });
+    const steps = [
+        { key: "password", title: "Your password", text: "You're signed in. Your first login is saved on the computer running Toolroll.", state: "done" },
+        { key: "project", title: "Add a project", text: projectDone ? plural(facts.projects, "project added.", "projects added.") : "A git repository agents work in.", state: projectDone ? "done" : "open", action: action("project", order[0].link) },
+        { key: "agent", title: "Agent and models", text: agentText, state: agentState, action: action("agent", agentLink) },
+        { key: "phone", title: "Alerts on your phone", text: facts.alerts ? "Alerts are on." : "Optional. Hear when something needs you.", state: facts.alerts ? "done" : "open", action: btn("Set up alerts", { sm: true, href: "/settings/alerts#this-device" }) },
+        { key: "task", title: "Your first task", text: taskDone ? "Filed. Its plan waits for your approval." : "Describe a change and approve its plan.", state: taskDone ? "done" : "open",
+            action: projectDone ? action("task", order[2].link) : null },
+    ];
+    return { steps, primary: lead?.link ?? null };
+}
+export function welcomePage(chrome, facts) {
+    const { steps, primary } = welcomeSteps(facts);
+    const left = steps.filter(one => one.state !== "done").length;
+    const body = html `${pageHeader("Welcome")}<div class="k-doc"><div class="k-hello"><h2>Get to your first result.</h2><p>${left === 0 ? "Setup is done." : `${plural(left, "step", "steps")} left.`}</p></div>\
+${checklist(steps, "Setup steps")}</div>${dock(primary === null ? null : btn(primary.label, { variant: "primary", href: primary.href }))}`;
+    return screen("Welcome", body, { chrome });
+}
+export function createWelcomeHandlers(runtime) {
+    const { store, sendScreen, chromeFor, firstRunStepsNow, managedRepos, visible } = runtime;
+    async function showWelcome(ctx) {
+        const { who, response, now, project } = ctx;
+        const steps = withBuilderStep(firstRunStepsNow(now), builderReadyFor(store, firstRunBuilderRepo(store, project, visible, managedRepos()), now));
+        // The first run is over (a first result, a project-limited account, the demo): the address leads Home.
+        if (steps === null)
+            return redirect(response, "/");
+        const alerts = who.via === "cookie" && store.listPushSubscriptions(who.name).some(one => one.retiredAt === null);
+        return sendScreen(response, 200, welcomePage(chromeFor(project, "work"), { steps, projects: managedRepos().length, alerts }));
+    }
+    return { registrations: handlersOf("tasks", { welcome: showWelcome }) };
+}