toolroll 0.9.100 → 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/kit.d.ts

@@ -9,7 +9,7 @@
  * as plain HTML without it.
  */
 import { type AttributeValue, type Html, type HtmlValue, type PostFormOptions } from "../html.js";
-import { type ApprovalFacts, type ApprovalKind, type ChipTone, type KitIcon, type StatusKey, type StepItem, type TimingRow } from "../design/kit.js";
+import { type ApprovalFacts, type ApprovalKind, type ChipTone, type KitIcon, type StatusKey, type StepItem, type StepRowMark, type TimingRow } from "../design/kit.js";
 import type { Headline } from "../task-status.js";
 type Attrs = Readonly<Record<string, AttributeValue>>;
 export declare function icon(name: KitIcon, small?: boolean): Html;
@@ -140,7 +140,7 @@ export declare function facts(rows: ReadonlyArray<readonly [key: string, value:
 export declare const note: (text: HtmlValue) => Html;
 /** A refusal or problem, where it happened (role=alert): what went wrong and what didn't change. */
 export declare const notice: (text: HtmlValue) => Html;
-/** One neutral system line (a builder offline, an update): not a failure, never amber. */
+/** One neutral system line (a builder offline, an update): not a failure, never the needs-you mark. */
 export declare const infoLine: (text: HtmlValue) => Html;
 export declare function empty(options: {
     title: string;
@@ -223,7 +223,7 @@ export declare function approveForm(options: {
 }): Html;
 /** The terms line for an act, from the same rules. */
 export declare const approvalTerms: (kind: ApprovalKind, facts: ApprovalFacts) => string;
-/** Waits that aren't tasks, on their own page (a spend limit, a failed backup): one amber outline, a count, items
+/** Waits that aren't tasks, on their own page (a spend limit, a failed backup): one ink outline, a count, items
  * split by hairlines, each with its one action. They never join the global Needs-you count. */
 export declare function needsPanel(items: ReadonlyArray<{
     title: string;
@@ -359,6 +359,39 @@ export declare function outField(options: {
     error?: string | null;
     attrs?: Attrs;
 }): Html;
+/** One step row: its marker, label, one sentence, a time (`at` ISO, `when` the words for it), and its body. `toggle`: a
+ * finished row's head is a disclosure button (aria-expanded) for its body; `open` shows the body. */
+export type StepRowItem = {
+    key: string;
+    label: string;
+    mark: StepRowMark;
+    sentence: HtmlValue;
+    needsYou?: boolean;
+    current?: boolean;
+    at?: string | null;
+    when?: string;
+    body?: HtmlValue;
+    toggle?: boolean;
+    open?: boolean;
+};
+/** The steps of one object as the page itself (a task: Plan · Approval · Build · Checks · Ready): an ordered list, a
+ * marker on a rail, the label, one sentence and a time per row, and the row's body under it. The current row is
+ * `aria-current="step"`. Same markup as `KStepRows`. */
+export declare function stepRows(items: readonly StepRowItem[], label?: string): Html;
+/** The work's frame (KIT.md "The work"): a header (the title, who is working with a blue dot while it runs, Close), the
+ * body that scrolls, and the message box at the foot. The records themselves are followed live by the workspace
+ * (`KWork` and `useConversation`); a page without script shows what `body` holds. Same markup as `KWork`. */
+export declare function work(options: {
+    id: string;
+    title: string;
+    who?: HtmlValue;
+    live?: boolean;
+    close?: string | null;
+    hidden?: boolean;
+    body?: HtmlValue;
+    foot?: HtmlValue;
+    attrs?: Attrs;
+}): Html;
 export type CheckStep = {
     key: string;
     title: string;

package/dist/server/kit.js

@@ -8,8 +8,8 @@
  * (src/browser/kit/behavior.ts), which wires any kit markup the workspace places; every control here still works
  * as plain HTML without it.
  */
-import { attributes, html, joinHtml, passwordlessRendering, postForm } from "../html.js";
-import { KIT_ICONS, NOT_FOUND, SETTINGS_GROUPS, STATUS, STEP_WORDS, TIMING_WORDS, approvalAsk, chipOfHeadline, dur, needsWords, stepsFill, termsOf, timingBars, } from "../design/kit.js";
+import { attributes, html, htmlString, joinHtml, passwordlessRendering, postForm } from "../html.js";
+import { KIT_ICONS, NOT_FOUND, SETTINGS_GROUPS, STATUS, STEP_ROW_WORDS, STEP_WORDS, stepRowBodyId, TIMING_WORDS, approvalAsk, chipOfHeadline, dur, needsWords, stepsFill, termsOf, timingBars, } from "../design/kit.js";
 const cls = (...names) => names.filter(Boolean).join(" ");
 // ---- text and icons ---------------------------------------------------------------------------------------------
 export function icon(name, small = false) {
@@ -106,7 +106,7 @@ export function facts(rows) {
 export const note = (text) => html `<p class="k-note">${text}</p>`;
 /** A refusal or problem, where it happened (role=alert): what went wrong and what didn't change. */
 export const notice = (text) => html `<p class="k-notice" role="alert">${icon("alert", true)}<span>${text}</span></p>`;
-/** One neutral system line (a builder offline, an update): not a failure, never amber. */
+/** One neutral system line (a builder offline, an update): not a failure, never the needs-you mark. */
 export const infoLine = (text) => html `<p class="k-notice info">${text}</p>`;
 export function empty(options) {
     return html `<div class="k-empty"><p class="k-empty-t">${options.title}</p>${options.text ? html `<p class="k-empty-x">${options.text}</p>` : ""}${options.action ?? ""}</div>`;
@@ -180,7 +180,7 @@ export function approveForm(options) {
 }
 /** The terms line for an act, from the same rules. */
 export const approvalTerms = (kind, facts) => termsOf(kind, facts);
-/** Waits that aren't tasks, on their own page (a spend limit, a failed backup): one amber outline, a count, items
+/** Waits that aren't tasks, on their own page (a spend limit, a failed backup): one ink outline, a count, items
  * split by hairlines, each with its one action. They never join the global Needs-you count. */
 export function needsPanel(items, label = "Needs you") {
     if (items.length === 0)
@@ -320,6 +320,35 @@ export function outField(options) {
     return html `<div class="k-field"><label class="k-label" for="${options.id}">${options.label}</label>${control}\
 ${options.hint ? html `<p class="k-hint" id="${options.id}-hint">${options.hint}</p>` : ""}${options.error ? html `<p class="k-err" id="${options.id}-err" role="alert">${options.error}</p>` : ""}</div>`;
 }
+/** The steps of one object as the page itself (a task: Plan · Approval · Build · Checks · Ready): an ordered list, a
+ * marker on a rail, the label, one sentence and a time per row, and the row's body under it. The current row is
+ * `aria-current="step"`. Same markup as `KStepRows`. */
+export function stepRows(items, label = "Steps") {
+    return html `<ol class="k-steprows" aria-label="${label}">${items.map(item => {
+        const hasBody = item.body !== undefined && htmlString(html `${item.body}`) !== "";
+        const id = stepRowBodyId(item.key);
+        const head = html `<span class="k-steprow-label">${item.label}<span class="k-sr">, ${STEP_ROW_WORDS[item.mark]}</span></span>\
+<span class="k-steprow-say">${item.needsYou ? chip("Needs you", "needs") : ""}${item.sentence === "" ? "" : html `<span>${item.sentence}</span>`}</span>\
+${item.at ? html `<time class="k-steprow-time k-num" datetime="${item.at}">${item.when ?? ""}</time>` : ""}`;
+        return html `<li class="${cls("k-steprow", item.mark)}" data-step-row="${item.key}"${item.current ? html ` aria-current="step"` : ""}><span class="k-steprow-mark" aria-hidden="true"></span>\
+<div class="k-steprow-main">${item.toggle && hasBody
+            ? html `<button class="k-steprow-head" type="button" aria-expanded="${item.open ? "true" : "false"}" aria-controls="${id}">${head}</button>`
+            : html `<div class="k-steprow-head">${head}</div>`}${hasBody ? html `<div class="k-steprow-body" id="${id}"${item.open ? "" : html ` hidden`}>${item.body}</div>` : ""}</div></li>`;
+    })}</ol>`;
+}
+// ---- the work -----------------------------------------------------------------------------------------------------
+/** The work's frame (KIT.md "The work"): a header (the title, who is working with a blue dot while it runs, Close), the
+ * body that scrolls, and the message box at the foot. The records themselves are followed live by the workspace
+ * (`KWork` and `useConversation`); a page without script shows what `body` holds. Same markup as `KWork`. */
+export function work(options) {
+    const who = options.who === undefined || htmlString(html `${options.who}`) === "" ? ""
+        : html `<p class="k-work-who">${options.live ? html `<span class="k-work-dot" aria-hidden="true"></span>` : ""}<span>${options.who}</span></p>`;
+    const close = options.close === undefined || options.close === null ? "" : btn(options.close, { variant: "ghost", sm: true, iconOnly: "x" });
+    const foot = options.foot === undefined || htmlString(html `${options.foot}`) === "" ? "" : html `<div class="k-work-foot">${options.foot}</div>`;
+    return html `<aside class="k-work" id="${options.id}" aria-labelledby="${options.id}-h"${options.hidden ? html ` hidden` : ""}${attributes(options.attrs ?? {})}>\
+<header class="k-work-head"><div class="k-work-title"><h2 id="${options.id}-h">${options.title}</h2>${who}</div>${close}</header>\
+<div class="k-work-body" data-agent-scroll="">${options.body ?? ""}</div>${foot}</aside>`;
+}
 /** A short list of steps: a mark, the step and one line, its one action. Done steps read muted with a check; a step
  * being checked shows a static ring (running state never animates). The state is also said in words. */
 export function checklist(steps, label = "Steps") {

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

@@ -84,6 +84,8 @@ export type TaskChatFocus = {
         origin?: TaskOrigin | null;
         /** The repair chain row when this task is a machine-drafted repair. */
         repairChain: RepairChainRow | null;
+        /** A release filed while its pull request's checks still ran: the sheet says nothing deploys until they pass. */
+        releaseCiRunning?: boolean;
     } | null;
     decisions: (Decision & {
         taskId: string;

package/dist/server/render-chat.js

@@ -93,6 +93,7 @@ export function taskChatApproval(focus, csrf) {
         coordinator: approval.coordinator,
         origin: approval.origin ?? null,
         deliverable: approval.deliverable,
+        releaseCiRunning: approval.releaseCiRunning === true,
         rebuild: focus.assignment?.need != null && "key" in focus.assignment.need && focus.assignment.need.key === "replan" ? focus.assignment.need.build : null,
         // Edit plan opens the task page's sheet with its fields open for editing.
         editHref: `${taskHref(focus.id)}?edit=plan#plan-editor`,

package/dist/server/render-pages.js

@@ -129,7 +129,7 @@ export function boardBody(data, ciRed) {
             return `${Math.round(minutes / 60)}h`;
         return `${Math.round(minutes / (24 * 60))}d`;
     };
-    // A lane's head is a status chip in its own tone (after ReUI's badge with a dot): amber only for the lane that
+    // A lane's head is a status chip in its own tone (after ReUI's badge with a dot): solid ink only for the lane that
     // waits on a person, blue for building, green for done, neutral otherwise. The word carries the state.
     const LANE_CHIP = { attention: "chip-needs", building: "chip-live", done: "chip-done", queued: "", waiting: "" };
     const laneChip = (key, title) => html `<span class="chip ${LANE_CHIP[key]}"><span class="chip-dot" aria-hidden="true"></span>${title}</span>`;

package/dist/server/render-results.js

@@ -70,7 +70,7 @@ export function editorFileHref(worktree, path, line) {
  * chat (v39, extending Priority 2's "one surface, six places" rule from
  * the verdict word to the per-criterion state). */
 export function matrixStateBadge(state) {
-    // Red belongs to a Failed headline alone (task-status.ts); an unmet requirement is an amber note.
+    // Red belongs to a Failed headline alone (task-status.ts); an unmet requirement is an ink note.
     const cls = state === "pass" ? "badge-done" : state === "failed" ? "badge-note" : state === "missing" ? "badge-note" : "badge-manual-review";
     // The same words as the Checks tab and the card's Requirements row (task-status.ts).
     return html `<span class="badge ${cls}" data-matrix-state="${state}">${requirementWordOf({ state })}</span>`;
@@ -828,7 +828,7 @@ export function pullRequestCardHtml(pr, csrf) {
     const view = pr.view;
     const url = safePrUrl(view.prUrl);
     const link = view.prNumber === null ? "" : url === null ? html `<span class="mono">PR #${view.prNumber}</span>` : html `<a href="${url}" class="mono" rel="noreferrer" target="_blank">PR #${view.prNumber}</a>`;
-    // A pull request's trouble never undoes the result: amber, never red.
+    // A pull request's trouble never undoes the result: an ink note, never red.
     const tone = view.state === "ready" || view.state === "merged" ? "ok" : view.state === "failing" || view.state === "failed" ? "problem" : "waiting";
     const revision = view.revisionTask === null || view.state !== "failing" ? "" : html ` <a href="${taskHref(view.revisionTask)}">Open revision</a>`;
     const merged = view.mergeCommit === null ? "" : html `<p class="meta">Merge commit <span class="mono">${view.mergeCommit.slice(0, 12)}</span></p>`;
@@ -1507,7 +1507,7 @@ export function completionReceiptCard(view, taskId, place, standing = receiptSta
         lead,
         html `<p class="receipt-summary">${conciseOutcomeOf(view.summary ?? (view.outcome === "no-change" ? "The agent found that no repository change was needed." : "The build finished without a concise handoff."))}</p>`,
         headline ? html `<div class="receipt-actions"><a class="button-link" href="${resultHref}" data-open-result data-primary-action>${status.action?.label ?? "Open result"}</a></div>` : "",
-        // A pull request that couldn't open never undoes the result: an amber note, not red.
+        // A pull request that couldn't open never undoes the result: an ink note, not red.
         view.publication?.state === "failed" ? html `<p class="receipt-note">${statusIconSvg("note")} Pull request couldn't open. The commit is safe locally.</p>` : "",
         caveats,
         coverage,

package/dist/server/render-tasks.d.ts

@@ -122,6 +122,8 @@ export type ApprovalSheetInput = {
     freshSince?: string | null;
     /** Easy-start C5: a laptop's local owner — eligible (no password field), or why not and where to go. */
     localOwner?: LocalApprovalView | null;
+    /** A release filed while its pull request's checks still ran: the plan sheet says nothing deploys until they pass. */
+    releaseCiRunning?: boolean;
 };
 export type LocalApprovalView = {
     eligible: true;
@@ -147,7 +149,15 @@ export declare function approvalSheetParts(input: ApprovalSheetInput): {
     after: Html;
     allowing: string[];
     passwordNote: string;
+    /** The same terms as `lead`, `rows` and `details`, re-ordered to read top to bottom (`planSheetHtml`), nothing folded. */
+    sheet: Html;
+    /** The sheet's lead sentence (the approach's first sentence, else the goal), for a one-line summary of the plan. */
+    sheetLead: string;
 };
+/** The plan sheet: what an approval signs, read top to bottom (approvalSheetParts' own parts, re-ordered). */
+export declare function planSheetHtml(input: ApprovalSheetInput): Html;
+/** Evidence kinds on the plan sheet: how each requirement is proven, in plain words. */
+export declare const EVIDENCE_SHEET: Record<string, string>;
 /** Earlier versions of a task still in flight, in plain words: queued
  * while they only wait, running once one has started; null when none. */
 export declare function earlierVersionsWords(active: number, running: number): string | null;