toolroll 0.9.14 → 0.9.16

package/dist/browser-crew.d.ts

@@ -4,7 +4,8 @@ import type { WorkIndexItem, WorkIndexPage } from './work-index.js';
 /** The index is navigation only. Controls retain their exact owning task, run,
  * decision and approval ceremony; opening a result keeps its saved execution. */
 export declare function browserWorkActionHref(item: WorkIndexItem): string | null;
-/** Render an already-admitted page without repeating its database query. */
+/** Render an already-admitted page without repeating its database query. Every task reads its one headline, the
+ * same words as the Tasks list, task page and result page. */
 export declare function browserCrewFromIndex(page: WorkIndexPage, conversationId?: string): {
     crew: BrowserCrewItem[];
     crewTruncated: boolean;

package/dist/browser-crew.js

@@ -32,7 +32,8 @@ export function browserWorkActionHref(item) {
                         : action.code === 'start-worker' || action.code === 'repair-dependency' ? '#run-status' : '';
     return `/t/${encodeURIComponent(item.rootId)}?version=${encodeURIComponent(taskId)}` + anchor;
 }
-/** Render an already-admitted page without repeating its database query. */
+/** Render an already-admitted page without repeating its database query. Every task reads its one headline, the
+ * same words as the Tasks list, task page and result page. */
 export function browserCrewFromIndex(page, conversationId) {
     const link = (href) => conversationId && href.startsWith('/chat?') ? href + '&conversation=' + encodeURIComponent(conversationId) : href;
     const rows = page.items.map(summary => {
@@ -46,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

@@ -7,11 +7,11 @@ export { browserCrewFromIndex, browserWorkActionHref } from './browser-crew.js';
 import type { Store } from './store.js';
 import type { WorkSummaryAccess } from './work-summary.js';
 import type { StatusTone } from './workspace-ui.js';
-import type { Ask } from './needs-you.js';
+import type { Ask, AskChip } from './needs-you.js';
 import type { WorkIndexGroup } from './work-index.js';
 import type { AssignmentCard } from './assignment-ui.js';
 import type { TaskStatus } from './task-status.js';
-import type { ResultActs } from './result-acts.js';
+import type { AcceptLabel, ResultActFacts, ResultActs } from './result-acts.js';
 import type { FirstRunStep, FirstTaskSuggestion, JourneyStep } from './first-run.js';
 export type BrowserProject = {
     name: string;
@@ -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;
@@ -125,8 +127,10 @@ export type BrowserTasksView = {
             tone: StatusTone;
             token: string;
         };
-        /** What a Needs you row asks (its chip); null for every other row. */
+        /** What a Needs you row asks: its group. */
         ask: Ask | null;
+        /** The row's chip under its group: the specific ask (Plan, Result, Mismatch, Plan changed, Failed, Builder offline), or none. */
+        chip: AskChip | null;
         group: BrowserTaskGroup;
         action: BrowserLink | null;
         detail: string | null;
@@ -367,17 +371,41 @@ export type BrowserTaskView = {
     rebuild?: {
         action: string;
     } | null;
-    /** A failed task's recorded reason in one line (the run's reason, the failing check's last error line, or that none was
-     * recorded) and where its log lines are; and Retry itself, with an optional note. */
-    failure?: {
+    /** What a failed task missed, in one line (the requirement it missed, the failing check's error line, or the stop
+     * reason), the evidence line behind it, one suggestion of what to change, and where to see it (its build's result
+     * page, or that exact check-log line); and Retry itself, its note starting with the suggestion. */
+    failure?: BrowserFailure | null;
+    retry?: {
+        action: string;
+        note?: string;
+    } | null;
+    /** Run checks in place, on a status row that offers it: posts and comes back to this page. */
+    runChecks?: BrowserRunChecks | null;
+    /** A live build: the step it is on (or stuck on, with the act that helps), and the earlier attempts that stopped
+     * before it, folded into one quiet line. */
+    progress?: {
         line: string;
-        link: {
-            label: string;
-            href: string;
+        stuck: {
+            step: number;
+            why: string | null;
+            line: string;
+            action: BrowserLink | null;
         } | null;
     } | null;
-    retry?: {
+    /** Stop, on the Building card: the exact live build's stop form (posts its run id). */
+    stop?: {
         action: string;
+        run: number;
+    } | null;
+    /** The Building card's link to the live build's own record ("Build #N record", /r/<id>). */
+    record?: BrowserLink | null;
+    earlier?: {
+        summary: string;
+        attempts: {
+            label: string;
+            href: string;
+            text: string | null;
+        }[];
     } | null;
     /** Server cards that may need a person now (stop/resume, scope prompt, plan, live attempt). */
     lead: {
@@ -470,6 +498,12 @@ export type BrowserResultPanel = {
             returnTo: string;
         } | null;
     } | null;
+    /** The Requirements row's counts, so it updates as the person answers their checks (null when it doesn't count them). */
+    requirements?: {
+        met: number;
+        total: number;
+        yours: number;
+    } | null;
     /** Storage limits on saved output (shortened logs or diffs): shown on request. */
     limits: string[];
     tabs: {
@@ -518,13 +552,19 @@ export type BrowserCheckItem = {
     }[];
 };
 /** The result's one decision: what Accept is called, why it isn't plain
- * Accept, and what pressing it does. */
+ * Accept and finish, and what pressing it does. `base`: the same words before
+ * the person's own checks, which the page adds as they answer them. */
 export type BrowserResultDecision = {
-    label: "Accept" | "Accept without checks";
+    label: AcceptLabel;
     ready: boolean;
     why: string | null;
     effect: string;
     sentence: string;
+    base?: {
+        label: AcceptLabel;
+        ready: boolean;
+        why: string | null;
+    };
 };
 /** A Needs you action: a link, (Confirm it stopped) a form behind the password, (Build again) one
  * button, or (on the result itself) Accept, which records the person's acceptance; `note` asks why
@@ -587,12 +627,17 @@ export type BrowserResultView = {
             detail: string;
             control: string;
         } | null;
+        /** Accept and finish: the exact receipt read; `accept` when the one request also records the person's acceptance
+         * (`note`: the words over the reason field it asks for, or null for none). */
         complete: {
             action: string;
             receipt: string;
             run: number;
+            accept?: {
+                note: string | null;
+            } | null;
         } | null;
-        /** Words for the result's Accept: Mark complete when offered, else the Needs you acceptance. */
+        /** Words for the result's Accept: Accept and finish when offered, else the Needs you acceptance. */
         decision: BrowserResultDecision | null;
         checks: {
             detail: string;
@@ -617,12 +662,24 @@ export type BrowserResultView = {
         } | null;
         /** The one ink act that resolves the result, the one outline act beside it, and why it can't be accepted yet (result-acts.ts). */
         acts: ResultActs;
+        /** The facts the acts were chosen from, so the page chooses again as the person answers their checks. */
+        actFacts?: ResultActFacts;
         /** Run checks on this result's commit: the project's check, when it didn't run. */
-        runChecks: {
-            action: string;
-            level: "quick" | "full";
-            returnTo: string;
-        } | null;
+        runChecks: BrowserRunChecks | null;
+        /** A failed build's result: what it missed and the suggestion Retry's note starts with; Retry itself when the task
+         * can be retried from here. Null for every other result. */
+        failure?: (BrowserFailure & {
+            retry: {
+                action: string;
+                note: string;
+            } | null;
+            /** A failed task's delivered result, accepted only in outline with a reason (the task's accept-proof). */
+            acceptAnyway?: {
+                action: string;
+                run: number;
+                returnTo: string;
+            } | null;
+        }) | null;
         /** The raw run record, under Details: its facts and the full record. */
         record: {
             build: number;
@@ -635,6 +692,7 @@ export type BrowserResultView = {
         /** The signed scope; null when none was filed. */
         intent: {
             approval: string;
+            approvedAt: string | null;
             html: string;
         } | null;
         noRun: string | null;
@@ -647,6 +705,20 @@ export type BrowserResultView = {
         }[];
     } | null;
 };
+export type BrowserFailure = {
+    line: string;
+    evidence: string | null;
+    suggestion: string;
+    link: {
+        label: string;
+        href: string;
+    } | null;
+};
+export type BrowserRunChecks = {
+    action: string;
+    level: "quick" | "full";
+    returnTo: string;
+};
 /** One zone on a flow's canvas: its step, where it leads, and where it sits. */
 export type BrowserFlowStage = {
     id: string;
@@ -954,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;
@@ -1048,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-actions.d.ts

@@ -202,7 +202,7 @@ export declare const CHAT_ACTIONS: {
         readonly password: true;
     };
     readonly result_accept: {
-        readonly label: "Mark complete";
+        readonly label: "Accept and finish";
         readonly protected: true;
         readonly password: false;
     };

package/dist/chat-actions.js

@@ -12,7 +12,7 @@ import { approve, authenticateApprover, describeScope, scopeAuthorityOf, } from
 import { readVerifiedArtifact, scanForSecrets } from "./evidence.js";
 import { readAuthModeStrict } from "./keys.js";
 import { parseProof } from "./proof.js";
-import { assignmentOf, checkAssignmentAsOperator } from "./assignment.js";
+import { acceptAndCompleteAsOperator, assignmentOf } from "./assignment.js";
 import { getDecision, recordDecision, retireDecision } from "./project-memory.js";
 import { resumeTaskStop, taskControlOf } from "./task-control.js";
 import { addToolTo, catalogTool, projectToolsOf, removeToolFrom, toolCommandLine, validateToolSpec } from "./project-tools.js";
@@ -108,7 +108,7 @@ export const CHAT_ACTIONS = {
     decision_record: { label: "Record decision", protected: false, password: false },
     decision_retire: { label: "Retire decision", protected: false, password: false },
     scope_approve: { label: "Approve work", protected: true, password: true },
-    result_accept: { label: "Mark complete", protected: true, password: false },
+    result_accept: { label: "Accept and finish", protected: true, password: false },
     task_cancel: { label: "Cancel task", protected: true, password: false },
     task_resume: { label: "Resume task", protected: true, password: true },
 };
@@ -1098,7 +1098,9 @@ export function executeSharedAction(store, who, id, payload, now, options) {
                     throw Error("The comparison terms changed. Nothing was approved.");
             }
             else if (payload.operation === "result_accept") {
-                const completed = checkAssignmentAsOperator(store, task, String(payload.state["receipt"] ?? ""), who, now, options.root);
+                // Accept and finish, as on the result page: whether a check only the person makes is accepted
+                // too is decided inside the same transaction, against the receipt as it stands.
+                const completed = acceptAndCompleteAsOperator(store, task, { runId: null, receiptDigest: String(payload.state["receipt"] ?? ""), note: null }, who, now, options.root);
                 if (!completed.ok)
                     throw Error(completed.message);
             }
@@ -1125,7 +1127,7 @@ export function executeSharedAction(store, who, id, payload, now, options) {
             const said = payload.operation === "skill_test"
                 ? "Skill test created. Existing approval rules apply."
                 : payload.operation === "result_accept"
-                    ? "Marked complete. The recorded checks are unchanged."
+                    ? "Accepted and finished. The recorded checks are unchanged."
                     : payload.operation === "scope_approve"
                         ? "The exact work is approved."
                         : payload.operation === "task_cancel"

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;
@@ -76,7 +76,7 @@ export type ChatContent = {
         label: string;
         path: string;
     };
-    /** More link buttons after `link`: [Look first] beside [Merge] or [Mark complete]. */
+    /** More link buttons after `link`: [Look first] beside [Merge] or [Accept and finish]. */
     also?: Array<{
         label: string;
         path: 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))