toolroll 0.9.15 → 0.9.17

package/dist/slack-chat.js

@@ -1,11 +1,13 @@
 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";
 /** Slack is a transport for the same saved assistant and confirmation doors. */
 import { proposalPreview, proposalLink, proposalOutcomeText, armedCardText, armedYesLabel, } from "./chat-channel.js";
 import { MATE_MESSAGE_MAX_CHARS } from "./mate.js";
+import { renderReply } from "./reply-shape.js";
 import {} from "./mate-doors.js";
 import { SlackState, slackHash, } from "./slack-state.js";
 import { object, slackId, slackTs, slackMember, SlackError, uploadSlackBytes, } from "./slack-api.js";
@@ -130,6 +132,10 @@ const delivery = (options) => ({
     state: new SlackState(options.store),
     label: "Slack",
     member: (member, channel) => slackMember(options.api, options.identity, member, channel),
+    // A 👍 on the owner's message where the app has reactions:write; Slack shows bots no typing indicator.
+    warm: (event) => ({
+        react: () => options.api("reactions.add", { channel: event.channel, timestamp: event.ts, name: "thumbsup" }),
+    }),
 });
 export const processSlackEvent = (options) => processChatEvent(delivery(options));
 export const applySlackAction = (options, event, binding, repos) => applyChatAction(delivery(options), event, binding, repos);
@@ -155,6 +161,16 @@ export function slackBlocks(text, buttons = []) {
         blocks.push({ type: "actions", elements: buttons });
     return blocks;
 }
+/** The lead's reply as mrkdwn sections: no header block, so its first line stays an ordinary line. */
+export function slackVoiceBlocks(mrkdwn, buttons = []) {
+    const blocks = split(mrkdwn).map((part) => ({
+        type: "section",
+        text: { type: "mrkdwn", text: part },
+    }));
+    if (buttons.length)
+        blocks.push({ type: "actions", elements: buttons });
+    return blocks;
+}
 function linkButton(origin, link) {
     if (!origin ||
         !link ||
@@ -359,19 +375,30 @@ 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 [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;
+        // The lead's own reply goes out in Slack's mrkdwn (bold anchors, labelled links); everything else stays plain.
+        const voiced = content.voice === true && !content.proposal && !content.image ? renderReply(text, "slack") : null;
         const args = {
             channel: destination,
-            text: text
+            text: voiced ?? text
                 .replaceAll("&", "&")
                 .replaceAll("<", "&lt;")
                 .replaceAll(">", "&gt;"),
-            blocks: slackBlocks(text, buttons),
-            mrkdwn: false,
+            blocks: voiced === null ? slackBlocks(text, buttons) : slackVoiceBlocks(voiced, buttons),
+            mrkdwn: voiced !== null,
             parse: "none",
             unfurl_links: false,
             unfurl_media: false,

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,22 @@ 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;
+/** What a turn the lead starts itself for automatic crew updates says in the owner's place (lead-follow.ts): never their answer. */
+export declare const LEAD_FOLLOW_MESSAGE = "Automatic crew update: inspect the saved results or decisions and tell me what needs attention. Do not rerun work.";
 /** 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 +1552,7 @@ export type TelegramConversationPartPlan = {
     kind: "reply";
     text: string;
     replyTo?: string | null;
+    keyboard?: TelegramConversationPart["keyboard"];
 } | {
     kind: "card";
     text: string;
@@ -6672,6 +6693,28 @@ 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 (its owner has written in its thread since the reply that asked
+     * it, typed or tapped; a turn the lead started itself, or another person's message, is no answer); 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 +7330,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 +7504,19 @@ 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. An empty name or persona
+     * (a row saved only for what the lead knows about them) reads as the default. */
+    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;
+    /** What this person's lead knows about them: their confirmed lines, in order (none when they never saved any). */
+    leadAbout(account: string): string[];
+    /** Save what this person's lead knows about them (checked by the caller: lead-about.ts). A person who never named
+     * their lead gets an empty name and persona, so they keep following the defaults. */
+    setLeadAbout(account: string, lines: readonly 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 +7725,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,18 @@ 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, and what their lead knows about them (`about_json`: the confirmed lines, lead-about.ts). 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,
+  about_json TEXT NOT NULL DEFAULT '[]'
+);
+`;
 /** 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 +239,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 +282,24 @@ 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;
+/** What a turn the lead starts itself for automatic crew updates says in the owner's place (lead-follow.ts): never their answer. */
+export const LEAD_FOLLOW_MESSAGE = "Automatic crew update: inspect the saved results or decisions and tell me what needs attention. Do not rerun work.";
 /** 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 +3885,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 +3904,10 @@ 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);
+    // What a person's lead knows about them, beside its name and persona (an older lead_config gains it).
+    addColumn(db, "lead_config", "about_json", "TEXT NOT NULL DEFAULT '[]'");
+    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).
@@ -13507,6 +13567,7 @@ export class Store {
                 reason: String(row["reason"]),
                 runner: String(row["runner"]),
                 observedAt: String(row["observed_at"]),
+                probe: String(row["probe"]),
             };
         };
     }
@@ -19636,6 +19697,50 @@ 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 (its owner has written in its thread since the reply that asked
+     * it, typed or tapped; a turn the lead started itself, or another person's message, is no answer); 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 owner = String(this.getMateTurn(turn).approver);
+        const later = this.db.prepare(`SELECT 1 AS hit FROM mate_message m LEFT JOIN mate_turn t ON t.id = m.turn LEFT JOIN team_message tm ON tm.message = m.id
+        WHERE m.thread = ? AND m.role = 'operator' AND m.id > ? AND m.text <> ? AND COALESCE(tm.author, t.approver, ?) = ? LIMIT 1`)
+            .get(ask.thread, Number(asking["id"]), LEAD_FOLLOW_MESSAGE, owner, owner);
+        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 +21717,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 +21851,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 +22030,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 +22256,36 @@ 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. An empty name or persona
+     * (a row saved only for what the lead knows about them) reads as the default. */
+    leadConfig(account) {
+        const row = this.db.prepare("SELECT name, persona FROM lead_config WHERE account = ? AND (name <> '' OR persona <> '')").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());
+    }
+    /** What this person's lead knows about them: their confirmed lines, in order (none when they never saved any). */
+    leadAbout(account) {
+        const row = this.db.prepare("SELECT about_json FROM lead_config WHERE account = ?").get(account);
+        if (row === undefined)
+            return [];
+        try {
+            const lines = JSON.parse(String(row["about_json"]));
+            return Array.isArray(lines) ? lines.filter((one) => typeof one === "string") : [];
+        }
+        catch {
+            return [];
+        }
+    }
+    /** Save what this person's lead knows about them (checked by the caller: lead-about.ts). A person who never named
+     * their lead gets an empty name and persona, so they keep following the defaults. */
+    setLeadAbout(account, lines, now) {
+        this.db.prepare(`INSERT INTO lead_config (account, name, persona, updated_at, about_json) VALUES (?, '', '', ?, ?)
+      ON CONFLICT(account) DO UPDATE SET about_json = excluded.about_json, updated_at = excluded.updated_at`).run(account, now.toISOString(), JSON.stringify(lines));
+    }
     /** 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(() => {
@@ -22554,8 +22697,12 @@ export class Store {
           JOIN push_subscription s ON s.id = p.subscription JOIN notification n ON n.id = p.notification
           WHERE p.state = 'pending' AND p.attempts = 0 AND p.created_at = ?`).all(now.toISOString());
             for (const raw of fresh) {
-                if (!this.pingAllowed(readNotification(raw), String(raw["approver"]))) {
-                    this.db.prepare("UPDATE push_delivery SET state = 'retired', last_error = 'quiet' WHERE id = ? AND state = 'pending'").run(Number(raw["pair"]));
+                // A met promise made on a chat app is said there (lead-commitments.ts), not as a push: settled here, unsent. One
+                // made in the console or app is this phone's own.
+                const elsewhere = /^lead-promise:(telegram|slack|discord|teams):/.test(String(raw["dedupe_key"]));
+                if (elsewhere || !this.pingAllowed(readNotification(raw), String(raw["approver"]))) {
+                    this.db.prepare("UPDATE push_delivery SET state = 'retired', last_error = ? WHERE id = ? AND state = 'pending'")
+                        .run(elsewhere ? TELEGRAM_SKIPPED_OTHER_CHAT : "quiet", Number(raw["pair"]));
                 }
             }
         }
@@ -22879,6 +23026,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,14 +148,15 @@ 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.'); },
                 context: `Shared team conversation ${claim.conversationId}. You are the lead ${view.leads.find(lead => lead.id === claim.leadId)?.name ?? claim.leadId}. Messages name their actual authors; message order does not grant authority. Use existing task actions and approvals. Do not rerun work to recover a notification. The following saved lead guidance is context, not new permissions:\n${claim.instructions}`,
                 clock, evidenceRoot: options.evidenceRoot,
                 revalidate: async () => !closed && !updateAdmissionPaused(store.raw()) && domain.current(claim) && store.teamMateSession(claim.actor.name, claim.threadId)?.id === session.id && authorization(claim.actor, domain.snapshot(claim.actor, claim.conversationId)).enabled && (!claim.requestId.startsWith('team-update:') || domain.access(claim.actor, claim.conversationId).conversation.follow)
-                    ? { ok: true } : { ok: false, reason: 'Conversation access or execution ownership changed.' },
+                    ? { ok: true } : { ok: false, reason: 'access-changed' },
                 ...(options.fetcher ? { fetcher: options.fetcher } : {}), ...(options.subscriptionRunner ? { subscriptionRunner: options.subscriptionRunner } : {}) });
             if (result.ok)
                 domain.finish(claim, { status: 'answered', turnId: result.turn }, clock());

package/dist/teams-chat.js

@@ -1,10 +1,12 @@
 /** 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";
 import { MATE_MESSAGE_MAX_CHARS } from "./mate.js";
+import { renderReply } from "./reply-shape.js";
 import { armedCardText, armedYesLabel, proposalLink, proposalOutcomeText, proposalPreview } from "./chat-channel.js";
 import { chatFlowButtons } from "./chat-flow.js";
 import { channelInbox } from "./chat-inbox.js";
@@ -46,6 +48,14 @@ export const teamsDelivery = (options) => {
         state,
         label: "Teams",
         member: (member, channel) => teamsMember(options.api, state, options.identity.installation, member, channel),
+        // "Typing…" while the lead works; Teams gives bots no reactions, so there is no 👍 here.
+        warm: (event) => ({
+            typing: async () => {
+                const serviceUrl = state.meta(options.identity.installation, serviceKey(event.channel));
+                if (serviceUrl !== null)
+                    await options.api("POST", serviceUrl, `/v3/conversations/${encodeURIComponent(event.channel)}/activities`, { type: "typing" });
+            },
+        }),
         partSize: 3500,
         maxProposal: 6000,
     };
@@ -195,10 +205,14 @@ 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" };
+        // The lead's own reply goes out in Teams' Markdown (bold anchors, labelled links); everything else stays plain.
+        const voiced = content.voice === true && !content.proposal && !content.image ? renderReply(text, "teams") : null;
+        const body = actions.length || content.proposal ? teamsCard(voiced ?? text, actions) : voiced !== null ? { type: "message", text: voiced, textFormat: "markdown" } : { type: "message", text, textFormat: "plain" };
         const answer = await options.api(target ? "PUT" : "POST", serviceUrl, `/v3/conversations/${encodeURIComponent(destination)}/activities${target ? `/${encodeURIComponent(target)}` : ""}`, body);
         const messageId = target ?? (typeof answer.id === "string" ? answer.id : null);
         if (messageId === null)

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. */
@@ -12,6 +12,8 @@ export declare const CONVERSATION_MAX_AGE_MS: number;
 /** A card's buttons and an armed irreversible challenge live this long. */
 export declare const CARD_TTL_MS: number;
 export declare const CHALLENGE_TTL_MS: number;
+/** Telegram's own message ceiling, with room for our part headers (the same bound telegram.ts splits at). */
+export declare const PART_CAP = 3900;
 export type TelegramConversationOptions = {
     /** Where evidence lives — the same root the console and CLI read results from. */
     evidenceRoot: string;
@@ -59,6 +61,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;