toolroll 0.9.101 → 0.9.102

package/dist/server/home.js

@@ -1,29 +1,44 @@
 import { browserWorkActionHref } from "../browser-crew.js";
-import { HOME_GROUP_LABEL, homeGroupOf } from "../home-groups.js";
+import { NO_REASON_RECORDED } from "../needs-you.js";
 import { projectName } from "../project.js";
-import { workIndexPage } from "../work-index.js";
-import { relativeAge } from "./chrome.js";
+import { WORK_ASK_GROUPS, workIndexPage } from "../work-index.js";
+import { oneLineOf, relativeAge } from "./chrome.js";
 import { taskHref } from "./http.js";
-const TONE = { attention: "needs", ready: "needs", live: "live", done: "done", problem: "failed", muted: "", neutral: "" };
-const ASK_WORD = { decide: "Decision", review: "Result", unblock: "Blocked" };
-/** 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 const HOME_NEEDS_SHOWN = 30;
 const HOME_RUNNING_SHOWN = 8;
-/** How many rows finished in the last 7 days Home lists; the rest open in Tasks. */
-const HOME_DONE_SHOWN = 8;
-/** "7 need you across 2 projects." — the sentence and the figures read the same totals. */
-export function homeSentence(needs, perProject, scope, any) {
+/** How many rows finished today Home lists; its figure counts them all. */
+export const HOME_DONE_SHOWN = 8;
+/** About one line of the lead's last message. */
+const LEAD_LINE_LIMIT = 160;
+/** Each group's heading, in the order Home shows them. */
+export const HOME_ASK_LABEL = {
+    approve: "Approve a plan", answer: "Answer a question", wrong: "Something went wrong", review: "Review results", other: "Needs you",
+};
+/** "19 tasks need you": the heading, said once, from the same total as the rail's count. */
+export function homeSentence(needs, any) {
     if (!any)
-        return "No tasks yet.";
+        return "No tasks yet";
     if (needs === 0)
-        return scope === null ? "Nothing needs you." : `Nothing needs you in ${scope}.`;
-    const verb = needs === 1 ? "needs" : "need";
-    if (scope !== null)
-        return `${needs} ${verb} you in ${scope}.`;
-    const waiting = perProject.filter(one => one.needs > 0);
-    return waiting.length === 1 ? `${needs} ${verb} you in ${waiting[0].name}.` : `${needs} ${verb} you across ${waiting.length} projects.`;
+        return "Nothing needs you";
+    return needs === 1 ? "1 task needs you" : `${needs} tasks need you`;
 }
-function rowOf(store, item, now, multi, canAnswer, closedDoor) {
+/** The lead's words as one plain line: no markdown marks, no line breaks, cut to about one line. */
+export function leadLineOf(text) {
+    const plain = text
+        .replace(/```[\s\S]*?```/g, " ")
+        .replace(/!?\[([^\]]*)\]\([^)]*\)/g, "$1")
+        .replace(/`([^`]*)`/g, "$1")
+        .replace(/^\s{0,3}(?:#{1,6}\s+|>\s?|[-*+]\s+|\d+[.)]\s+)/gm, "")
+        .replace(/(\*\*|__|~~)(.*?)\1/g, "$2")
+        .replace(/(^|[\s(])[*_]([^*_\n]+)[*_](?=[\s).,!?:;]|$)/g, "$1$2");
+    return oneLineOf(plain, LEAD_LINE_LIMIT);
+}
+/** Midnight today on this computer's clock: "finished today" starts here. */
+export function startOfToday(now) {
+    return new Date(now.getFullYear(), now.getMonth(), now.getDate());
+}
+function rowOf(store, item, now, multi, canAnswer, closedDoor, state) {
     const action = item.primaryAction;
     const href = action?.code === "open-result" && action.target.runId != null
         ? `/review?result=${encodeURIComponent(action.target.taskId)}&run=${action.target.runId}` : browserWorkActionHref(item);
@@ -31,87 +46,87 @@ function rowOf(store, item, now, multi, canAnswer, closedDoor) {
     const decision = decisionId === null ? null : store.getDecision(decisionId);
     const open = decision !== null && decision.state === "open" && decision.supersededReason === null;
     // An irreversible option is armed behind a confirmation on its own page; Home answers only what one click may.
-    const question = open && canAnswer && decision.options.every(option => option.reversible) ? {
+    const question = state === "needs" && open && canAnswer && decision.options.every(option => option.reversible) ? {
         id: decision.id, text: decision.question, recap: decision.recap,
         options: decision.options.map(option => ({ id: option.id, label: option.label, consequence: option.consequence, recommended: option.id === decision.recommendation })),
     } : null;
-    const waits = item.status.views.includes("needs-you");
-    // The specific ask, never the group's own words again: "Needs you" under Unblock reads "Blocked".
-    const word = waits ? (open ? "Question" : item.chip ?? (item.status.label === "Needs you" && item.ask !== null ? ASK_WORD[item.ask] : item.status.label)) : item.status.label;
-    const tone = waits ? "ask" : TONE[item.status.tone];
-    const line = waits
-        ? (open ? decision.question : item.status.detail !== item.status.label ? item.status.detail : null)
-        : item.progress ?? (item.status.detail !== item.status.label ? item.status.detail : null);
+    const ask = state === "needs" ? item.askGroup ?? "other" : null;
+    const said = item.status.detail !== item.status.label ? item.status.detail : null;
+    const line = state === "needs" && open ? decision.question : item.progress ?? said;
+    // Only a row where something went wrong says why, in one short line.
+    // With no reason on record, the row says what happened (its status) instead of a sentence about the missing reason.
+    const reason = ask === "wrong" ? oneLineOf((said !== null && said !== NO_REASON_RECORDED ? said : item.status.label).replace(/[.\s]+$/, ""), 120) : null;
     // A plan that can't take a yes never offers one: the reason, and the one act that opens it, as the task page says.
-    const door = action?.code === "approve-scope" ? closedDoor(action.target.taskId) : null;
+    const door = state === "needs" && action?.code === "approve-scope" ? closedDoor(action.target.taskId) : null;
     return {
-        id: item.rootId, title: item.title, href: taskHref(item.rootId),
+        id: item.rootId, title: item.title, href: taskHref(item.rootId), state, ask, reason,
         project: multi || item.repo === null ? (item.repo === null ? "Unplaced" : projectName(item.repo)) : null,
-        age: relativeAge(item.updatedAt, now), chip: { word, tone }, line: door === null ? line : door.title,
+        age: relativeAge(item.updatedAt, now), line: door === null ? line : door.title,
         action: door !== null ? { label: door.road === "agents" ? "Change the agents" : "Edit the plan", href: `${taskHref(action.target.taskId)}#${door.road === "agents" ? "agents" : "scope"}` }
             : href === null || action === null ? null : { label: action.label, href }, question,
     };
 }
-/** 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). */
+/** 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 function homeView(facts) {
     const { store, now, access, project } = facts;
-    const read = (view, limit) => workIndexPage(store, now, access, { view, limit, project, ...(facts.evidenceRoot === undefined ? {} : { root: facts.evidenceRoot }) });
+    const read = (view, limit, completedSince) => workIndexPage(store, now, access, { view, limit, project, ...(completedSince === undefined ? {} : { completedSince }),
+        ...(facts.evidenceRoot === undefined ? {} : { root: facts.evidenceRoot }) });
     const needs = read("needs-you", HOME_NEEDS_SHOWN);
     const running = read("running", HOME_RUNNING_SHOWN);
     // Queued: what waits its turn, or what Toolroll or another task moves on, with no person asked.
     const waiting = read("queued", HOME_RUNNING_SHOWN);
-    // Done: the Completed list is ordered by completion time, newest first, so its first rows are the newest finished;
-    // only those finished in the last 7 days are listed, and that filter runs before the cap.
-    const completed = read("completed", HOME_DONE_SHOWN);
+    // Done today: the Completed list from midnight on, filtered in the read itself, so the figure and the rows are
+    // what finished today however many there are.
+    const today = read("completed", HOME_DONE_SHOWN, startOfToday(now).toISOString());
     const totals = needs.totals;
-    // Queued: the Tasks list's own Queued count (the same predicate its view=queued filter lists).
-    const queued = totals.queued;
     // Every project is said by name (scope=all): /tasks alone would narrow to the session's open project.
     const scopeQuery = project === null ? "scope=all&" : `project=${encodeURIComponent(project)}&`;
-    // Each figure keeps the name of the list it opens; Done is the whole Completed list, not just this week.
+    // Each figure keeps the list it opens.
     const counts = [
-        { key: "needs", label: HOME_GROUP_LABEL.you, value: totals["needs-you"], href: `/tasks?${scopeQuery}view=needs-you` },
+        { key: "needs", label: "Needs you", value: totals["needs-you"], href: `/tasks?${scopeQuery}view=needs-you` },
         { key: "running", label: "Running", value: totals.running, href: `/tasks?${scopeQuery}view=running` },
-        { key: "queued", label: "Queued", value: queued, href: `/tasks?${scopeQuery}view=queued` },
-        { key: "finished", label: HOME_GROUP_LABEL.done, value: totals.completed, href: `/tasks?${scopeQuery}view=completed` },
+        { key: "queued", label: "Queued", value: totals.queued, href: `/tasks?${scopeQuery}view=queued` },
+        { key: "finished", label: "Finished", value: totals.completed, href: `/tasks?${scopeQuery}view=completed` },
     ];
-    // One row per family, in the first group that claims it.
+    // One row per family, in the first list that claims it.
     const seen = new Set();
-    const take = (items, group) => items.filter(one => {
-        if (homeGroupOf(one) !== group || seen.has(one.rootId))
+    const take = (items, view) => items.filter(one => {
+        if (!one.status.views.includes(view) || seen.has(one.rootId))
             return false;
         seen.add(one.rootId);
         return true;
     });
-    // Waiting on you, in today's order of what it asks: decide (with any row whose ask the index couldn't name, which
-    // still waits on this person and is never lost), then review, then unblock. Each row's chip names its ask.
-    const yours = take(["decide", null, "review", "unblock"].flatMap(ask => needs.items.filter(one => one.ask === ask)), "you");
-    // Working: what runs, then what is queued (waits its turn, or on Toolroll or another task), each read with its own bound.
-    const working = [...take(running.items, "working"), ...take(waiting.items, "working")];
-    const weekAgo = new Date(now.getTime() - 7 * 86_400_000).toISOString();
-    const done = take(completed.items.filter(one => (one.completion?.at ?? one.updatedAt) >= weekAgo), "done").slice(0, HOME_DONE_SHOWN);
-    const multi = project === null && new Set([...yours, ...working, ...done].map(one => one.repo ?? "")).size > 1;
-    const groups = [];
-    for (const [key, items] of [["you", yours], ["working", working], ["done", done]]) {
-        if (items.length > 0)
-            groups.push({ key, label: HOME_GROUP_LABEL[key], rows: items.map(one => rowOf(store, one, now, multi, facts.canAnswer, facts.closedDoor)) });
-    }
-    const perProject = needs.projects.map(one => ({ name: one.repo === null ? "Unplaced" : projectName(one.repo), needs: one.totals["needs-you"] }));
+    const yours = take(needs.items, "needs-you");
+    const live = take(running.items, "running");
+    const queued = take(waiting.items, "queued");
+    const done = take(today.items, "completed");
+    const multi = project === null && new Set([...yours, ...live, ...queued, ...done].map(one => one.repo ?? "")).size > 1;
+    const row = (item, state) => rowOf(store, item, now, multi, facts.canAnswer, facts.closedDoor, state);
+    const rows = yours.map(one => row(one, "needs"));
+    // Each group's count is the work index's exact total for that ask, over every row in view, not only those listed.
+    const groups = WORK_ASK_GROUPS.flatMap(key => {
+        const count = needs.asks[key];
+        const listed = rows.filter(one => one.ask === key);
+        return count === 0 && listed.length === 0 ? [] : [{ key, label: HOME_ASK_LABEL[key], count: Math.max(count, listed.length), rows: listed }];
+    });
     const any = totals.all > 0 || totals.completed > 0 || (totals.archived ?? 0) > 0;
-    const shown = yours.length;
+    const lead = facts.chat ? facts.leadMessage ?? null : null;
+    const leadText = lead === null ? "" : leadLineOf(lead.text);
     return {
         kind: "home",
-        say: homeSentence(totals["needs-you"], perProject, project === null ? null : projectName(project), any),
+        say: homeSentence(totals["needs-you"], any),
         project,
         scopes: facts.projects.length < 2 ? null : [
             { key: "", label: "All projects", href: "/", active: project === null },
             ...facts.projects.map(one => ({ key: one.path, label: one.name, href: `/?project=${encodeURIComponent(one.path)}`, active: one.path === project })),
         ],
         counts, groups,
-        more: totals["needs-you"] > shown ? { count: totals["needs-you"] - shown, href: counts[0].href } : null,
+        working: [...live.map(one => row(one, "running")), ...queued.map(one => row(one, "queued"))],
+        finishedToday: { count: Math.max(today.completedSince, done.length), rows: done.map(one => row(one, "done")), href: counts[3].href },
         newTask: "/tasks/new",
-        ask: facts.chat ? { project, placeholder: project === null ? "Ask the lead about your projects…" : `Ask the lead about ${projectName(project)}…` } : null,
-        empty: any ? null : { title: "No tasks yet.", text: "Describe a change in a sentence; an agent writes a plan for you to approve." },
+        ask: facts.chat ? { project, placeholder: "Message the lead" } : null,
+        lastLead: lead === null || leadText === "" ? null : { text: leadText, age: relativeAge(lead.at, now), href: "/chat" },
+        empty: any ? null : { title: "No tasks yet", text: "Describe a change in a sentence; an agent writes a plan for you to approve." },
     };
 }

package/dist/server/http.d.ts

@@ -329,3 +329,9 @@ export declare function passwordSetNext(raw: string | null | undefined): string;
  * the console sends no Referer to name the page the form was on. Checked by passwordSetNext; else home.
  */
 export declare function refusalNext(method: string, url: URL): string;
+/**
+ * Whether an act asked for its answer in place (live-pages-and-home.md B2.3): `x-toolroll-act: in-place` turns the
+ * answer into a small JSON outcome (`{ outcome, words }`) instead of a page or a redirect. It chooses only the answer's
+ * shape: a handler reads it after every proof and authorisation decision is made, and no decision ever reads it.
+ */
+export declare function answersInPlace(request: IncomingMessage | null | undefined): boolean;

package/dist/server/http.js

@@ -315,3 +315,11 @@ export function refusalNext(method, url) {
     }
     return "/";
 }
+/**
+ * Whether an act asked for its answer in place (live-pages-and-home.md B2.3): `x-toolroll-act: in-place` turns the
+ * answer into a small JSON outcome (`{ outcome, words }`) instead of a page or a redirect. It chooses only the answer's
+ * shape: a handler reads it after every proof and authorisation decision is made, and no decision ever reads it.
+ */
+export function answersInPlace(request) {
+    return request?.headers["x-toolroll-act"] === "in-place";
+}

package/dist/server/in-place.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Which pages may change in place, and which may be read ahead (docs/plans/live-pages-and-home.md A1.1, A1.4).
+ *
+ * Both are explicit allowlists of route-table ids (route-table.ts): nothing is eligible by default, so a new route
+ * loads as its own document until it is added here on purpose. The welcome and first-run pages, the terminal, sign-in,
+ * the release sheet and every page not named below are never eligible. A page on the in-place list is still a document
+ * load when it is sensitive (a password field) or carries a page script (serve.ts sendScreen decides `inPlace`).
+ */
+/** Home, the Tasks list, a task page, Projects, Agents (the list), Search and the Settings pages. */
+export declare const IN_PLACE_ROUTES: ReadonlySet<string>;
+/** What may be read ahead with `x-toolroll-read: prefetch`: Home, the Tasks list, Projects, Agents (the list, never an
+ * opened agent), Search, a task page. Everything else answers 204. */
+export declare const PREFETCH_ROUTES: ReadonlySet<string>;
+export declare function inPlaceRoute(id: string | undefined, url: URL): boolean;
+export declare function prefetchRoute(id: string | undefined, url: URL): boolean;

package/dist/server/in-place.js

@@ -0,0 +1,32 @@
+/**
+ * Which pages may change in place, and which may be read ahead (docs/plans/live-pages-and-home.md A1.1, A1.4).
+ *
+ * Both are explicit allowlists of route-table ids (route-table.ts): nothing is eligible by default, so a new route
+ * loads as its own document until it is added here on purpose. The welcome and first-run pages, the terminal, sign-in,
+ * the release sheet and every page not named below are never eligible. A page on the in-place list is still a document
+ * load when it is sensitive (a password field) or carries a page script (serve.ts sendScreen decides `inPlace`).
+ */
+/** The Settings pages (route-table.ts): the overview, its groups and each section page. Not the Slack manifest file. */
+const SETTINGS_PAGES = [
+    "settings.page",
+    ...["general", "agents", "alerts", "projects", "access", "system"].map(one => `settings.group-${one}`),
+    ...["models", "tools", "project", "approval", "policy", "sessions", "integrations", "monitoring", "updates", "retention", "storage",
+        "pull-requests", "checks", "backups", "data", "sign-in", "lead", "teams", "discord", "slack",
+        "skills", "flows", "knowledge", "learning", "spend", "passwordless"].map(one => `settings.${one}`),
+];
+/** Home, the Tasks list, a task page, Projects, Agents (the list), Search and the Settings pages. */
+export const IN_PLACE_ROUTES = new Set(["home", "tasks", "task.page", "projects.page", "agents", "search", ...SETTINGS_PAGES]);
+/** What may be read ahead with `x-toolroll-read: prefetch`: Home, the Tasks list, Projects, Agents (the list, never an
+ * opened agent), Search, a task page. Everything else answers 204. */
+export const PREFETCH_ROUTES = new Set(["home", "tasks", "projects.page", "agents", "search", "task.page"]);
+/** The Agents view's Live grid shares the `agents` row (`/agents?view=live`); it only watches, and is never in place. */
+const liveGrid = (id, url) => id === "agents" && url.searchParams.get("view") === "live";
+export function inPlaceRoute(id, url) {
+    return id !== undefined && IN_PLACE_ROUTES.has(id) && !liveGrid(id, url);
+}
+/** An opened agent shares the `agents` row too (`/agents?run=`): opening one marks it seen or watched, which is an
+ * act, so its page is never read ahead (the browser never shows it before the person's own read). */
+const openedAgent = (id, url) => id === "agents" && url.searchParams.has("run");
+export function prefetchRoute(id, url) {
+    return id !== undefined && PREFETCH_ROUTES.has(id) && !liveGrid(id, url) && !openedAgent(id, url);
+}

package/dist/server/pages.js

@@ -72,7 +72,7 @@ import { rereadBrowser } from "./live.js";
 import { homeView } from "./home.js";
 import { workIndexPage } from "../work-index.js";
 export function createPagesHandlers(runtime) {
-    const { identities, clock, lastChecks, store, visible, consoleProjects, restricted, ceiling, options, projectFamilyPeek, sendScreen, chromeFor, unscopedMode, admissionList, taskRepoOf, taskViewData, runVisible, evidenceRoot, workAccess, identify, liveCeiling, sessions, deletedRepos, authenticateApprover, authenticateCredential, projectOf, lookupSession, firstRunStepsNow } = runtime;
+    const { identities, clock, lastChecks, store, visible, consoleProjects, restricted, ceiling, options, projectFamilyPeek, sendScreen, chromeFor, unscopedMode, admissionList, taskRepoOf, taskViewData, runVisible, evidenceRoot, workAccess, identify, liveCeiling, sessions, deletedRepos, authenticateApprover, authenticateCredential, projectOf, lookupSession, firstRunStepsNow, chatEnablement, leadPrincipal, leadConversationRows } = runtime;
     // The filesystem browser (operator request): pick a project folder by
     // looking, not typing. CONFINED to exactly what opening allows —
     // explicit --repo mode has an enumerable list and gets no browser at
@@ -203,7 +203,9 @@ export function createPagesHandlers(runtime) {
             const door = consentDoorOf(scope, runtime.routeViewOf(taskId, store.lookupRef(taskId), scope, now, who));
             return door.open ? null : door;
         };
-        const view = { ...homeView({ store, now, access: workAccess(), evidenceRoot, project, projects, chat: chrome.chat === true, canAnswer: who.role === "approver", closedDoor }),
+        const chat = chrome.chat === true;
+        const view = { ...homeView({ store, now, access: workAccess(), evidenceRoot, project, projects, chat, canAnswer: who.role === "approver", closedDoor,
+                leadMessage: chat ? leadLastMessage(who, now) : null }),
             // Until the first result: the welcome's three steps stay one link away.
             setup: firstRunStepsNow(now) !== null ? "/welcome" : null };
         return sendScreen(response, 200, screen("Home", html `<div data-kit-page><h1>Home</h1><p>${view.say}</p><p><a href="/tasks">Tasks</a></p></div>`, { chrome, workspace: { view } }));
@@ -1205,5 +1207,24 @@ export function createPagesHandlers(runtime) {
         "edge.font": fontAsset,
         "edge.desktop-health": desktopHealth,
     });
+    /** The lead's last message in this person's main thread, for Home's one line above the message box. The thread is
+     * read only through the gate a docked conversation uses (serve.ts dockedConversation): an approver in a browser
+     * session, chat enabled, the approver's standing re-proved now (leadPrincipal), their lead session under the current
+     * ceiling and generation; and then through leadConversationRows, the very rows /chat renders, which keep only a thread
+     * under this person's current ceiling. Null at any refusal, and when the lead has said nothing yet. */
+    function leadLastMessage(who, now) {
+        if (who.role !== "approver")
+            return null;
+        const enabled = chatEnablement();
+        const principal = enabled.ok ? leadPrincipal(who) : null;
+        if (!enabled.ok || principal === null)
+            return null;
+        const found = store.activeLeadSession(who.name);
+        const notStarted = (found === null || found.ceilingDigest !== principal.ceilingDigest) && enabled.billing === "subscription";
+        if (!notStarted && (found === null || found.ceilingDigest !== principal.ceilingDigest || found.approverGeneration !== principal.generation))
+            return null;
+        const said = leadConversationRows(who, principal, null, now, null).messages.filter(one => one.role === "assistant" && one.pending !== true).at(-1);
+        return said === undefined ? null : { text: said.text, at: said.createdAt };
+    }
     return { registrations, projectsScreen };
 }

package/dist/server/render-tasks.js

@@ -2597,7 +2597,7 @@ export function taskBodyParts(data) {
             { key: "fast-grown", html: data.fastGrown == null || data.csrf === "" ? "" : htmlString(html `<div class="card"><p>${data.fastGrown}</p>${postForm(`${taskHref(task.id)}/keep-grown`, btn("Approve it", { variant: "primary", type: "submit" }))}</div>`) },
             { key: "pull-request", html: fragmentString(pullRequestCard) },
             { key: "needs-scope", html: fragmentString(needsScopeCard) },
-            { key: "mirror", html: fragmentString(mirrorCard) }, { key: "attempt", html: fragmentString(attemptPanel) },
+            { key: "mirror", html: fragmentString(mirrorCard) }, { key: "attempt", html: fragmentString(attemptPanel), ...(liveRunId === null ? {} : { instance: String(liveRunId) }) },
         ].filter(one => one.html !== ""),
         // Open questions are a lead block (key "questions"), so they sit in the step that waits.
         questions: "",
@@ -2672,13 +2672,22 @@ export function taskPage(chrome, data) {
     }
     const liveRunId = data.liveRunId ?? null;
     const liveRun = liveRunId === null ? undefined : data.runs.find(one => one.id === liveRunId);
+    const answers = data.csrf !== "" && data.decisions.some(one => one.state === "open" || one.state === "expired");
     const script = (liveRun === undefined ? "" : regionScript("check-progress", "check", `/r/${liveRun.id}`)) +
         (liveRun !== undefined && data.peekable === true ? regionScript("run-peek", "peek", `/r/${liveRun.id}`) : "") +
-        (data.csrf !== "" && data.decisions.some(one => one.state === "open" || one.state === "expired") ? decisionAnswerScript() : "");
+        (answers ? decisionAnswerScript() : "");
+    // The same three, named for the app (task-page-in-app.md): it runs its own version of each where it can.
+    const app = [];
+    if (liveRun !== undefined)
+        app.push({ kind: "region", region: "check-progress", run: liveRun.id });
+    if (liveRun !== undefined && data.peekable === true)
+        app.push({ kind: "region", region: "run-peek", run: liveRun.id });
+    if (answers)
+        app.push({ kind: "answer" });
     return screen(`task \u00b7 ${data.task.id}`, first.html, {
         chrome,
         workspace: { view: first.view },
-        ...(script === "" ? {} : { functional: { script, fetches: true } }),
+        ...(script === "" ? {} : { functional: { script, fetches: true, app } }),
     });
 }
 /** One accessible two-choice control everywhere permissions are selected.
@@ -2780,6 +2789,8 @@ export function approveKitOf(input, freshSince) {
         ...(input.localOwner?.eligible === true ? { termsWords: "No password needed on this computer." } : {}),
         // What it signs: the plan sheet (the same parts as the chat's sheet, re-ordered), then the in-place editor.
         planHtml: htmlString(joinHtml([parts.sheet, parts.editor ?? "", parts.editorForm])),
+        // The plan sheet alone, with no editor and no form: what Home shows beside its one-click Approve (B2.1).
+        sheetHtml: htmlString(parts.sheet),
     };
 }
 /** How an approved plan was approved, for the status box's terms line: by whom and how, or the rule that approved it. */

package/dist/server/request-context.d.ts

@@ -22,6 +22,13 @@ export type RequestFacts = {
     timeline?: import("../latency-timeline.js").Timeline;
     browser?: boolean;
     workspaceRead?: boolean;
+    /** Why a `?format=workspace` GET was made (`x-toolroll-read`, readPurpose below): bookkeeping only, never authority. */
+    readPurpose?: ReadPurpose;
+    /** A workspace read from an app that runs page work itself (`x-toolroll-work`, task-page-in-app.md §2): it picks
+     * which of two forms of the same page is sent, never what may be read. */
+    appWork?: boolean;
+    /** The route table row that matched this request (route-table.ts ids), for the in-place allowlists (serve.ts). */
+    routeId?: string;
     /** Receipt reconciliation, task and result reads (`request`, `task`, `result`): work is read afresh, never cached. */
     freshWork?: boolean;
     /** A workspace re-read's If-None-Match: the content validator it holds from its last read. */
@@ -62,3 +69,10 @@ export type RequestFacts = {
 export declare const requestContext: AsyncLocalStorage<RequestFacts>;
 /** Run a render outside a live request (a test, a background render) as if a browser session with this token asked. */
 export declare function withFormToken<T>(csrf: string, render: () => T): T;
+/**
+ * What a workspace read is for (docs/plans/live-pages-and-home.md A1.4), from its `x-toolroll-read` header. It is a hint
+ * about bookkeeping (does the read extend the session, does it mint an approval nonce), never proof that a person
+ * clicked, and no authorisation decision reads it. Absent, `poll` or anything unknown is today's re-read: `poll`.
+ */
+export type ReadPurpose = "poll" | "navigate" | "prefetch";
+export declare function readPurpose(header: string | string[] | undefined): ReadPurpose;

package/dist/server/request-context.js

@@ -16,3 +16,6 @@ export function withFormToken(csrf, render) {
     const facts = requestContext.getStore();
     return requestContext.run({ ...(facts ?? { returnTo: "/" }), csrf }, render);
 }
+export function readPurpose(header) {
+    return header === "navigate" || header === "prefetch" ? header : "poll";
+}

package/dist/server/task-views.js

@@ -1,3 +1,4 @@
+import { requestContext } from "./request-context.js";
 import { heldFindingCount } from "../findings.js";
 import { familyInWebReach } from "../findings.js";
 import { existsSync } from "node:fs";
@@ -54,7 +55,7 @@ import { isRevisionFeedback } from "../result-review.js";
 import { buildReviewOf } from "../review-switch.js";
 import { isAlive as runnerAlive } from "../runner.js";
 import { approvalOf } from "../scope.js";
-import { oneLineOf, refuse, screen } from "./chrome.js";
+import { oneLineOf, refuse, screen, withScript } from "./chrome.js";
 import { chatResultHref, reviewHref, taskChatHref, taskHref } from "./http.js";
 import { decisionsFor } from "./render-chat.js";
 import {} from "./render-pages.js";
@@ -817,7 +818,8 @@ export function createTaskViews(runtime) {
         const admittedFamily = runtime.familyOf(taskId);
         if (admittedFamily?.problem != null)
             return runtime.sendScreen(response, status, screen(admittedFamily.root.title, html `<h1>${admittedFamily.root.title}</h1><p>${admittedFamily.current.state}</p><p class="problem" data-history-problem>${admittedFamily.problem}</p>`, { chrome: runtime.chromeFor(admittedFamily.root.repo, "tasks") }));
-        const data = taskViewData(taskId, who, problem);
+        // A read ahead (x-toolroll-read: prefetch, live-pages-and-home.md A1.4) mints nothing: its plan form says "unminted".
+        const data = taskViewData(taskId, who, problem, { mintNonce: requestContext.getStore()?.readPurpose !== "prefetch" });
         if (data === null)
             return refuse(response, who, 404, "no such task", "/tasks");
         const family = runtime.familyOf(taskId);
@@ -895,7 +897,8 @@ export function createTaskViews(runtime) {
             page.body = html `${page.body}<section class="task-result-tab" id="task-result" aria-label="Result">${extras.result.html}</section>`;
             // The result's own script, as its result page ships it (a password form there keeps it too: Request changes and
             // the line notes need it).
-            page.functional = { script: `${page.functional?.script ?? ""}${reviewEvidenceScript()}${RESULT_REVIEW_SCRIPT}`, fetches: page.functional?.fetches ?? false };
+            // The app runs its own version (browser/work/result.ts), so a task with a result can open in place.
+            page.functional = withScript(page.functional, { script: `${reviewEvidenceScript()}${RESULT_REVIEW_SCRIPT}`, app: [{ kind: "result" }] });
         }
         if (docked !== null)
             page.workspace = { ...page.workspace, ...(oneTaskView === undefined ? {} : { view: oneTaskView }), conversation: docked, pageHtml: page.body };

package/dist/server/tasks.d.ts

@@ -1,6 +1,6 @@
 /** tasks handlers, moved without changing their route bodies. */
 import { type Html } from "../html.js";
-import { type ServerResponse } from "node:http";
+import { type IncomingMessage, 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';
@@ -15,7 +15,7 @@ export declare function createTasksHandlers(runtime: ServerRuntime): {
         body: Html;
         retryAfter?: number;
     }>;
-    taskMutation: (response: ServerResponse, who: Who, taskId: string, verb: string, posted: URLSearchParams, now: Date) => void;
+    taskMutation: (response: ServerResponse, who: Who, taskId: string, verb: string, posted: URLSearchParams, now: Date, request?: IncomingMessage | null) => void;
     queueRegionFor: (project: string | null, csrf: string, revision: number, now: Date) => Html;
     ciFailingFor: (runId: number | null, prNumber: number | null) => boolean;
     completedRowFor: (taskId: string, project: string | null) => CompletedWorkRow | null;
@@ -75,3 +75,9 @@ export declare function createReleaseSheetHandlers(runtime: ServerRuntime): {
     sheetScreen: (ctx: Pick<HandlerContext, "who" | "response" | "project">, taskId: string, problem: string | null, status: number) => void;
     approveFromSheet: (ctx: Pick<HandlerContext, "who" | "response" | "project">, taskId: string, cardDigest: string, token: string) => void;
 };
+/** What a plan approval asked in place came to (live-pages-and-home.md B2.3): approved; a first yes on protected work
+ * recorded; approved but building again did not start; or refused, with nothing changed. */
+export type ApprovalOutcome = "approved" | "vote" | "approved-not-rebuilt" | "refused";
+/** The answer to an approval asked in place: its named outcome and the same words the page would show, as JSON. Written
+ * only after the approve route's proofs, by the caller that knows the outcome. */
+export declare function answerApprovalInPlace(response: ServerResponse, outcome: ApprovalOutcome, words: string, status: number): void;