toolroll 0.9.15 → 0.9.17

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-actions.d.ts

@@ -196,6 +196,11 @@ export declare const CHAT_ACTIONS: {
         readonly protected: false;
         readonly password: false;
     };
+    readonly lead_about_you: {
+        readonly label: "Remember";
+        readonly protected: false;
+        readonly password: false;
+    };
     readonly scope_approve: {
         readonly label: "Approve work";
         readonly protected: true;
@@ -222,6 +227,8 @@ export type ChatAction = keyof typeof CHAT_ACTIONS;
  * yes/cancel challenge instead of the console's secure screen. Password
  * actions and long or redacted terms never qualify. */
 export declare const CHALLENGE_ACTIONS: ReadonlySet<ChatAction>;
+/** Actions about the person themselves, in no project: their card carries no project (repo ""). */
+export declare const OWNER_ACTIONS: ReadonlySet<ChatAction>;
 export declare function isChatAction(value: unknown): value is ChatAction;
 export type SharedAction = {
     operation: ChatAction;

package/dist/chat-actions.js

@@ -32,6 +32,7 @@ import { kitInstalled, kitOf, KITS, setUpKitNow } from "./kits.js";
 import { starterFlowOf, starterOf, startersFor, starterTerms, STARTER_FLOWS, switchOnStarter } from "./flow-starters.js";
 import { answerTeammateQuestion } from "./teammate-work.js";
 import { callWords, checkRule, defaultRule, grantListed, revokeTool, ruleWords, setToolRules } from "./teammate-tools.js";
+import { aboutYouOf, checkAboutYouLine, saveAboutYou, withAboutYouLine } from "./lead-about.js";
 /** A tool from the lead's card: a common tool by its id, or the operator's own program or address. */
 function toolSpecFromRequest(input) {
     if (input["catalog"] !== undefined) {
@@ -107,6 +108,8 @@ export const CHAT_ACTIONS = {
     kit_setup: { label: "Set up kit", protected: false, password: false },
     decision_record: { label: "Record decision", protected: false, password: false },
     decision_retire: { label: "Retire decision", protected: false, password: false },
+    // What the owner's own lead knows about them: theirs alone, in no project (lead-about.ts).
+    lead_about_you: { label: "Remember", protected: false, password: false },
     scope_approve: { label: "Approve work", protected: true, password: true },
     result_accept: { label: "Accept and finish", protected: true, password: false },
     task_cancel: { label: "Cancel task", protected: true, password: false },
@@ -116,6 +119,8 @@ export const CHAT_ACTIONS = {
  * yes/cancel challenge instead of the console's secure screen. Password
  * actions and long or redacted terms never qualify. */
 export const CHALLENGE_ACTIONS = new Set(["result_accept"]);
+/** Actions about the person themselves, in no project: their card carries no project (repo ""). */
+export const OWNER_ACTIONS = new Set(["lead_about_you"]);
 export function isChatAction(value) {
     return typeof value === "string" && Object.hasOwn(CHAT_ACTIONS, value);
 }
@@ -160,19 +165,21 @@ export const CHAT_ACTION_FIELDS = {
     kit_setup: ["repo", "kit"],
     decision_record: ["repo", "claim", "why", "supersedes", "source"],
     decision_retire: ["repo", "decision", "reason"],
+    lead_about_you: ["line", "replaces"],
     scope_approve: ["task"],
     result_accept: ["task", "run"],
     task_cancel: ["task"],
     task_resume: ["task", "run"],
 };
 const nonceHash = (value) => createHash("sha256").update(value).digest("hex");
-function requireActor(store, who, repo) {
+function requireActor(store, who, repo, operation) {
     if (!store.schemaCurrent())
         throw Error("The running build changed. Reload before proposing an action.");
+    // An action about the person themselves names no project; every other one names one they can reach.
+    const owned = repo === "" && operation !== undefined && OWNER_ACTIONS.has(operation);
     if (!isVerifiedApprover(who) ||
         !reproveApprover(store, who).ok ||
-        !who.repos.includes(repo) ||
-        !store.accountCanAccess(who.name, repo))
+        (!owned && (!who.repos.includes(repo) || !store.accountCanAccess(who.name, repo))))
         throw Error("This project is outside your current access.");
 }
 function text(input, key, cap, optional = false) {
@@ -267,6 +274,28 @@ export function prepareSharedAction(store, who, operation, input, root, now = ne
     const allowed = CHAT_ACTION_FIELDS[operation];
     if (Object.keys(input).some((key) => !allowed.includes(key)))
         throw Error("This action contains an unsupported field.");
+    if (operation === "lead_about_you") {
+        // The owner's own note: the card shows the line, and the line it replaces beside it.
+        const checked = checkAboutYouLine(input["line"]);
+        if (!checked.ok)
+            throw Error(checked.message);
+        const lines = aboutYouOf(store, who.name);
+        const replaces = input["replaces"] === undefined || input["replaces"] === 0 ? 0 : integer(input, "replaces");
+        const next = withAboutYouLine(lines, checked.line, replaces);
+        if (!next.ok)
+            throw Error(next.message);
+        requireActor(store, who, "", operation);
+        const request = { line: checked.line, ...(replaces === 0 ? {} : { replaces }) };
+        const terms = replaces === 0
+            ? [checked.line, "Your lead keeps this about you in every project. Change it in Settings → Lead."]
+            : [`Was: ${lines[replaces - 1]}`, `Now: ${checked.line}`, "Replaces that line in what your lead knows about you. Change it in Settings → Lead."];
+        // An added line goes on the end, so it holds whatever else changed; a replacing card holds only while the line
+        // it replaces is still that line.
+        const state = replaces === 0 ? {} : { was: lines[replaces - 1] };
+        const title = replaces === 0 ? "Remember about you" : "Update what your lead knows about you";
+        const stamp = hash({ operation, request, repo: "", state, terms, actor: who.name, generation: who.generation, ceiling: who.ceilingDigest });
+        return { operation, request, repo: "", title, terms, stamp, state };
+    }
     const task = operation.startsWith("skill_") || operation.startsWith("knowledge_") || operation.startsWith("decision_") || operation.startsWith("tool_") || operation.startsWith("flow_") || operation.startsWith("teammate_") || operation.startsWith("kit_")
         ? null
         : text(input, "task", 64);
@@ -954,7 +983,7 @@ function savedActionContext(store, who, id, state) {
         (!shared && turn?.session !== session.id) ||
         turn?.state !== "answered")
         throw Error("This conversation ended or its project access changed. Ask for a fresh proposal.");
-    requireActor(store, who, payload.repo);
+    requireActor(store, who, payload.repo, payload.operation);
     return payload;
 }
 export function mintSharedActionReview(store, who, id, root, now) {
@@ -1013,6 +1042,13 @@ export function executeSharedAction(store, who, id, payload, now, options) {
         return store.savepoint(() => {
             const task = typeof req["task"] === "string" ? req["task"] : null, repo = payload.repo, actor = who.name;
             let taskId = task;
+            if (payload.operation === "lead_about_you") {
+                const next = withAboutYouLine(aboutYouOf(store, actor), String(req["line"]), Number(req["replaces"] ?? 0));
+                if (!next.ok)
+                    throw Error(next.message);
+                saveAboutYou(store, actor, next.lines, now);
+                return { ok: true, taskId: null, said: req["replaces"] === undefined ? "Your lead will remember this." : "Updated what your lead knows about you.", href: "/settings/lead" };
+            }
             if (payload.operation === "skill_import")
                 importSkill(store, repo, actor, req["files"], "Chat import", now);
             else if (payload.operation === "skill_test")

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,91 @@
+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);
+}
+/** How old a part may be and still be sent: older ones are dropped undelivered (slack-chat.ts, discord-chat.ts,
+ * teams-chat.ts), so an edit to one would never land. */
+const EDIT_WINDOW_MS = 86_400_000;
+/** Show the question again with what happened, and without its buttons: one edit, under the part's own time. A question
+ * too old to edit gets the line once as a new message instead. */
+function repaint(state, part, event, line, now) {
+    const row = state.prepare("SELECT payload,created FROM chat_part WHERE id=?").get(part);
+    if (row === undefined || new Date(String(row["created"])).getTime() + EDIT_WINDOW_MS <= now.getTime()) {
+        state.plan(event.id, [{ text: line }], now);
+        return;
+    }
+    const before = 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);
+    state.finish(event.id);
+}
+/** 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"]);
+    // Only the person the lead asked answers it: anyone else's tap changes nothing and says nothing.
+    const asker = store.getMateTurn(turn)?.approver;
+    if (asker !== undefined && asker !== binding.approver) {
+        state.finish(event.id);
+        return true;
+    }
+    const found = asker === undefined ? { state: "expired" } : store.mateAskState(turn, now);
+    const expired = found.state === "expired" || String(action["expires"]) <= now.toISOString();
+    // A question already settled was shown so once (or is being): a later tap says nothing more.
+    if (action["consumed"] !== null) {
+        state.finish(event.id);
+        return true;
+    }
+    if (found.state !== "open" || expired) {
+        state.prepare("UPDATE chat_ask_action SET consumed=? WHERE part=? AND consumed IS NULL").run(now.toISOString(), part);
+        // The question is shown again without its buttons, so a later tap has nothing to press.
+        repaint(state, part, event, found.state === "answered" ? "This question was already answered." : "This question expired. If it still matters, send your answer as a message.", now);
+        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}`, now);
+    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,13 @@ 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, project instruction or about-you card, through the shared confirm door; an about-you card shows the line it replaces.", gap: null },
+    get_person: { support: "direct", how: "Read during a turn: one person, AI teammate or team chat in full, with their open tasks.", 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 },
+    get_capabilities: { support: "direct", how: "Read during a turn: which agents are signed in, which workers are online, which tools and skills work, which integrations are connected and what checks the project runs, each with its next step and settings link.", 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,13 @@ 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[];
+    };
+    /** The lead's own reply, already shaped (reply-shape.ts): the channel renders its bold anchors and labelled links in its own format. */
+    voice?: true;
 };
 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.d.ts

@@ -1,3 +1,4 @@
+import { type WarmHooks } from "./chat-warmth.js";
 import { type DoorOptions } from "./mate-doors.js";
 import { ChatState, type ChatBinding, type ChatEvent, type ChatIdentity } from "./chat-delivery-state.js";
 import { type Store } from "./store.js";
@@ -20,6 +21,8 @@ export type ChatDeliveryOptions = {
     clock?: () => Date;
     partSize?: number;
     maxProposal?: number;
+    /** The app's warm touches for one owner message (a 👍, typing), where the app and the bot's permissions allow them. */
+    warm?: (event: ChatEvent, binding: ChatBinding) => WarmHooks;
 };
 export declare const splitChatText: (text: string, size?: number) => string[];
 export declare function channelAccess(options: ChatDeliveryOptions, binding: ChatBinding, ceiling?: string): Promise<string[]>;

package/dist/chat-delivery.js

@@ -1,7 +1,10 @@
 /** 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 { MATE_MESSAGE_MAX_CHARS, mateFailureText, runMateTurn } from "./mate.js";
+import { shapeReplyParts } from "./reply-shape.js";
+import { warmTurn } from "./chat-warmth.js";
 import { confirmMateProposal, dismissMateProposal, } from "./mate-doors.js";
 import { ceilingDigestOf, verifyApproverStanding } from "./principal.js";
 import { ChatState, ChatDeliveryError, chatHash, } from "./chat-delivery-state.js";
@@ -11,7 +14,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";
@@ -22,7 +27,8 @@ export const chatObject = (v) => v !== null && typeof v === "object" && !Array.i
     : {};
 const object = chatObject;
 const nowOf = (options) => options.clock?.() ?? new Date();
-export const splitChatText = (text, size = 2800) => {
+const CHAT_PART_SIZE = 2800;
+export const splitChatText = (text, size = CHAT_PART_SIZE) => {
     const parts = [];
     for (let at = 0; at < text.length;) {
         let end = Math.min(at + size, text.length);
@@ -218,7 +224,7 @@ export async function processChatEvent(options) {
                 return true;
             }
             if (event.session !== null && event.session !== resolved.session.id) {
-                state.plan(event.id, [{ text: "Your chat session changed. Send your message again." }], now);
+                state.plan(event.id, [{ text: "This conversation was restarted after you sent that, so it wasn't answered. Send your message again." }], now);
                 return true;
             }
             state
@@ -258,6 +264,11 @@ 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);
+            // Only ever the owner's own message in their own chat: never the bot's, never a room.
+            const warm = warmTurn(options.warm !== undefined && event.kind === "message" && event.member !== identity.bot && event.member === binding.member && event.channel === binding.channel
+                ? options.warm(event, binding) : {});
             const outcome = await runMateTurn({
                 store,
                 who: resolved.who,
@@ -276,19 +287,21 @@ export async function processChatEvent(options) {
                 clock: () => nowOf(options),
                 evidenceRoot: options.evidenceRoot,
                 mediaDelivery: "documents",
+                ...(channel === undefined ? {} : { channel }),
+                onProgress: warm.onProgress,
                 revalidate: async () => {
                     try {
                         await channelAccess(options, binding, resolved.who.ceilingDigest);
                         return { ok: true };
                     }
-                    catch {
-                        return {
-                            ok: false,
-                            reason: `${options.label} access could not be verified`,
-                        };
+                    catch (error) {
+                        const code = error instanceof ChatDeliveryError ? error.code : "";
+                        const reason = code === "Connected projects changed" ? "projects-changed"
+                            : code.endsWith("account access changed") ? "member-changed" : "access-changed";
+                        return { ok: false, reason };
                     }
                 },
-            });
+            }).finally(warm.stop);
             if (outcome.ok && !outcome.replayed && context?.task)
                 mirrorToTaskChat(store, resolved.who, context.task, options.label, text, outcome.reply, nowOf(options));
             if (!state.owns(identity.installation, options.owner, nowOf(options)) ||
@@ -321,7 +334,7 @@ export async function processChatEvent(options) {
         if (turn?.state !== "answered") {
             state.plan(event.id, [
                 {
-                    text: "The assistant’s reply did not finish. No proposed changes were kept. Send your message again to retry.",
+                    text: mateFailureText(turn?.failureReason ?? null),
                 },
             ], nowOf(options));
             return true;
@@ -336,7 +349,15 @@ export async function processChatEvent(options) {
             .listMateMessages(turn.thread, 200)
             .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 }) }));
+        // Split as written, then shape each part: no cut ever lands inside a link, code or a bold anchor.
+        const shapedParts = shapeReplyParts(reply, options.partSize ?? CHAT_PART_SIZE, { asked: text, appOrigin: options.origin() });
+        const parts = (shapedParts.length > 0 ? shapedParts : splitChatText("")).map((text) => (about === null ? { text, voice: true } : { text, voice: true, 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 +453,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);
@@ -566,8 +590,13 @@ export async function planRoomMessages(options) {
             if (carrier === null)
                 break;
             const parts = [];
-            if (text !== null)
-                parts.push({ text, channel: room.chat });
+            if (text !== null) {
+                if (message.role === "assistant")
+                    for (const part of shapeReplyParts(text, options.partSize ?? CHAT_PART_SIZE, { appOrigin: options.origin() }))
+                        parts.push({ text: part, voice: true, channel: room.chat });
+                else
+                    parts.push({ text, channel: room.chat });
+            }
             if (message.role === "assistant" && message.turn !== null)
                 for (const proposal of store.listMateProposals(row.thread, ["pending"]).filter(one => one.turn === message.turn))
                     parts.push({ text: "", proposal: proposal.id, channel: room.chat });
@@ -665,8 +694,11 @@ 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); one its owner asked for on
+                    // this chat is always said here, however quiet the lead's own work is kept.
+                    (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) &&
+                    (promiseChannelOf(notification) === state.channel || store.pingAllowed(notification, binding.approver)) &&
                     // A flow decision for "anyone who approves" reaches every approver who can see the project.
                     // A notification addressed to this person reaches them whatever project
                     // their channel follows (a sign-in pause is the installation's, v108).
@@ -680,7 +712,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, binding.approver),
                             ...(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 +816,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))