toolroll 0.9.16 → 0.9.17

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 0.9.17 — 2026-10-03
+
+- **The lead checks before it promises.** One check covers agents (signed in
+  or not), workers, tools and skills, integrations and checks. It won't
+  propose work that needs one until it has looked. If something isn't ready,
+  it says so with the next step and a link.
+- **Replies read like a person wrote them.** On every channel: no headers,
+  links with plain labels, no internal ids, and little bold. A reply that
+  says it's attaching something has to attach it. Errors are in plain words,
+  and you see a 👍 and typing while it works.
+- **It knows you and your people.** "What your lead knows about you" is a
+  short list you confirm line by line, editable in Settings → Lead. The lead
+  also keeps an index of the people, teammates and team chats you work with,
+  and looks a person up before answering about them.
+- Promises made on Slack, Discord and Teams are delivered there. Long
+  Telegram replies split safely.
+
 ## 0.9.16 — 2026-10-03
 
 - **Name your lead.** Settings → Lead takes a name and a short persona. The

package/dist/assignment-brief.js

@@ -7,13 +7,20 @@ import { publicChatText } from "./chat-display.js";
 const sha = (value) => createHash("sha256").update(value).digest("hex");
 const MAX_BYTES = 16_000;
 const RECENT_MS = 7 * 24 * 60 * 60_000;
-/** A sentence's end: not an abbreviation's full stop ("e.g.", "i.e.", "etc."), and followed by a new sentence. */
-const SENTENCE_END = /(?<!\b(?:e\.g|i\.e|etc|vs|cf|approx|incl|Mr|Mrs|Ms|Dr|St|No))[.!?](?=\s+["'“(]?[\p{Lu}\p{N}])/u;
+/** A full stop, question or exclamation mark followed by a new sentence. */
+const SENTENCE_END = /[.!?](?=\s+["'“(]?([\p{Lu}\p{N}]))/gu;
+/** An abbreviation's full stop ("e.g.", "E.g.", "etc."), in any case; "No." only before a number ("No. 5"). */
+const ABBREVIATION = /\b(?:e\.g|i\.e|etc|vs|cf|approx|incl|mr|mrs|ms|dr|st)$/i;
 /** A reason's first sentence, or its first line. */
 export function firstSentenceOf(text) {
     const line = text.split("\n")[0].trim();
-    const end = SENTENCE_END.exec(line);
-    return end === null ? line : line.slice(0, end.index + 1);
+    for (const end of line.matchAll(SENTENCE_END)) {
+        const before = line.slice(0, end.index);
+        if (end[0] === "." && (ABBREVIATION.test(before) || /\bno$/i.test(before) && /\p{N}/u.test(end[1])))
+            continue;
+        return line.slice(0, end.index + 1);
+    }
+    return line;
 }
 /** A project's active decisions, newest first: each one's title and its reason in one line (first sentence or
  * line). Memory absent on an older database reads as no decisions. */

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.js

@@ -21,12 +21,21 @@ export function chatAskButtons(state, part, now) {
     })
         .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"]));
+/** 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) {
@@ -41,17 +50,23 @@ export function applyChatAskTap(options, event, binding, token, now) {
         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" };
+    // 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();
-    if (action["consumed"] !== null || found.state !== "open" || expired) {
+    // 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);
-        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.");
+        // 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;
@@ -71,7 +86,6 @@ export function applyChatAskTap(options, event, binding, token, now) {
         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);
+    repaint(state, part, event, `You chose: ${option}`, now);
     return true;
 }

package/dist/chat-channel.js

@@ -513,8 +513,10 @@ export const CHAT_ACTION_PARITY = {
     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 },
+    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 },

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

@@ -100,6 +100,8 @@ export type ChatContent = {
         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.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

@@ -2,7 +2,9 @@
 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";
@@ -25,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);
@@ -221,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
@@ -263,6 +266,9 @@ export async function processChatEvent(options) {
             }
             // 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,
@@ -282,19 +288,20 @@ export async function processChatEvent(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)) ||
@@ -327,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;
@@ -342,7 +349,9 @@ 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);
@@ -581,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 });
@@ -680,10 +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).
+                    // 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).
@@ -697,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(store, 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);

package/dist/chat-warmth.d.ts

@@ -0,0 +1,21 @@
+/** Small warm touches while the lead works on a chat app: once a turn will take more than a few seconds (its first tool
+ * step starts), a 👍 on the owner's message and the app's typing indicator until the turn ends. Best effort only: an
+ * app or permission that does not allow it is skipped silently, and nothing here can fail, delay or change the turn. */
+import type { MateProgress } from "./mate-progress.js";
+export declare const WARM_EMOJI = "\uD83D\uDC4D";
+/** Telegram and Teams show typing for about five seconds, Discord for ten: refreshed inside the shorter window. */
+export declare const TYPING_REFRESH_MS = 4000;
+export type WarmHooks = {
+    /** React to the owner's own message. Absent: the app (or this bot's permission) has no reactions. */
+    react?: () => Promise<unknown>;
+    /** Show the app's typing indicator once. Absent: the app has none for bots. */
+    typing?: () => Promise<unknown>;
+};
+export type WarmTurn = {
+    onProgress: (event: MateProgress) => void;
+    stop: () => void;
+};
+/** The turn's progress listener: on the first tool step, react once and keep typing shown until `stop`. */
+export declare function warmTurn(hooks: WarmHooks, options?: {
+    refreshMs?: number;
+}): WarmTurn;

package/dist/chat-warmth.js

@@ -0,0 +1,36 @@
+export const WARM_EMOJI = "👍";
+/** Telegram and Teams show typing for about five seconds, Discord for ten: refreshed inside the shorter window. */
+export const TYPING_REFRESH_MS = 4_000;
+/** The turn's progress listener: on the first tool step, react once and keep typing shown until `stop`. */
+export function warmTurn(hooks, options = {}) {
+    let started = false;
+    let stopped = false;
+    let timer = null;
+    const quietly = (call) => {
+        if (call === undefined || stopped)
+            return;
+        try {
+            void call().catch(() => undefined);
+        }
+        catch { /* skipped silently */ }
+    };
+    return {
+        onProgress: event => {
+            if (stopped || event.kind !== "tool" || started)
+                return;
+            started = true;
+            quietly(hooks.react);
+            quietly(hooks.typing);
+            if (hooks.typing !== undefined) {
+                timer = setInterval(() => quietly(hooks.typing), options.refreshMs ?? TYPING_REFRESH_MS);
+                timer.unref?.();
+            }
+        },
+        stop: () => {
+            stopped = true;
+            if (timer !== null)
+                clearInterval(timer);
+            timer = null;
+        },
+    };
+}

package/dist/discord-api.d.ts

@@ -5,7 +5,7 @@ export declare const discordId: (v: unknown) => v is string;
 export type DiscordCredentials = ChatIdentity & {
     botToken: string;
 };
-export type DiscordApi = (method: "GET" | "POST" | "PATCH", path: string, body?: Record<string, unknown>, file?: {
+export type DiscordApi = (method: "GET" | "POST" | "PATCH" | "PUT", path: string, body?: Record<string, unknown>, file?: {
     bytes: Uint8Array;
     name: string;
 }) => Promise<Record<string, unknown>>;

package/dist/discord-api.js

@@ -11,7 +11,7 @@ export class DiscordError extends ChatDeliveryError {
 export function discordApi(token, fetcher = fetch) {
     return async (method, path, body, file) => {
         // Only relative API routes; never send the bot credential to supplied URLs.
-        if (!/^\/(?:users\/@me|users\/[0-9]+|oauth2\/applications\/@me|channels\/[0-9]+(?:\/messages(?:\/[0-9]+)?(?:\?limit=100)?)?|interactions\/[0-9]+\/[A-Za-z0-9._-]+\/callback)$/.test(path))
+        if (!/^\/(?:users\/@me|users\/[0-9]+|oauth2\/applications\/@me|channels\/[0-9]+(?:\/typing|\/messages\/[0-9]+\/reactions\/%F0%9F%91%8D\/@me|\/messages(?:\/[0-9]+)?(?:\?limit=100)?)?|interactions\/[0-9]+\/[A-Za-z0-9._-]+\/callback)$/.test(path))
             throw new DiscordError("Invalid Discord request");
         let response;
         const headers = { Authorization: `Bot ${token}` };

package/dist/discord-chat.d.ts

@@ -1,5 +1,6 @@
 import { ChatState, type ChatIdentity } from "./chat-delivery-state.js";
 import { type ChatDeliveryOptions } from "./chat-delivery.js";
+import { discordPlain } from "./reply-shape.js";
 import { type DiscordApi } from "./discord-api.js";
 export type DiscordChatOptions = Omit<ChatDeliveryOptions, "state" | "label" | "member" | "partSize" | "maxProposal"> & {
     api: DiscordApi;
@@ -11,6 +12,6 @@ export declare const planDiscordNotifications: (options: DiscordChatOptions) =>
 /** Save only normalized input. Interaction credentials and pairing codes never enter SQLite. */
 export declare function receiveDiscord(state: ChatState, identity: ChatIdentity, type: string, raw: unknown, now: Date): boolean;
 /** Escape Discord's presentation syntax; allowed_mentions also prevents actual pings. */
-export declare const discordPlain: (text: string) => string;
-export declare function discordCard(text: string, buttons?: Record<string, unknown>[]): Record<string, unknown>;
+export { discordPlain };
+export declare function discordCard(text: string, buttons?: Record<string, unknown>[], voice?: boolean): Record<string, unknown>;
 export declare function deliverDiscordPart(options: DiscordChatOptions): Promise<boolean>;

package/dist/discord-chat.js

@@ -8,6 +8,8 @@ import { ChatState, ChatDeliveryError, chatHash, } from "./chat-delivery-state.j
 import { processChatEvent, planChatNotifications, channelAccess, chatObject as object, planRoomMessages, } from "./chat-delivery.js";
 import { chatResultHref } from "./chat-controls.js";
 import { MATE_MESSAGE_MAX_CHARS } from "./mate.js";
+import { discordPlain, renderReply } from "./reply-shape.js";
+import { WARM_EMOJI } from "./chat-warmth.js";
 import { proposalPreview, proposalLink, proposalOutcomeText, armedCardText, armedYesLabel, } from "./chat-channel.js";
 import { resultImageFileName, safeResultImageCaption, verifyResultImage, } from "./chat-evidence.js";
 import { discordId, discordMember, DiscordError, } from "./discord-api.js";
@@ -16,6 +18,11 @@ export const discordDelivery = (options) => ({
     state: new ChatState(options.store, "discord"),
     label: "Discord",
     member: (member, channel) => discordMember(options.api, member, channel),
+    // A 👍 on the owner's message and "typing…" while the lead works; a missing permission is skipped silently.
+    warm: (event) => ({
+        react: () => options.api("PUT", `/channels/${event.channel}/messages/${event.ts}/reactions/${encodeURIComponent(WARM_EMOJI)}/@me`),
+        typing: () => options.api("POST", `/channels/${event.channel}/typing`),
+    }),
     partSize: 1800,
     maxProposal: 3400,
 });
@@ -140,8 +147,16 @@ function link(origin, target) {
     }
 }
 /** Escape Discord's presentation syntax; allowed_mentions also prevents actual pings. */
-export const discordPlain = (text) => text.replace(/([\\`*_~|>#\[\]])/g, "\\$1").replace(/@/g, "@\u200b");
-export function discordCard(text, buttons = []) {
+export { discordPlain };
+export function discordCard(text, buttons = [], voice = false) {
+    // The lead's own reply: one description in Discord's Markdown (bold anchors, labelled links), no title line promoted to a header.
+    if (voice)
+        return {
+            content: "",
+            embeds: [{ description: renderReply(text, "discord").slice(0, 4096), color: 0x297b70 }],
+            components: Array.from({ length: Math.min(5, Math.ceil(buttons.length / 5)) }, (_, row) => ({ type: 1, components: buttons.slice(row * 5, row * 5 + 5) })),
+            allowed_mentions: { parse: [], replied_user: false },
+        };
     const lines = text.split("\n"), first = lines[0] ?? "Toolroll", title = discordPlain(first).length <= 256 &&
         first.length <= 150 &&
         lines.length > 1
@@ -336,7 +351,7 @@ export async function deliverDiscordPart(options) {
                 throw new DiscordError("Screenshot evidence changed before upload");
             file.bytes = fresh.bytes;
         }
-        const args = discordCard(text, buttons);
+        const args = discordCard(text, buttons, content.voice === true && !content.proposal && !content.image);
         if (file)
             args.attachments = [
                 { id: 0, filename: file.name, description: text.slice(0, 1024) },

package/dist/lead-about.d.ts

@@ -0,0 +1,35 @@
+/** What your lead knows about you (Settings → Lead): a short list of the owner's own lasting preferences, the same
+ * across projects ("keep copy terse", "I test myself"). Stored beside the lead's name and persona; only lines the
+ * owner confirmed (a remember about-you card) or wrote themselves are kept, never a guess. */
+import type { Store } from "./store.js";
+export declare const ABOUT_YOU_MAX_LINES = 20;
+/** Each line is under 200 characters. */
+export declare const ABOUT_YOU_LINE_MAX = 199;
+/** This person's confirmed lines; an older store reads as none. */
+export declare function aboutYouOf(store: Store, account: string | null | undefined): string[];
+/** One line as it is saved, or the problem with it. */
+export declare function checkAboutYouLine(value: unknown): {
+    ok: true;
+    line: string;
+} | {
+    ok: false;
+    message: string;
+};
+/** The Settings form's text, one line each: the saved list, or the problem with it. Blank lines and repeats go. */
+export declare function checkAboutYou(text: string): {
+    ok: true;
+    lines: string[];
+} | {
+    ok: false;
+    message: string;
+};
+/** Save the whole list for this person (already checked). Their lead's name and persona are left as they are. */
+export declare function saveAboutYou(store: Store, account: string, lines: readonly string[], now: Date): void;
+/** The list once a confirmed line is added, or once it replaces line `replaces` (1-based). */
+export declare function withAboutYouLine(lines: readonly string[], line: string, replaces: number): {
+    ok: true;
+    lines: string[];
+} | {
+    ok: false;
+    message: string;
+};