toolroll 0.9.15 → 0.9.16

package/dist/browser-crew.js

@@ -47,6 +47,7 @@ export function browserCrewFromIndex(page, conversationId) {
             id: summary.rootId, title: summary.title, project: summary.repo,
             state: summary.assignmentState, label: status.label, tone: status.tone, href: link(href), resultHref: resultHref === null ? null : link(resultHref),
             action: action === null || actionHref === null ? null : { label: action.label, href: link(actionHref) },
+            ...(summary.lead === undefined ? {} : { lead: summary.lead }),
         };
         return { item, rank: status.rank };
     });

package/dist/browser-workspace.d.ts

@@ -46,6 +46,8 @@ export type BrowserCrewItem = {
         label: string;
         href: string;
     } | null;
+    /** "<name> is on it.": the person's own lead took it on, by the name they gave it. */
+    lead?: string;
 };
 export type BrowserMessage = {
     id: number;
@@ -1024,6 +1026,8 @@ export type BrowserWorkspace = {
     user: string;
     csrf: string;
     sensitive: boolean;
+    /** What this person named their lead (Settings → Lead): the chat header and every lead message say it. */
+    leadName?: string;
     refreshUrl: string;
     receipt: {
         request: string;
@@ -1118,6 +1122,7 @@ export type BrowserHome = {
     allHref: string;
     /** What this person's lead is doing now and when it last acted (lead-voice.ts); its task when it named one. */
     lead?: {
+        name?: string;
         doing: string;
         at: string;
         href: string | null;

package/dist/chat-ask.d.ts

@@ -0,0 +1,28 @@
+/**
+ * The lead's question to its owner (ask_owner) in Slack, Discord and Teams.
+ *
+ * The reply's last part carries the question with one button per option and
+ * one for "Something else", minted when the part is planned (chat_ask_action).
+ * A tapped option is sent as the owner's next message in their own chat with
+ * Toolroll, so the lead reads it like anything they typed; "Something else"
+ * asks them to type it. Buttons are drawn only in that own chat (any thread of
+ * it): in a room the question goes out as text, since a tap there is not the
+ * owner's own message. A button works once, only for the person the lead
+ * asked, and only while nobody has written in that thread since.
+ */
+import type { ChatBinding, ChatEvent, ChatState } from "./chat-delivery-state.js";
+import { type MateAsk, type Store } from "./store.js";
+/** The question as text with its options, where no buttons are drawn. */
+export declare function chatAskText(ask: Pick<MateAsk, "question" | "options">): string;
+/** The live buttons on one part, in the order they were minted: the options, then "Something else". None when the part
+ * is not in its owner's own chat with Toolroll (a room), where a tap could not be their message. */
+export declare function chatAskButtons(state: ChatState, part: number, now: Date): Array<{
+    token: string;
+    label: string;
+    words: boolean;
+}>;
+/** A tapped ask button, inside the action's transaction; false when the token isn't one. */
+export declare function applyChatAskTap(options: {
+    store: Store;
+    state: ChatState;
+}, event: ChatEvent, binding: ChatBinding, token: string, now: Date): boolean;

package/dist/chat-ask.js

@@ -0,0 +1,77 @@
+import { chatHash } from "./chat-delivery-state.js";
+import { MATE_ASK_OTHER } from "./store.js";
+/** The question as text with its options, where no buttons are drawn. */
+export function chatAskText(ask) {
+    return [ask.question, ...ask.options.map(one => `• ${one}`), `• ${MATE_ASK_OTHER}: say it in your own words`].join("\n");
+}
+/** The live buttons on one part, in the order they were minted: the options, then "Something else". None when the part
+ * is not in its owner's own chat with Toolroll (a room), where a tap could not be their message. */
+export function chatAskButtons(state, part, now) {
+    const row = state.prepare("SELECT p.payload,e.channel,b.channel AS own FROM chat_part p JOIN chat_event e ON e.id=p.event JOIN chat_binding b ON b.id=e.binding WHERE p.id=?").get(part);
+    if (row === undefined)
+        return [];
+    const content = JSON.parse(String(row["payload"]));
+    if ((content.channel ?? row["channel"]) !== row["own"])
+        return [];
+    const options = content.ask?.options ?? [];
+    return state.prepare("SELECT token,choice FROM chat_ask_action WHERE part=? AND consumed IS NULL AND expires>? ORDER BY rowid").all(part, now.toISOString())
+        .map(one => {
+        const label = one.choice === null ? MATE_ASK_OTHER : options[Number(one.choice)] ?? null;
+        return label === null ? null : { token: String(one.token), label: label.slice(0, 75), words: one.choice === null };
+    })
+        .filter((one) => one !== null);
+}
+/** Show the question again with what happened, and without its buttons. */
+function repaint(state, part, event, line) {
+    const row = state.prepare("SELECT payload FROM chat_part WHERE id=?").get(part);
+    const before = row === undefined ? { text: "" } : JSON.parse(String(row["payload"]));
+    const content = { text: `${before.text}\n\n${line}`.slice(0, 3400), edit: event.ts, ...(before.channel === undefined ? {} : { channel: before.channel }) };
+    state.prepare("UPDATE chat_part SET payload=?,state='pending',next_at=NULL WHERE id=?").run(JSON.stringify(content), part);
+}
+/** A tapped ask button, inside the action's transaction; false when the token isn't one. */
+export function applyChatAskTap(options, event, binding, token, now) {
+    const { store, state } = options;
+    const action = state.prepare("SELECT a.*,p.message,e.binding AS owner,e.channel FROM chat_ask_action a JOIN chat_part p ON p.id=a.part JOIN chat_event e ON e.id=p.event WHERE a.token=?").get(token);
+    if (action === undefined)
+        return false;
+    const say = (text) => state.plan(event.id, [{ text }], now);
+    // Bound to the person, their own chat and the exact message the button rode.
+    if (Number(action["owner"]) !== binding.id || action["channel"] !== event.channel || event.channel !== binding.channel || action["message"] !== event.ts) {
+        say("That button expired or was already used.");
+        return true;
+    }
+    const turn = Number(action["turn"]), part = Number(action["part"]);
+    const found = store.getMateTurn(turn)?.approver === binding.approver ? store.mateAskState(turn, now) : { state: "expired" };
+    const expired = found.state === "expired" || String(action["expires"]) <= now.toISOString();
+    if (action["consumed"] !== null || found.state !== "open" || expired) {
+        state.prepare("UPDATE chat_ask_action SET consumed=? WHERE part=? AND consumed IS NULL").run(now.toISOString(), part);
+        if (found.state === "answered" || (action["consumed"] !== null && !expired)) {
+            repaint(state, part, event, "This question was already answered.");
+            state.finish(event.id);
+        }
+        // A question this old can no longer be edited in place: the answer to the tap is a new message.
+        else
+            say("This question expired. If it still matters, send your answer as a message.");
+        return true;
+    }
+    const ask = found.ask;
+    if (action["choice"] === null) {
+        say("Type your answer here as your next message.");
+        return true;
+    }
+    const option = ask.options[Number(action["choice"])];
+    if (option === undefined) {
+        say("That option is no longer there.");
+        return true;
+    }
+    state.prepare("UPDATE chat_ask_action SET consumed=? WHERE part=? AND consumed IS NULL").run(now.toISOString(), part);
+    // The option is the owner's next message, answered like one they typed.
+    state.enqueue({
+        id: chatHash(`${state.channel}:ask:${event.id}`).slice(0, 32), installation: event.installation, binding: binding.id, kind: "message",
+        channel: event.channel, member: event.member, ts: event.ts, thread: event.thread,
+        payload: JSON.stringify({ text: option, originalLength: option.length }), created: now.toISOString(),
+    });
+    repaint(state, part, event, `You chose: ${option}`);
+    state.finish(event.id);
+    return true;
+}

package/dist/chat-channel.js

@@ -117,7 +117,7 @@ export function mirrorToTaskChat(store, who, taskId, surface, message, reply, no
 }
 /** The one short message a person gets when their question could not be answered. */
 export function couldNotAnswerText(reason) {
-    return `I couldn't answer that just now: ${reason}. Ask again, or open the console.`;
+    return `I couldn't answer that just now: ${reason.replace(/\.$/, "")}. Ask again, or open the console.`;
 }
 export function tooLongText(length) {
     return `That message is ${length.toLocaleString("en-US")} characters; chat takes up to ${MATE_MESSAGE_MAX_CHARS.toLocaleString("en-US")}. Nothing was sent to the assistant. Send it in shorter parts, or say which part matters most.`;
@@ -511,6 +511,11 @@ export const CHAT_ACTION_PARITY = {
     propose_teammate: { support: "direct", how: "Adds a teammate from a template or a soul file, changes one section of its soul file (or the whole short file), pauses, resumes or removes it, passes it a note, or answers its question for the person asked, through the shared confirm door.", gap: "Soul files longer than one message are edited on the console's teammate page; the phone changes one section at a time." },
     get_flow_insights: { support: "direct", how: "Read during a turn: where each flow's cards pass, fail or are sent back, how long they wait, how its scripts did, and a run's log.", gap: null },
     propose_flow: { support: "direct", how: "Creates or changes a flow, adds, moves, approves, sends back or cancels its cards, comments on them (@name pings that person), sets their owner, follows them, saves the project's scripts, and adds, pauses or removes its triggers, through the shared confirm door; a long drawing opens the secure review. Work a card files is an ordinary task under the usual approvals.", gap: "The flow canvas itself is on the console; the phone confirms cards but draws nothing. Webhook addresses and the Linear key are set on the console's Triggers panel." },
+    commit_to: { support: "direct", how: "Records what the lead promised to follow up on (a task, attempt, check or time; 7 days at most). The follow pass says one line when it is met, in the shared conversation and on the chat the promise was made on.", gap: null },
+    release_commitment: { support: "direct", how: "Stops following up on one of the person's open promises, with the reason.", gap: null },
+    remember: { support: "direct", how: "Proposes a correction or lasting preference as a decision or project instruction card, through the shared confirm door.", gap: null },
+    get_integrations: { support: "direct", how: "Read during a turn: which chat apps, email, GitHub, project tools and monitoring are Connected, Not set up or Broken, as Settings → Integrations shows them.", gap: null },
+    ask_owner: { support: "direct", how: "One question with 2-4 options and Something else, drawn as buttons under the reply; the tapped option is sent as the person's next message.", gap: null },
     search_project_memory: { support: "direct", how: "Read during a turn: one search over decisions, references, lessons and the conversations the person may read.", gap: null },
     list_tasks: { support: "direct", how: "Read during a turn.", gap: null },
     get_task: {

package/dist/chat-controls.d.ts

@@ -66,6 +66,14 @@ export declare const CHAT_CONTROLS: {
         readonly label: "Manage Discord";
         readonly href: "/settings/discord";
     };
+    readonly lead: {
+        readonly label: "Name your lead";
+        readonly href: "/settings/lead";
+    };
+    readonly integrations: {
+        readonly label: "Set up integrations";
+        readonly href: "/settings/integrations";
+    };
     readonly settings: {
         readonly label: "Open settings";
         readonly href: "/settings";

package/dist/chat-controls.js

@@ -18,6 +18,9 @@ export const CHAT_CONTROLS = {
     workers: { label: "Manage workers", href: "/fleet" },
     slack: { label: "Manage Slack", href: "/settings/slack" },
     discord: { label: "Manage Discord", href: "/settings/discord" },
+    // Settings → Lead: the lead's name and persona, changed there by its person.
+    lead: { label: "Name your lead", href: "/settings/lead" },
+    integrations: { label: "Set up integrations", href: "/settings/integrations" },
     settings: { label: "Open settings", href: "/settings" },
     permissions: { label: "Review permissions", href: "/settings" },
     providers: { label: "Connect an agent", href: "/settings#providers" },

package/dist/chat-delivery-state.d.ts

@@ -1,4 +1,4 @@
-import type { Store } from "./store.js";
+import { type Store } from "./store.js";
 export type ChatIdentity = {
     installation: string;
     team?: string;
@@ -95,6 +95,11 @@ export type ChatContent = {
             label: string;
         }>;
     };
+    /** The lead's question to its owner rides this part: its options, then "Something else". */
+    ask?: {
+        turn: number;
+        options: string[];
+    };
 };
 export declare const chatHash: (text: string) => string;
 export declare class ChatState {

package/dist/chat-delivery-state.js

@@ -1,5 +1,6 @@
 /** Durable private-chat receipts. Each transport has its own tables and lease. */
 import { createHash, randomBytes } from "node:crypto";
+import { MATE_ASK_TTL_MS } from "./store.js";
 const CHAT_SCHEMA = `
 CREATE TABLE IF NOT EXISTS chat_binding (
  id INTEGER PRIMARY KEY AUTOINCREMENT, installation TEXT NOT NULL,
@@ -93,6 +94,15 @@ CREATE TABLE IF NOT EXISTS chat_question_prompt (
 );
 CREATE INDEX IF NOT EXISTS chat_question_prompt_open ON chat_question_prompt(binding, consumed);
 `;
+/** The lead's question to its owner (ask_owner) in the chat app: one button per option (choice is its index) and one for
+ * "Something else" (choice NULL). A tap sends the option as the owner's next message. Never in CHAT_TABLES. */
+const CHAT_ASK_SCHEMA = `
+CREATE TABLE IF NOT EXISTS chat_ask_action (
+ token TEXT PRIMARY KEY, part INTEGER NOT NULL REFERENCES chat_part(id) ON DELETE CASCADE,
+ turn INTEGER NOT NULL, choice INTEGER, expires TEXT NOT NULL, consumed TEXT
+);
+CREATE INDEX IF NOT EXISTS chat_ask_action_turn ON chat_ask_action(turn);
+`;
 const CHAT_TABLES = [
     "chat_binding",
     "chat_pair",
@@ -111,7 +121,7 @@ export class ChatState {
         this.channel = channel;
     }
     prepare(sql) {
-        return this.db.prepare(sql.replace(/\bchat_(binding|pair|event|part|action|progress|runtime|room|meta|flow_action|flow_prompt|question_action|question_prompt)\b/g, `${this.channel}_$1`));
+        return this.db.prepare(sql.replace(/\bchat_(binding|pair|event|part|action|progress|runtime|room|meta|flow_action|flow_prompt|question_action|question_prompt|ask_action)\b/g, `${this.channel}_$1`));
     }
     /** Small transport facts a channel must remember per chat (a Teams service URL). Never credentials. */
     meta(installation, key) {
@@ -273,6 +283,9 @@ export class ChatState {
                 if (Number(inserted.changes) && part.question)
                     for (const one of part.question.choices)
                         this.prepare("INSERT INTO chat_question_action(token,part,question,choice,expires) VALUES(?,?,?,?,?)").run(randomBytes(16).toString("hex"), Number(inserted.lastInsertRowid), part.question.id, one.choice, new Date(now.getTime() + 7 * 86_400_000).toISOString());
+                if (Number(inserted.changes) && part.ask)
+                    for (const choice of [...part.ask.options.map((_, index) => index), null])
+                        this.prepare("INSERT INTO chat_ask_action(token,part,turn,choice,expires) VALUES(?,?,?,?,?)").run(randomBytes(16).toString("hex"), Number(inserted.lastInsertRowid), part.ask.turn, choice, new Date(now.getTime() + MATE_ASK_TTL_MS).toISOString());
                 if (Number(inserted.changes) && part.flow)
                     for (const action of part.flow.actions)
                         this.prepare("INSERT INTO chat_flow_action(token,part,card,entry,action,expires) VALUES(?,?,?,?,?,?)").run(randomBytes(16).toString("hex"), Number(inserted.lastInsertRowid), part.flow.card, part.flow.entry, action, new Date(now.getTime() + 7 * 86_400_000).toISOString());
@@ -294,7 +307,7 @@ export class ChatState {
         return !!this.prepare("SELECT 1 FROM chat_runtime WHERE installation=? AND owner=? AND lease_until>?").get(installation, owner, now.toISOString());
     }
 }
-export const chatSchema = (channel) => (CHAT_SCHEMA + CHAT_ROOM_SCHEMA + CHAT_FLOW_SCHEMA + CHAT_QUESTION_SCHEMA).replaceAll("chat_", `${channel}_`);
+export const chatSchema = (channel) => (CHAT_SCHEMA + CHAT_ROOM_SCHEMA + CHAT_FLOW_SCHEMA + CHAT_QUESTION_SCHEMA + CHAT_ASK_SCHEMA).replaceAll("chat_", `${channel}_`);
 export const chatTables = (channel) => CHAT_TABLES.map((name) => name.replace("chat_", `${channel}_`));
 export class ChatDeliveryError extends Error {
     code;

package/dist/chat-delivery.js

@@ -1,5 +1,6 @@
 /** Shared saved replies, explicit confirmations and progress for private chat transports. */
 import { answerChatQuestionPrompt, applyChatQuestionTap, questionParts } from "./teammate-question.js";
+import { applyChatAskTap, chatAskText } from "./chat-ask.js";
 import { channelRepos, resolveChannelMate, proposalPreview, proposalOutcomeText, confirmedLink, confirmedCardText, replyContextFor, mirrorToTaskChat, focusContextFor, taskInCeiling, tooLongText, } from "./chat-channel.js";
 import { MATE_MESSAGE_MAX_CHARS, runMateTurn } from "./mate.js";
 import { confirmMateProposal, dismissMateProposal, } from "./mate-doors.js";
@@ -11,7 +12,9 @@ import { triggerConfigOf } from "./flow-triggers.js";
 import { telegramProgressCard } from "./telegram-progress.js";
 import { enqueueEveningDigests, finishedView, isTaskFact, joinsBatch, needsPerson, quietCardView } from "./chat-quiet.js";
 import { BATCH_MS, chatText, chatTitle } 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 { leadChannelOf } from "./lead-context.js";
+import { promiseChannelOf } from "./lead-commitments.js";
 import { phoneText, PHONE_HELP, phoneCommand, phoneStatus, phoneTaskView, phoneTaskChoices, phoneTaskListText, resolvePhoneTask, phoneFocusText, PHONE_NO_MATCH, PHONE_BACK_TO_LEAD } from "./telegram-status.js";
 import { applyRoomInbound, conversationRow, roomCardApprover, roomCommand, roomGrantAllowed, roomMessagesAfter, roomMessageText, teamDomain } from "./chat-rooms.js";
 import { isTelegramProgressNotification, proposalTaskOf } from "./store.js";
@@ -258,6 +261,8 @@ export async function processChatEvent(options) {
                     .prepare("UPDATE chat_event SET payload=? WHERE id=? AND state='queued'")
                     .run(JSON.stringify({ ...input, about }), event.id);
             }
+            // An unknown surface names no channel rather than a guess.
+            const channel = leadChannelOf(options.label);
             const outcome = await runMateTurn({
                 store,
                 who: resolved.who,
@@ -276,6 +281,7 @@ export async function processChatEvent(options) {
                 clock: () => nowOf(options),
                 evidenceRoot: options.evidenceRoot,
                 mediaDelivery: "documents",
+                ...(channel === undefined ? {} : { channel }),
                 revalidate: async () => {
                     try {
                         await channelAccess(options, binding, resolved.who.ceilingDigest);
@@ -337,6 +343,12 @@ export async function processChatEvent(options) {
             .find((message) => message.turn === turn.id && message.role === "assistant")?.text ?? "The reply is no longer in the saved thread.";
         // The lead's answer about one task names it: a reply to it stays on that task.
         const parts = splitChatText(reply, options.partSize).map((text) => (about === null ? { text } : { text, task: about.task, ...(about.run === null ? {} : { run: about.run }) }));
+        // The lead's question to its owner: its options as buttons, then "Something else", in their own chat (any thread);
+        // in a room a tap is not their message, so the question and its options go out as text.
+        const ask = store.mateAsk(turn.id);
+        if (ask !== null)
+            parts.push({ ...(event.channel === binding.channel ? { text: phoneText(ask.question, 1000), ask: { turn: ask.turn, options: ask.options } } : { text: phoneText(chatAskText(ask), 1000) }),
+                ...(about === null ? {} : { task: about.task, ...(about.run === null ? {} : { run: about.run }) }) });
         for (const image of store.listMateTurnEvidence(turn.id))
             parts.push({
                 text: image.caption,
@@ -432,6 +444,9 @@ export function applyChatAction(options, event, binding, repos) {
         // A teammate's question's button (v93) is answered by the question's own door.
         if (applyChatQuestionTap({ store, state, label: options.label }, event, binding, token, now))
             return;
+        // The lead's question to its owner: the tapped option becomes their next message.
+        if (applyChatAskTap({ store, state }, event, binding, token, now))
+            return;
         const action = state
             .prepare("SELECT a.*,p.message,e.binding,e.channel,e.thread FROM chat_action a JOIN chat_part p ON p.id=a.part JOIN chat_event e ON e.id=p.event WHERE token=?")
             .get(token);
@@ -665,6 +680,8 @@ export async function planChatNotifications(options) {
                 const personal = notification.recipient !== null;
                 if (notification.createdAt >= binding.created &&
                     notification.resolvedAt === null &&
+                    // A promise the lead made on another chat is reported there (lead-commitments.ts).
+                    (promiseChannelOf(notification) ?? state.channel) === state.channel &&
                     // Pings follow responsibility: the lead's work, this person's own act and a muted project stay in the console.
                     store.pingAllowed(notification, binding.approver) &&
                     // A flow decision for "anyone who approves" reaches every approver who can see the project.
@@ -680,7 +697,7 @@ export async function planChatNotifications(options) {
                     const quiet = !personal && isTaskFact(notification) && store.notificationPreference(binding.approver).mode === "quiet";
                     if (notification.kind === LEAD_SAY_KIND) {
                         // The lead's words (lead-voice.ts): one message, repainted in place when a later say joins it.
-                        const content = { text: leadSayText(notification),
+                        const content = { text: leadSayText(store, notification),
                             ...(notification.link ? { link: { label: "Open", path: notification.link } } : {}) };
                         const earlier = leadSayEarlier(store, notification).map(one => state.prepare("SELECT id FROM chat_part WHERE event=?")
                             .get(chatHash(`${options.state.channel}:notice:${binding.id}:${one}`))).find(one => one !== undefined);
@@ -784,7 +801,7 @@ export async function planChatNotifications(options) {
                         state.plan(id, [
                             {
                                 // Never the task's id or a "— revision" suffix (chat-voice.ts).
-                                text: chatText(phoneText(notification.body === "" ? notification.subject : `${notification.subject}\n\n${notification.body}`, 2500), notification.taskId === null ? [] : [{ id: notification.taskId, title: chatTitle(store, notification.taskId) }]),
+                                text: chatText(phoneText(notification.body === "" ? leadSubjectOf(store, notification, binding.approver) : `${leadSubjectOf(store, notification, binding.approver)}\n\n${notification.body}`, 2500), notification.taskId === null ? [] : [{ id: notification.taskId, title: chatTitle(store, notification.taskId) }]),
                                 ...(notification.taskId ? { task: notification.taskId } : {}),
                                 ...(run ? { run: run.id } : {}),
                                 ...(notification.link

package/dist/chat-quiet.js

@@ -11,6 +11,7 @@ import { assignmentStatusFacts, headlineEmoji, taskStatusOf } from "./task-statu
 import { asksToFinish, batchLine, chatText, chatTitle, factLinkLabel, mentions, READY_ACTIONS } from "./chat-voice.js";
 import { phoneText, projectLabel } from "./telegram-status.js";
 import { isLifecycleNotification } from "./store.js";
+import { leadSubjectOf } from "./lead-voice.js";
 /** What always makes a new message, even in quiet mode: a question or approval waiting, a failure or other
  * attention fact, a result Ready for review, a security alert or release, and anything addressed to one person
  * (a sign-in or plan-limit pause, an evening digest). */
@@ -128,7 +129,8 @@ function lineOf(store, item, now, root, viewer) {
     const row = item.notification === null ? null : store.notificationById(item.notification);
     if (row !== null && row.kind !== "run-finished") {
         // Never the task's id or a "— revision" suffix; the title once, in front unless the words already name it.
-        const words = chatText(phoneText(row.body === "" ? row.subject : `${row.subject}\n\n${row.body}`, 2500), [{ id: ref.externalId, title: summary }]);
+        const subject = leadSubjectOf(store, row, viewer);
+        const words = chatText(phoneText(row.body === "" ? subject : `${subject}\n\n${row.body}`, 2500), [{ id: ref.externalId, title: summary }]);
         const { phrase, headline } = updatePhrase(row);
         return { also: [], link: row.link === null ? { label: "Open task", path: chatControlHref("task", ref.externalId) } : { label: factLinkLabel(row.link), path: row.link },
             fact: { summary, headline, checks: null, report: false, completedBy: null, update: { words: mentions(words, summary) ? words : `${summary} · ${words}`, phrase } } };
@@ -149,7 +151,7 @@ function lineOf(store, item, now, root, viewer) {
         pullRequest,
         // The lead speaks as "I" for what it did: the work it filed or approved, or the completion it recorded.
         lead: card.status.headline === "Complete" ? card.completedByLead : store.leadWorkOf(item.taskRef) !== null,
-        ...(card.facts.lead === "on-it" ? { leadOnIt: true } : {}),
+        ...(card.facts.lead === "on-it" ? { leadOnIt: true, ...(card.facts.leadName === undefined ? {} : { leadName: card.facts.leadName }) } : {}),
     };
     // A result ready for a person offers its real next step, then a look first.
     if (asksToFinish(fact))

package/dist/chat-voice.d.ts

@@ -1,8 +1,3 @@
-/** How chat sounds: a teammate talking. One or two short sentences, outcome
- * first, plain words, one action at most. Every chat (Telegram, Slack,
- * Discord, Teams) takes its titles and its finished-work lines from here, so a
- * task id, a "— revision" suffix or a person's own act never reaches a chat.
- * The console keeps every exact name and fact. */
 import type { TelegramTransport } from "./telegram.js";
 import type { Store } from "./store.js";
 /** The bot's display name in every chat app. */
@@ -34,8 +29,10 @@ export type FinishedFact = {
         words: string;
         phrase: string;
     } | null;
-    /** The person's lead took it on (lead-voice.ts): "Your lead is on it", never "It waits for you". */
+    /** The person's lead took it on (lead-voice.ts): "<name> is on it", never "It waits for you". */
     leadOnIt?: boolean;
+    /** What the person calls their lead (Settings → Lead); "Lead" when unnamed. */
+    leadName?: string;
 };
 /** The two buttons under a result ready for a person: the real next step, then a look first. */
 export declare const READY_ACTIONS: {

package/dist/chat-voice.js

@@ -1,3 +1,9 @@
+/** How chat sounds: a teammate talking. One or two short sentences, outcome
+ * first, plain words, one action at most. Every chat (Telegram, Slack,
+ * Discord, Teams) takes its titles and its finished-work lines from here, so a
+ * task id, a "— revision" suffix or a person's own act never reaches a chat.
+ * The console keeps every exact name and fact. */
+import { leadOnIt } from "./task-status.js";
 import { phoneText } from "./telegram-status.js";
 /** The bot's display name in every chat app. */
 export const BOT_NAME = "Toolroll";
@@ -55,7 +61,7 @@ export function finishedLine(fact) {
     const ready = fact.lead === true ? `I finished ${lower}` : `${name} is ready`;
     // What waited on the person and the lead has taken on (Needs you reads Waiting then).
     if (fact.leadOnIt === true && (fact.headline === "Needs you" || fact.headline === "Waiting" || fact.headline === "Stopped"))
-        return `${name}: your lead is on it.`;
+        return `${name}: ${leadOnIt(fact.leadName)}`;
     switch (fact.headline) {
         case "Ready for review":
             if (fact.report)
@@ -67,7 +73,7 @@ export function finishedLine(fact) {
             return `${ready}, but no tests ran. Look it over first.`;
         case "Failed":
             if (fact.leadOnIt === true)
-                return fact.checks === "failed" ? `${name} is built, but its tests failed. Your lead is on it.` : `${name} stopped before it finished. Your lead is on it.`;
+                return fact.checks === "failed" ? `${name} is built, but its tests failed. ${leadOnIt(fact.leadName)}` : `${name} stopped before it finished. ${leadOnIt(fact.leadName)}`;
             if (fact.checks === "failed")
                 return fact.lead === true
                     ? `I built ${lower}, but its tests failed. It waits for you: retry or ask for changes.`

package/dist/discord-chat.js

@@ -1,5 +1,6 @@
 /** Discord messages and buttons transport the shared assistant's saved actions. */
 import { chatQuestionButtons } from "./teammate-question.js";
+import { chatAskButtons } from "./chat-ask.js";
 import { chatFlowButtons } from "./chat-flow.js";
 import { channelInbox } from "./chat-inbox.js";
 import { roomCommand } from "./chat-rooms.js";
@@ -272,6 +273,15 @@ export async function deliverDiscordPart(options) {
                         custom_id: `so_${one.token}`,
                     }))
                     : []),
+                // The lead's question to its owner: its options, then "Something else".
+                ...(content.ask
+                    ? chatAskButtons(state, row.id, now).map((one) => ({
+                        type: 2,
+                        style: one.words ? 2 : 1,
+                        label: one.label.slice(0, 80),
+                        custom_id: `so_${one.token}`,
+                    }))
+                    : []),
                 ...link(options.origin(), content.link),
                 ...(content.also ?? []).flatMap(one => link(options.origin(), one)),
             ];

package/dist/lead-commitments.d.ts

@@ -0,0 +1,84 @@
+/** What the lead promised to follow up on. A commitment records the promise in the lead's words, the condition
+ * that completes it, when to look next, where to report and when it lapses. The follow pass reads open ones
+ * without a model and says one short line when the condition is met, on the channel the promise was made on;
+ * nothing otherwise.
+ * The table is additive (no schema version bump), so a build that predates it still opens the store. */
+import type { Notification, Store } from './store.js';
+import { type AssignmentSnapshot } from './assignment.js';
+/** The table: `LEAD_COMMITMENT_SCHEMA` in store.ts (additive, no version bump). */
+export declare const COMMITMENT_DAYS = 7;
+export type TaskState = AssignmentSnapshot['state'];
+export declare const TASK_STATES: readonly TaskState[];
+export declare const RUN_OUTCOMES: readonly ['finished', 'built', 'failed'];
+export declare const CHECK_RESULTS: readonly ['passed', 'failed', 'either'];
+/** Where a promise was made, and so where it is reported: `chat` is the console or terminal conversation; a phone
+ * or team chat also gets the line as the lead's own message, on that chat only. */
+export declare const COMMITMENT_CHANNELS: readonly ['chat', 'telegram', 'slack', 'discord', 'teams'];
+export type CommitmentChannel = typeof COMMITMENT_CHANNELS[number];
+/** `afterRun`: only a result newer than the one there was when the promise was made counts. */
+export type CommitmentCondition = {
+    kind: 'task';
+    task: string;
+    states: TaskState[];
+} | {
+    kind: 'run';
+    run: number;
+    outcome: typeof RUN_OUTCOMES[number];
+} | {
+    kind: 'check';
+    task: string;
+    result: typeof CHECK_RESULTS[number];
+    afterRun: number;
+} | {
+    kind: 'check';
+    run: number;
+    result: typeof CHECK_RESULTS[number];
+} | {
+    kind: 'time';
+    at: string;
+};
+export type Commitment = {
+    id: number;
+    owner: string;
+    repo: string | null;
+    thread: number;
+    turn: number | null;
+    channel: string;
+    what: string;
+    condition: CommitmentCondition;
+    checkAt: string;
+    expiresAt: string;
+    state: 'open' | 'done' | 'cancelled' | 'expired';
+    createdAt: string;
+    checkedAt: string | null;
+    closedAt: string | null;
+    closedBy: string | null;
+    outcome: string | null;
+};
+/** The condition in a few words, for Settings and for the lead's own catch-up. */
+export declare function conditionWords(store: Store, condition: CommitmentCondition): string;
+export type CommitInput = {
+    owner: string;
+    repo: string | null;
+    thread: number;
+    turn: number | null;
+    channel?: string;
+    what: string;
+    condition: CommitmentCondition;
+    checkAt?: string | null;
+};
+/** Record a promise. The caller has already proved the task, attempt or project is within the owner's access. */
+export declare function recordCommitment(store: Store, input: CommitInput, now: Date): Commitment;
+export declare function getCommitment(store: Store, id: number): Commitment | null;
+/** The owner's open promises that they heard, oldest first. */
+export declare function openCommitments(store: Store, owner: string, limit?: number): Commitment[];
+/** The phone or team chat a lead message is for, when it is a met promise (`lead-promise:<channel>:<id>`); null for
+ * every other notification, which goes wherever it always went. */
+export declare function promiseChannelOf(row: Pick<Notification, 'dedupeKey'>): string | null;
+/** Stop following up. Only the owner (from Settings or through their lead) cancels; a closed one stays as it was. */
+export declare function cancelCommitment(store: Store, owner: string, id: number, by: string, reason: string, now: Date): boolean;
+/** The newest result run for a task, for a check condition's baseline. */
+export declare function latestResultRun(store: Store, task: string, repos: readonly string[], now: Date): number;
+/** One deterministic pass over due promises (no model): expire, drop what can no longer be delivered or seen,
+ * and report a met condition once — the state change and the message share one transaction. Returns how many reported. */
+export declare function checkLeadCommitments(store: Store, now: Date, root?: string): number;