toolroll 0.9.16 → 0.9.18

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";
@@ -17,7 +19,8 @@ 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";
+import { isTelegramProgressNotification, proposalTaskOf, RESULT_SHOTS_KIND } from "./store.js";
+import { resultShotsFor } from "./result-shots.js";
 import { messageTeammate } from "./teammate-desk.js";
 import { CHAT_APP_NAMES } from "./flow-triggers.js";
 export const chatObject = (v) => v !== null && typeof v === "object" && !Array.isArray(v)
@@ -25,7 +28,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 +225,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 +267,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 +289,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 +335,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 +350,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 +591,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 });
@@ -654,6 +669,32 @@ function planFinished(options, binding, taskRef, run, now, notification = null)
         store.setChatBatchMessage(batch.id, String(part.id), shown);
     return true;
 }
+/** Screenshots with a result (result-shots.ts), planned after the result's own message: each an upload that follows
+ * it in its thread (Slack, Discord), or one link to them (Teams). A failed check is one plain line instead. */
+function planResultShots(options, binding, notification, repos, id, now) {
+    const { state, store, identity } = options;
+    const plan = resultShotsFor(store, options.evidenceRoot, repos, notification);
+    if (plan.kind === "none" || notification.taskId === null || notification.run === null)
+        return;
+    const where = { task: notification.taskId, run: notification.run };
+    // The result's message here: its finished-work batch (quiet), or its progress card (every step).
+    const follows = (() => {
+        const batch = notification.taskRef === null ? null : store.chatBatchMessageFor(`${state.channel}:${binding.id}`, notification.taskRef, notification.run);
+        if (batch !== null)
+            return Number(batch);
+        const card = state.prepare("SELECT part FROM chat_progress WHERE binding=? AND run=?").get(binding.id, notification.run);
+        return card === undefined ? null : Number(card.part);
+    })();
+    const image = (artifact, sha256) => ({ taskId: where.task, run: where.run, artifact, sha256 });
+    const parts = plan.kind === "line" ? [{ text: plan.text, ...where }]
+        // Teams has no file upload here: one message that links to the saved result.
+        : state.channel === "teams" ? [{ text: plan.shots.length === 1 ? plan.shots[0].caption : `${plan.shots[0].caption} · ${plan.shots.length} screenshots`,
+                image: image(plan.shots[0].artifact, plan.shots[0].sha256), shot: { follows: null }, ...where }]
+            : plan.shots.map(one => ({ text: one.caption, image: image(one.artifact, one.sha256), shot: { follows }, ...where }));
+    state.enqueue({ id, installation: identity.installation, binding: binding.id, kind: "notice", channel: binding.channel, member: binding.member,
+        ts: "", thread: "", payload: "{}", created: now.toISOString() });
+    state.plan(id, parts, now);
+}
 /** One progress card per exact result; separate urgent facts retain their own review link. */
 export async function planChatNotifications(options) {
     const state = options.state, { store, identity } = options, bindings = state.bindings(identity.installation).filter(one => state.live(one));
@@ -680,10 +721,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).
@@ -695,9 +737,13 @@ export async function planChatNotifications(options) {
                     // Only when I'm needed (the default): the task's one card is edited in place, and a new message
                     // follows only when this person is needed. Every step keeps the branches below unchanged.
                     const quiet = !personal && isTaskFact(notification) && store.notificationPreference(binding.approver).mode === "quiet";
+                    if (notification.kind === RESULT_SHOTS_KIND) {
+                        planResultShots(options, binding, notification, repos, id, now);
+                        return;
+                    }
                     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-quiet.d.ts

@@ -1,12 +1,15 @@
 import { type ProgressEntity } from "./telegram-progress.js";
 import { type PhoneTaskLink } from "./telegram-status.js";
 import { type ChatBatch, type Notification, type Store } from "./store.js";
-/** `also`: more buttons after `link`, such as [Look first] beside [Merge]. */
+import { type DecideTarget } from "./chat-decide.js";
+/** `also`: more buttons after `link`, such as [Look first] beside [Merge]. `target`: the one card a chat may act on in
+ * place (chat-decide.ts), when the message is about one result, plan, failure or pull request. */
 export type QuietView = {
     text: string;
     entities: ProgressEntity[];
     link: PhoneTaskLink;
     also?: PhoneTaskLink[];
+    target?: DecideTarget;
 };
 export declare function needsPerson(row: Pick<Notification, "dedupeKey" | "kind" | "pushClass" | "recipient">): boolean;
 /** A fact about one placed task: in quiet mode it lands on that task's card. */

package/dist/chat-quiet.js

@@ -12,6 +12,7 @@ import { asksToFinish, batchLine, chatText, chatTitle, factLinkLabel, mentions,
 import { phoneText, projectLabel } from "./telegram-status.js";
 import { isLifecycleNotification } from "./store.js";
 import { leadSubjectOf } from "./lead-voice.js";
+import { decideFallbackLink, decideTargetOf } from "./chat-decide.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). */
@@ -132,7 +133,8 @@ function lineOf(store, item, now, root, viewer) {
         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 },
+        const target = decideTargetOf(row);
+        return { also: [], target, link: decideFallbackLink(target) ?? (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 } } };
     }
     const run = item.run === null ? null : store.getRun(item.run);
@@ -156,6 +158,7 @@ function lineOf(store, item, now, root, viewer) {
     // A result ready for a person offers its real next step, then a look first.
     if (asksToFinish(fact))
         return { fact, also: [{ label: READY_ACTIONS.look, path: chatResultHref(ref.externalId, run.id, "changes") }],
+            target: pullRequest ? { kind: "merge", taskId: ref.externalId, run: run.id } : { kind: "result", taskId: ref.externalId, run: run.id },
             link: pullRequest ? { label: READY_ACTIONS.merge, path: `/t/${encodeURIComponent(ref.externalId)}#merge` } : { label: READY_ACTIONS.complete, path: chatResultHref(ref.externalId, run.id) } };
     return { fact, link: card.link, also: [] };
 }
@@ -168,7 +171,8 @@ export function finishedView(store, batch, now, root, viewer) {
     const text = batchLine(lines.map(one => one.fact));
     if (lines.length > 1)
         return { text, entities: [], link: { label: "Open", path: "/tasks" } };
-    return { text, entities: [], link: lines[0].link, ...(lines[0].also.length === 0 ? {} : { also: lines[0].also }) };
+    const target = lines[0].target ?? null;
+    return { text, entities: [], link: lines[0].link, ...(lines[0].also.length === 0 ? {} : { also: lines[0].also }), ...(target === null ? {} : { target }) };
 }
 // ---- the evening digest ----------------------------------------------------------
 const FAILURE = /fail|exhausted|fenced/;

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/desktop-update.d.ts

@@ -125,6 +125,7 @@ export declare function prepareDesktopUpdate(stateDir: string, installed: string
 export declare function sqliteLock(file: string, busyTimeoutMs?: number): DatabaseSync | null;
 export declare const installationLock: (j: UpdateJournal) => DatabaseSync | null;
 export declare function desktopUpdateStatus(stateDir: string): {
+    version?: never;
     active: boolean;
     phase: string;
     detail: string;
@@ -138,7 +139,6 @@ export declare function desktopUpdateStatus(stateDir: string): {
     wasRunning?: never;
     backupPath?: never;
     updateId?: never;
-    version?: never;
     buildId?: never;
     workDir?: never;
 } | {

package/dist/discord-api.d.ts

@@ -5,12 +5,14 @@ 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>>;
 export declare class DiscordError extends ChatDeliveryError {
 }
+/** Discord's 403: the bot may not do this here (for a file, no Attach Files permission). */
+export declare const DISCORD_REFUSED = "Discord refused access. Check the app and direct-message permissions.";
 export declare function discordApi(token: string, fetcher?: typeof fetch): DiscordApi;
 export declare const discordCredentialFile: (dir: string) => string;
 export declare function loadDiscordCredentials(dir: string): DiscordCredentials | null;

package/dist/discord-api.js

@@ -8,10 +8,12 @@ export { object };
 export const discordId = (v) => typeof v === "string" && /^[1-9][0-9]{16,19}$/.test(v);
 export class DiscordError extends ChatDeliveryError {
 }
+/** Discord's 403: the bot may not do this here (for a file, no Attach Files permission). */
+export const DISCORD_REFUSED = "Discord refused access. Check the app and direct-message permissions.";
 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}` };
@@ -56,7 +58,7 @@ export function discordApi(token, fetcher = fetch) {
             const message = response.status === 401
                 ? "Discord access expired. Disconnect and reconnect with the current bot token."
                 : response.status === 403
-                    ? "Discord refused access. Check the app and direct-message permissions."
+                    ? DISCORD_REFUSED
                     : response.status === 404
                         ? "The Discord message or conversation is unavailable. Open the saved chat."
                         : response.status === 413

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

@@ -2,20 +2,28 @@
 import { chatQuestionButtons } from "./teammate-question.js";
 import { chatAskButtons } from "./chat-ask.js";
 import { chatFlowButtons } from "./chat-flow.js";
+import { refuseResultShots, resultShotsPruned } from "./result-shots.js";
 import { channelInbox } from "./chat-inbox.js";
 import { roomCommand } from "./chat-rooms.js";
 import { ChatState, ChatDeliveryError, chatHash, } from "./chat-delivery-state.js";
 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";
+import { discordId, discordMember, DiscordError, DISCORD_REFUSED, } from "./discord-api.js";
 export const discordDelivery = (options) => ({
     ...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 +148,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
@@ -190,6 +206,13 @@ export async function deliverDiscordPart(options) {
             !repos.includes(store.lookupRef(content.task)?.repo ?? ""))
             throw new DiscordError("Connected projects changed");
         let text = content.text, buttons = [], file;
+        if (content.image && content.shot && resultShotsPruned(options.evidenceRoot, content.image.run)) {
+            state.prepare("UPDATE chat_part SET state='dropped',problem='Removed by retention' WHERE id=?").run(row.id);
+            return true;
+        }
+        // A screenshot sent with a result replies to that result's message once it is placed.
+        const follows = content.shot?.follows == null ? undefined : state.prepare("SELECT message FROM chat_part WHERE id=? AND state='sent'").get(content.shot.follows)?.message;
+        const thread = discordId(follows) ? String(follows) : event.thread;
         if (content.image) {
             const image = verifyResultImage(store, options.evidenceRoot, repos, content.image);
             if (!image.ok)
@@ -336,7 +359,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) },
@@ -344,9 +367,9 @@ export async function deliverDiscordPart(options) {
         if (!target) {
             args.nonce = nonce;
             args.enforce_nonce = true;
-            if (discordId(event.thread))
+            if (discordId(thread))
                 args.message_reference = {
-                    message_id: event.thread,
+                    message_id: thread,
                     channel_id: destination,
                     fail_if_not_exists: false,
                 };
@@ -370,6 +393,12 @@ export async function deliverDiscordPart(options) {
         return true;
     }
     catch (error) {
+        // No permission to attach files here: one plain line instead of the result's screenshots.
+        const content = JSON.parse(row.payload);
+        if (content.image && content.shot && error instanceof DiscordError && error.code === DISCORD_REFUSED) {
+            refuseResultShots(state, store, row, content, "Discord", options.clock?.() ?? new Date());
+            return true;
+        }
         const problem = error instanceof ChatDeliveryError
             ? error
             : new DiscordError("Discord delivery is waiting to retry", 15_000, true);

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;
+};

package/dist/lead-about.js

@@ -0,0 +1,62 @@
+import { scanForSecrets } from "./evidence.js";
+export const ABOUT_YOU_MAX_LINES = 20;
+/** Each line is under 200 characters. */
+export const ABOUT_YOU_LINE_MAX = 199;
+/** This person's confirmed lines; an older store reads as none. */
+export function aboutYouOf(store, account) {
+    if (account == null || account === "")
+        return [];
+    try {
+        return store.leadAbout(account);
+    }
+    catch {
+        return [];
+    }
+}
+/** One line as it is saved, or the problem with it. */
+export function checkAboutYouLine(value) {
+    const line = typeof value === "string" ? value.replace(/^\s*[-*•]\s*/, "").replace(/\s+/g, " ").trim() : "";
+    if (line.length < 2)
+        return { ok: false, message: "Say it in a few words." };
+    if (line.length > ABOUT_YOU_LINE_MAX)
+        return { ok: false, message: `Keep each line under ${ABOUT_YOU_LINE_MAX + 1} characters.` };
+    if (/[\u0000-\u001f\u007f​-‏‪-‮⁦-⁩�]/.test(line) || scanForSecrets(line).length > 0)
+        return { ok: false, message: "Use plain words, with no passwords or keys." };
+    return { ok: true, line };
+}
+/** The Settings form's text, one line each: the saved list, or the problem with it. Blank lines and repeats go. */
+export function checkAboutYou(text) {
+    const lines = [];
+    // A problem names the line as the person sees it in the box, blank lines and repeats counted.
+    for (const [index, raw] of text.replace(/\r\n?/g, "\n").split("\n").entries()) {
+        if (raw.trim() === "")
+            continue;
+        const checked = checkAboutYouLine(raw);
+        if (!checked.ok)
+            return { ok: false, message: `Line ${index + 1}: ${checked.message}` };
+        if (!lines.some(one => one.toLowerCase() === checked.line.toLowerCase()))
+            lines.push(checked.line);
+    }
+    if (lines.length > ABOUT_YOU_MAX_LINES)
+        return { ok: false, message: `Keep it to ${ABOUT_YOU_MAX_LINES} lines.` };
+    return { ok: true, lines };
+}
+/** Save the whole list for this person (already checked). Their lead's name and persona are left as they are. */
+export function saveAboutYou(store, account, lines, now) {
+    store.setLeadAbout(account, lines, now);
+}
+/** The list once a confirmed line is added, or once it replaces line `replaces` (1-based). */
+export function withAboutYouLine(lines, line, replaces) {
+    if (replaces > 0) {
+        if (replaces > lines.length)
+            return { ok: false, message: "That line is no longer in what your lead knows about you." };
+        const next = [...lines];
+        next[replaces - 1] = line;
+        return { ok: true, lines: next.filter((one, index) => index === replaces - 1 || one.toLowerCase() !== line.toLowerCase()) };
+    }
+    if (lines.some(one => one.toLowerCase() === line.toLowerCase()))
+        return { ok: false, message: "Your lead already knows this." };
+    if (lines.length >= ABOUT_YOU_MAX_LINES)
+        return { ok: false, message: `What your lead knows about you is full (${ABOUT_YOU_MAX_LINES} lines). Replace a line, or tidy it in Settings → Lead.` };
+    return { ok: true, lines: [...lines, line] };
+}

package/dist/lead-capabilities.d.ts

@@ -0,0 +1,64 @@
+/**
+ * What the lead can rely on right now, in one read (get_capabilities): the agents a project's route would run, the
+ * workers that would run them, the project's tools and skills, the integrations, and the project's checks. Every entry
+ * says what it lets the lead do and, when it can't, the one next step and the settings control (show_control) that
+ * takes the owner there. Everything here reads what is already recorded — runner readiness reports, sign-in pauses,
+ * plan-limit readings, tool tests, skill tests, integration checks — and never probes anything that spends.
+ */
+import type { Store } from "./store.js";
+import type { ChatControl } from "./chat-controls.js";
+import type { ProviderId } from "./provider.js";
+import { type AuthMode } from "./keys.js";
+import { type Integration } from "./integrations.js";
+/** One thing the lead may depend on: its state in a few words, what it lets the lead do, and when it can't, the next step. */
+export type Capability = {
+    name: string;
+    state: string;
+    ok: boolean;
+    lets: string;
+    next: string | null;
+    link: ChatControl | null;
+};
+export type ProjectCapabilities = {
+    repo: string;
+    agents: (Capability & {
+        provider: string;
+        model: string;
+        roles: string[];
+    })[];
+    agentsProblem: Capability | null;
+    tools: Capability[];
+    skills: Capability[];
+    checks: Capability & {
+        level: string;
+        quickCheck: boolean;
+        releaseCheck: boolean;
+    };
+};
+export type Capabilities = {
+    projects: ProjectCapabilities[];
+    workers: (Capability & {
+        online: boolean;
+        capacity: number;
+        running: string[];
+    })[];
+    integrations: (Capability & {
+        kind: string;
+        account: string | null;
+        usedBy: string[];
+        lastError: string | null;
+    })[];
+};
+/** The integrations exactly as get_integrations reads them, with what each lets the lead do and the next step. */
+export declare function integrationCapabilities(list: readonly Integration[]): Capabilities["integrations"];
+/** Every capability, for one project or every admitted one. Read-only and spends nothing. */
+export declare function capabilitiesOf(store: Store, input: {
+    repos: readonly string[];
+    admitted: readonly string[];
+    actor: string;
+    integrations: readonly Integration[];
+    authMode?: (provider: ProviderId) => AuthMode;
+    now: Date;
+}): Capabilities;
+export declare function needsCapabilities(name: string, args: Record<string, unknown>, channel: string | undefined): boolean;
+export declare const CAPABILITIES_UNREAD = "This depends on an agent, a worker or an integration. Read get_capabilities first, then propose or promise in a later step; if something it needs can't work, say so plainly with its next step and show_control link instead.";