toolroll 0.9.101 → 0.9.103

package/dist/release-refusal.js

@@ -0,0 +1,73 @@
+/**
+ * Why a release can't be approved now, from the plane's own state (release-approval.ts re-exports all of it): the
+ * coordinator's GitHub CI reading on the exact candidate, and the one list of refusals the release sheet shows and every
+ * approval road applies (scope.ts approve() reads `releaseApprovalRefusal` inside its transaction). Kept apart from
+ * release-approval.ts so scope.ts reads it without importing the card machinery (an import cycle through store.ts).
+ */
+import { releaseCiHoldOf, releaseCiHoldWords } from "./release-ci-hold.js";
+import { taskArchived } from "./task-archive.js";
+import { cleanTerminalLine } from "./terminal-text.js";
+/** The ledger act holding the coordinator's latest reading of the pull request's CI on the exact candidate. */
+export const RELEASE_CI_SEEN_ACTION = "release CI observed";
+export const ciName = (value) => cleanTerminalLine(String(value ?? "")).trim().slice(0, 120);
+/** The coordinator's latest CI reading for this task on exactly `candidate`, or null (not read yet, or another commit). */
+export function releaseCiOf(store, taskId, candidate) {
+    const row = store.handle.prepare("SELECT detail, at FROM action_ledger WHERE task_id = ? AND action = ? ORDER BY id DESC LIMIT 1").get(taskId, RELEASE_CI_SEEN_ACTION);
+    if (row === undefined)
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(String(row["detail"]));
+    }
+    catch {
+        return null;
+    }
+    const one = parsed;
+    if (one.v !== 1 || one.candidate !== candidate || !["passed", "running", "failed"].includes(String(one.state)) || !Array.isArray(one.failed) || !Array.isArray(one.runs))
+        return null;
+    return { candidate, at: String(row["at"]), state: one.state, failed: one.failed.map(ciName),
+        runs: one.runs.map(run => { const r = run; return { id: typeof r["id"] === "number" ? r["id"] : null, name: ciName(r["name"]), status: ciName(r["status"]), conclusion: r["conclusion"] == null ? null : ciName(r["conclusion"]) }; }) };
+}
+/** GitHub CI in one line, as the sheet and the CLI say it. */
+export function ciWords(ci, candidate) {
+    const short = candidate.slice(0, 7);
+    if (ci === null)
+        return `GitHub CI on ${short} hasn't been read yet.`;
+    if (ci.state === "passed")
+        return `GitHub CI passed on ${short}.`;
+    if (ci.state === "failed")
+        return `GitHub CI failed on ${short}: ${ci.failed.join(", ") || "a check"}.`;
+    const finished = ci.runs.filter(run => run.status === "completed").length;
+    return `GitHub CI is running on ${short}: ${finished} of ${ci.runs.length} checks finished.`;
+}
+/** The release check failed on this task already (the coordinator's record): nobody approves it again here. */
+function checkFailed(store, taskId) {
+    return store.handle.prepare("SELECT 1 FROM release_step WHERE task_id = ? AND step = 'check' AND state = 'failed' LIMIT 1").get(taskId) !== undefined;
+}
+/** Why a release can't be approved now, from the plane's own state, or null. */
+export function refusalOf(store, taskId, scope, ci) {
+    if (taskArchived(store, taskId))
+        return "This release is put away. Restore it before approving.";
+    const hold = releaseCiHoldOf(store, taskId);
+    if (hold !== null)
+        return releaseCiHoldWords(hold);
+    if (ci?.state === "failed")
+        return `${ciWords(ci, scope.candidate)} Fix the branch or rerun the failed job on GitHub, then release again.`;
+    if (checkFailed(store, taskId))
+        return "The release check already failed on this commit. Fix the branch and release the new commit.";
+    if (scope.approvedAt !== null && scope.approvedDigest !== scope.digest)
+        return "The release's terms changed after an earlier approval. Read them again.";
+    return null;
+}
+/**
+ * The release refusals every approval road shares (scope.ts approve(), read inside its transaction): for a scope
+ * sealing release terms or a release check's purpose, the sheet's own reasons in the sheet's own words, so the task
+ * page, Home's in-place yes, chat and `toolroll task approve` refuse exactly what `/t/<id>/release` refuses. Null for
+ * every other scope, and for a release nothing stops. The sheet's card digest binding stays the sheet's.
+ */
+export function releaseApprovalRefusal(store, taskId, scope) {
+    // A sealed form, as release-card.ts releaseSealOf reads it (release terms, or a release check's purpose).
+    if (scope.releaseTerms == null && scope.releaseCheck == null)
+        return null;
+    return refusalOf(store, taskId, scope, scope.candidate == null ? null : releaseCiOf(store, taskId, scope.candidate));
+}

package/dist/run-efficiency.d.ts

@@ -68,6 +68,7 @@ export declare function deriveRunEfficiency(run: Run & {
 }, evidenceRoot: string, now: Date, commands?: boolean): RunEfficiency;
 /**
  * A finished run's How it ran: the saved one when it was derived by this version, else derived now and saved (once:
- * a row whose steps were complete or have expired is final). An unfinished run is derived but never saved.
+ * a row whose steps were complete or have expired is final). An unfinished run is derived but never saved, and
+ * nothing is saved when `save` is false (a page read ahead of its link writes nothing).
  */
-export declare function runEfficiencyOf(store: Store, evidenceRoot: string, runId: number, now: Date): RunEfficiency | null;
+export declare function runEfficiencyOf(store: Store, evidenceRoot: string, runId: number, now: Date, save?: boolean): RunEfficiency | null;

package/dist/run-efficiency.js

@@ -199,9 +199,10 @@ export function deriveRunEfficiency(run, evidenceRoot, now, commands = false) {
 }
 /**
  * A finished run's How it ran: the saved one when it was derived by this version, else derived now and saved (once:
- * a row whose steps were complete or have expired is final). An unfinished run is derived but never saved.
+ * a row whose steps were complete or have expired is final). An unfinished run is derived but never saved, and
+ * nothing is saved when `save` is false (a page read ahead of its link writes nothing).
  */
-export function runEfficiencyOf(store, evidenceRoot, runId, now) {
+export function runEfficiencyOf(store, evidenceRoot, runId, now, save = true) {
     const run = store.getRun(runId);
     if (run === null)
         return null;
@@ -227,7 +228,7 @@ export function runEfficiencyOf(store, evidenceRoot, runId, now) {
     const payload = JSON.stringify(derived);
     // A row too large for its column (it can't be: the counts are bounded) is shown, never saved.
     // Saving is a convenience: a store that can't take the row (read-only, busy) still shows what was derived.
-    if (payload.length <= 16_384) {
+    if (save && payload.length <= 16_384) {
         try {
             store.handle.prepare(`INSERT INTO run_efficiency (run, parser_version, steps, steps_reason, payload_json, derived_at) VALUES (?, ?, ?, ?, ?, ?)
         ON CONFLICT(run) DO UPDATE SET parser_version = excluded.parser_version, steps = excluded.steps, steps_reason = excluded.steps_reason,

package/dist/scope.js

@@ -54,6 +54,7 @@ import { parseContract } from "./contracts/contract.js";
 import { readAcceptance, readScopeTerms, storedRubricSchema } from "./contracts/scope.js";
 import { taskArchived, taskCancelled } from "./task-archive.js";
 import { releaseCiHoldOf, releaseCiHoldWords } from "./release-ci-hold.js";
+import { releaseApprovalRefusal } from "./release-refusal.js";
 import { NO_READINESS, exactModelId, legOf, projectRoute, routeDigestOf, routeFromJson, routeJsonProblem, routeWords, } from "./phase-routing.js";
 /** Same shape as a runner's credential, for the same reasons. */
 function mintToken() {
@@ -1117,6 +1118,11 @@ chat) {
         const scope = store.getScope(taskId);
         if (scope === null)
             return { ok: false, reason: "no-scope" };
+        // A release takes no yes the release sheet would refuse (put away, CI held or failed, its check failed on this
+        // commit, terms changed after an earlier yes), in the sheet's words, on every road: read here, before any vote.
+        const releaseRefusal = releaseApprovalRefusal(store, taskId, scope);
+        if (releaseRefusal !== null)
+            return { ok: false, reason: "policy", message: releaseRefusal };
         // A put-away task (v145) is restored first; sealScopeApproval refuses it too, on every road.
         if (taskArchived(store, taskId))
             return { ok: false, reason: "archived" };

package/dist/serve.js

@@ -27,6 +27,7 @@ const PROXY_HEADER = /^(forwarded|via|x-forwarded-.+|x-real-ip|x-client-ip|x-ori
 const BACKGROUND_CHECKS_MS = 30_000;
 const LOCAL_AGENTS_EVERY_MS = 2 * 60_000;
 import { browserCrewFromIndex, browserCrewOf, browserNavigationOf, browserProjectsOf, needsYouLabelOf } from './browser-workspace.js';
+import { PAGE_WORK_HEADER, PAGE_WORK_VERSION } from './page-work-contract.js';
 import { sharedActionPayload } from './chat-actions.js';
 import { prepareCodingContext } from './coding-context.js';
 import { CodingWorkspace } from './coding-workspace.js';
@@ -155,7 +156,8 @@ import { createFlowsHandlers } from './server/flows.js';
 import { createPagesHandlers } from './server/pages.js';
 import { createPeopleHandlers } from './server/people-tokens.js';
 import { createSettingsHandlers } from './server/settings.js';
-import { requestContext } from "./server/request-context.js";
+import { readPurpose, requestContext } from "./server/request-context.js";
+import { inPlaceRoute, prefetchRoute } from "./server/in-place.js";
 import { asLocalOwner, localModeOn, localOwnerRefusal, localOwnerStandsNow } from "./local-owner.js";
 import { defaultAgentOf, fillDefaultRouting } from "./model-choices.js";
 import { chromeScript, DEMO_BANNER, DEMO_BANNER_SHORT, focusDocument, KBD_HELP, pinnedTheme, QUEUE_VIEW, refuse, screen, SENSITIVE_INPUT, shell, sidebarScript } from "./server/chrome.js";
@@ -878,9 +880,22 @@ export function createDecisionServer(options) {
         // Passive polls authenticate without extending the browser session.
         const fragmentName = url.searchParams.get("fragment");
         const workspaceRead = method === "GET" && url.searchParams.get('format') === 'workspace';
-        const touch = !(method === "GET" && (edgeRoute?.domain === 'live' || workspaceRead || (fragmentName !== null && NO_TOUCH_FRAGMENTS.has(fragmentName)) || /^\/code\/[a-f0-9]{32}\/state$/.test(url.pathname) || url.pathname === '/term/state'
+        // A workspace read's purpose (live-pages-and-home.md A1.4): bookkeeping only. Read on workspace GETs alone; on any other
+        // request the header means nothing. No authorisation decision below reads it.
+        const purpose = workspaceRead ? readPurpose(request.headers['x-toolroll-read']) : 'poll';
+        // The reads that never extend the session, whatever their header says.
+        const noTouch = edgeRoute?.domain === 'live' || (fragmentName !== null && NO_TOUCH_FRAGMENTS.has(fragmentName)) || /^\/code\/[a-f0-9]{32}\/state$/.test(url.pathname) || url.pathname === '/term/state'
             // The Agents view's Live grid only watches: its polls never extend or write the session.
-            || url.pathname === '/agents/live' || /^\/agents\/live\/[0-9]{1,15}$/.test(url.pathname) || (url.pathname === '/agents' && url.searchParams.get('view') === 'live')));
+            || url.pathname === '/agents/live' || /^\/agents\/live\/[0-9]{1,15}$/.test(url.pathname) || (url.pathname === '/agents' && url.searchParams.get('view') === 'live');
+        // A followed link (`navigate`) extends the session exactly as the HTML GET of the same address would; every other
+        // workspace read (a re-read, a prefetch) does not.
+        const touch = !(method === "GET" && (noTouch || (workspaceRead && purpose !== 'navigate')));
+        // A read ahead is answered only for a browser session, only for the prefetch allowlist (in-place.ts): anything else
+        // hears 204 before any sign-in bookkeeping (a token's last use, a sign-in charge) is written.
+        if (purpose === 'prefetch' && (request.headers.authorization !== undefined || !prefetchRoute(matchedRoute?.id, url))) {
+            request.resume();
+            return respond(response, 204, "text/plain; charset=utf-8", "");
+        }
         const refuseBudget = (admitted) => {
             if (admitted.ok)
                 return false;
@@ -906,6 +921,11 @@ export function createDecisionServer(options) {
         }
         if (who?.via === "bearer" && refuseBudget(admitBearer(request, who)))
             return;
+        // A read ahead from anything but a signed-in browser session (signed out, a token): 204, never the sign-in page.
+        if (purpose === 'prefetch' && who?.via !== 'cookie') {
+            request.resume();
+            return respond(response, 204, "text/plain; charset=utf-8", "");
+        }
         const passwordProof = who?.via === 'cookie' ? { name: who.name, generation: who.session.generation } : null;
         const fresh = freshFactsOf(request, who, matchedRoute?.freshness === 'allowlist');
         if (edgeRoute?.domain === 'people')
@@ -940,6 +960,9 @@ export function createDecisionServer(options) {
                 get fresh() { return freshFacts.getStore() != null && ssoNowAvailable(who.name); } } : undefined,
             refusal: (answer, status, body) => sendScreen(answer, status, screen(status === 404 ? "Not found" : "Request refused", body, { chrome: chromeFor(who.via === "cookie" ? who.session.project : null, "work") })),
             workspaceRead,
+            readPurpose: purpose,
+            ...(workspaceRead && request.headers[PAGE_WORK_HEADER] === String(PAGE_WORK_VERSION) ? { appWork: true } : {}),
+            ...(matchedRoute?.stage === 'console' ? { routeId: matchedRoute.id } : {}),
             freshWork: ["request", "task", "result"].some(name => url.searchParams.has(name)),
             ...(workspaceRead && typeof request.headers['if-none-match'] === 'string' ? { workspaceIfNoneMatch: request.headers['if-none-match'] } : {}),
             workspaceRequest: url.searchParams.get('request'),
@@ -952,7 +975,9 @@ export function createDecisionServer(options) {
                 ? { localStepUp: localOwnerRefusal(false, method === "GET" ? passwordSetNext(pagePathOf(url)) : "/").href } : {}),
             reconnect: browserKeys.stale(who, method === "GET" ? safeReturn(pagePathOf(url)) : "/"),
         };
-        response.once("finish", () => keepSlowRequest(store, timeline, matchedRoute?.id ?? "unmatched", response.statusCode, clock()));
+        // A read ahead writes nothing, not even a slow request's record.
+        if (purpose !== 'prefetch')
+            response.once("finish", () => keepSlowRequest(store, timeline, matchedRoute?.id ?? "unmatched", response.statusCode, clock()));
         if (method === "GET" || method === "POST")
             return freshFacts.run(fresh, () => provenPasswordAccount.run(passwordProof, () => requestContext.run(requestFacts, async () => {
                 if (edgeRoute?.domain === 'live')
@@ -1669,8 +1694,29 @@ export function createDecisionServer(options) {
             }
             const conversation = extras.conversation ?? null;
             const request = requestFacts.workspaceRequest;
+            // React owns the conversation and its refresh/draft lifecycle. Native
+            // guarded forms keep their current behavior after React inserts them.
+            // A page with its own view keeps its script; the chat page runs the result script.
+            // The exact page script the document would run: the JSON arm and the document arm read this one value.
+            const ownScript = conversation === null || extras.view;
+            const pageScript = ownScript ? (s.functional?.script ?? '') : RESULT_REVIEW_SCRIPT;
+            const routeInPlace = inPlaceRoute(requestFacts.routeId, path);
+            // The app runs the page's behaviour itself (docs/plans/task-page-in-app.md §2) only when all of these hold: the
+            // app covers the WHOLE script, no password field (a password page keeps its string path), an in-place route, and a
+            // reader that can run it: a document load (its bundle is this server's, served no-store) or a workspace read that
+            // says so. Anything else is the page exactly as before: the string, no work, a document.
+            const covered = ownScript ? s.functional?.app : undefined;
+            const work = pageScript !== '' && covered !== undefined && covered.length > 0 && !sensitive && routeInPlace
+                && (!requestFacts.workspaceRead || requestFacts.appWork === true) ? covered : null;
+            const functional = work === null ? pageScript : '';
+            // May replace another page without a document load (live-pages-and-home.md A1.1): an allowlisted route, no password
+            // field, no page script (a page script runs once per document, so its page always loads as one).
+            const inPlace = routeInPlace && !sensitive && functional === '';
             const workspace = {
-                version: 1, path: currentPath, title: s.title, user: requestFacts.actor ?? '', csrf: requestFacts.csrf, sensitive,
+                version: 1, path: currentPath, title: s.title, user: requestFacts.actor ?? '', csrf: requestFacts.csrf, sensitive, inPlace,
+                ...(work === null ? {} : { work }),
+                // Said on the document that ships it: this document's page script listens for as long as the document lives.
+                ...(functional !== '' && !requestFacts.workspaceRead ? { scripted: true } : {}),
                 // The project picker names the open project; the settings frame carries its breadcrumb.
                 // Only a project this person may see now: never the raw saved path (settings-kit.ts openProjectFor).
                 openProject: openProjectFor(requestFacts.openProject ?? null, s.chrome.project, s.chrome.projects ?? []),
@@ -1761,10 +1807,6 @@ export function createDecisionServer(options) {
                 return respond(response, status, 'application/json; charset=utf-8', body);
             }
             const nonce = randomBytes(16).toString('base64');
-            // React owns the conversation and its refresh/draft lifecycle. Native
-            // guarded forms keep their current behavior after React inserts them.
-            // A page with its own view keeps its script; the chat page runs the result script.
-            const functional = conversation === null || extras.view ? (s.functional?.script ?? '') : RESULT_REVIEW_SCRIPT;
             const document = shell(s.title, s.body, { chrome: s.chrome, sensitive });
             // The keys and their list (keymap.ts) work here as on every chromed page; the list sits beside the app React owns.
             // A sensitive page keeps to its own script.

package/dist/server/chrome.d.ts

@@ -1,4 +1,4 @@
-import { type BrowserSignIn, type BrowserUpdateNotice, type BrowserWorkspace } from "../browser-workspace.js";
+import { type BrowserSignIn, type BrowserUpdateNotice, type BrowserWorkspace, type PageWork } from "../browser-workspace.js";
 import { type Crumb } from "../settings-kit.js";
 import { type Decision, type Run } from "../store.js";
 import { type tally } from "../summary.js";
@@ -176,6 +176,9 @@ export type Screen = {
     functional?: {
         script: string;
         fetches?: boolean;
+        /** The app's own version of this WHOLE script (task-page-in-app.md §1): where the app can run it, the document
+         * ships no script string and the page may change in place. Added to only through withScript. */
+        app?: readonly PageWork[];
     };
     refreshSeconds?: number;
     /** Render sensitive even when no password field is visible — one-time
@@ -317,3 +320,9 @@ export declare function oneLineOf(text: string, cap: number): string;
  * minutes are the answer without script.
  */
 export declare function boardTickScript(regionId?: string): string;
+/**
+ * A page's script with one more added (docs/plans/task-page-in-app.md §1). All or nothing: `app` survives only when
+ * every part has it, so a script the app does not cover keeps the whole page a document, and a page never gets half
+ * its behaviour from the string and half from the app.
+ */
+export declare function withScript(base: Screen["functional"], add: NonNullable<Screen["functional"]>): NonNullable<Screen["functional"]>;

package/dist/server/chrome.js

@@ -807,3 +807,12 @@ export function boardTickScript(regionId = "board-region") {
         `run();setInterval(function(){if(!document.hidden)run();},1000);document.addEventListener("visibilitychange",function(){if(!document.hidden)run();});` +
         `if(region&&typeof MutationObserver==="function")new MutationObserver(run).observe(region,{childList:true});})();`);
 }
+/**
+ * A page's script with one more added (docs/plans/task-page-in-app.md §1). All or nothing: `app` survives only when
+ * every part has it, so a script the app does not cover keeps the whole page a document, and a page never gets half
+ * its behaviour from the string and half from the app.
+ */
+export function withScript(base, add) {
+    const app = base === undefined ? add.app : base.app !== undefined && add.app !== undefined ? [...base.app, ...add.app] : undefined;
+    return { script: (base?.script ?? "") + add.script, fetches: (base?.fetches ?? false) || (add.fetches ?? false), ...(app === undefined ? {} : { app }) };
+}

package/dist/server/console.css

@@ -2662,14 +2662,29 @@ button { min-height: 44px; }
    the same on both, swaps in place instead of fading (each shell names its
    own, so a page can never carry the name twice). */
 ::view-transition-old(root) { animation: so-page-leave 80ms ease-in both; }
-::view-transition-new(root) { animation: so-page-arrive 140ms ease-out 60ms both; }
+::view-transition-new(root) { animation: so-page-arrive 160ms ease-out 60ms both; }
 @keyframes so-page-leave { to { opacity: 0; } }
 @keyframes so-page-arrive { from { opacity: 0; } }
 .side { view-transition-name: so-nav-page; }
 .so-sidebar { view-transition-name: so-nav-app; }
-::view-transition-group(so-nav-page), ::view-transition-group(so-nav-app),
+.so-ph { view-transition-name: so-phone-header; }
+::view-transition-group(so-nav-page), ::view-transition-group(so-nav-app), ::view-transition-group(so-phone-header), ::view-transition-group(so-message-box),
 ::view-transition-old(so-nav-page), ::view-transition-new(so-nav-page),
-::view-transition-old(so-nav-app), ::view-transition-new(so-nav-app) { animation: none; }
+::view-transition-old(so-nav-app), ::view-transition-new(so-nav-app),
+::view-transition-old(so-phone-header), ::view-transition-new(so-phone-header),
+::view-transition-old(so-message-box), ::view-transition-new(so-message-box) { animation: none; }
+/* A page changed in place (docs/plans/live-pages-and-home.md A2.2, browser/transition.ts): only the page content
+   moves; everything else (the root, the sidebar, the phone header, the message box) swaps where it stands. The same
+   level fades through like a document load (80 ms out, 160 ms in); deeper, the new page also moves 8px in from the
+   right over 200 ms; shallower, from the left. Nothing runs past 220 ms. */
+html.so-nav #workspace-main { view-transition-name: so-page; }
+html.so-nav::view-transition-old(root), html.so-nav::view-transition-new(root), html.so-nav::view-transition-group(so-page) { animation: none; }
+html.so-nav::view-transition-old(so-page) { animation: so-page-leave 80ms ease-in both; }
+html.so-nav-same::view-transition-new(so-page) { animation: so-page-arrive 160ms ease-out 60ms both; }
+html.so-nav-deeper::view-transition-new(so-page) { animation: so-page-deeper 200ms cubic-bezier(.2, .8, .2, 1) both; }
+html.so-nav-shallower::view-transition-new(so-page) { animation: so-page-shallower 200ms cubic-bezier(.2, .8, .2, 1) both; }
+@keyframes so-page-deeper { from { opacity: 0; transform: translateX(8px); } }
+@keyframes so-page-shallower { from { opacity: 0; transform: translateX(-8px); } }
 /* UI polish 2026-09-13 — the motion contract. Feedback transitions run
    140–200 ms on color, border, shadow, opacity, and transform only; an
    overlay's entrance is at most 220 ms of opacity + transform. Nothing
@@ -2699,7 +2714,7 @@ button { min-height: 44px; }
 @keyframes fade { from { opacity: 0; } }
 @media (prefers-reduced-motion: reduce) {
   *, *::before, *::after { animation: none !important; transition: none !important; }
-  ::view-transition-group(*), ::view-transition-old(root), ::view-transition-new(root) { animation: none; }
+  ::view-transition-group(*), ::view-transition-old(*), ::view-transition-new(*) { animation: none !important; }
   button:active, :is(.button-link, .side .new-task, .content .new-task, .result-feedback-link, .next-pager .skip):active { transform: none; }
   @media (hover: hover) and (pointer: fine) { button:hover, .side nav a:hover, .chat-project-card:hover, .lane-card:hover, .decide-card:hover, .menu-row:hover { transform: none; } }
 }

package/dist/server/home-asks.d.ts

@@ -0,0 +1,45 @@
+import type { FirstRunStep } from "../first-run.js";
+import type { Store } from "../store.js";
+import type { WorkSummaryAccess } from "../work-summary.js";
+/** One row Home lists that isn't a task's own row. `id` is namespaced so it never meets a task's id; `at` (when it
+ * started waiting) gives its age, or null for a setup step; `repo` its project. */
+export type HomeAskRow = {
+    id: string;
+    title: string;
+    href: string;
+    repo: string | null;
+    at: string | null;
+    line: string | null;
+    action: {
+        label: string;
+        href: string;
+    };
+};
+export type HomeAsks = {
+    /** A release's line for an approver (its version, or why the sheet can't take a yes now); null when it isn't one. */
+    release: (taskId: string) => string | null;
+    /** Releases whose publication waits for a person, one per family, only where that family isn't already a row. */
+    held: HomeAskRow[];
+    /** Flow cards waiting on this person. */
+    flows: HomeAskRow[];
+    /** First-run steps still to do, keyed by step. */
+    setup: (HomeAskRow & {
+        key: FirstRunStep["key"];
+    })[];
+};
+export declare const NO_HOME_ASKS: HomeAsks;
+/** The release sheet: where a release is read and approved, never Home. */
+export declare const releaseSheetHref: (taskId: string) => string;
+/** A release's line (its version, or the sheet's refusal) and every held publication in view. Approvers only: the sheet
+ * mints its approval only for them; anyone else reads a release as an ordinary task row. */
+export declare function releaseAsks(store: Store, now: Date, access: WorkSummaryAccess, project: string | null, approver: boolean): Pick<HomeAsks, "release" | "held">;
+/** Every active card, in a flow of a project this person may see, that waits on them (flows-ui.ts flowCardWaitsOn, the
+ * flow page's own rule). Newest wait first. */
+export declare function flowAsks(store: Store, repos: readonly string[], viewer: {
+    name: string;
+    approver: boolean;
+}, project: string | null): HomeAskRow[];
+/** The first-run steps (first-run.ts, with the builder step) still to do, for an approver. A step that is done, or only
+ * being checked (no answer yet, so no action), is not a row. Null steps (a restricted console, the demo, after the first
+ * success) are none. */
+export declare function setupAsks(steps: readonly FirstRunStep[] | null, approver: boolean): HomeAsks["setup"];

package/dist/server/home-asks.js

@@ -0,0 +1,108 @@
+/**
+ * What else waits on a person at Home (docs/plans/home-other-asks.md): a release's line and a held publication, a flow
+ * card waiting on them, and the first-run steps left to do. Reads only, each through the same admission as the page it
+ * links to; nothing here acts: every row's one link opens its own page, whose own checks decide what this person may do
+ * there. `homeView` (home.ts) assembles these with the work index's rows.
+ */
+import { flowCardHref, flowDefinitionOf } from "../flow-engine.js";
+import { browserViewOf } from "../flow-browser.js";
+import { flowCardWaitsOn } from "../flows-ui.js";
+import { releaseAskOf, releaseTaskOf } from "../release-approval.js";
+import { autoPublishHeld, PUBLISH_ALLOWED_ACTION, PUBLISH_HELD_ACTION } from "../release-auto.js";
+import { taskArchived } from "../task-archive.js";
+import { workStateRows } from "../work-index.js";
+export const NO_HOME_ASKS = { release: () => null, held: [], flows: [], setup: [] };
+/** The release sheet: where a release is read and approved, never Home. */
+export const releaseSheetHref = (taskId) => `/t/${encodeURIComponent(taskId)}/release`;
+const REVIEW_RELEASE = "Review the release";
+/** A release's line (its version, or the sheet's refusal) and every held publication in view. Approvers only: the sheet
+ * mints its approval only for them; anyone else reads a release as an ordinary task row. */
+export function releaseAsks(store, now, access, project, approver) {
+    if (!approver)
+        return { release: () => null, held: [] };
+    const release = (taskId) => {
+        const ask = releaseAskOf(store, taskId);
+        return ask === null ? null : ask.refusal ?? `Version ${ask.version} waits for your approval.`;
+    };
+    const shown = (repo) => (access.repos === null || access.repos.includes(repo)) && (project === null || repo === project);
+    // Only what is still held: the newest held-or-allowed act per task is the held one (release-auto.ts autoPublishHeld's
+    // own rule, read in one statement). Each is then a release this person may see in this scope, before anything heavier.
+    const marked = store.handle.prepare(`SELECT a.task_id, a.at, a.detail FROM action_ledger a WHERE a.action = $held AND a.task_id IS NOT NULL
+    AND a.id = (SELECT MAX(b.id) FROM action_ledger b WHERE b.task_id = a.task_id AND b.action IN ($held, $allowed)) ORDER BY a.at DESC, a.id DESC`)
+        .all({ $held: PUBLISH_HELD_ACTION, $allowed: PUBLISH_ALLOWED_ACTION });
+    const candidates = marked.flatMap(row => {
+        const taskId = String(row["task_id"]);
+        const found = releaseTaskOf(store, taskId);
+        return found === null || !shown(found.ref.repo) || taskArchived(store, taskId) ? []
+            : [{ taskId, ref: found.ref.id, repo: found.ref.repo, at: String(row["at"]), why: autoPublishHeld(store, taskId) ?? String(row["detail"] ?? "") }];
+    });
+    if (candidates.length === 0)
+        return { release, held: [] };
+    // Every family in this person's view, read once (the Tasks list's own projection): a held release's family that is
+    // already a row that needs them (in any group) is not listed twice, and one the view doesn't admit is not listed.
+    const familyOf = new Map();
+    for (const family of workStateRows(store, now, access))
+        for (const member of family.members)
+            familyOf.set(member, { rootId: family.rootId, needs: family.needs });
+    const families = new Set();
+    const held = [];
+    for (const one of candidates) {
+        const family = familyOf.get(one.ref);
+        if (family === undefined || family.needs || families.has(family.rootId))
+            continue;
+        families.add(family.rootId);
+        held.push({ id: `release:${family.rootId}`, title: store.getTask(one.taskId)?.title ?? one.taskId, href: releaseSheetHref(one.taskId), repo: one.repo, at: one.at,
+            line: one.why, action: { label: REVIEW_RELEASE, href: releaseSheetHref(one.taskId) } });
+    }
+    return { release, held };
+}
+/** Every active card, in a flow of a project this person may see, that waits on them (flows-ui.ts flowCardWaitsOn, the
+ * flow page's own rule). Newest wait first. */
+export function flowAsks(store, repos, viewer, project) {
+    if (!viewer.approver)
+        return [];
+    const rows = [];
+    for (const flow of store.listFlows(repos)) {
+        if (flow.state !== "active" || (project !== null && flow.repo !== project) || !store.accountCanAccess(viewer.name, flow.repo))
+            continue;
+        const stages = flowDefinitionOf(flow)?.stages ?? [];
+        // The flow's browser standing, read once and only when a card waits in a zone that starts a browser.
+        let browser;
+        for (const card of store.flowCards(flow.id, false)) {
+            if (card.state !== "active")
+                continue;
+            // A card whose zone was removed still has its subagent's open question (the flow page still takes the answer).
+            const stage = stages.find(one => one.id === card.stage);
+            if (stage?.kind === "check" && stage.browser === true && browser === undefined)
+                browser = browserViewOf(store, flow);
+            const waits = flowCardWaitsOn(store, flow, card, viewer, { stage, ...(browser === undefined ? {} : { browser }) });
+            if (!waits.decide && !waits.choose && !waits.answer && !waits.browser && !waits.reply)
+                continue;
+            const asked = waits.answer ? store.openSubagentQuestionOn(card.id, card.entry)?.question ?? null : null;
+            // The card's own waiting words (a browser wait without the command the page offers as a button).
+            const waiting = card.waiting?.replace(/ Approve it with: toolroll flows browser \d+ on$/, "") ?? null;
+            const said = waiting ?? asked ?? (waits.choose ? "Waits for your choice." : "Waits for your decision.");
+            const href = flowCardHref(flow.id, card.id);
+            rows.push({ id: `flow:${card.id}`, title: card.title, href, repo: flow.repo, at: store.flowCardEnteredAt(card.id) ?? card.updatedAt,
+                line: `${flow.name}: ${said}`, action: { label: "Open the card", href } });
+        }
+    }
+    return rows.sort((a, b) => (b.at ?? "").localeCompare(a.at ?? ""));
+}
+const SETUP_TITLES = {
+    agent: "Sign in to a coding agent", project: "Add a project", builder: "Connect a builder", task: "File your first task",
+};
+/** The first-run steps (first-run.ts, with the builder step) still to do, for an approver. A step that is done, or only
+ * being checked (no answer yet, so no action), is not a row. Null steps (a restricted console, the demo, after the first
+ * success) are none. */
+export function setupAsks(steps, approver) {
+    if (steps === null || !approver)
+        return [];
+    return steps.flatMap(step => {
+        if (step.done || step.checking === true || step.action === null)
+            return [];
+        const action = step.action.kind === "link" ? { label: step.action.label, href: step.action.href } : { label: "Open setup", href: "/welcome" };
+        return [{ key: step.key, id: `setup:${step.key}`, title: SETUP_TITLES[step.key], href: action.href, repo: null, at: null,
+                line: step.action.kind === "command" ? `Run ${step.action.command} in a terminal.` : null, action }];
+    });
+}

package/dist/server/home.d.ts

@@ -1,14 +1,23 @@
 /**
- * Home ("/", UI revamp wave B): one sentence that answers "what needs me?", four counts read from the same work index
- * the Tasks list filters (so a count and the list it opens always agree), the work in three groups (Waiting on you,
- * Working, Done; home-groups.ts), and the lead's message box. Reads only: every act keeps its own route and rules (an agent's
- * question is answered through POST /d/<id>/answer, the same one-click act as its own page).
+ * Home ("/", docs/plans/live-pages-and-home.md B1, home-other-asks.md): what needs this person, grouped by what is asked
+ * (Approve a release, Approve a plan, Answer a question, Flow decisions, Something went wrong, Review results, Finish
+ * setting up, and Needs you for the rest), each group with its exact count; one quiet line for what runs and waits; with nothing waiting, what runs and what finished today. The figures
+ * are read from the same work index the Tasks list filters, so a count and the list it opens always agree. Reads
+ * only: every act keeps its own route and rules (an agent's question is answered through POST /d/<id>/answer, the
+ * same one-click act as its own page).
  */
-import type { BrowserHomeView } from "../browser-workspace.js";
+import type { BrowserHomeAsk, BrowserHomeView } from "../browser-workspace.js";
 import type { Store } from "../store.js";
 import type { WorkSummaryAccess } from "../work-summary.js";
-/** How many waiting rows Home lists; the rest open in Tasks. */
+import { type HomeAsks } from "./home-asks.js";
+/** How many waiting rows Home lists; each group says how many more open in Tasks. */
 export declare const HOME_NEEDS_SHOWN = 30;
+/** How many rows finished today Home lists; its figure counts them all. */
+export declare const HOME_DONE_SHOWN = 8;
+/** Each group's heading, in the order Home shows them. */
+export declare const HOME_ASK_LABEL: Readonly<Record<BrowserHomeAsk, string>>;
+/** The groups in Home's one order. */
+export declare const HOME_ASK_ORDER: readonly BrowserHomeAsk[];
 export type HomeFacts = {
     store: Store;
     now: Date;
@@ -16,7 +25,7 @@ export type HomeFacts = {
     evidenceRoot?: string;
     /** The project in view (already admitted), or null for every project. */
     project: string | null;
-    /** Every admitted project, for the scope links. */
+    /** Every admitted project, for the project filter. */
     projects: readonly {
         name: string;
         path: string;
@@ -25,18 +34,32 @@ export type HomeFacts = {
     chat: boolean;
     /** This person can answer an agent's question (an approver in a browser session). */
     canAnswer: boolean;
+    /** An approver in a browser session (default: `canAnswer`): a release is then read in Approve a release, never
+     * approved here; for anyone else it stays an ordinary task row. */
+    approver?: boolean;
+    /** What else waits on this person (home-asks.ts), already read through each page's own admission. */
+    asks?: HomeAsks;
     /** Why this task's plan can't take a yes right now (render-tasks.ts consentDoorOf), or null when it can. */
     closedDoor: (taskId: string) => {
         title: string;
         why: string;
         road: "scope" | "agents";
     } | null;
+    /** The lead's last message in this person's main thread, already read through the chat's own access check
+     * (pages.ts leadLastMessage); null when there is none or this person may not read that thread. */
+    leadMessage?: {
+        text: string;
+        at: string;
+    } | null;
 };
-/** "7 need you across 2 projects." — the sentence and the figures read the same totals. */
-export declare function homeSentence(needs: number, perProject: readonly {
-    name: string;
-    needs: number;
-}[], scope: string | null, any: boolean): string;
-/** Home's view for one person and scope, from four reads of the work index (what waits on you, what runs, what waits on
- * Toolroll, what was done), grouped by the one rule every surface shares (home-groups.ts). */
+/** "19 tasks need you", "3 tasks and 2 other things need you", "2 things need you": the heading, said once. Tasks
+ * are the same total as the rail's count; `others` are the rows that aren't tasks (a held publication, a flow card, a
+ * setup step). */
+export declare function homeSentence(needs: number, any: boolean, others?: number): string;
+/** The lead's words as one plain line: no markdown marks, no line breaks, cut to about one line. */
+export declare function leadLineOf(text: string): string;
+/** Midnight today on this computer's clock: "finished today" starts here. */
+export declare function startOfToday(now: Date): Date;
+/** Home's view for one person and scope, from four reads of the work index: what waits on you (with exact per-ask
+ * totals), what runs, what waits its turn, and what was completed today (filtered before its limit). */
 export declare function homeView(facts: HomeFacts): BrowserHomeView;