toolroll 0.9.102 → 0.9.103

package/dist/server/home-asks.js

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

package/dist/server/home.d.ts

@@ -1,7 +1,7 @@
 /**
- * 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
+ * Home ("/", docs/plans/live-pages-and-home.md B1, home-other-asks.md): what needs this person, grouped by what is asked
+ * (Approve a release, Approve a plan, Answer a question, Flow decisions, Something went wrong, Review results, Finish
+ * setting up, and Needs you for the rest), each group with its exact count; one quiet line for what runs and waits; with nothing waiting, what runs and what finished today. The figures
  * are read from the same work index the Tasks list filters, so a count and the list it opens always agree. Reads
  * only: every act keeps its own route and rules (an agent's question is answered through POST /d/<id>/answer, the
  * same one-click act as its own page).
@@ -9,12 +9,15 @@
 import type { BrowserHomeAsk, BrowserHomeView } from "../browser-workspace.js";
 import type { Store } from "../store.js";
 import type { WorkSummaryAccess } from "../work-summary.js";
+import { type HomeAsks } from "./home-asks.js";
 /** How many waiting rows Home lists; each group says how many more open in Tasks. */
 export declare const HOME_NEEDS_SHOWN = 30;
 /** How many rows finished today Home lists; its figure counts them all. */
 export declare const HOME_DONE_SHOWN = 8;
 /** Each group's heading, in the order Home shows them. */
 export declare const HOME_ASK_LABEL: Readonly<Record<BrowserHomeAsk, string>>;
+/** The groups in Home's one order. */
+export declare const HOME_ASK_ORDER: readonly BrowserHomeAsk[];
 export type HomeFacts = {
     store: Store;
     now: Date;
@@ -31,6 +34,11 @@ export type HomeFacts = {
     chat: boolean;
     /** This person can answer an agent's question (an approver in a browser session). */
     canAnswer: boolean;
+    /** An approver in a browser session (default: `canAnswer`): a release is then read in Approve a release, never
+     * approved here; for anyone else it stays an ordinary task row. */
+    approver?: boolean;
+    /** What else waits on this person (home-asks.ts), already read through each page's own admission. */
+    asks?: HomeAsks;
     /** Why this task's plan can't take a yes right now (render-tasks.ts consentDoorOf), or null when it can. */
     closedDoor: (taskId: string) => {
         title: string;
@@ -44,8 +52,10 @@ export type HomeFacts = {
         at: string;
     } | null;
 };
-/** "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;
+/** "19 tasks need you", "3 tasks and 2 other things need you", "2 things need you": the heading, said once. Tasks
+ * are the same total as the rail's count; `others` are the rows that aren't tasks (a held publication, a flow card, a
+ * setup step). */
+export declare function homeSentence(needs: number, any: boolean, others?: number): string;
 /** The lead's words as one plain line: no markdown marks, no line breaks, cut to about one line. */
 export declare function leadLineOf(text: string): string;
 /** Midnight today on this computer's clock: "finished today" starts here. */

package/dist/server/home.js

@@ -1,9 +1,10 @@
 import { browserWorkActionHref } from "../browser-crew.js";
 import { NO_REASON_RECORDED } from "../needs-you.js";
 import { projectName } from "../project.js";
-import { WORK_ASK_GROUPS, workIndexPage } from "../work-index.js";
+import { workIndexPage } from "../work-index.js";
 import { oneLineOf, relativeAge } from "./chrome.js";
 import { taskHref } from "./http.js";
+import { NO_HOME_ASKS, releaseSheetHref } from "./home-asks.js";
 /** 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;
@@ -13,15 +14,21 @@ export const HOME_DONE_SHOWN = 8;
 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",
+    release: "Approve a release", approve: "Approve a plan", answer: "Answer a question", flow: "Flow decisions", wrong: "Something went wrong",
+    review: "Review results", setup: "Finish setting up", 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";
+/** The groups in Home's one order. */
+export const HOME_ASK_ORDER = ["release", "approve", "answer", "flow", "wrong", "review", "setup", "other"];
+/** "19 tasks need you", "3 tasks and 2 other things need you", "2 things need you": the heading, said once. Tasks
+ * are the same total as the rail's count; `others` are the rows that aren't tasks (a held publication, a flow card, a
+ * setup step). */
+export function homeSentence(needs, any, others = 0) {
+    const tasks = needs === 1 ? "1 task" : `${needs} tasks`;
+    if (others === 0)
+        return !any ? "No tasks yet" : needs === 0 ? "Nothing needs you" : `${tasks} ${needs === 1 ? "needs" : "need"} you`;
     if (needs === 0)
-        return "Nothing needs you";
-    return needs === 1 ? "1 task needs you" : `${needs} tasks need you`;
+        return others === 1 ? "1 thing needs you" : `${others} things need you`;
+    return `${tasks} and ${others} other ${others === 1 ? "thing" : "things"} need you`;
 }
 /** The lead's words as one plain line: no markdown marks, no line breaks, cut to about one line. */
 export function leadLineOf(text) {
@@ -38,7 +45,15 @@ export function leadLineOf(text) {
 export function startOfToday(now) {
     return new Date(now.getFullYear(), now.getMonth(), now.getDate());
 }
-function rowOf(store, item, now, multi, canAnswer, closedDoor, state) {
+function rowOf(store, item, now, multi, canAnswer, closedDoor, state, release) {
+    // A release (approvers): read on its own sheet, never approved here. Its line is its version, or why the sheet can't
+    // take a yes now; its one link opens the sheet.
+    if (state === "needs" && item.askGroup === "release" && release !== null) {
+        const href = releaseSheetHref(item.activeTaskId);
+        return { id: item.rootId, title: item.title, href, state, ask: "release", reason: null,
+            project: multi || item.repo === null ? (item.repo === null ? "Unplaced" : projectName(item.repo)) : null,
+            age: relativeAge(item.updatedAt, now), line: release(item.activeTaskId), action: { label: "Review the release", href }, question: null };
+    }
     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);
@@ -50,7 +65,8 @@ function rowOf(store, item, now, multi, canAnswer, closedDoor, state) {
         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 ask = state === "needs" ? item.askGroup ?? "other" : null;
+    // Anyone else reads a release as the plan it is.
+    const ask = state === "needs" ? (item.askGroup === "release" ? "approve" : 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.
@@ -101,21 +117,40 @@ export function homeView(facts) {
     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 approver = facts.approver ?? facts.canAnswer;
+    const asks = facts.asks ?? NO_HOME_ASKS;
+    // A held publication, a flow card and a setup step are an approver's alone (home-asks.ts reads them only for one).
+    const held = approver ? asks.held : [], flows = approver ? asks.flows : [];
+    // The builder step waits behind a task row that already asks for a builder: that row says it.
+    const setup = approver ? asks.setup.filter(one => one.key !== "builder" || needs.builderWaits === 0) : [];
+    const extra = [...held, ...flows, ...setup];
+    const multi = project === null && new Set([...yours, ...live, ...queued, ...done].map(one => one.repo ?? "").concat(extra.flatMap(one => one.repo === null ? [] : [one.repo]))).size > 1;
+    const row = (item, state) => rowOf(store, item, now, multi, facts.canAnswer, facts.closedDoor, state, approver ? asks.release : null);
     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);
+    const askRow = (one, ask) => ({ id: one.id, title: one.title, href: one.href, state: "needs", ask, reason: null,
+        project: multi && one.repo !== null ? projectName(one.repo) : null, age: one.at === null ? "" : relativeAge(one.at, now), line: one.line, action: one.action, question: null });
+    // Each group's count is exact over every row in view, not only those listed: the work index's total for a task ask
+    // (a release counted once, in its own group for an approver and as a plan for anyone else), and every other row.
+    const askTotals = {
+        release: (approver ? needs.asks.release : 0) + held.length, approve: needs.asks.approve + (approver ? 0 : needs.asks.release), answer: needs.asks.answer,
+        flow: flows.length, wrong: needs.asks.wrong, review: needs.asks.review, setup: setup.length, other: needs.asks.other,
+    };
+    const listedOf = {
+        release: [...rows.filter(one => one.ask === "release"), ...held.map(one => askRow(one, "release"))], approve: rows.filter(one => one.ask === "approve"),
+        answer: rows.filter(one => one.ask === "answer"), flow: flows.map(one => askRow(one, "flow")), wrong: rows.filter(one => one.ask === "wrong"),
+        review: rows.filter(one => one.ask === "review"), setup: setup.map(one => askRow(one, "setup")), other: rows.filter(one => one.ask === "other"),
+    };
+    const groups = HOME_ASK_ORDER.flatMap(key => {
+        const count = askTotals[key], listed = listedOf[key];
         return count === 0 && listed.length === 0 ? [] : [{ key, label: HOME_ASK_LABEL[key], count: Math.max(count, listed.length), rows: listed }];
     });
+    const others = extra.length;
     const any = totals.all > 0 || totals.completed > 0 || (totals.archived ?? 0) > 0;
     const lead = facts.chat ? facts.leadMessage ?? null : null;
     const leadText = lead === null ? "" : leadLineOf(lead.text);
     return {
         kind: "home",
-        say: homeSentence(totals["needs-you"], any),
+        say: homeSentence(totals["needs-you"], any, others),
         project,
         scopes: facts.projects.length < 2 ? null : [
             { key: "", label: "All projects", href: "/", active: project === null },
@@ -127,6 +162,6 @@ export function homeView(facts) {
         newTask: "/tasks/new",
         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." },
+        empty: any || others > 0 ? null : { title: "No tasks yet", text: "Describe a change in a sentence; an agent writes a plan for you to approve." },
     };
 }

package/dist/server/pages.js

@@ -11,7 +11,8 @@ import { realpathSync } from "node:fs";
 import {} from "node:http";
 import { homedir, hostname } from "node:os";
 import { basename, dirname, join, resolve } from "node:path";
-import { buildersFor } from "../dispatch.js";
+import { builderReadyFor, buildersFor, firstRunBuilderRepo } from "../dispatch.js";
+import { withBuilderStep } from "../first-run.js";
 import { listFolder, localOrigins } from "../folder-look.js";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
@@ -70,6 +71,7 @@ import { consentDoorOf, decisionAnswerScript, taskBody } from "./render-tasks.js
 import {} from "./session.js";
 import { rereadBrowser } from "./live.js";
 import { homeView } from "./home.js";
+import { flowAsks, releaseAsks, setupAsks } from "./home-asks.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, chatEnablement, leadPrincipal, leadConversationRows } = runtime;
@@ -204,8 +206,9 @@ export function createPagesHandlers(runtime) {
             return door.open ? null : door;
         };
         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 }),
+        const access = workAccess(), approver = who.role === "approver";
+        const view = { ...homeView({ store, now, access, evidenceRoot, project, projects, chat, canAnswer: approver, approver, closedDoor,
+                leadMessage: chat ? leadLastMessage(who, now) : null, asks: homeAsksFor(who, access, now, project) }),
             // 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 } }));
@@ -1226,5 +1229,14 @@ export function createPagesHandlers(runtime) {
         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 };
     }
+    /** What else waits on this person at Home (home-asks.ts): releases and held publications in the work index's own
+     * access, flow cards in the projects this person may pick (the Flows list's admission, each flow's project re-checked
+     * against the account), and the first-run steps with the builder step as Chat reads them. Approvers only. */
+    function homeAsksFor(who, access, now, project) {
+        const approver = who.role === "approver";
+        const steps = withBuilderStep(firstRunStepsNow(now), builderReadyFor(store, firstRunBuilderRepo(store, project, visible, runtime.managedRepos()), now));
+        return { ...releaseAsks(store, now, access, project, approver), flows: flowAsks(store, consoleProjects(), { name: who.name, approver }, project),
+            setup: setupAsks(steps, approver) };
+    }
     return { registrations, projectsScreen };
 }

package/dist/work-index.d.ts

@@ -27,7 +27,7 @@ export type WorkIndexItem = {
     ask: Ask | null;
     /** The row's chip under its group: the specific ask (needs-you.ts askChipOf), or none. */
     chip: AskChip | null;
-    /** What a Needs you row asks, in Home's five groups (ASK_GROUP_SQL); null for every other row. */
+    /** What a Needs you row asks, in Home's six groups (ASK_GROUP_SQL); null for every other row. */
     askGroup: WorkAskGroup | null;
     primaryAction: WorkAction | null;
     completion: {
@@ -65,18 +65,23 @@ export type WorkIndexOptions = {
 /** How the list is grouped: the Needs you rows by their ask, then building, then the rest. */
 export type WorkIndexGroup = Ask | 'building' | 'rest';
 export type WorkIndexGroupCounts = Record<WorkIndexGroup, number>;
-/** What a Needs you row asks, as Home groups it (docs/plans/live-pages-and-home.md B1.2): a plan to approve, a question
- * to answer, something that went wrong, a result to review, or anything else that needs the person. */
-export type WorkAskGroup = 'approve' | 'answer' | 'wrong' | 'review' | 'other';
+/** What a Needs you row asks, as Home groups it (docs/plans/live-pages-and-home.md B1.2): a release to approve, a plan
+ * to approve, a question to answer, something that went wrong, a result to review, or anything else that needs the
+ * person. A release is a plan to approve whose active task the plane's sealed state names a release (release-approval.ts
+ * releaseTaskOf, docs/plans/home-other-asks.md v2.1); a failed release is still something that went wrong and a
+ * release's result still a result to review. */
+export type WorkAskGroup = 'release' | 'approve' | 'answer' | 'wrong' | 'review' | 'other';
 export declare const WORK_ASK_GROUPS: readonly WorkAskGroup[];
 /** `asks`: the exact Needs you totals per ask group, over every row in view (never only the page). `completedSince`:
- * how many the Completed view lists from `options.completedSince` on (0 without it). */
+ * how many the Completed view lists from `options.completedSince` on (0 without it). `builderWaits`: how many Needs you
+ * rows wait for a builder to connect or start (no worker registered or none online). */
 export type WorkIndexPage = {
     items: WorkIndexItem[];
     totals: WorkIndexCounts;
     groups: WorkIndexGroupCounts;
     asks: Record<WorkAskGroup, number>;
     completedSince: number;
+    builderWaits: number;
     projects: WorkProjectCounts[];
     nextCursor: string | null;
     limit: number;

package/dist/work-index.js

@@ -21,13 +21,14 @@ import { withFollowUps } from './result-follow-ups.js';
 import { LANDED_ACTOR, landedReasonOf } from './result-completion.js';
 import { ASKS, CODE_READING, STORAGE_HOLD_PREFIX, NEED_ASK, NEEDS, askChipOf, failedAttemptSentence, isWaitCode, processNeedOf, resultHoldUpSentence } from './needs-you.js';
 import { retryWhenWords } from './dispatch.js';
+import { releaseTaskOf } from './release-approval.js';
 import { LEAD_CLAIM_SQL, LEAD_IDLE_MS } from './lead-voice.js';
-export const WORK_ASK_GROUPS = ['approve', 'answer', 'wrong', 'review', 'other'];
+export const WORK_ASK_GROUPS = ['release', 'approve', 'answer', 'wrong', 'review', 'other'];
 export const WORK_INDEX_PAGE_LIMIT = 40;
 export const WORK_INDEX_MAX_LIMIT = 100;
 const EMPTY = { all: 0, 'needs-you': 0, ready: 0, running: 0, queued: 0, completed: 0, archived: 0 };
 const NO_GROUPS = { decide: 0, review: 0, unblock: 0, building: 0, rest: 0 };
-const NO_ASKS = { approve: 0, answer: 0, wrong: 0, review: 0, other: 0 };
+const NO_ASKS = { release: 0, approve: 0, answer: 0, wrong: 0, review: 0, other: 0 };
 const FAMILY_PROBLEM = 'Task history is unavailable or incomplete. This task is shown separately.';
 const VIEWS = ['all', 'needs-you', 'ready', 'running', 'queued', 'completed', 'archived'];
 /** The family's current version is put away (v145): it waits on nobody and only the Archived view lists it. */
@@ -75,7 +76,7 @@ const ASK_RANK = `CASE WHEN code IN (${codesOf('decide')}) THEN 0 WHEN code IN (
 /** Home's ask group of a row, by its code alone, so a row's group and its group's count are one rule: a plan waiting
  * for its yes, a question, a build that failed or stopped unexpectedly, a saved result to review (ASK_RANK's Review),
  * and everything else that waits on a person. Read on Needs you rows only. */
-const ASK_GROUP_SQL = `CASE WHEN code='needs-approval' THEN 'approve' WHEN code IN ('waiting-decision','decision-queue') THEN 'answer'
+const ASK_GROUP_SQL = `CASE WHEN code='needs-approval' AND c.id IN (SELECT value FROM json_each($releaseTasks)) THEN 'release' WHEN code='needs-approval' THEN 'approve' WHEN code IN ('waiting-decision','decision-queue') THEN 'answer'
       WHEN code IN ('failed','waiting-incident','vanished-run') THEN 'wrong' WHEN code IN (${codesOf('review')}) AND NOT custody_unresolved THEN 'review' ELSE 'other' END`;
 /** Where a row sits in the list: Decide, Review, Unblock, then building, then the rest by recency. */
 const ORDER = `(CASE WHEN rank=0 THEN ask_rank WHEN rank=1 THEN 3 ELSE 4 END)`;
@@ -348,9 +349,17 @@ function custodyReadings(store) {
     }
     return { readings, workspace: new Set(noted) };
 }
-function parameters(now, access, options, custody) {
+/** The list can't read a release's sealed state in SQL: each queued task (the only state a plan waiting for a yes is in)
+ * whose scope carries a release form, kept only where release-approval.ts releaseTaskOf names it a release, the one
+ * rule the release sheet reads (never a title or a task id). */
+function releaseTaskIds(store) {
+    const sealed = store.handle.prepare(`SELECT s.task_id FROM task_scope s JOIN task t ON t.id=s.task_id
+    WHERE t.state='queued' AND (s.release_terms_json IS NOT NULL OR s.release_check_json IS NOT NULL)`).all().map(row => String(row['task_id']));
+    return JSON.stringify(sealed.filter(taskId => releaseTaskOf(store, taskId) !== null));
+}
+function parameters(store, now, access, options, custody) {
     const ids = (keep) => JSON.stringify([...custody.readings].filter(([ref, fact]) => keep(ref, fact)).map(([ref]) => ref));
-    return { $settledCustody: ids((_, fact) => fact === null), $waitingCustody: ids((_, fact) => fact !== null && 'wait' in (processNeedOf(fact) ?? {})),
+    return { $releaseTasks: releaseTaskIds(store), $settledCustody: ids((_, fact) => fact === null), $waitingCustody: ids((_, fact) => fact !== null && 'wait' in (processNeedOf(fact) ?? {})),
         $workspaceCustody: ids((ref, fact) => fact !== null && custody.workspace.has(ref)),
         $now: now.toISOString(), $alive: new Date(now.getTime() - 180_000).toISOString(),
         $all: access.repos === null ? 1 : 0, $repos: JSON.stringify(access.repos ?? []),
@@ -373,7 +382,8 @@ const GROUP_TOTALS = `COALESCE(SUM(rank=0 AND ask_rank=0 AND archived=0),0) deci
     + `COALESCE(SUM(rank=1 AND archived=0),0) building_count,COALESCE(SUM(rank>1 AND archived=0),0) rest_count`;
 /** The exact Needs you totals per ask group, and what was completed since the page's `completedSince`: page reads only. */
 const ASK_TOTALS = WORK_ASK_GROUPS.map(group => `COALESCE(SUM(needs AND ask_group='${group}'),0) ask_${group}_count`).join(',')
-    + `,COALESCE(SUM(code='complete' AND archived=0 AND $completedSince IS NOT NULL AND sort_at>=$completedSince),0) completed_since_count`;
+    + `,COALESCE(SUM(code='complete' AND archived=0 AND $completedSince IS NOT NULL AND sort_at>=$completedSince),0) completed_since_count`
+    + `,COALESCE(SUM(needs AND code IN ('no-worker-registered','no-worker-online')),0) builder_wait_count`;
 function askCounts(row) {
     return Object.fromEntries(WORK_ASK_GROUPS.map(group => [group, n(row, `ask_${group}_count`)]));
 }
@@ -438,7 +448,7 @@ function readWorkIndexPage(store, now, access, options, taskId = null) {
   )
   SELECT 0 record_kind,totals.*,(SELECT json_group_array(json_object('repo',repo,'all_count',all_count,'needs_count',needs_count,'ready_count',ready_count,
     'running_count',running_count,'queued_count',queued_count,'completed_count',completed_count,'archived_count',archived_count,'queued',queued,'done_recently',done_recently)) FROM project_totals) row_json FROM totals
-  UNION ALL SELECT 1,0,0,0,0,0,0,0,0,0,0,0,0,${WORK_ASK_GROUPS.map(() => '0,').join('')}0,json_object('archived',archived,'archived_by',(SELECT by FROM task_archive WHERE task_ref=page.ref_id),
+  UNION ALL SELECT 1,0,0,0,0,0,0,0,0,0,0,0,0,${WORK_ASK_GROUPS.map(() => '0,').join('')}0,0,json_object('archived',archived,'archived_by',(SELECT by FROM task_archive WHERE task_ref=page.ref_id),
     'archived_kind',(SELECT by_kind FROM task_archive WHERE task_ref=page.ref_id),'archived_reason',(SELECT reason FROM task_archive WHERE task_ref=page.ref_id),
     'archived_at',(SELECT at FROM task_archive WHERE task_ref=page.ref_id),'root_ref',root_ref,'root_id',root_id,'id',id,'root_title',root_title,'repo',repo,
     'state',state,'created_at',created_at,'family_updated',family_updated,'version_count',version_count,'earlier_active',earlier_active,
@@ -458,7 +468,7 @@ function readWorkIndexPage(store, now, access, options, taskId = null) {
     'agent_ask_run',(SELECT run FROM agent_question WHERE id=page.agent_ask),'agent_ask_text',(SELECT substr(question,1,300) FROM agent_question WHERE id=page.agent_ask),'replaced_by',(SELECT successor FROM task_replacement WHERE task_ref=page.ref_id),
     'completed_by_lead',(SELECT lead FROM task_act WHERE task_ref=page.root_ref AND act='completed' ORDER BY id DESC LIMIT 1),'machine_check',COALESCE(machine_check,0),
     'question_task',(SELECT r.external_id FROM decision d JOIN run ON run.id=d.run JOIN task_ref r ON r.id=run.task_ref WHERE d.id=page.question_id)) FROM page`)
-        .all({ ...parameters(now, access, options, custody), $taskId: taskId, $roots: options.roots === undefined ? null : JSON.stringify(options.roots), $cursorRoot: cursor?.root ?? 0, $cursorRank: cursor?.rank ?? 0, $cursorAt: cursor?.at ?? '', $limit: limit + 1, $completedSince: options.completedSince ?? null, $recent: new Date(now.getTime() - 86_400_000).toISOString() });
+        .all({ ...parameters(store, now, access, options, custody), $taskId: taskId, $roots: options.roots === undefined ? null : JSON.stringify(options.roots), $cursorRoot: cursor?.root ?? 0, $cursorRank: cursor?.rank ?? 0, $cursorAt: cursor?.at ?? '', $limit: limit + 1, $completedSince: options.completedSince ?? null, $recent: new Date(now.getTime() - 86_400_000).toISOString() });
     const selected = rows.slice(1).map(row => JSON.parse(String(row['row_json'])));
     const page = selected.slice(0, limit), last = page.at(-1);
     const nextCursor = selected.length > limit && last !== undefined ? Buffer.from(JSON.stringify({ version: 2, scope,
@@ -477,13 +487,13 @@ function readWorkIndexPage(store, now, access, options, taskId = null) {
     const readiness = (row, checks) => resultReadinessFacts(store, now, options.root, row, checks, memo);
     return { items: page.map(row => itemOf(row, access.principal, probe, leadName, readiness, options.root !== undefined, now)), projects, totals: rows[0] === undefined ? { ...EMPTY } : counts(rows[0]),
         groups: rows[0] === undefined ? { ...NO_GROUPS } : groupCounts(rows[0]), asks: rows[0] === undefined ? { ...NO_ASKS } : askCounts(rows[0]),
-        completedSince: rows[0] === undefined ? 0 : n(rows[0], 'completed_since_count'), nextCursor, limit, view };
+        completedSince: rows[0] === undefined ? 0 : n(rows[0], 'completed_since_count'), builderWaits: rows[0] === undefined ? 0 : n(rows[0], 'builder_wait_count'), nextCursor, limit, view };
 }
 export function workCountsByProject(store, now, access) {
     const projection = registerValidators(store);
     return store.handle.prepare(`${projection} SELECT repo,${TOTALS},SUM(state='queued' AND family_running=0 AND archived=0) queued,
     SUM(state='done' AND family_running=0 AND archived=0 AND updated_at>=$recent) done_recently FROM ranked GROUP BY repo ORDER BY repo`)
-        .all({ ...parameters(now, access, {}, custodyReadings(store)), $recent: new Date(now.getTime() - 86_400_000).toISOString() })
+        .all({ ...parameters(store, now, access, {}, custodyReadings(store)), $recent: new Date(now.getTime() - 86_400_000).toISOString() })
         .map(row => ({ repo: s(row, 'repo'), totals: counts(row), queued: n(row, 'queued'), doneRecently: n(row, 'done_recently') }));
 }
 export function workStateRows(store, now, access) {
@@ -495,7 +505,7 @@ export function workStateRows(store, now, access) {
         COALESCE((SELECT held_at FROM hold WHERE id=hold_id),''),COALESCE((SELECT requested_at FROM run_stop WHERE run=stop_run),'')),''),sort_at) ask_at,
       COALESCE(live_run,(SELECT run FROM decision WHERE id=question_id),(SELECT run FROM agent_question WHERE id=agent_ask)) ask_run,
       (SELECT json_group_array(m.ref_id) FROM members m WHERE m.root_ref=ranked.root_ref) members FROM ranked WHERE archived=0`)
-        .all(parameters(now, access, {}, custodyReadings(store)))
+        .all(parameters(store, now, access, {}, custodyReadings(store)))
         .map(row => ({ repo: s(row, 'repo'), rootId: String(row['root_id']), code: String(row['code']), needs: n(row, 'needs') === 1, personNeed: n(row, 'person_need') === 1,
         leadClaim: n(row, 'lead_claim') === 1, liveRun: row['live_run'] == null ? null : n(row, 'live_run'), unfinished: row['unfinished'] == null ? null : n(row, 'unfinished'),
         resultRun: row['result_id'] == null ? null : n(row, 'result_id'), waits: Number(row['rank']) === 2, version: String(row['version']), at: String(row['ask_at'] ?? ''), askRun: row['ask_run'] == null ? null : n(row, 'ask_run'), members: JSON.parse(String(row['members'] ?? '[]')).map(Number) }));
@@ -530,7 +540,7 @@ export function workOutcomeRows(store, now, access, project, since, limit) {
     (SELECT status FROM run_check WHERE run=f.result_id) check_status,
     COALESCE(a.runs,0) runs,COALESCE(a.api_runs,0) api_runs,a.api_microusd,COALESCE(a.subscription_runs,0) subscription_runs,a.subscription_usd
     FROM selected f LEFT JOIN attempts a ON a.root_ref=f.root_ref ORDER BY f.sort_at DESC,f.root_ref DESC`)
-        .all({ ...parameters(now, access, { project }, custodyReadings(store)), $since: since, $outcomeLimit: limit + 1 });
+        .all({ ...parameters(store, now, access, { project }, custodyReadings(store)), $since: since, $outcomeLimit: limit + 1 });
 }
 /** Families whose headline is Ready for review, newest first: the Tasks
  * list's own rows, so a completed family (root or any revision), a failed
@@ -783,7 +793,7 @@ export function workTidyRows(store, now, access) {
       (family_running OR live_lease IS NOT NULL OR unfinished IS NOT NULL OR custody_unresolved OR stop_run IS NOT NULL AND stop_settled IS NULL OR state='running') live,
       (SELECT json_group_array(m.ref_id) FROM members m WHERE m.root_ref=ranked.root_ref) members,
       (SELECT json_group_array(m.id) FROM members m WHERE m.root_ref=ranked.root_ref) member_ids FROM ranked`)
-        .all(parameters(now, access, {}, custodyReadings(store)))
+        .all(parameters(store, now, access, {}, custodyReadings(store)))
         .map(row => ({ rootId: String(row['root_id']), currentId: String(row['id']), title: String(row['root_title']), repo: s(row, 'repo'),
         state: String(row['state']), code: String(row['code']), live: n(row, 'live') === 1, archived: n(row, 'archived') === 1, broken: n(row, 'broken') === 1,
         updatedAt: String(row['family_updated'] ?? ''), members: JSON.parse(String(row['members'] ?? '[]')).map(Number),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolroll",
-  "version": "0.9.102",
+  "version": "0.9.103",
   "description": "A control plane for unattended coding agents — queue tasks, walk away, come back to pull requests. Agents build in leased worktrees, never touch your default branch, and interrupt you only for decisions that need a human.",
   "directories": {
     "doc": "docs"