toolroll 0.9.101 → 0.9.102

package/dist/browser-workspace.d.ts

@@ -9,6 +9,7 @@ export { browserCrewFromIndex, browserWorkActionHref } from './browser-crew.js';
 import type { Store } from './store.js';
 import type { WorkSummaryAccess } from './work-summary.js';
 import type { StatusTone, StepRow } from './workspace-ui.js';
+import type { PageWork } from './page-work-contract.js';
 import type { Ask, AskChip } from './needs-you.js';
 import type { WorkIndexGroup } from './work-index.js';
 import type { AssignmentCard } from './assignment-ui.js';
@@ -486,9 +487,12 @@ export type BrowserTaskView = {
         }[];
     } | null;
     /** Server cards that may need a person now (stop/resume, scope prompt, plan, live attempt). */
+    /** `instance`: what the block is about now (the attempt card: its build). The page installs a block's HTML once;
+     * another instance replaces it. */
     lead: {
         key: string;
         html: string;
+        instance?: string;
     }[];
     questions: string;
     facts: BrowserTaskFact[];
@@ -549,6 +553,8 @@ export type BrowserTaskView = {
         /** When a remembered password stops counting (ISO); the page words it in the viewer's zone. */
         rememberedUntil: string | null;
         planHtml: string;
+        /** The plan sheet alone (no editor, no form): what Home shows beside its Approve (live-pages-and-home.md B2.1). */
+        sheetHtml?: string;
         /** The terms line in words, when the rule isn't one of the kit's (easy-start C5: a laptop's own owner). */
         termsWords?: string;
     } | null;
@@ -1613,6 +1619,15 @@ export type BrowserWorkspace = {
     user: string;
     csrf: string;
     sensitive: boolean;
+    /** True when this page may replace another without a document load (docs/plans/live-pages-and-home.md A1.1): the server
+     * sets it on every workspace it sends; absent (an older server, a fixture) is false. */
+    inPlace?: boolean;
+    /** What the app runs for this page in place of a page script (docs/plans/task-page-in-app.md): data, a closed list.
+     * Present only when the app covers the page's whole script; the document then ships no page script string. */
+    work?: readonly PageWork[];
+    /** This document ships a page script string (set on a document load only). Its listeners live as long as the
+     * document, so the app never changes pages in place from it, and never runs `work` in it. */
+    scripted?: boolean;
     /** Passwordless is on for this signed-in browser: ceremony password fields are left out (docs/plans/passwordless.md). */
     passwordless?: boolean;
     /** The session's open project (its path), or null: the sidebar's project picker names it. */
@@ -1688,13 +1703,14 @@ export type BrowserWorkspace = {
         command: string;
     };
 };
-/** Home ("/"): one sentence that answers "what needs me?", four counts that agree with the Tasks filters they open,
- * the work grouped as Waiting on you, Working and Done, and the selected item answered in place. */
+/** Home ("/", docs/plans/live-pages-and-home.md B1): the heading said once, one quiet line for what runs and waits, what
+ * needs this person grouped by what is asked (each group with its exact count), the selected one open beside the list,
+ * and the lead's last message above the message box. With nothing waiting: what runs and what finished today. */
 export type BrowserHomeView = {
     kind: 'home';
-    /** "7 need you across 2 projects.", derived from the same counts as the figures. */
+    /** "19 tasks need you", "Nothing needs you", read from the same total as the rail's count. */
     say: string;
-    /** The project in view (a path) or every project (null), and the scope links (null with one project). */
+    /** The project in view (a path) or every project (null), and the project filter's choices (null with one project). */
     project: string | null;
     scopes: {
         key: string;
@@ -1702,29 +1718,42 @@ export type BrowserHomeView = {
         href: string;
         active: boolean;
     }[] | null;
+    /** The work index totals, each with the Tasks list it opens. */
     counts: {
         key: 'needs' | 'running' | 'queued' | 'finished';
         label: string;
         value: number;
         href: string;
     }[];
-    /** The work in three groups, in this order (home-groups.ts): Waiting on you, Working, Done (finished in the last 7 days). */
+    /** What needs you, by what is asked, in this order: approve, answer, wrong, review, other (anything none of the four
+     * fits). `count` is the exact total for that ask, past the rows listed. */
     groups: {
-        key: 'you' | 'working' | 'done';
+        key: BrowserHomeAsk;
         label: string;
+        count: number;
         rows: BrowserHomeRow[];
     }[];
-    /** More waits on you than the list shows: open them all in Tasks. */
-    more: {
+    /** What runs, then what waits its turn. */
+    working: BrowserHomeRow[];
+    /** What was completed today: the exact figure, the newest rows, and the list that has them all. */
+    finishedToday: {
         count: number;
+        rows: BrowserHomeRow[];
         href: string;
-    } | null;
+    };
     newTask: string;
     /** The lead's message box, where chat is allowed for this person: a POST to /chat in this scope. */
     ask: {
         project: string | null;
         placeholder: string;
     } | null;
+    /** The lead's last message in this person's main thread, as one plain line that opens the chat; null when there is
+     * none or this person may not read that thread. */
+    lastLead: {
+        text: string;
+        age: string;
+        href: string;
+    } | null;
     empty: {
         title: string;
         text: string;
@@ -1732,16 +1761,20 @@ export type BrowserHomeView = {
     /** While the first run is open (no first result yet): the welcome's address, linked as Finish setup. */
     setup?: string | null;
 };
+/** What a waiting row asks (work-index.ts WorkAskGroup). */
+export type BrowserHomeAsk = 'approve' | 'answer' | 'wrong' | 'review' | 'other';
 export type BrowserHomeRow = {
     id: string;
     title: string;
     href: string;
     project: string | null;
     age: string;
-    chip: {
-        word: string;
-        tone: '' | 'needs' | 'ask' | 'live' | 'done' | 'failed';
-    };
+    /** Which list it is in: it needs you, it runs, it waits its turn, or it finished. */
+    state: 'needs' | 'running' | 'queued' | 'done';
+    /** What it asks of you (its group), or null when it doesn't wait on you. */
+    ask: BrowserHomeAsk | null;
+    /** Why, in one short line: only a row where something went wrong. */
+    reason: string | null;
     /** One line: what it asks, or what the agent is doing now. */
     line: string | null;
     /** The one act that resolves it (a link), or null. */
@@ -1933,3 +1966,4 @@ export type MergeReadyView = {
         act: MergeReadyAct | null;
     }[];
 };
+export type { PageWork } from './page-work-contract.js';

package/dist/browser-workspace.js

@@ -97,11 +97,13 @@ export function browserProjectsOf(projects) {
 export function browserNavigationOf(path, project = null, needsYou = 0, tasksProject = project, needsYouLabel) {
     const pathname = path.split('?')[0].split('#')[0];
     const under = (...roots) => roots.some(root => pathname === root || pathname.startsWith(`${root}/`));
-    // The rail (UI revamp, wave B): Home carries the one Needs-you count; the lead chat and an agent's question live
-    // under Home, a task's pages under Tasks, every computer and terminal under Agents, every setting under Settings.
+    // The rail (UI revamp, wave B; Chat under Home, live-pages-and-home.md B1): Home carries the one Needs-you count and
+    // an agent's question lives under it; the lead chat is its own item; a task's pages under Tasks, every computer and
+    // terminal under Agents, every setting under Settings.
     return [
-        { label: 'Home', href: '/', active: pathname === '/' || pathname === '/chat' || under('/d', '/activity', '/morning'),
+        { label: 'Home', href: '/', active: pathname === '/' || under('/d', '/activity', '/morning'),
             ...(needsYou > 0 ? { count: needsYou, ...(needsYouLabel === undefined ? {} : { countLabel: needsYouLabel }) } : {}) },
+        { label: 'Chat', href: '/chat', active: under('/chat') },
         { label: 'Tasks', href: `/tasks${tasksProject === null ? '' : `?project=${encodeURIComponent(tasksProject)}`}`,
             active: under('/tasks', '/t', '/r', '/review') },
         { label: 'Flows', href: '/flows', active: under('/flows', '/recipes', '/kits', '/routines') },

package/dist/desktop-update.d.ts

@@ -97,13 +97,13 @@ export declare function sqliteLock(file: string, busyTimeoutMs?: number): Databa
 export declare function lockHeld(file: string): boolean;
 export declare const installationLock: (j: UpdateJournal) => DatabaseSync | null;
 export declare function desktopUpdateStatus(stateDir: string): {
+    error?: never;
     active: boolean;
     phase: string;
     detail: string;
     running: boolean;
     canResume: boolean;
     canCancel: boolean;
-    error?: never;
     automaticRecovery?: never;
     recoveryAttempts?: never;
     recoveryRepairs?: never;

package/dist/page-work-contract.d.ts

@@ -0,0 +1,21 @@
+/**
+ * One behaviour the app runs for the page on screen instead of a page script string (docs/plans/task-page-in-app.md).
+ * `answer`: a question's inline answer (render-tasks.ts decisionAnswerScript). `region`: a server-drawn region kept
+ * current from a build's own fragment (chrome.ts regionScript), `/r/<run>?fragment=check|peek`. `result`: reviewing the
+ * result the page shows (result-review.ts RESULT_REVIEW_SCRIPT with render-results.ts reviewEvidenceScript). No code,
+ * selector or address travels here: the app runs only the kinds it knows.
+ */
+export type PageWork = {
+    kind: "answer";
+} | {
+    kind: "result";
+} | {
+    kind: "region";
+    region: "check-progress" | "run-peek";
+    run: number;
+};
+/** The work the app and the server agree on. A workspace read says it with `x-toolroll-work`; a reader that does not
+ * say exactly this version (an older tab) gets the page as a document with its script string, as before. A hint, never
+ * authority. It moves whenever a kind is added: 2 added `result`. */
+export declare const PAGE_WORK_VERSION = 2;
+export declare const PAGE_WORK_HEADER = "x-toolroll-work";

package/dist/page-work-contract.js

@@ -0,0 +1,5 @@
+/** The work the app and the server agree on. A workspace read says it with `x-toolroll-work`; a reader that does not
+ * say exactly this version (an older tab) gets the page as a document with its script string, as before. A hint, never
+ * authority. It moves whenever a kind is added: 2 added `result`. */
+export const PAGE_WORK_VERSION = 2;
+export const PAGE_WORK_HEADER = "x-toolroll-work";

package/dist/project-knowledge.d.ts

@@ -22,18 +22,19 @@ export type KnowledgeView = ReturnType<typeof knowledgeView>;
 export declare function knowledgeVersion(store: Store, repo: string, actor: string, revision: number): Knowledge;
 /** Chat reads only an admitted project. Keep the full source in the project UI. */
 export declare function conversationKnowledge(store: Store, repo: string, actor: string, reference?: string, decision?: number): {
+    title?: never;
+    content?: never;
     history?: never;
     revision: number;
     stale: boolean;
     notice: string;
-    title?: never;
-    content?: never;
     instructions?: never;
     references?: never;
     decisions?: never;
     waiting?: never;
 } | {
-    revision?: never;
+    title?: never;
+    content?: never;
     history?: never;
     stale?: never;
     decision: {
@@ -52,8 +53,7 @@ export declare function conversationKnowledge(store: Store, repo: string, actor:
     };
     afterwards?: string;
     notice: string;
-    title?: never;
-    content?: never;
+    revision?: never;
     instructions?: never;
     references?: never;
     decisions?: never;
@@ -70,9 +70,9 @@ export declare function conversationKnowledge(store: Store, repo: string, actor:
     decisions?: never;
     waiting?: never;
 } | {
-    stale?: never;
     title?: never;
     content?: never;
+    stale?: never;
     revision: number;
     history: {
         revision: number;

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/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.d.ts

@@ -1,14 +1,20 @@
 /**
- * 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): what needs this person, grouped by what is asked (Approve a plan,
+ * Answer a question, Something went wrong, Review results, 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. */
+/** 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>>;
 export type HomeFacts = {
     store: Store;
     now: Date;
@@ -16,7 +22,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;
@@ -31,12 +37,19 @@ export type HomeFacts = {
         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": the heading, said once, from the same total as the rail's count. */
+export declare function homeSentence(needs: number, any: boolean): 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;