toolroll 0.9.14 → 0.9.16

package/dist/slack-chat.js

@@ -1,5 +1,6 @@
 import { chatFlowButtons } from "./chat-flow.js";
 import { chatQuestionButtons } from "./teammate-question.js";
+import { chatAskButtons } from "./chat-ask.js";
 import { channelInbox } from "./chat-inbox.js";
 import { roomCommand } from "./chat-rooms.js";
 import { processChatEvent, applyChatAction, planChatNotifications, channelAccess, planRoomMessages, } from "./chat-delivery.js";
@@ -359,8 +360,17 @@ export async function deliverSlackPart(options) {
                         value: one.token,
                     }))
                     : []),
+                // The lead's question to its owner: its options, then "Something else".
+                ...(content.ask
+                    ? chatAskButtons(state, row.id, now).map((one) => ({
+                        type: "button",
+                        text: { type: "plain_text", text: one.label },
+                        action_id: one.words ? "toolroll_question_words" : "toolroll_question_choice",
+                        value: one.token,
+                    }))
+                    : []),
                 ...linkButton(options.origin(), content.link),
-                // [Look first] beside [Merge] or [Mark complete]: each button's own action id.
+                // [Look first] beside [Merge] or [Accept and finish]: each button's own action id.
                 ...(content.also ?? []).flatMap((one, index) => linkButton(options.origin(), one).map(button => ({ ...button, action_id: `toolroll_link_${index + 2}` }))),
             ];
         const target = content.edit ?? row.message;

package/dist/store.d.ts

@@ -21,6 +21,10 @@ import { type RetentionKind, type RetentionPeriods } from "./retention.js";
 import { type CheckoutCleanup } from "./storage.js";
 import { type LedgerChainReport } from "./ledger-chain.js";
 import { type ApprovalGate, type ApprovalRules, type ApproverKind, type Filer } from "./approval-policy.js";
+/** What the lead promised to follow up on (lead-commitments.ts; no version bump: additive only, so a build that
+ * predates it still opens the store). `condition_json` is a task, attempt, check or time; `check_at` is when to look
+ * next; `channel` is where it reports (`chat`: the conversation it was promised in); a promise lapses at `expires_at`. */
+export declare const LEAD_COMMITMENT_SCHEMA = "\nCREATE TABLE IF NOT EXISTS lead_commitment (\n  id             INTEGER PRIMARY KEY AUTOINCREMENT,\n  owner          TEXT NOT NULL,\n  repo           TEXT,\n  thread         INTEGER NOT NULL,\n  turn           INTEGER,\n  channel        TEXT NOT NULL DEFAULT 'chat',\n  what           TEXT NOT NULL,\n  condition_json TEXT NOT NULL,\n  check_at       TEXT NOT NULL,\n  expires_at     TEXT NOT NULL,\n  state          TEXT NOT NULL DEFAULT 'open' CHECK (state IN ('open', 'done', 'cancelled', 'expired')),\n  created_at     TEXT NOT NULL,\n  checked_at     TEXT,\n  closed_at      TEXT,\n  closed_by      TEXT,\n  outcome        TEXT\n);\nCREATE INDEX IF NOT EXISTS lead_commitment_due ON lead_commitment (state, check_at);\nCREATE INDEX IF NOT EXISTS lead_commitment_owner ON lead_commitment (owner, state, id);\n";
 /** What stops a finished run reading stopped (Store.stopQuiescenceFact). */
 export type StopFactKind = "open" | "alive" | "elsewhere" | "unprovable" | "unknown";
 export type TaskAct = "filed" | "approved" | "cancelled" | "completed" | "asked";
@@ -39,6 +43,20 @@ export type TaskActRow = {
     why: string | null;
     at: string;
 };
+/** The lead's one question to its owner (no version bump): at most one per answered turn, two to four short options;
+ * "Something else" is implied. The tapped option comes back as the owner's next message, so nothing here is an answer:
+ * a question is open while no later message from the owner sits in its thread. */
+export declare const MATE_ASK_SCHEMA = "\nCREATE TABLE IF NOT EXISTS mate_ask (\n  turn         INTEGER PRIMARY KEY REFERENCES mate_turn(id) ON DELETE CASCADE,\n  thread       INTEGER NOT NULL REFERENCES mate_thread(id) ON DELETE CASCADE,\n  question     TEXT NOT NULL,\n  options_json TEXT NOT NULL,\n  created_at   TEXT NOT NULL\n);\nCREATE INDEX IF NOT EXISTS mate_ask_thread ON mate_ask (thread, turn);\n";
+export type MateAsk = {
+    turn: number;
+    thread: number;
+    question: string;
+    options: string[];
+    createdAt: string;
+};
+export declare const MATE_ASK_OTHER = "Something else";
+/** How long the question's buttons work, on every channel. */
+export declare const MATE_ASK_TTL_MS: number;
 /** Settings → Integrations (no version bump): each integration's last check. `outcome` is ok, failed, or absent (the check found
  * nothing set up, such as no `gh` sign-in). `ok_at` and `error`/`error_at` keep the last success and the last
  * failure across checks, so a row can say both. `account` is a display name only, never a credential. */
@@ -1532,6 +1550,7 @@ export type TelegramConversationPartPlan = {
     kind: "reply";
     text: string;
     replyTo?: string | null;
+    keyboard?: TelegramConversationPart["keyboard"];
 } | {
     kind: "card";
     text: string;
@@ -6672,6 +6691,27 @@ export declare class Store {
         payload: Record<string, unknown>;
         ceilingDigest: string;
     }, now: Date): number;
+    /** Record this turn's one question; false when the turn already asked one. */
+    recordMateAsk(ask: {
+        turn: number;
+        thread: number;
+        question: string;
+        options: readonly string[];
+    }, now: Date): boolean;
+    /** A failed turn keeps no question, as it keeps no drafts. */
+    dropMateAsk(turn: number): void;
+    /** The question an ANSWERED turn asked; null when it asked none or did not answer. */
+    mateAsk(turn: number): MateAsk | null;
+    /** What a tap on the question finds: open; answered (the owner has written in its thread since the reply that asked it);
+     * or expired (older than MATE_ASK_TTL_MS, or the question or the reply that asked it is gone, as after a retention purge). */
+    mateAskState(turn: number, now: Date): {
+        state: "open";
+        ask: MateAsk;
+    } | {
+        state: "answered" | "expired";
+    };
+    /** The question while it is open (see mateAskState); null otherwise. */
+    mateAskOpen(turn: number, now: Date): MateAsk | null;
     /**
      * Record the screenshots one turn selected for an exact result, under the
      * turn, so a channel that delivers files can plan them from the completed
@@ -7287,6 +7327,8 @@ export declare class Store {
         taskId: string | null;
         sourceRun: number | null;
     }, now: Date): number;
+    /** Whether a message from this chat is already waiting on, or being answered from, this bot message (a tapped question). */
+    telegramConversationWaitingOn(binding: number, messageId: string): boolean;
     getTelegramConversation(id: number): TelegramConversation | null;
     listTelegramConversations(botId: string): TelegramConversation[];
     /**
@@ -7459,6 +7501,13 @@ export declare class Store {
     }[];
     /** Claim one local day's digest for one person: true once, false if it was already considered. */
     claimEveningDigestDay(account: string, day: string): boolean;
+    /** What this person named their lead and its persona, or null when they never saved one. */
+    leadConfig(account: string): {
+        name: string;
+        persona: string;
+    } | null;
+    /** Save this person's lead name and persona (checked by the caller: lead-identity.ts). */
+    setLeadConfig(account: string, name: string, persona: string, now: Date): void;
     /** A lead token for one person, shown once. A new one ends their earlier ones; the ledger names it "lead for <owner>". */
     mintLeadCredential(owner: string, by: string, now: Date): {
         id: string;
@@ -7667,6 +7716,8 @@ export declare class Store {
 export declare const TELEGRAM_SKIPPED_RECEIPT = "skipped:before-pairing";
 /** v83: a notification for another person, settled for this destination without sending. */
 export declare const TELEGRAM_SKIPPED_ELSEWHERE = "skipped:for-another-person";
+/** A met promise the lead made on another chat: reported there, settled here without sending. */
+export declare const TELEGRAM_SKIPPED_OTHER_CHAT = "skipped:for-another-chat";
 /** A fact this person is not messaged about: the lead's work, their own act, or a project they muted. */
 export declare const TELEGRAM_SKIPPED_QUIET = "skipped:quiet";
 /**

package/dist/store.js

@@ -183,6 +183,16 @@ CREATE TABLE IF NOT EXISTS chat_batch_item (
   PRIMARY KEY (batch, task_ref)
 );
 `;
+/** Settings → Lead (no version bump: additive only): what one person calls their lead and the short persona it
+ * speaks with. No row reads as the defaults (lead-identity.ts). */
+const LEAD_CONFIG_SCHEMA = `
+CREATE TABLE IF NOT EXISTS lead_config (
+  account    TEXT PRIMARY KEY,
+  name       TEXT NOT NULL,
+  persona    TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+`;
 /** Pings follow responsibility (no version bump: additive only). `lead_credential` is a lead token: an agent acting
  * for `owner`, only its hash kept. `task_act` is who filed, approved, cancelled, completed or handed on a task
  * (`lead` 1: the owner's lead; `person`/`why`: who the lead asked, and why). `notification_actor` is whose act made
@@ -227,6 +237,31 @@ CREATE TABLE IF NOT EXISTS project_mute (
   PRIMARY KEY (account, repo)
 );
 `;
+/** What the lead promised to follow up on (lead-commitments.ts; no version bump: additive only, so a build that
+ * predates it still opens the store). `condition_json` is a task, attempt, check or time; `check_at` is when to look
+ * next; `channel` is where it reports (`chat`: the conversation it was promised in); a promise lapses at `expires_at`. */
+export const LEAD_COMMITMENT_SCHEMA = `
+CREATE TABLE IF NOT EXISTS lead_commitment (
+  id             INTEGER PRIMARY KEY AUTOINCREMENT,
+  owner          TEXT NOT NULL,
+  repo           TEXT,
+  thread         INTEGER NOT NULL,
+  turn           INTEGER,
+  channel        TEXT NOT NULL DEFAULT 'chat',
+  what           TEXT NOT NULL,
+  condition_json TEXT NOT NULL,
+  check_at       TEXT NOT NULL,
+  expires_at     TEXT NOT NULL,
+  state          TEXT NOT NULL DEFAULT 'open' CHECK (state IN ('open', 'done', 'cancelled', 'expired')),
+  created_at     TEXT NOT NULL,
+  checked_at     TEXT,
+  closed_at      TEXT,
+  closed_by      TEXT,
+  outcome        TEXT
+);
+CREATE INDEX IF NOT EXISTS lead_commitment_due ON lead_commitment (state, check_at);
+CREATE INDEX IF NOT EXISTS lead_commitment_owner ON lead_commitment (owner, state, id);
+`;
 /** What still pings on the lead's own work: a security alert. */
 const SECURITY_KINDS = new Set(["secret-detected", "security-release"]);
 /** A failure that leaves nothing for the lead to try: the attempts are spent. */
@@ -245,6 +280,22 @@ export function stopFactOf(store, runId) {
                 : /cannot be proven|could not be established|incomplete native/.test(problem) ? "unknown" : "unprovable";
     return { run: Number(/run #(\d+)/.exec(problem)?.[1] ?? runId), kind, problem };
 }
+/** The lead's one question to its owner (no version bump): at most one per answered turn, two to four short options;
+ * "Something else" is implied. The tapped option comes back as the owner's next message, so nothing here is an answer:
+ * a question is open while no later message from the owner sits in its thread. */
+export const MATE_ASK_SCHEMA = `
+CREATE TABLE IF NOT EXISTS mate_ask (
+  turn         INTEGER PRIMARY KEY REFERENCES mate_turn(id) ON DELETE CASCADE,
+  thread       INTEGER NOT NULL REFERENCES mate_thread(id) ON DELETE CASCADE,
+  question     TEXT NOT NULL,
+  options_json TEXT NOT NULL,
+  created_at   TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS mate_ask_thread ON mate_ask (thread, turn);
+`;
+export const MATE_ASK_OTHER = "Something else";
+/** How long the question's buttons work, on every channel. */
+export const MATE_ASK_TTL_MS = 7 * 86_400_000;
 /** Settings → Integrations (no version bump): each integration's last check. `outcome` is ok, failed, or absent (the check found
  * nothing set up, such as no `gh` sign-in). `ok_at` and `error`/`error_at` keep the last success and the last
  * failure across checks, so a row can say both. `account` is a display name only, never a credential. */
@@ -3830,6 +3881,7 @@ function initializeStore(db, file) {
     db.exec(LEDGER_CHAIN_SCHEMA);
     db.exec(MONITORING_SCHEMA);
     db.exec(INTEGRATIONS_SCHEMA);
+    db.exec(MATE_ASK_SCHEMA);
     db.exec(SPEND_SCHEMA);
     // Sign-in pauses: one row per incident of a provider's sign-in no longer working.
     db.exec(PROVIDER_AUTH_SCHEMA);
@@ -3848,6 +3900,8 @@ function initializeStore(db, file) {
     // The update a batch line speaks for: its newest fact about that task (null: a finished result).
     addColumn(db, "chat_batch_item", "notification", "INTEGER");
     db.exec(LEAD_QUIET_SCHEMA);
+    db.exec(LEAD_CONFIG_SCHEMA);
+    db.exec(LEAD_COMMITMENT_SCHEMA);
     mergeCheckTables(db);
     addColumn(db, "monitoring_status", "target", "TEXT");
     // v105: how a teammate's turn was billed (this computer's Claude sign-in, as last seen).
@@ -19636,6 +19690,46 @@ export class Store {
             .run(proposal.thread, proposal.turn, proposal.kind, JSON.stringify(proposal.payload), proposal.ceilingDigest, now.toISOString());
         return Number(inserted.lastInsertRowid);
     }
+    // ---- the lead's question to its owner (ask_owner) -----------------------------
+    /** Record this turn's one question; false when the turn already asked one. */
+    recordMateAsk(ask, now) {
+        const inserted = this.db.prepare("INSERT OR IGNORE INTO mate_ask (turn, thread, question, options_json, created_at) VALUES (?, ?, ?, ?, ?)")
+            .run(ask.turn, ask.thread, ask.question, JSON.stringify(ask.options), now.toISOString());
+        return Number(inserted.changes) === 1;
+    }
+    /** A failed turn keeps no question, as it keeps no drafts. */
+    dropMateAsk(turn) {
+        this.db.prepare("DELETE FROM mate_ask WHERE turn = ?").run(turn);
+    }
+    /** The question an ANSWERED turn asked; null when it asked none or did not answer. */
+    mateAsk(turn) {
+        const row = this.db.prepare("SELECT a.* FROM mate_ask a JOIN mate_turn t ON t.id = a.turn WHERE a.turn = ? AND t.state = 'answered'").get(turn);
+        if (row === undefined)
+            return null;
+        const options = JSON.parse(String(row["options_json"]));
+        return { turn: Number(row["turn"]), thread: Number(row["thread"]), question: String(row["question"]), options: Array.isArray(options) ? options.map(String) : [], createdAt: String(row["created_at"]) };
+    }
+    /** What a tap on the question finds: open; answered (the owner has written in its thread since the reply that asked it);
+     * or expired (older than MATE_ASK_TTL_MS, or the question or the reply that asked it is gone, as after a retention purge). */
+    mateAskState(turn, now) {
+        const ask = this.mateAsk(turn);
+        if (ask === null)
+            return { state: "expired" };
+        const asking = this.db.prepare("SELECT MAX(id) AS id FROM mate_message WHERE thread = ? AND turn = ? AND role = 'assistant'").get(ask.thread, turn);
+        if (asking === undefined || asking["id"] === null)
+            return { state: "expired" };
+        const later = this.db.prepare("SELECT 1 AS hit FROM mate_message WHERE thread = ? AND role = 'operator' AND id > ? LIMIT 1").get(ask.thread, Number(asking["id"]));
+        if (later !== undefined)
+            return { state: "answered" };
+        if (new Date(ask.createdAt).getTime() + MATE_ASK_TTL_MS <= now.getTime())
+            return { state: "expired" };
+        return { state: "open", ask };
+    }
+    /** The question while it is open (see mateAskState); null otherwise. */
+    mateAskOpen(turn, now) {
+        const found = this.mateAskState(turn, now);
+        return found.state === "open" ? found.ask : null;
+    }
     // ---- the screenshots a turn selected (v64) ------------------------------------
     /**
      * Record the screenshots one turn selected for an exact result, under the
@@ -21612,6 +21706,10 @@ export class Store {
             .run(row.binding.id, row.binding.botId, row.binding.chatId, row.binding.userId, row.binding.approver, row.binding.approverGeneration, row.updateId, row.messageId, row.replyTo, row.request, row.text, row.context, row.taskId, row.sourceRun, now.toISOString());
         return Number(inserted.lastInsertRowid);
     }
+    /** Whether a message from this chat is already waiting on, or being answered from, this bot message (a tapped question). */
+    telegramConversationWaitingOn(binding, messageId) {
+        return this.db.prepare("SELECT 1 AS hit FROM telegram_conversation WHERE binding = ? AND message_id = ? AND state IN ('queued', 'running') LIMIT 1").get(binding, messageId) !== undefined;
+    }
     getTelegramConversation(id) {
         const row = this.db.prepare("SELECT * FROM telegram_conversation WHERE id = ?").get(id);
         return row === undefined ? null : readTelegramConversation(row);
@@ -21742,7 +21840,7 @@ export class Store {
          VALUES (?, ?, ?, ?, ?, ?, ?, 'pending', ?, ?, ?, ?, ?)`);
             parts.forEach((part, ordinal) => {
                 const image = part.kind === "image" ? part : null;
-                insert.run(id, ordinal, part.kind, part.text, part.kind === "reply" ? part.replyTo ?? null : null, part.kind === "card" ? part.proposal : null, part.kind === "card" && part.keyboard != null ? JSON.stringify(part.keyboard) : null, stamp, image?.taskId ?? null, image?.run ?? null, image?.artifact ?? null, image?.sha256 ?? null);
+                insert.run(id, ordinal, part.kind, part.text, part.kind === "reply" ? part.replyTo ?? null : null, part.kind === "card" ? part.proposal : null, (part.kind === "card" || part.kind === "reply") && part.keyboard != null ? JSON.stringify(part.keyboard) : null, stamp, image?.taskId ?? null, image?.run ?? null, image?.artifact ?? null, image?.sha256 ?? null);
             });
             return true;
         });
@@ -21921,6 +22019,10 @@ export class Store {
             this.db.prepare(`UPDATE notification_delivery SET receipt = '${TELEGRAM_SKIPPED_ELSEWHERE}'
         WHERE destination = ? AND delivered_at IS NULL AND receipt IS NULL
           AND notification IN (SELECT id FROM notification WHERE recipient IS NOT NULL AND recipient <> ?)`).run(destination, binding.approver);
+            // A promise the lead made on another chat is reported there (lead-commitments.ts), not here.
+            this.db.prepare(`UPDATE notification_delivery SET receipt = '${TELEGRAM_SKIPPED_OTHER_CHAT}'
+        WHERE destination = ? AND delivered_at IS NULL AND receipt IS NULL
+          AND notification IN (SELECT id FROM notification WHERE dedupe_key LIKE 'lead-promise:%' AND dedupe_key NOT LIKE 'lead-promise:telegram:%')`).run(destination);
             // Pings follow responsibility (the lead's work, this person's own act, a muted project): settled here, unsent.
             for (const raw of this.db.prepare(`SELECT n.* FROM notification n JOIN notification_delivery d ON d.notification = n.id AND d.destination = ?
           WHERE n.resolved_at IS NULL AND d.delivered_at IS NULL AND d.receipt IS NULL AND (d.claim_owner IS NULL OR d.claim_expires_at <= ?)`).all(destination, now.toISOString())) {
@@ -22143,6 +22245,16 @@ export class Store {
             .run(day, account, day).changes) === 1;
     }
     // ---- pings follow responsibility: the lead, who acted, replacements and muted projects ----
+    /** What this person named their lead and its persona, or null when they never saved one. */
+    leadConfig(account) {
+        const row = this.db.prepare("SELECT name, persona FROM lead_config WHERE account = ?").get(account);
+        return row === undefined ? null : { name: String(row["name"]), persona: String(row["persona"]) };
+    }
+    /** Save this person's lead name and persona (checked by the caller: lead-identity.ts). */
+    setLeadConfig(account, name, persona, now) {
+        this.db.prepare(`INSERT INTO lead_config (account, name, persona, updated_at) VALUES (?, ?, ?, ?)
+      ON CONFLICT(account) DO UPDATE SET name = excluded.name, persona = excluded.persona, updated_at = excluded.updated_at`).run(account, name, persona, now.toISOString());
+    }
     /** A lead token for one person, shown once. A new one ends their earlier ones; the ledger names it "lead for <owner>". */
     mintLeadCredential(owner, by, now) {
         return this.transact(() => {
@@ -22879,6 +22991,8 @@ function readHold(row) {
 export const TELEGRAM_SKIPPED_RECEIPT = "skipped:before-pairing";
 /** v83: a notification for another person, settled for this destination without sending. */
 export const TELEGRAM_SKIPPED_ELSEWHERE = "skipped:for-another-person";
+/** A met promise the lead made on another chat: reported there, settled here without sending. */
+export const TELEGRAM_SKIPPED_OTHER_CHAT = "skipped:for-another-chat";
 /** A fact this person is not messaged about: the lead's work, their own act, or a project they muted. */
 export const TELEGRAM_SKIPPED_QUIET = "skipped:quiet";
 /** A destination receipt (`d` = notification_delivery) that still owes a

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 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 === "claim" ? "record lead ownership; with the lead token the task reads \"<the lead's name> 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,7 +215,7 @@ 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",
+    { invocation: "lead say", synopsis: "as the lead: one short message in its person's chat under the lead's name (Settings → 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,

package/dist/task-status.d.ts

@@ -1,15 +1,3 @@
-/** One answer per task, then the details (docs/design/task-status.md). Every
- * surface — the Tasks list, the task page, the build page, Crew, the Chat
- * result, the Telegram/Slack/Discord/Teams cards and `toolroll status` — reads
- * its headline, sentence, tone and detail rows from `taskStatusOf`, so the
- * words cannot drift apart again. Pure: it reads facts the existing
- * projections already recorded and never changes a check, approval or
- * completion.
- *
- * Severity: red belongs to the Failed headline alone. A detail problem that
- * doesn't undo the outcome (a pull request that couldn't open, shortened
- * output) is an amber note on its own row with one action; the exact
- * technical reason stays one tap away in `why`. */
 import type { AssignmentSnapshot } from "./assignment.js";
 import { type NeedAction, type NeedContext, type NeedKey, type WaitKey } from "./needs-you.js";
 export type { NeedKey, WaitKey } from "./needs-you.js";
@@ -20,6 +8,11 @@ export declare const HEADLINES: readonly ["Queued", "Planning", "Needs you", "Wa
 export type Headline = (typeof HEADLINES)[number];
 export type HeadlineTone = "neutral" | "live" | "attention" | "ready" | "success" | "danger";
 export declare const HEADLINE_TONE: Readonly<Record<Headline, HeadlineTone>>;
+/** The project's own checks and the pull request's CI are two different things, never one word (Checks beside CI). */
+export declare const CHECKS_LABEL = "Project checks";
+export declare const PR_CI_LABEL = "PR CI";
+/** The one verb for opening a saved result, on every surface. */
+export declare const OPEN_RESULT = "Open result";
 export type DetailKey = "checks" | "pull-request" | "requirements" | "evidence";
 /** The row's small icon: the only coloured part of a detail. `failed` is red
  * and only ever appears under the Failed headline; `note` is amber. */
@@ -86,11 +79,13 @@ export type TaskStatusFacts = {
     report?: boolean;
     checks?: ChecksFact | null;
     pullRequest?: PullRequestFact | null;
-    /** `unverified`: the report is refuted, so no requirement counts as met however it was marked. */
+    /** `unverified`: the report is refuted, so no requirement counts as met however it was marked. `missed`: the ones it
+     * failed or left unanswered. */
     requirements?: {
         met: number;
         total: number;
         yours: number;
+        missed?: number;
         unverified?: boolean;
     } | null;
     evidence?: {
@@ -109,14 +104,16 @@ 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"
+    /** The person's lead took this on (lead-voice.ts): "on-it" reads "<name> 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;
+    /** What the person calls their lead (Settings → Lead); "Lead" when unnamed. */
+    leadName?: string;
 };
 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 const leadOnIt: (name?: string) => string;
+export declare const leadLapsed: (name?: string) => string;
 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?: {
@@ -153,14 +150,19 @@ export declare function assignmentStageOf(assignment: Pick<AssignmentSnapshot, "
     need?: TaskStatusFacts["need"];
     wait?: WaitKey;
 };
-/** Requirements from the stored matrix: met, the ones only a person confirms, and the total. */
-export declare function requirementsOf(matrix: readonly {
+type RequirementRow = {
     state: string;
     assessment?: {
         evidenceState?: string;
     } | undefined;
     review?: unknown;
-}[] | null | undefined): NonNullable<TaskStatusFacts["requirements"]> | null;
+};
+/** One requirement's state in words: the card's Requirements row and the Checks tab read this one source, so they
+ * can't disagree. A refuted report verifies none of its requirements, so each reads Unverified, as the card does. */
+export type RequirementWord = "Met" | "You check" | "Not shown yet" | "Not met" | "Unverified";
+export declare function requirementWordOf(row: RequirementRow, verdict?: string | null): RequirementWord;
+/** Requirements from the stored matrix: met, the ones only a person confirms, and the total. */
+export declare function requirementsOf(matrix: readonly RequirementRow[] | null | undefined): NonNullable<TaskStatusFacts["requirements"]> | null;
 /** A refuted report verifies none of its requirements, whatever it marked met (a person's acceptance doesn't change that). */
 export declare function unverifiedWhenRefuted(requirements: NonNullable<TaskStatusFacts["requirements"]> | null, verdict: string | null | undefined): NonNullable<TaskStatusFacts["requirements"]> | null;
 /** Saved evidence health from the receipt's artifact list and its caveats. */
@@ -188,6 +190,8 @@ export declare function headlineEmoji(headline: Headline): string;
 export declare const statusIconSvg: (mark: DetailMark) => string;
 /** The detail rows as server HTML: quiet rows, colour only on the icon. */
 export declare function statusDetailsHtml(status: TaskStatus): string;
+/** The status card's fold of exact reasons: "More", never a third thing called Details. */
+export declare const STATUS_MORE = "More";
 /** The technical reasons, one tap away. */
 export declare function statusWhyHtml(status: TaskStatus, extra?: readonly string[], diagnostics?: readonly {
     token: string;
@@ -211,3 +215,6 @@ export declare function stageOfDispatch(d: {
     stage: TaskStage;
     need?: TaskStatusFacts["need"];
 };
+/** The demo runs no checks: a Checks row that would offer to run one (or open one that never ran) says so instead. */
+export declare const DEMO_CHECKS = "Can't run in the demo";
+export declare function demoChecksOf(status: TaskStatus): TaskStatus;

package/dist/task-status.js

@@ -1,3 +1,16 @@
+/** One answer per task, then the details (docs/design/task-status.md). Every
+ * surface — the Tasks list, the task page, the build page, Crew, the Chat
+ * result, the Telegram/Slack/Discord/Teams cards and `toolroll status` — reads
+ * its headline, sentence, tone and detail rows from `taskStatusOf`, so the
+ * words cannot drift apart again. Pure: it reads facts the existing
+ * projections already recorded and never changes a check, approval or
+ * completion.
+ *
+ * Severity: red belongs to the Failed headline alone. A detail problem that
+ * doesn't undo the outcome (a pull request that couldn't open, shortened
+ * output) is an amber note on its own row with one action; the exact
+ * technical reason stays one tap away in `why`. */
+import { DEFAULT_LEAD_NAME } from "./lead-identity.js";
 import { CODE_NEED, NEEDS, needSentence, waitSentence } from "./needs-you.js";
 /** A cancelled task with a successor reads "Replaced by <id>" everywhere, never "Cancelled". */
 export const replacedWords = (successor) => `Replaced by ${successor}`;
@@ -8,6 +21,11 @@ export const HEADLINE_TONE = {
     Queued: "neutral", Planning: "live", "Needs you": "attention", Waiting: "neutral", Building: "live",
     "Ready for review": "ready", Complete: "success", Failed: "danger", Stopped: "neutral",
 };
+/** The project's own checks and the pull request's CI are two different things, never one word (Checks beside CI). */
+export const CHECKS_LABEL = "Project checks";
+export const PR_CI_LABEL = "PR CI";
+/** The one verb for opening a saved result, on every surface. */
+export const OPEN_RESULT = "Open result";
 const short = (sha) => sha !== null && /^[a-f0-9]{7,40}$/.test(sha) ? sha.slice(0, 7) : null;
 export function headlineOf(facts) {
     switch (facts.stage) {
@@ -76,19 +94,20 @@ function detailsOf(headline, facts) {
         const runChecks = facts.links?.runChecks === undefined ? null : { label: "Run checks", href: facts.links.runChecks };
         const quick = checks.level === "quick";
         if (checks.running != null)
-            row("checks", "Checks", `${checks.running === "quick" ? "Quick" : "Full"} checks running`, "running", { href: checksHref });
+            row("checks", CHECKS_LABEL, `${checks.running === "quick" ? "Quick" : "Full"} checks running`, "running", { href: checksHref });
         else if (checks.status === "passed")
-            row("checks", "Checks", `${quick ? "Quick checks passed" : "Passed"}${sha === null ? "" : ` on ${sha}`}`, "ok", quick && runChecks !== null && headline !== "Complete" ? { href: checksHref, action: { label: "Run full checks", href: runChecks.href } } : { href: checksHref });
+            row("checks", CHECKS_LABEL, `${quick ? "Quick checks passed" : "Passed"}${sha === null ? "" : ` on ${sha}`}`, "ok", quick && runChecks !== null && headline !== "Complete" ? { href: checksHref, action: { label: "Run full checks", href: runChecks.href } } : { href: checksHref });
         else if (checks.status === "failed")
-            row("checks", "Checks", `${quick ? "Quick checks failed" : "Failed"}${checks.exitCode === null ? "" : ` (exit ${checks.exitCode})`}`, problem(headline), headline === "Failed" ? { href: checksHref } : { action: { label: "See what failed", href: checksHref } });
+            row("checks", CHECKS_LABEL, `${quick ? "Quick checks failed" : "Failed"}${checks.exitCode === null ? "" : ` (exit ${checks.exitCode})`}`, problem(headline), headline === "Failed" ? { href: checksHref } : { action: { label: "See what failed", href: checksHref } });
         else if (checks.status === "running")
-            row("checks", "Checks", "Running", "running");
+            row("checks", CHECKS_LABEL, "Running", "running");
         else if (checks.level === "off")
-            row("checks", "Checks", "Off for this project", "none", runChecks === null ? {} : { action: runChecks });
+            row("checks", CHECKS_LABEL, "Off for this project", "none", runChecks === null ? {} : { action: runChecks });
         else if (checks.status === "not-run")
-            row("checks", "Checks", "Didn't run", "none", runChecks === null ? {} : { action: runChecks });
+            row("checks", CHECKS_LABEL, "Didn't run", "none", runChecks === null ? {} : { action: runChecks });
+        // A saved check that can't be read is run again where that is possible.
         else
-            row("checks", "Checks", "Couldn't be read", "note", { action: { label: "Open the result", href: facts.links?.result ?? null } });
+            row("checks", CHECKS_LABEL, "Couldn't be read", "note", { action: runChecks ?? { label: OPEN_RESULT, href: facts.links?.result ?? null } });
     }
     const pr = facts.pullRequest;
     if (pr != null) {
@@ -105,16 +124,19 @@ function detailsOf(headline, facts) {
         else if (pr.state === "failed")
             row("pull-request", "Pull request", "Couldn't open", "note", { action: pr.compareUrl ? { label: "Open it on GitHub", href: pr.compareUrl } : { label: "See why", href: facts.links?.pullRequest ?? null }, why: pr.error === null ? "Publishing gave up. The commit is safe locally." : `${pr.error} The commit is safe locally.` });
         else if (pr.ci === "running")
-            row("pull-request", "Pull request", `${name} open, CI running`, "running", { href: github });
+            row("pull-request", "Pull request", `${name} open · ${PR_CI_LABEL} running`, "running", { href: github });
         else if (pr.ci === "passing")
-            row("pull-request", "Pull request", `${name} open, CI passed`, "ok", { href: github });
+            row("pull-request", "Pull request", `${name} open · ${PR_CI_LABEL} passed`, "ok", { href: github });
         else if (pr.ci === "failing")
-            row("pull-request", "Pull request", `${name} open, CI failing`, "note", { action: { label: "Open it on GitHub", href: github } });
+            row("pull-request", "Pull request", `${name} open · ${PR_CI_LABEL} failing`, "note", { action: { label: "Open it on GitHub", href: github } });
         else
             row("pull-request", "Pull request", `${name} open`, "none", { href: github });
     }
     const req = facts.requirements;
-    if (req != null && req.total > 0 && req.unverified === true)
+    // A failed result names how many it missed, refuted or not: that is what failed.
+    if (req != null && req.total > 0 && headline === "Failed" && (req.missed ?? 0) > 0)
+        row("requirements", "Requirements", `${req.missed} missed`, "failed");
+    else if (req != null && req.total > 0 && req.unverified === true)
         row("requirements", "Requirements", "Unverified", "none");
     else if (req != null && req.total > 0) {
         const unmet = req.total - req.met - req.yours;
@@ -136,16 +158,16 @@ 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.";
+export const leadOnIt = (name = DEFAULT_LEAD_NAME) => `${name} is on it.`;
+export const leadLapsed = (name = DEFAULT_LEAD_NAME) => `${name} 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;
+        return `${facts.checks.level === "quick" ? "Quick checks" : "Checks"} failed${sha === null ? "" : ` on ${sha}`}. ${leadOnIt(facts.leadName)}`;
+    return leadOnIt(facts.leadName);
 }
 export function taskStatusOf(facts) {
     const read = headlineOf(facts);
@@ -156,7 +178,7 @@ export function taskStatusOf(facts) {
     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 };
-    const sentence = lead === "on-it" ? leadSentence(headline, facts) : lead === "lapsed" ? `${LEAD_LAPSED} ${sentenceOf(headline, facts)}` : sentenceOf(headline, facts);
+    const sentence = lead === "on-it" ? leadSentence(headline, facts) : lead === "lapsed" ? `${leadLapsed(facts.leadName)} ${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 };
 }
@@ -258,13 +280,21 @@ export function assignmentStageOf(assignment, work, planning = false) {
         }
     }
 }
+/** Evidence that passed and only awaits the retired assessment step is met. */
+const requirementMet = (row) => row.state === "pass" || (row.assessment?.evidenceState === "pass" && (row.review ?? null) === null);
+export function requirementWordOf(row, verdict) {
+    if (verdict === "refuted")
+        return "Unverified";
+    if (requirementMet(row))
+        return "Met";
+    return row.state === "manual-review" ? "You check" : row.state === "missing" ? "Not shown yet" : "Not met";
+}
 /** Requirements from the stored matrix: met, the ones only a person confirms, and the total. */
 export function requirementsOf(matrix) {
     if (!matrix || matrix.length === 0)
         return null;
-    // Evidence that passed and only awaits the retired assessment step is met.
-    const met = (row) => row.state === "pass" || (row.assessment?.evidenceState === "pass" && (row.review ?? null) === null);
-    return { met: matrix.filter(met).length, total: matrix.length, yours: matrix.filter(row => !met(row) && row.state === "manual-review").length };
+    return { met: matrix.filter(requirementMet).length, total: matrix.length, yours: matrix.filter(row => requirementWordOf(row) === "You check").length,
+        missed: matrix.filter(row => !requirementMet(row) && (row.state === "failed" || row.state === "missing")).length };
 }
 /** A refuted report verifies none of its requirements, whatever it marked met (a person's acceptance doesn't change that). */
 export function unverifiedWhenRefuted(requirements, verdict) {
@@ -347,18 +377,20 @@ export const statusIconSvg = (mark) => `<svg class="status-icon status-icon--${m
 export function statusDetailsHtml(status) {
     if (status.details.length === 0)
         return "";
-    return `<ul class="status-details" aria-label="Details">` + status.details.map(one => {
+    return `<ul class="status-details" aria-label="Status">` + status.details.map(one => {
         const text = one.href === null ? escapeHtml(one.text) : `<a href="${escapeHtml(one.href)}">${escapeHtml(one.text)}</a>`;
         const action = one.action === null ? "" : one.action.href === null ? `<span class="status-detail-act">${escapeHtml(one.action.label)}</span>` : `<a class="status-detail-act" href="${escapeHtml(one.action.href)}">${escapeHtml(one.action.label)}</a>`;
         return `<li class="status-detail status-detail--${one.mark}" data-status-detail="${one.key}" data-mark="${one.mark}">${statusIconSvg(one.mark)}<span class="status-detail-label">${escapeHtml(one.label)}</span><span class="status-detail-text"><span>${text}</span>${action}</span></li>`;
     }).join("") + `</ul>`;
 }
+/** The status card's fold of exact reasons: "More", never a third thing called Details. */
+export const STATUS_MORE = "More";
 /** The technical reasons, one tap away. */
 export function statusWhyHtml(status, extra = [], diagnostics = []) {
     const lines = [...new Set([...status.details.flatMap(one => one.why === null ? [] : [`${one.label}: ${one.why}`]), ...status.why, ...extra])];
     if (lines.length === 0 && diagnostics.length === 0)
         return "";
-    return `<details class="status-why"><summary>Details</summary>${lines.map(one => `<p class="meta">${escapeHtml(one)}</p>`).join("")}` +
+    return `<details class="status-why"><summary>${STATUS_MORE}</summary>${lines.map(one => `<p class="meta">${escapeHtml(one)}</p>`).join("")}` +
         diagnostics.map(one => `<p class="meta" data-work-diagnostic="${escapeHtml(one.token)}">${escapeHtml(one.label)} · ${escapeHtml(one.detail)}</p>`).join("") + `</details>`;
 }
 /** Shared CSS for the server-rendered status: neutral rows, coloured icons. */
@@ -377,3 +409,9 @@ export function stageOfDispatch(d, options = {}) {
         return { stage: "needs-you", need: "review-result" };
     return stageOfCode(d.code, { needsPerson: d.condition === "waiting" && d.action !== null, planning: d.condition === "running" && d.role === "planner", operatorHold: d.action === "unhold" });
 }
+/** The demo runs no checks: a Checks row that would offer to run one (or open one that never ran) says so instead. */
+export const DEMO_CHECKS = "Can't run in the demo";
+export function demoChecksOf(status) {
+    return { ...status, details: status.details.map(one => one.key !== "checks" || one.mark === "ok" || one.mark === "failed" || one.mark === "running" ? one
+            : { ...one, text: DEMO_CHECKS, mark: "none", href: null, action: null, why: null }) };
+}

package/dist/team-runtime.js

@@ -148,7 +148,8 @@ export function createTeamRuntime(options) {
                     turnId: receipt.turn, ...(turn?.state === 'answered' ? {} : { error: 'Inspect the saved response; this message was not sent again.' }) }, clock());
                 return;
             }
-            const result = await runMateTurn({ store, who: proof.who, session, thread, ...provider, message: claim.text, requestId,
+            const result = await runMateTurn({ store, who: proof.who, session, thread, ...provider, message: claim.text, requestId, channel: "console",
+                ...(() => { const name = view.leads.find(lead => lead.id === claim.leadId)?.name; return name === undefined ? {} : { leadName: name }; })(),
                 queuedMessageId: claim.messageId,
                 onAdmitted: turn => { if (!domain.current(claim) || !domain.bindTurn(claim, turn))
                     throw new Error('The queued message changed before admission.'); },