toolroll 0.9.15 → 0.9.16

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";
@@ -116,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?: {

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}`;
@@ -145,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);
@@ -165,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 };
 }

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.'); },

package/dist/teams-chat.js

@@ -1,6 +1,7 @@
 /** Microsoft Teams on the shared chat layer: activities in, Adaptive Cards
  * out, the same durable receipts, rooms and commands as every other channel. */
 import { chatQuestionButtons } from "./teammate-question.js";
+import { chatAskButtons } from "./chat-ask.js";
 import { ChatState, chatHash } from "./chat-delivery-state.js";
 import { channelAccess, chatObject as object, planChatNotifications, planRoomMessages, processChatEvent } from "./chat-delivery.js";
 import { roomCommand } from "./chat-rooms.js";
@@ -195,7 +196,9 @@ export async function deliverTeamsPart(options) {
             const flow = content.flow ? chatFlowButtons(state, row.id, now).map(one => ({ type: "Action.Submit", title: one.label, data: { so: one.token }, ...(one.action === "approve" ? { style: "positive" } : {}) })) : [];
             // A teammate's question (v93): its options, then "Answer in words".
             const asked = content.question ? chatQuestionButtons(state, row.id, now).map(one => ({ type: "Action.Submit", title: one.label.slice(0, 80), data: { so: one.token } })) : [];
-            actions = [...flow, ...asked, ...openUrlAction(options.origin(), content.link), ...(content.also ?? []).flatMap(one => openUrlAction(options.origin(), one))];
+            // The lead's question to its owner: its options, then "Something else".
+            const owner = content.ask ? chatAskButtons(state, row.id, now).map(one => ({ type: "Action.Submit", title: one.label.slice(0, 80), data: { so: one.token } })) : [];
+            actions = [...flow, ...asked, ...owner, ...openUrlAction(options.origin(), content.link), ...(content.also ?? []).flatMap(one => openUrlAction(options.origin(), one))];
         }
         const target = content.edit ?? row.message;
         const body = actions.length || content.proposal ? teamsCard(text, actions) : { type: "message", text, textFormat: "plain" };

package/dist/telegram-mate.d.ts

@@ -1,7 +1,7 @@
 import { type PhoneLink } from "./chat-channel.js";
 export { channelRepos as telegramConversationRepos, resolveChannelMate as resolveTelegramMate, tooLongText, whichTaskText, replyContextFor, NO_PHONE_LINK, NO_TASK_LINK, proposalLink, confirmedLink, proposalPreview, proposalOutcomeText, handoffCardText, confirmedCardText, CHAT_ACTION_PARITY as TELEGRAM_ACTION_PARITY, parityGaps, type PhoneLink, type ResolvedMate, type ParitySupport } from "./chat-channel.js";
 import { type DoorOptions } from "./mate-doors.js";
-import type { Store, TelegramBinding } from "./store.js";
+import { type MateAsk, type Store, type TelegramBinding } from "./store.js";
 import type { SubscriptionMateRunner } from "./subscription-chat.js";
 import type { TelegramTransport } from "./telegram.js";
 /** How long one claimed turn may go without a heartbeat before another poller may take it over. */
@@ -59,6 +59,9 @@ export declare function telegramChannelProblem(store: Store, expected: {
 }), readProjects: () => Promise<readonly string[]>): Promise<string | null>;
 export declare function phoneLinkButton(origin: string | null, link: PhoneLink | null): InlineButton[] | null;
 /** One inline button: an opaque callback token (a real in-chat act) or a url (navigation, never authority). */
+/** The buttons under the lead's question: options two to a row, then "Something else". Each names the turn and the
+ * option's place, nothing more; a tap re-proves that the question is still open and is the tapper's own. */
+export declare function askKeyboard(ask: MateAsk): CallbackKeyboard;
 export type InlineButton = {
     text: string;
     callback_data: string;

package/dist/telegram-mate.js

@@ -26,6 +26,7 @@ import { createHash, randomBytes } from "node:crypto";
 import { MATE_MESSAGE_MAX_CHARS, runMateTurn } from "./mate.js";
 import { confirmMateProposal, dismissMateProposal } from "./mate-doors.js";
 import { ceilingDigestOf, verifyApproverStanding } from "./principal.js";
+import { MATE_ASK_OTHER } from "./store.js";
 import { phoneText } from "./telegram-status.js";
 import { TeamLeads } from "./team-leads.js";
 import { chatResultHref } from "./chat-controls.js";
@@ -100,6 +101,17 @@ function keyboardWith(callbacks, link) {
     const rows = [...(callbacks ?? []), ...(link === null ? [] : [link])];
     return rows.length === 0 ? undefined : rows;
 }
+// ---- proposal cards on the wire ------------------------------------------------------
+/** One inline button: an opaque callback token (a real in-chat act) or a url (navigation, never authority). */
+/** The buttons under the lead's question: options two to a row, then "Something else". Each names the turn and the
+ * option's place, nothing more; a tap re-proves that the question is still open and is the tapper's own. */
+export function askKeyboard(ask) {
+    const rows = [];
+    for (let at = 0; at < ask.options.length; at += 2)
+        rows.push(ask.options.slice(at, at + 2).map((label, offset) => ({ text: label.slice(0, 60), callback_data: `ask:${ask.turn}:${at + offset}` })));
+    rows.push([{ text: MATE_ASK_OTHER, callback_data: `ask:${ask.turn}:x` }]);
+    return rows;
+}
 /** Mint the card's tokens before the send, so a tap can never name a token that does not exist. */
 export function mintCardTokens(store, binding, proposal, now, messageId, chatId = binding.chatId) {
     const confirm = randomBytes(16).toString("hex");
@@ -579,6 +591,10 @@ async function runTelegramConversation(row, args) {
             return store.transact(() => {
                 const now = clock();
                 const parts = splitParts(reply).map((text, index) => ({ kind: "reply", text, replyTo: index === 0 ? row.messageId : null }));
+                // The lead's question to its owner: one tap per option, then "Something else".
+                const ask = store.mateAsk(turn);
+                if (ask !== null)
+                    parts.push({ kind: "reply", text: phoneText(ask.question, 1_000), keyboard: askKeyboard(ask) });
                 // Only a turn that answered may have its selection sent: a failed or revoked turn's rows were deleted with its drafts, and the state is read again here.
                 const selected = store.getMateTurn(turn)?.state === "answered" ? store.listMateTurnEvidence(turn) : [];
                 for (const image of selected)
@@ -694,7 +710,7 @@ async function runTelegramConversation(row, args) {
             store, who, session, thread, config, key: null, message: row.text, requestId: row.request,
             ...(row.context === null ? {} : { context: row.context }),
             ...(options.subscriptionRunner === undefined ? {} : { subscriptionRunner: options.subscriptionRunner }),
-            clock, evidenceRoot: options.evidenceRoot, revalidate, mediaDelivery: "documents",
+            clock, evidenceRoot: options.evidenceRoot, revalidate, mediaDelivery: "documents", channel: "telegram",
         });
     }
     finally {

package/dist/telegram-progress.js

@@ -9,6 +9,7 @@ import { chatResultHref, chatControlHref } from "./chat-controls.js";
 import { phoneText, projectLabel } from "./telegram-status.js";
 import { assignmentStatusFacts, headlineEmoji, pullRequestFactOf, requirementsOf, statusDetailLines, unverifiedWhenRefuted, taskStatusOf } from "./task-status.js";
 import { leadClaimOf } from "./lead-voice.js";
+import { leadNameOf } from "./lead-identity.js";
 import { chatTitle } from "./chat-voice.js";
 import { manualReviewOnly } from "./proof.js";
 import { failedCheckExit } from "./workspace-ui.js";
@@ -79,11 +80,11 @@ 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).
+    // The person's lead took it on: "<name> 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 };
+            facts = { ...facts, lead: lead.state, leadName: leadNameOf(store, lead.owner) };
     }
     const status = taskStatusOf(facts);
     const checkProgress = store.checkProgress(run.id);

package/dist/telegram.js

@@ -31,7 +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 { LEAD_SAY_KIND, enqueueLeadLapses, leadSayEarlier, leadSayText, leadSubjectOf } 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";
@@ -920,7 +920,7 @@ async function deliverOutboxTo(store, botId, binding, transport, owner, clock, r
         };
         /** 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 words = leadSayText(store, 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;
@@ -1064,7 +1064,7 @@ async function deliverOne(store, botId, binding, sender, notification, clock, ph
         // A short title, never the task's id or a "— revision" suffix (chat-voice.ts).
         const title = notification.taskId === null ? undefined : chatTitle(store, notification.taskId);
         const task = notification.taskId === null ? [] : [{ id: notification.taskId, ...(title === undefined ? {} : { title }) }];
-        const words = chatText(`${alreadyAccepted ? "Acceptance recorded" : notification.subject}${body === "" ? "" : `\n\n${body}`}`, task);
+        const words = chatText(`${alreadyAccepted ? "Acceptance recorded" : leadSubjectOf(store, notification, binding.approver)}${body === "" ? "" : `\n\n${body}`}`, task);
         // The task's title once: in front, unless the words already name it.
         const parts = split(`${notificationIdentity(notification, title !== undefined && mentions(words, title) ? undefined : title)}${words}`);
         const button = notification.link !== null && !alreadyAccepted && current ? factButton(phoneOrigin, notification.link) : null;
@@ -1970,6 +1970,46 @@ function applyCallback(context, update, effects) {
         }
         return;
     }
+    // The lead's question to its owner: an option is sent as their next message; "Something else" asks them to type it.
+    const askTap = /^ask:([1-9][0-9]{0,14}):([0-3]|x)$/.exec(token);
+    if (askTap !== null) {
+        if (tapChat !== binding.chatId || context.conversation === undefined) {
+            report.ignored++;
+            return;
+        }
+        const turn = Number(askTap[1]);
+        const found = store.getMateTurn(turn)?.approver === binding.approver ? store.mateAskState(turn, clock()) : { state: "expired" };
+        if (found.state !== "open") {
+            const line = found.state === "answered" ? "That question was already answered." : "That question expired. Send your answer as a message.";
+            ack(line);
+            editText(`${message.text ?? ""}\n\n${line}`.trim().slice(0, 4000));
+            return;
+        }
+        const ask = found.ask;
+        if (store.telegramConversationWaitingOn(binding.id, String(message.message_id))) {
+            ack("Your answer is on its way.");
+            return;
+        }
+        if (askTap[2] === "x") {
+            ack("Type your answer as a message.");
+            return;
+        }
+        const option = ask.options[Number(askTap[2])];
+        if (option === undefined) {
+            ack("That option is no longer there.");
+            return;
+        }
+        const focused = store.chatFocus("telegram", binding.id);
+        store.enqueueTelegramConversation({
+            binding, updateId: update.update_id, messageId: String(message.message_id), replyTo: null,
+            request: telegramRequestId(botId, binding.id, update.update_id), text: option,
+            context: focused === null ? null : focusContextFor(focused), taskId: focused, sourceRun: null,
+        }, clock());
+        report.chatQueued = (report.chatQueued ?? 0) + 1;
+        ack(`Sent: ${option}`.slice(0, 190));
+        editText(`${message.text ?? ask.question}\n\nYou chose: ${option}`.slice(0, 4000));
+        return;
+    }
     const action = store.getTelegramAction(token);
     if (action === null && context.conversation !== undefined && store.getTelegramProposalAction(token) !== null) {
         // A proposal card's button: the shared confirm door, inside this

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-", "deploy-restore-", "result-review-", "one-result-page-", "deploy-before-swap-", "one-vocabulary-", "accept-finishes-",
+    "needs-you-", "deps-lock-", "deps-state-", "upgrade-fresh-", "upgrade-path-", "deploy-restore-", "result-review-", "one-result-page-", "deploy-before-swap-", "one-vocabulary-", "accept-finishes-", "lead-promises-",
     // Playwright's browser profiles and artifacts.
     "playwright_chromiumdev_profile-", "playwright_firefoxdev_profile-", "playwright-artifacts-",
 ];

package/dist/when-html.d.ts

@@ -13,10 +13,15 @@ export declare function deadlineWords(deadline: {
 /** The exact minute in `zone` ("2026-09-30 16:39", with " UTC" when it is UTC): a time's title, one hover away. */
 export declare function fullWhen(iso: string, zone?: string): string;
 /** Every server-rendered stamp (`whenHtml`'s `<time data-when>`) inside `root`, reworded by the one formatter in the
- * viewer's zone: the same words on a desk and a phone, the exact minute in the title. The server's UTC words stay
- * only without script. Times React writes, relative ages ("3 min ago") and exact stamps (the ledger's seconds) carry
- * no `data-when` and are never touched. */
+ * viewer's zone: the same words on a desk and a phone, the exact minute in the title. An exact stamp
+ * (`exactWhenHtml`'s `data-when="exact"`, the ledger's seconds) keeps its seconds, in the viewer's zone, and its
+ * ISO title. The server's UTC words stay only without script. Times React writes and relative ages ("3 min ago")
+ * carry no `data-when` and are never touched. */
 export declare function localizeTimes(root: ParentNode, now?: Date, zone?: string): void;
+/** The exact second in `zone` ("2026-09-30 16:39:12", with " UTC" when it is UTC): an audit record's stamp. */
+export declare function exactWhen(iso: string, zone?: string): string;
+/** The `<time>` for an exact stamp: its seconds in UTC words on the server, the viewer's zone in a browser. */
+export declare function exactWhenHtml(iso: string): string;
 /** The `<time>` for a stamp: `full` is the words a desk shows ("2026-09-30 16:39 UTC"). Empty for no stamp. */
 export declare function whenHtml(iso: string | null, full: string, now?: Date): string;
 /** "2026-09-30 16:39 UTC" — the desk's words for a stamp. */

package/dist/when-html.js

@@ -75,14 +75,21 @@ export function fullWhen(iso, zone = "UTC") {
     return `${p.year}-${String(p.month).padStart(2, "0")}-${String(p.day).padStart(2, "0")} ${p.clock}${zone === "UTC" ? " UTC" : ""}`;
 }
 /** Every server-rendered stamp (`whenHtml`'s `<time data-when>`) inside `root`, reworded by the one formatter in the
- * viewer's zone: the same words on a desk and a phone, the exact minute in the title. The server's UTC words stay
- * only without script. Times React writes, relative ages ("3 min ago") and exact stamps (the ledger's seconds) carry
- * no `data-when` and are never touched. */
+ * viewer's zone: the same words on a desk and a phone, the exact minute in the title. An exact stamp
+ * (`exactWhenHtml`'s `data-when="exact"`, the ledger's seconds) keeps its seconds, in the viewer's zone, and its
+ * ISO title. The server's UTC words stay only without script. Times React writes and relative ages ("3 min ago")
+ * carry no `data-when` and are never touched. */
 export function localizeTimes(root, now = new Date(), zone = viewerZone()) {
     root.querySelectorAll("time[data-when][datetime]").forEach(node => {
         const iso = node.getAttribute("datetime") ?? "";
         if (iso === "" || Number.isNaN(new Date(iso).getTime()))
             return;
+        if (node.getAttribute("data-when") === "exact") {
+            const words = exactWhen(iso, zone);
+            if (node.textContent !== words)
+                node.textContent = words;
+            return;
+        }
         const words = shortWhen(iso, now, zone), full = fullWhen(iso, zone);
         if (node.title !== full)
             node.title = full;
@@ -90,6 +97,19 @@ export function localizeTimes(root, now = new Date(), zone = viewerZone()) {
             node.textContent = words;
     });
 }
+/** The exact second in `zone` ("2026-09-30 16:39:12", with " UTC" when it is UTC): an audit record's stamp. */
+export function exactWhen(iso, zone = "UTC") {
+    const at = new Date(iso);
+    if (Number.isNaN(at.getTime()))
+        return iso;
+    const seconds = String(at.getUTCSeconds()).padStart(2, "0");
+    const minute = fullWhen(iso, zone);
+    return zone === "UTC" ? minute.replace(/ UTC$/, `:${seconds} UTC`) : `${minute}:${seconds}`;
+}
+/** The `<time>` for an exact stamp: its seconds in UTC words on the server, the viewer's zone in a browser. */
+export function exactWhenHtml(iso) {
+    return `<time data-when="exact" datetime="${escape(iso)}" title="${escape(iso)}">${escape(exactWhen(iso))}</time>`;
+}
 /** The `<time>` for a stamp: `full` is the words a desk shows ("2026-09-30 16:39 UTC"). Empty for no stamp. */
 export function whenHtml(iso, full, now = new Date()) {
     if (iso === null || iso === "")

package/dist/work-index.d.ts

@@ -34,6 +34,8 @@ export type WorkIndexItem = {
         digest: string;
     } | null;
     evidence: 'recorded';
+    /** The viewer's own lead took it on (lead-voice.ts): "<name> is on it.", by the name they gave it, read now. */
+    lead?: string;
 };
 export type WorkIndexOptions = {
     view?: WorkView;