toolroll 0.9.11 → 0.9.12

package/dist/setup-guide.d.ts

@@ -15,10 +15,10 @@ export declare function detectPreparation(repo: string): {
 } | null;
 /** Browser installation may write only this known file inside its project. */
 export declare function previewProjectInstructions(repo: string): {
-    content?: never;
     ok: false;
     message: string;
     plan?: never;
+    content?: never;
     fingerprint?: never;
     installed?: never;
 } | {
@@ -30,10 +30,10 @@ export declare function previewProjectInstructions(repo: string): {
     installed: boolean;
 };
 export declare function addProjectInstructions(repo: string, fingerprint: string): {
-    content?: never;
     ok: false;
     message: string;
     plan?: never;
+    content?: never;
     fingerprint?: never;
     installed?: never;
 } | import("./skills.js").InstallResult;

package/dist/store.js

@@ -657,6 +657,9 @@ export function isTelegramProgressNotification(row) {
         return false;
     if (row.kind === "build-failed" && row.run !== null && row.dedupeKey === `run:${row.run}:failed`)
         return true;
+    // The owner's lead took the attempt on, or let it lapse (lead-voice.ts): its card repaints in place.
+    if ((row.kind === "lead-on-it" || row.kind === "lead-lapsed") && row.run !== null)
+        return true;
     return isLifecycleNotification(row) &&
         ["run-started", "run-phase", "run-finished", "review-requested", "review-finished", "run-stopping", "run-stopped", "run-resumed", "task-held", "task-released"].includes(row.kind);
 }
@@ -22253,7 +22256,12 @@ export class Store {
             return true;
         if (row.recipient !== null && row.kind === "task-ask")
             return true;
+        // The lead's own words reach the person it speaks for, and its claim repaints only that person's card (lead-voice.ts).
+        if (row.kind === "lead-say")
+            return row.recipient === account;
         const actor = this.notificationActor(row.id);
+        if (row.kind === "lead-on-it" || row.kind === "lead-lapsed")
+            return actor?.lead === true && actor.account === account;
         if (actor !== null && actor.account === account)
             return false;
         if (row.recipient !== null)

package/dist/surface.js

@@ -194,7 +194,7 @@ export const COMMAND_GUIDE = [
         invocation: `assignment ${action}`,
         synopsis: action === "show" ? "read the root, current work, owner and exact receipt"
             : action === "updates" ? "read durable updates after a cursor; save nextCursor after processing"
-                : action === "claim" ? "record coordinator lead ownership; grants no approval or execution authority"
+                : action === "claim" ? "record lead ownership; with the lead token the task reads \"Your lead is on it\" and leaves Needs you until done, handed over, or 2 hours idle; grants no approval or execution authority"
                     : action === "brief" ? "catch up from current assignments and project knowledge in the local database"
                         : action === "inbox" ? "receive or replay a saved batch of lead status updates"
                             : action === "ack" ? "acknowledge delivery of an inbox batch; leaves task completion unchanged"
@@ -215,6 +215,13 @@ export const COMMAND_GUIDE = [
     })),
     operator("task state", "set a task's state by hand — an operator correction, not a workflow step (--replaced-by <id> with cancelled)"),
     operator("lead token", "mint the lead's credential behind your password (--revoke ends it): its own work pings nobody"),
+    { invocation: "lead say", synopsis: "as the lead: one short message in its person's chat from \"Your lead\"; several within two minutes are one message",
+        audience: "agent", agentMayInvoke: true, mutation: "unkeyed",
+        positionals: [{ name: "text", required: true, meaning: "one short line in plain words" }],
+        flags: [jsonFlag, dbFlag,
+            { name: "task", takesValue: true, meaning: "the task it is about" },
+            { name: "token", takesValue: true, meaning: "the lead token (or TOOLROLL_LEAD_TOKEN)" }],
+        notableReasons: ["usage", "unknown-task", "unauthenticated"] },
     { invocation: "task block", synopsis: "make one task wait for another", audience: "agent", agentMayInvoke: true, mutation: "keyed",
         positionals: [{ name: "id", required: true, meaning: "the waiting task" }],
         flags: [jsonFlag, dbFlag, keyFlag, { name: "on", takesValue: true, meaning: "the blocker's id" }],

package/dist/task-status.d.ts

@@ -107,8 +107,14 @@ export type TaskStatusFacts = {
     };
     /** Exact technical reasons, shown only on request. */
     why?: readonly string[];
+    /** The person's lead took this on (lead-voice.ts): "on-it" reads "Your lead is on it" and needs nobody; "lapsed"
+     * (two hours without a lead act) is back with the person, and says so. */
+    lead?: "on-it" | "lapsed" | null;
 };
 export declare function headlineOf(facts: Pick<TaskStatusFacts, "stage" | "checks" | "report">): Headline;
+/** What the lead's claim says, in place of "waits for you" (lead-voice.ts). */
+export declare const LEAD_ON_IT = "Your lead is on it.";
+export declare const LEAD_LAPSED = "Your lead hasn't acted on this for 2 hours, so it's back with you.";
 export declare function taskStatusOf(facts: TaskStatusFacts): TaskStatus;
 export declare function plainReasonOf(stage: TaskStage, code: string, detail: string | null | undefined): string | null;
 export declare function stageOfCode(code: string, options?: {

package/dist/task-status.js

@@ -133,13 +133,29 @@ function detailsOf(headline, facts) {
     }
     return rows;
 }
+/** What the lead's claim says, in place of "waits for you" (lead-voice.ts). */
+export const LEAD_ON_IT = "Your lead is on it.";
+export const LEAD_LAPSED = "Your lead hasn't acted on this for 2 hours, so it's back with you.";
+/** The headlines a lead's claim speaks for: the ones that would otherwise wait on a person. */
+const LEAD_HEADLINES = new Set(["Needs you", "Failed", "Ready for review", "Stopped"]);
+function leadSentence(headline, facts) {
+    const sha = short(facts.checks?.head ?? null);
+    // A failed check stays said: the claim changes who acts next, never the result.
+    if (headline === "Failed" && facts.checks?.status === "failed")
+        return `${facts.checks.level === "quick" ? "Quick checks" : "Checks"} failed${sha === null ? "" : ` on ${sha}`}. ${LEAD_ON_IT}`;
+    return LEAD_ON_IT;
+}
 export function taskStatusOf(facts) {
-    const headline = headlineOf(facts);
+    const read = headlineOf(facts);
+    const lead = facts.lead != null && LEAD_HEADLINES.has(read) ? facts.lead : null;
+    // The lead has it: nothing waits on the person, so a Needs you reads Waiting.
+    const headline = lead === "on-it" && read === "Needs you" ? "Waiting" : read;
     // Every Needs you carries the one action that resolves it, worded the same everywhere.
     const need = headline === "Needs you" ? { key: facts.need ?? "other", action: NEEDS[facts.need ?? "other"].action } : null;
     const ownWords = need !== null && (need.key === "other" || need.key === "review-result") && facts.action != null;
     const primaryAction = need === null || ownWords ? facts.action ?? null : { label: need.action.label, href: facts.action?.href ?? null };
-    return { headline, tone: HEADLINE_TONE[headline], sentence: sentenceOf(headline, facts), details: detailsOf(headline, facts),
+    const sentence = lead === "on-it" ? leadSentence(headline, facts) : lead === "lapsed" ? `${LEAD_LAPSED} ${sentenceOf(headline, facts)}` : sentenceOf(headline, facts);
+    return { headline, tone: HEADLINE_TONE[headline], sentence, details: detailsOf(headline, facts),
         primaryAction, why: [...new Set(facts.why ?? [])].filter(one => one.trim() !== ""), need };
 }
 // ---- reading the existing projections ----------------------------------------
@@ -287,6 +303,7 @@ export function assignmentStatusFacts(assignment, options = {}) {
         action: options.action ?? null,
         ...(options.links === undefined ? {} : { links: options.links }),
         why: options.why ?? [],
+        ...(assignment.lead == null ? {} : { lead: assignment.lead.state }),
     };
 }
 // ---- rendering helpers shared by the server pages and chat cards ------------

package/dist/team-cli.js

@@ -306,7 +306,7 @@ function render(reply, listing) {
 export async function maybeRunTeamCommand(argv, write, options = {}) {
     const command = argv[0];
     // `lead token` is local: the credential a lead agent acts with on this computer.
-    if (command === 'lead' && argv[1] === 'token')
+    if (command === 'lead' && (argv[1] === 'token' || argv[1] === 'say'))
         return null;
     if (!['connect', 'lead', 'conversation', 'chat', 'brief'].includes(command ?? '') && !argv.includes('--profile'))
         return null;

package/dist/telegram-progress.js

@@ -8,6 +8,7 @@ import { assignmentOf } from "./assignment.js";
 import { chatResultHref, chatControlHref } from "./chat-controls.js";
 import { phoneText, projectLabel } from "./telegram-status.js";
 import { assignmentStatusFacts, headlineEmoji, pullRequestFactOf, requirementsOf, statusDetailLines, taskStatusOf } from "./task-status.js";
+import { leadClaimOf } from "./lead-voice.js";
 import { chatTitle } from "./chat-voice.js";
 import { manualReviewOnly } from "./proof.js";
 import { failedCheckExit } from "./workspace-ui.js";
@@ -78,6 +79,12 @@ export function telegramProgressCard(store, run, taskId, project, now = new Date
     const completer = assignment?.completion?.actor.replace(/^(?:operator|coordinator|lead):/, "") ?? null;
     if (viewer !== undefined && facts.completedBy != null && (completer === viewer || facts.completedBy === viewer))
         facts = { ...facts, completedBy: null };
+    // The person's lead took it on: "Your lead is on it" rather than waiting for them (lead-voice.ts).
+    if (facts.lead === undefined) {
+        const lead = leadClaimOf(store, taskId, now, viewer);
+        if (lead !== null)
+            facts = { ...facts, lead: lead.state };
+    }
     const status = taskStatusOf(facts);
     const checkProgress = store.checkProgress(run.id);
     const progress = status.headline === "Building" && checkProgress !== null ? [`● ${checkProgress.line}`] : [];

package/dist/telegram.js

@@ -31,6 +31,7 @@ import { isLifecycleNotification, isTelegramProgressNotification, TELEGRAM_HOLD_
 import { telegramProgressCard } from "./telegram-progress.js";
 import { enqueueEveningDigests, finishedView, isTaskFact, joinsBatch, needsPerson, quietCardView } from "./chat-quiet.js";
 import { BATCH_MS, chatText, chatTitle, factLinkLabel, mentions, nameTelegramBot } from "./chat-voice.js";
+import { LEAD_SAY_KIND, enqueueLeadLapses, leadSayEarlier, leadSayText } from "./lead-voice.js";
 import { applyTeamInbound, deliverTeamChats, teamCommand } from "./telegram-team.js";
 import { applyFlowReply, applyFlowTap, FLOW_DECIDE_KEY, flowButtons, flowDecisionAt } from "./telegram-flow.js";
 import { connectChannel, FLOW_WORDS, takeChannelMessage, watchedChannel } from "./chat-inbox.js";
@@ -481,12 +482,13 @@ export async function followBridge(store, options) {
             // the picker first. Best effort; typed commands work either way.
             if (!commandsListed && options.conversation !== undefined) {
                 commandsListed = true;
+                // Both carry the stop signal: a stop never waits on a slow Bot API for them.
                 try {
-                    await transport("setMyCommands", { commands: TELEGRAM_COMMANDS });
+                    await transport("setMyCommands", { commands: TELEGRAM_COMMANDS }, signal);
                 }
                 catch { /* typed commands still work */ }
                 // After an upgrade, a bot still called StandingOrders becomes Toolroll, once per start; any other name is kept.
-                await nameTelegramBot(transport, "upgrade");
+                await nameTelegramBot(transport, "upgrade", signal);
             }
             const startedAt = Date.now();
             const report = { sent: 0, answered: 0, paired: 0, ignored: 0, backlog: false, problems: [] };
@@ -642,6 +644,8 @@ async function deliverOutbox(store, botId, transport, owner, clock, report, read
     catch {
         report.problems.push("evening digest could not be prepared");
     }
+    // A lead claim that went two hours quiet repaints its owner's card back to the task's real state.
+    enqueueLeadLapses(store, now);
     const digestDue = digest.everyMs === null || digest.lastSentAt === null || now.getTime() >= new Date(digest.lastSentAt).getTime() + digest.everyMs;
     // Every paired person is a destination of their own: each binding claims
     // and settles its own rows under its own ceiling, in turn.
@@ -914,8 +918,35 @@ async function deliverOutboxTo(store, botId, binding, transport, owner, clock, r
             }
             return fact.kind === "acceptance-evidence" ? imageSender(fact) : deliverOne(store, botId, binding, sender, fact, clock, phoneOrigin, evidenceRoot, projects);
         };
+        /** The lead's words (lead-voice.ts): one message; a later say within two minutes edits it in place. */
+        const leadSayOutcome = async (fact) => {
+            const words = leadSayText(fact);
+            const button = fact.link === null ? null : factButton(phoneOrigin, fact.link);
+            const keyboard = button === null ? [] : [button];
+            const earlier = leadSayEarlier(store, fact).map(id => store.telegramMessageOf(id, fact.destination)).find(one => one !== null) ?? null;
+            if (earlier !== null) {
+                const problem = (await readAccess()) ?? fence();
+                if (problem !== null)
+                    return { ok: false, error: problem };
+                const edited = await editProgress(transport, binding.chatId, earlier, words, keyboard);
+                if (edited.ok) {
+                    store.recordTelegramMessage(fact, binding, earlier, clock());
+                    const after = (await readAccess()) ?? fence();
+                    return after === null ? { ok: true, receipt: receiptFor(botId, binding.chatId, earlier) } : { ok: false, error: after };
+                }
+                if (edited.retryAfter !== undefined)
+                    store.deferTelegram(botId, new Date(clock().getTime() + edited.retryAfter * 1000).toISOString());
+                // Only Telegram's definitive missing/uneditable answer permits a new message.
+                if (!edited.replace)
+                    return edited;
+            }
+            const sent = await sender(words, keyboard.length === 0 ? undefined : keyboard, [fact]);
+            return sent.ok ? { ok: true, receipt: receiptFor(botId, binding.chatId, sent.messageId) } : sent;
+        };
         let outcome;
-        if (quiet && rows.length === 1 && isTaskFact(row))
+        if (rows.length === 1 && row.kind === LEAD_SAY_KIND)
+            outcome = await leadSayOutcome(row);
+        else if (quiet && rows.length === 1 && isTaskFact(row))
             outcome = await quietOutcome(row);
         else {
             // A failure or decision still gets its own alert. Refresh an existing

package/dist/test-temp.js

@@ -18,7 +18,7 @@ export const TEST_TEMP_PREFIXES = [
     "flow-goal-", "flow-scratch", "flows-chat-", "invoke-attest-", "knowledge-test-", "learning-", "peek-", "phone-origin-",
     "proposal-repo-", "race-", "refresh-migration-", "refresh-refusal-", "release-check-", "shared-chat-", "skills-test-",
     "task-status-surfaces-", "template-repo-", "template-test-", "v14-migrate-", "v17-migrate-", "watch-anchor-",
-    "needs-you-", "deps-lock-", "deps-state-", "upgrade-fresh-", "upgrade-path-",
+    "needs-you-", "deps-lock-", "deps-state-", "upgrade-fresh-", "upgrade-path-", "deploy-restore-", "result-review-",
     // Playwright's browser profiles and artifacts.
     "playwright_chromiumdev_profile-", "playwright_firefoxdev_profile-", "playwright-artifacts-",
 ];

package/dist/toolroll-update.d.ts

@@ -1,5 +1,6 @@
 import type { DatabaseSync } from "node:sqlite";
 import { type LingeringRun, type UpdateWaiting } from "./desktop-update.js";
+import { type ReleasedCodingOwner } from "./coding-update.js";
 import { type SupervisorRunner } from "./daemon.js";
 export declare const PROVENANCE_REPOSITORY = "https://github.com/ap9000/toolroll";
 export declare const PROVENANCE_WORKFLOW = ".github/workflows/publish.yml";
@@ -103,6 +104,8 @@ export type RuntimeUpdateJournal = {
     /** The restore put the backup back: a retried restore never puts it back again (what was written since belongs to
      * the restored version and would be lost), and it keeps a fresh copy aside before every attempt until then. */
     restoredDatabase?: boolean;
+    /** A stale coding owner record this run released after proving its processes gone. */
+    codingOwnerReleased?: ReleasedCodingOwner;
     seen?: boolean;
     /** The finished run the update is waiting on (or stopped waiting on): what is in the way and the command that
      * clears it. Absent while it waits on ordinary running work. */

package/dist/toolroll-update.js

@@ -31,7 +31,8 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 import { createRequire } from "node:module";
 import { clearWords, durableJson, LINGERING_LIMIT_MS, lingeringRun, lingeringWords, settleLeftoverRecords, sqliteLock, desktopUpdateWaitingOf, stoppedWaitingWords, updateWaitingWords, verifiedDatabaseBackup } from "./desktop-update.js";
 import { activeUpdateWork, freezeUpdateGate, installUpdateGate, removeUpdateGate, updateAdmissionPaused, updateGateOwned } from "./desktop-update-gate.js";
-import { assertCodingUpdateStopped, backupCodingCatalog, codingCatalogExists, removeCodingUpdateGate } from "./coding-update.js";
+import { processMayBeAlive } from "./process-liveness.js";
+import { assertCodingUpdateStopped, backupCodingCatalog, codingCatalogExists, releaseStaleCodingOwner, removeCodingUpdateGate } from "./coding-update.js";
 import { installLaunchdService, launchdPlist, stopLaunchdService, writeFileDurably } from "./daemon.js";
 import { NAME } from "./names.js";
 import { isNewer, REGISTRY } from "./releases.js";
@@ -887,6 +888,12 @@ async function driveRuntimeUpdate(j, system) {
             refuseWhileWatching(j, system);
             const db = new (sqlite().DatabaseSync)(j.databaseFile, { readOnly: true });
             try {
+                // An older runtime killed before its close left its owner record behind: released once its processes are proved gone.
+                const released = releaseStaleCodingOwner(db, [...j.service?.pids ?? [], ...(j.watches ?? []).flatMap(w => w.pids)], (pid, group) => system.processAlive(pid) || processMayBeAlive(pid, group));
+                if (released !== null) {
+                    j.codingOwnerReleased = released;
+                    ledger(j.databaseFile, system.now(), j.actor, "toolroll coding owner released", "released", `${j.from.version} stopped without releasing the coding workspace; process ${released.pid}${released.nativePid === null ? "" : ` and agent ${released.nativePid}`} proved gone`);
+                }
                 assertCodingUpdateStopped(db);
             }
             finally {
@@ -1392,7 +1399,11 @@ export function machineSystem(home = homedir(), env = process.env, seams = {}) {
         servicePids: async (unit) => {
             const printed = await supervise("launchctl", ["print", `${domain}/${labelOf(unit)}`]);
             const pid = Number(printed.stdout.match(/\n\s*pid = (\d+)/)?.[1]);
-            return printed.code === 0 && pid > 1 ? [pid] : [];
+            if (printed.code !== 0 || !(pid > 1))
+                return [];
+            // Its `up` child too: the process that owns the coding catalog, so its exit is proved as well.
+            const children = await supervise("pgrep", ["-P", String(pid)]);
+            return [pid, ...(children.code === 0 ? children.stdout.trim().split(/\s+/).map(Number).filter(one => Number.isSafeInteger(one) && one > 1) : [])];
         },
         stopService: async (unit) => {
             // As long as a watch's toolroll up takes to exit.

package/dist/work-index.d.ts

@@ -2,6 +2,7 @@ import { type Store, type TaskState } from './store.js';
 import type { AssignmentSnapshot } from './assignment.js';
 import type { WorkAction, WorkSummaryAccess } from './work-summary.js';
 import type { WorkStatus, WorkView } from './workspace-ui.js';
+import { type Ask } from './needs-you.js';
 export type WorkIndexCounts = Record<WorkView, number>;
 export type WorkIndexItem = {
     rootId: string;
@@ -22,6 +23,8 @@ export type WorkIndexItem = {
     resultOutcome: string | null;
     publicationUrl: string | null;
     status: WorkStatus;
+    /** What a Needs you row asks of a person (needs-you.ts); null for every other row. */
+    ask: Ask | null;
     primaryAction: WorkAction | null;
     completion: {
         actor: string;
@@ -38,9 +41,13 @@ export type WorkIndexOptions = {
     state?: TaskState;
     leadId?: string;
 };
+/** 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>;
 export type WorkIndexPage = {
     items: WorkIndexItem[];
     totals: WorkIndexCounts;
+    groups: WorkIndexGroupCounts;
     projects: WorkProjectCounts[];
     nextCursor: string | null;
     limit: number;
@@ -54,6 +61,8 @@ export type WorkProjectCounts = {
 };
 export declare const WORK_INDEX_PAGE_LIMIT = 40;
 export declare const WORK_INDEX_MAX_LIMIT = 100;
+/** A code's ask: a saved result is Review (unless its build may still run), otherwise its need's ask. */
+export declare function askOfCode(code: string, custody?: boolean): Ask;
 export declare class WorkIndexCursorError extends Error {
     constructor();
 }

package/dist/work-index.js

@@ -11,10 +11,12 @@ import { plainReasonOf, replacedWords, stageOfCode, taskStatusOf, workToneOf } f
 import { isCheckLevel } from './check-levels.js';
 import { MARKER } from './worktree.js';
 import { withFollowUps } from './result-follow-ups.js';
-import { NEEDS, processNeedOf } from './needs-you.js';
+import { ASKS, NEED_ASK, NEEDS, processNeedOf } from './needs-you.js';
+import { LEAD_CLAIM_SQL, LEAD_IDLE_MS } from './lead-voice.js';
 export const WORK_INDEX_PAGE_LIMIT = 40;
 export const WORK_INDEX_MAX_LIMIT = 100;
 const EMPTY = { all: 0, 'needs-you': 0, running: 0, completed: 0 };
+const NO_GROUPS = { decide: 0, review: 0, unblock: 0, building: 0, rest: 0 };
 const FAMILY_PROBLEM = 'Task history is unavailable or incomplete. This task is shown separately.';
 const VIEWS = ['all', 'needs-you', 'running', 'completed'];
 const n = (row, key) => Number(row[key] ?? 0);
@@ -25,6 +27,27 @@ const s = (row, key) => row[key] == null ? null : String(row[key]);
  * MATERIALIZED prevents counts + page selection repeating correlated reads. */
 /** A gate note counts only while its pause is on one of the task's current providers. */
 const GATE_PAUSE_ON_TASK = pauseOnTaskProviders('p', 'c.ref_id');
+/** Index codes that wait on a person, as their need (needs-you.ts); dispatch codes come from task-status's own table. */
+const INDEX_NEED = {
+    'earlier-active': 'earlier-version', 'process-needs-attention': 'confirm-stopped', 'invalid-scope': 'define-task', 'decision-queue': 'questions',
+};
+/** Every index code that can wait on a person. */
+const PERSON_CODES = ['history-problem', 'earlier-active', 'ready-to-check', 'waiting-decision', 'decision-queue', 'result-needs-attention',
+    'process-needs-attention', 'failed', 'vanished-run', 'stopping', 'stopped', 'held', 'waiting-incident', 'terminal-dependency', 'needs-project',
+    'needs-scope', 'invalid-scope', 'needs-agent-profile', 'needs-approval', 'missing-requirement', 'no-worker-registered', 'no-worker-online', 'signed-out'];
+/** A code's ask: a saved result is Review (unless its build may still run), otherwise its need's ask. */
+export function askOfCode(code, custody = false) {
+    if (custody)
+        return 'unblock';
+    if (code === 'ready-to-check' || code === 'result-needs-attention')
+        return 'review';
+    return NEED_ASK[INDEX_NEED[code] ?? stageOfCode(code, { needsPerson: true }).need ?? 'other'];
+}
+const codesOf = (ask) => PERSON_CODES.filter(code => askOfCode(code) === ask).map(code => `'${code}'`).join(',');
+/** The ask as its place in the list (ASKS order), read by the same code the row's status reads. */
+const ASK_RANK = `CASE WHEN code IN (${codesOf('decide')}) THEN 0 WHEN code IN (${codesOf('review')}) AND NOT custody_unresolved THEN 1 ELSE 2 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)`;
 /** A row whose build may still be running (the store's reading, custodyReadings): Waiting, not Needs you. */
 const CUSTODY_WAITS = `(custody_unresolved AND code IN ('process-needs-attention','result-needs-attention') AND ref_id IN (SELECT value FROM json_each($waitingCustody)))`;
 const PROJECTION = `WITH RECURSIVE admitted AS MATERIALIZED (
@@ -204,13 +227,18 @@ const PROJECTION = `WITH RECURSIVE admitted AS MATERIALIZED (
     WHEN deliverable='report' THEN 'scouting-ready'
     ELSE 'queued' END code
   FROM checked f
+), claimed AS MATERIALIZED (
+  SELECT c.*,CASE WHEN code IN ('cancelled','complete') THEN 0 ELSE ${LEAD_CLAIM_SQL} END lead_claim FROM classified c
 ), ranked AS MATERIALIZED (
-  SELECT c.*,code NOT IN ('cancelled','complete','running','updating','retry-scheduled','waiting-dependency','worker-at-capacity','planning-ready','scouting-ready','queued') AND NOT ${CUSTODY_WAITS} needs,
+  -- A task the person's lead is on (lead-voice.ts) waits on nobody: it leaves Needs you until the claim ends or lapses.
+  SELECT c.*,code NOT IN ('cancelled','complete','running','updating','retry-scheduled','waiting-dependency','worker-at-capacity','planning-ready','scouting-ready','queued') AND NOT ${CUSTODY_WAITS} AND lead_claim<>1 needs,
+    code NOT IN ('cancelled','complete','running','updating','retry-scheduled','waiting-dependency','worker-at-capacity','planning-ready','scouting-ready','queued') AND NOT ${CUSTODY_WAITS} person_need,
     CASE WHEN code='complete' THEN 3 WHEN code='cancelled' THEN 4 WHEN code='running' THEN 1
       WHEN ${CUSTODY_WAITS} OR code IN ('updating','retry-scheduled','waiting-dependency','worker-at-capacity','planning-ready','scouting-ready','queued') THEN 2 ELSE 0 END rank,
+    ${ASK_RANK} ask_rank,
     CASE WHEN code='complete' THEN completed.at ELSE family_updated END sort_at,
     completed.actor checked_actor,completed.at checked_at,completed.outcome checked_digest
-  FROM classified c LEFT JOIN action_ledger completed ON completed.id=c.checked_id WHERE ($state IS NULL OR c.state=$state) AND ($leadId IS NULL OR EXISTS(SELECT 1 FROM team_task_owner own WHERE own.task_ref=c.root_ref AND own.lead=$leadId))
+  FROM claimed c LEFT JOIN action_ledger completed ON completed.id=c.checked_id WHERE ($state IS NULL OR c.state=$state) AND ($leadId IS NULL OR EXISTS(SELECT 1 FROM team_task_owner own WHERE own.task_ref=c.root_ref AND own.lead=$leadId))
 )`;
 const registered = new WeakMap();
 /** Connection-local pure parsing, with exactly the authoritative stored-scope
@@ -277,12 +305,19 @@ function parameters(now, access, options, custody) {
         $now: now.toISOString(), $alive: new Date(now.getTime() - 180_000).toISOString(),
         $all: access.repos === null ? 1 : 0, $repos: JSON.stringify(access.repos ?? []),
         $unplaced: access.principal === 'operator' && access.includeUnplaced === true ? 1 : 0,
-        $projectSet: options.project != null ? 1 : 0, $project: options.project ?? null, $state: options.state ?? null, $leadId: options.leadId ?? null };
+        $projectSet: options.project != null ? 1 : 0, $project: options.project ?? null, $state: options.state ?? null, $leadId: options.leadId ?? null,
+        $leadIdleSince: new Date(now.getTime() - LEAD_IDLE_MS).toISOString(),
+        $leadOf: access.principal === 'operator' && access.viewer != null && access.viewer !== '' ? `lead for ${access.viewer}` : null };
 }
 function counts(row) {
     return { all: n(row, 'all_count'), 'needs-you': n(row, 'needs_count'), running: n(row, 'running_count'), completed: n(row, 'completed_count') };
 }
 const TOTALS = `COUNT(*) all_count,COALESCE(SUM(needs),0) needs_count,COALESCE(SUM(family_running),0) running_count,COALESCE(SUM(code='complete'),0) completed_count`;
+const GROUP_TOTALS = `COALESCE(SUM(rank=0 AND ask_rank=0),0) decide_count,COALESCE(SUM(rank=0 AND ask_rank=1),0) review_count,COALESCE(SUM(rank=0 AND ask_rank=2),0) unblock_count,`
+    + `COALESCE(SUM(rank=1),0) building_count,COALESCE(SUM(rank>1),0) rest_count`;
+function groupCounts(row) {
+    return { decide: n(row, 'decide_count'), review: n(row, 'review_count'), unblock: n(row, 'unblock_count'), building: n(row, 'building_count'), rest: n(row, 'rest_count') };
+}
 export class WorkIndexCursorError extends Error {
     constructor() { super('This work page cursor is invalid or belongs to a different view.'); this.name = 'WorkIndexCursorError'; }
 }
@@ -299,7 +334,7 @@ function readCursor(value, scope) {
         if (value.length > 1024 || !/^[\w-]+$/.test(value))
             throw Error();
         const c = JSON.parse(Buffer.from(value, 'base64url').toString());
-        if (c.version !== 1 || c.scope !== scope || !Number.isSafeInteger(c.rank) || c.rank < 0 || c.rank > 4 ||
+        if (c.version !== 2 || c.scope !== scope || !Number.isSafeInteger(c.rank) || c.rank < 0 || c.rank > 4 ||
             !Number.isSafeInteger(c.root) || c.root < 1 || typeof c.at !== 'string' || !/^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d\.\d{3}Z$/.test(c.at))
             throw Error();
         return c;
@@ -323,16 +358,16 @@ export function workIndexPage(store, now, access, options = {}) {
     const scope = cursorScope(access, options, view), cursor = readCursor(options.cursor, scope);
     const filter = view === 'needs-you' ? 'needs=1' : view === 'running' ? 'family_running=1' : view === 'completed' ? "code='complete'" : '1';
     const rows = store.handle.prepare(`${projection}, selected_page AS MATERIALIZED (
-    SELECT * FROM ranked WHERE ${filter} AND ($cursorRoot=0 OR rank>$cursorRank OR
-      (rank=$cursorRank AND (sort_at<$cursorAt OR (sort_at=$cursorAt AND root_ref<$cursorRoot))))
-    ORDER BY rank,sort_at DESC,root_ref DESC LIMIT $limit
-  ), page AS (SELECT p.*,COALESCE(p.result_id,(SELECT id FROM run WHERE task_ref=p.ref_id AND finished_at IS NOT NULL AND role IN ('builder','scout') ORDER BY id DESC LIMIT 1)) page_result_id FROM selected_page p), totals AS (SELECT ${TOTALS} FROM ranked), project_totals AS (
+    SELECT * FROM ranked WHERE ${filter} AND ($cursorRoot=0 OR
+      ${ORDER}>$cursorRank OR (${ORDER}=$cursorRank AND (sort_at<$cursorAt OR (sort_at=$cursorAt AND root_ref<$cursorRoot))))
+    ORDER BY ${ORDER},sort_at DESC,root_ref DESC LIMIT $limit
+  ), page AS (SELECT p.*,COALESCE(p.result_id,(SELECT id FROM run WHERE task_ref=p.ref_id AND finished_at IS NOT NULL AND role IN ('builder','scout') ORDER BY id DESC LIMIT 1)) page_result_id FROM selected_page p), totals AS (SELECT ${TOTALS},${GROUP_TOTALS} FROM ranked), project_totals AS (
     SELECT repo,${TOTALS},SUM(state='queued' AND family_running=0) queued,
       SUM(state='done' AND family_running=0 AND updated_at>=$recent) done_recently FROM ranked GROUP BY repo
   )
   SELECT 0 record_kind,totals.*,(SELECT json_group_array(json_object('repo',repo,'all_count',all_count,'needs_count',needs_count,
     'running_count',running_count,'completed_count',completed_count,'queued',queued,'done_recently',done_recently)) FROM project_totals) row_json FROM totals
-  UNION ALL SELECT 1,0,0,0,0,json_object('root_ref',root_ref,'root_id',root_id,'id',id,'root_title',root_title,'repo',repo,
+  UNION ALL SELECT 1,0,0,0,0,0,0,0,0,0,json_object('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,
     'earlier_id',earlier_id,'broken',broken,'live_run',live_run,'result_id',page_result_id,'result_outcome',(SELECT outcome FROM run WHERE id=page_result_id),
     'publication_url',(SELECT pr_url FROM publication WHERE run=page_result_id),
@@ -342,7 +377,7 @@ export function workIndexPage(store, now, access, options = {}) {
     'check_follows',(SELECT json_group_array(q.outcome||' '||COALESCE((SELECT substr(f.outcome,instr(f.outcome,':')+1) FROM action_ledger f WHERE f.repo IS page.repo AND f.run_id=page_result_id
       AND f.action='checks finished' AND f.outcome LIKE q.id||':%' LIMIT 1),'open')) FROM (SELECT id,outcome FROM action_ledger WHERE repo IS page.repo AND run_id=page_result_id AND action='checks requested' ORDER BY id) q),
     'proof_verdict',(SELECT COALESCE(machine_verdict,verdict) FROM proof_verdict WHERE run=page_result_id),
-    'proof_failed_check',(SELECT verdict='refuted' AND reasons_json LIKE '%approved verification command exited%' FROM proof_verdict WHERE run=page_result_id),'code',code,'needs',needs,'family_running',family_running,'rank',rank,'sort_at',sort_at,
+    'proof_failed_check',(SELECT verdict='refuted' AND reasons_json LIKE '%approved verification command exited%' FROM proof_verdict WHERE run=page_result_id),'code',code,'needs',needs,'person_need',person_need,'lead_claim',lead_claim,'family_running',family_running,'rank',rank,'ask_rank',ask_rank,'list_order',${ORDER},'sort_at',sort_at,
     'checked_actor',checked_actor,'checked_at',checked_at,'checked_digest',checked_digest,'question_id',question_id,
     'dependency_id',dependency_id,'dependency_state',dependency_state,'custody_unresolved',custody_unresolved,'hold_kind',hold_kind,'hold_reason',substr(hold_reason,1,300),'stop_run',stop_run,'unfinished',unfinished,'signed_out',signed_out,
     'question_run',(SELECT run FROM decision WHERE id=page.question_id),'replaced_by',(SELECT successor FROM task_replacement WHERE task_ref=page.ref_id),
@@ -351,15 +386,16 @@ export function workIndexPage(store, now, access, options = {}) {
         .all({ ...parameters(now, access, options, custody), $cursorRoot: cursor?.root ?? 0, $cursorRank: cursor?.rank ?? 0, $cursorAt: cursor?.at ?? '', $limit: limit + 1, $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: 1, scope,
-        rank: n(last, 'rank'), at: s(last, 'sort_at'), root: n(last, 'root_ref') })).toString('base64url') : null;
+    const nextCursor = selected.length > limit && last !== undefined ? Buffer.from(JSON.stringify({ version: 2, scope,
+        rank: n(last, 'list_order'), at: s(last, 'sort_at'), root: n(last, 'root_ref') })).toString('base64url') : null;
     const projects = JSON.parse(String(rows[0]?.['row_json'] ?? '[]')).map(row => ({ repo: s(row, 'repo'), totals: counts(row), queued: n(row, 'queued'), doneRecently: n(row, 'done_recently') }));
     // A row whose build Toolroll can't confirm stopped reads the store's own answer, as the task page does.
     const probe = (taskId) => {
         const ref = store.lookupRef(taskId);
         return ref === null ? null : custody.readings.get(ref.id) ?? null;
     };
-    return { items: page.map(row => itemOf(row, access.principal, probe)), projects, totals: rows[0] === undefined ? { ...EMPTY } : counts(rows[0]), nextCursor, limit, view };
+    return { items: page.map(row => itemOf(row, access.principal, probe)), projects, totals: rows[0] === undefined ? { ...EMPTY } : counts(rows[0]),
+        groups: rows[0] === undefined ? { ...NO_GROUPS } : groupCounts(rows[0]), nextCursor, limit, view };
 }
 export function workCountsByProject(store, now, access) {
     const projection = registerValidators(store);
@@ -404,16 +440,15 @@ function listChecksOf(own, level, follows) {
         return null;
     return { status: read.status, exitCode: null, head: null, level: read.level, running: read.running };
 }
-/** Index codes that wait on a person, as their need (needs-you.ts); dispatch codes come from task-status's own table. */
-const INDEX_NEED = {
-    'earlier-active': 'earlier-version', 'process-needs-attention': 'confirm-stopped', 'invalid-scope': 'define-task', 'decision-queue': 'questions',
-};
 function itemOf(row, principal, probe) {
     const code = String(row['code']), id = String(row['id']);
     const custody = code === 'process-needs-attention' || (code === 'result-needs-attention' && n(row, 'custody_unresolved') === 1);
     const process = custody && probe !== undefined ? processNeedOf(probe(id)) : null;
     const waiting = process !== null && 'wait' in process;
     const need = n(row, 'needs') === 1 && !waiting, running = n(row, 'family_running') === 1;
+    // The lead's claim (lead-voice.ts): the row still reads its own stage, worded "Your lead is on it".
+    const lead = n(row, 'lead_claim') === 1 ? 'on-it' : n(row, 'lead_claim') === 2 ? 'lapsed' : null;
+    const personNeed = (n(row, 'person_need') === 1 || need) && !waiting;
     const assignmentState = code === 'complete' ? 'complete' : code === 'ready-to-check' ? 'ready-to-check'
         : code === 'cancelled' ? 'cancelled' : need ? 'needs-decision' : 'working';
     const words = {
@@ -499,7 +534,7 @@ function itemOf(row, principal, probe) {
         access: read ? 'read' : principal === 'operator' ? 'operator-control' : ['answer-decision', 'write-scope', 'unhold'].includes(actionCode) ? 'proposal-only' : 'operator-handoff',
         retry: actionCode === 'reconcile-run' ? 'reconcile-before-retry' : read ? 'read-again' : 'refresh-before-acting' };
     // The one shared status: the headline and sentence every surface uses.
-    const coded = stageOfCode(code, { needsPerson: need, planning: s(row, 'live_role') === 'planner', operatorHold: s(row, 'hold_kind') === 'operator' });
+    const coded = stageOfCode(code, { needsPerson: personNeed, planning: s(row, 'live_role') === 'planner', operatorHold: s(row, 'hold_kind') === 'operator' });
     const reading = process !== null
         ? 'wait' in process ? { stage: 'waiting', wait: process.wait } : { stage: 'needs-you', need: process.need }
         : custody ? { stage: 'needs-you', need: 'confirm-stopped' }
@@ -511,7 +546,8 @@ function itemOf(row, principal, probe) {
         ...(process === null ? {} : { needContext: { build: process.build } }),
         reason: finished ? null : plainReasonOf(reading.stage, code, detail || null), report: s(row, 'result_role') === 'scout',
         checks: !finished ? null : listChecksOf(own, s(row, 'check_level'), row['check_follows']),
-        completedBy: code !== 'complete' ? null : n(row, 'completed_by_lead') === 1 ? 'the lead' : String(row['checked_actor']).replace(/^(?:operator|coordinator|lead):/, '') });
+        completedBy: code !== 'complete' ? null : n(row, 'completed_by_lead') === 1 ? 'the lead' : String(row['checked_actor']).replace(/^(?:operator|coordinator|lead):/, ''),
+        ...(lead === null ? {} : { lead }) });
     label = shared.headline;
     detail = shared.sentence;
     // Every Needs you action wears its need's own words.
@@ -533,6 +569,7 @@ function itemOf(row, principal, probe) {
         resultOutcome: s(row, 'result_outcome'), publicationUrl: s(row, 'publication_url'),
         status: { token: `assignment-${assignmentState}`, label, detail, tone: workToneOf(shared.headline),
             action: primaryAction === null ? null : { label: actionLabel, kind: actionCode === 'open-result' ? 'open-result' : 'open-task' }, views, rank: n(row, 'rank') },
+        ask: need ? ASKS[n(row, 'ask_rank')] ?? 'unblock' : null,
         primaryAction, completion: code === 'complete' ? { actor: String(row['checked_actor']), at: String(row['checked_at']), digest: String(row['checked_digest']) } : null,
         evidence: 'recorded' };
 }

package/dist/work-summary.d.ts

@@ -41,10 +41,13 @@ export declare function openWorkDecisionOf(store: Store, taskRef: number, now: D
 export declare function workDecisionAction(taskId: string, decision: NonNullable<WorkFacts["openDecision"]>, principal: WorkPrincipal): WorkAction;
 /** Pure counterpart for callers already holding the same facts. */
 export declare function workSummaryOf(facts: WorkFacts, principal: WorkPrincipal, resultDisplay?: DisplayStatus): WorkSummary;
-export type WorkSummaryAccess = {
+export type WorkSummaryAccess = 
+/** `viewer`: the person reading, whose own lead's claim (lead-voice.ts) a task reads as "Your lead is on it". */
+{
     principal: "operator";
     repos: readonly string[] | null;
     includeUnplaced?: boolean;
+    viewer?: string | null;
 } | {
     principal: "coordinator";
     repos: readonly string[];

package/dist/workspace-ui.d.ts

@@ -190,6 +190,31 @@ export declare function dispatchActionLabel(dispatch: DispatchDiagnosis | null):
 /** A finished result's display status in the shared headline's words: a
  * failed project check is Failed, a result missing its record needs a
  * person, every other saved result is Ready for review. Token and action stay. */
+/** The result page's own sentence when the decision is on it. */
+export declare const RESULT_DECISION_SENTENCE = "Review the change, then accept it or ask for changes.";
+/** What the result page's Accept says, from facts it already shows: the
+ * recorded checks, the requirements not met, the ones a person still checks,
+ * whether the saved proof reads, and what the button posts. "Accept" only when everything is met and the
+ * checks passed; otherwise "Accept without checks" and one line naming what.
+ * `effect` says what pressing it does, in the action's own terms. */
+export type AcceptFacts = {
+    checks: "passed" | "failed" | "not-run" | "off" | "running" | "unavailable" | null;
+    unmet: number;
+    yours: number;
+    /** `complete`: marks the exact result complete; `accept`: records a person's acceptance only. */
+    action: "complete" | "accept";
+    /** `pull-request`: one can be opened from the task after; `off`: publishing isn't set up; `other`: neither is said. Accept itself never publishes. */
+    publishing: "pull-request" | "off" | "other";
+    /** False when the saved proof is missing or can't be read: nothing on record says what was met. */
+    proof: boolean;
+};
+export type AcceptWords = {
+    label: "Accept" | "Accept without checks";
+    ready: boolean;
+    why: string | null;
+    effect: string;
+};
+export declare function acceptWordsOf(facts: AcceptFacts): AcceptWords;
 export declare function resultHeadlineOf<T extends DisplayStatus>(status: T): T;
 /** The one shared headline (task-status.ts) over the work status below: the
  * token, views, rank, action and diagnostics stay; the words and tone are

package/dist/workspace-ui.js

@@ -195,7 +195,7 @@ function storedResultStatusOf(result, publication) {
         };
     }
     if (result.verdict === "short" && humanReview) {
-        return { token: "verification-needed", label: "Ready to inspect", detail: withPublication("The remaining requirements need a person's inspection. Open the result and record your decision."), tone: "attention", action: { label: "Inspect the result", kind: "open-review" } };
+        return { token: "verification-needed", label: "Ready to inspect", detail: withPublication("The remaining requirements need a person's inspection."), tone: "attention", action: { label: "Inspect the result", kind: "open-review" } };
     }
     if (result.verdict === "short") {
         return {
@@ -312,6 +312,25 @@ const VERIFIED_RESULT = new Set(["ready-to-review", "pr-opened", "merge-observed
 /** A finished result's display status in the shared headline's words: a
  * failed project check is Failed, a result missing its record needs a
  * person, every other saved result is Ready for review. Token and action stay. */
+/** The result page's own sentence when the decision is on it. */
+export const RESULT_DECISION_SENTENCE = "Review the change, then accept it or ask for changes.";
+export function acceptWordsOf(facts) {
+    const plural = (n, one, many) => `${n} ${n === 1 ? one : many}`;
+    const parts = [
+        ...(facts.proof ? [] : ["nothing on record says what was met"]),
+        ...(facts.checks === "passed" ? [] : [facts.checks === "failed" ? "checks failed" : facts.checks === "off" ? "checks are off for this project"
+                : facts.checks === "running" ? "checks are still running" : facts.checks === "unavailable" ? "saved checks can't be read" : "checks didn't run"]),
+        ...(facts.unmet > 0 ? [`${plural(facts.unmet, "requirement isn't", "requirements aren't")} met`] : []),
+        ...(facts.yours > 0 ? [`${plural(facts.yours, "item still needs", "items still need")} your check`] : []),
+    ];
+    const ready = parts.length === 0;
+    const joined = parts.length <= 1 ? parts.join("") : `${parts.slice(0, -1).join(", ")} and ${parts.at(-1)}`;
+    const effect = facts.action === "accept" ? "Records that you accept it. You mark it complete next."
+        : facts.publishing === "pull-request" ? "Marks it complete. No pull request opens; you can open one from the task after."
+            : facts.publishing === "off" ? "Marks it complete. The branch stays; publishing isn't set up."
+                : "Marks it complete. Nothing is published.";
+    return { label: ready ? "Accept" : "Accept without checks", ready, why: ready ? null : `${joined.charAt(0).toUpperCase()}${joined.slice(1)}.`, effect };
+}
 export function resultHeadlineOf(status) {
     const read = RESULT_NEEDS_YOU.has(status.token) ? { stage: "needs-you", need: "other" }
         : status.token === "checks-failed" ? { stage: "failed" } : { stage: "finished" };