toolroll 0.9.15 → 0.9.17

package/dist/telegram-mate.js

@@ -23,10 +23,13 @@ export { channelRepos as telegramConversationRepos, resolveChannelMate as resolv
  * the console and CLI state), and the door re-proves everything again.
  */
 import { createHash, randomBytes } from "node:crypto";
-import { MATE_MESSAGE_MAX_CHARS, runMateTurn } from "./mate.js";
+import { MATE_MESSAGE_MAX_CHARS, mateFailureText, runMateTurn } from "./mate.js";
 import { confirmMateProposal, dismissMateProposal } from "./mate-doors.js";
 import { ceilingDigestOf, verifyApproverStanding } from "./principal.js";
+import { MATE_ASK_OTHER } from "./store.js";
 import { phoneText } from "./telegram-status.js";
+import { shapeReplyParts, telegramReply } from "./reply-shape.js";
+import { WARM_EMOJI, warmTurn } from "./chat-warmth.js";
 import { TeamLeads } from "./team-leads.js";
 import { chatResultHref } from "./chat-controls.js";
 import { resultImageFileName, safeResultImageCaption, verifyResultImage } from "./chat-evidence.js";
@@ -39,7 +42,7 @@ export const CONVERSATION_MAX_AGE_MS = 10 * 60_000;
 export const CARD_TTL_MS = 24 * 3_600_000;
 export const CHALLENGE_TTL_MS = 10 * 60_000;
 /** Telegram's own message ceiling, with room for our part headers (the same bound telegram.ts splits at). */
-const PART_CAP = 3_900;
+export const PART_CAP = 3_900;
 // ---- the ceiling and the principal --------------------------------------------
 /**
  * The phone's project ceiling: the enrolled registry, canonicalized and
@@ -100,6 +103,17 @@ function keyboardWith(callbacks, link) {
     const rows = [...(callbacks ?? []), ...(link === null ? [] : [link])];
     return rows.length === 0 ? undefined : rows;
 }
+// ---- proposal cards on the wire ------------------------------------------------------
+/** One inline button: an opaque callback token (a real in-chat act) or a url (navigation, never authority). */
+/** The buttons under the lead's question: options two to a row, then "Something else". Each names the turn and the
+ * option's place, nothing more; a tap re-proves that the question is still open and is the tapper's own. */
+export function askKeyboard(ask) {
+    const rows = [];
+    for (let at = 0; at < ask.options.length; at += 2)
+        rows.push(ask.options.slice(at, at + 2).map((label, offset) => ({ text: label.slice(0, 60), callback_data: `ask:${ask.turn}:${at + offset}` })));
+    rows.push([{ text: MATE_ASK_OTHER, callback_data: `ask:${ask.turn}:x` }]);
+    return rows;
+}
 /** Mint the card's tokens before the send, so a tap can never name a token that does not exist. */
 export function mintCardTokens(store, binding, proposal, now, messageId, chatId = binding.chatId) {
     const confirm = randomBytes(16).toString("hex");
@@ -393,7 +407,7 @@ async function runTelegramConversation(row, args) {
         const bound = store.getTelegramConversation(row.id)?.session ?? null;
         const session = bound === null ? null : store.getMateSession(bound);
         if (session === null) {
-            await notify(couldNotAnswerText("the chat session for this reply is gone"));
+            await notify("This conversation was restarted before my reply went out, so it wasn't sent. Nothing was changed. Send your message again.");
             finish({ state: "failed", outcome: "unsent:no-session" });
             report.refused++;
             return;
@@ -513,11 +527,14 @@ async function runTelegramConversation(row, args) {
                 const origin = proposal === null ? null : options.phoneOrigin?.() ?? null;
                 const wanted = proposal === null ? null : proposalLink(store, proposal, repos);
                 const keyboard = keyboardWith(part.keyboard, phoneLinkButton(origin, wanted));
-                const text = proposal !== null && part.keyboard === null ? handoffCardText(part.text, linkNote(origin, wanted)) : part.text;
+                // The lead's own words carry their bold anchors and labelled links as entities, never as Markdown characters.
+                const voiced = part.kind === "reply" ? telegramReply(part.text) : null;
+                const text = proposal !== null && part.keyboard === null ? handoffCardText(part.text, linkNote(origin, wanted)) : voiced?.text ?? part.text;
                 method = "sendMessage";
                 send = () => transport("sendMessage", {
                     chat_id: chatId,
                     text,
+                    ...(voiced === null || voiced.entities.length === 0 ? {} : { entities: voiced.entities }),
                     link_preview_options: { is_disabled: true },
                     ...(part.replyTo === null ? {} : { reply_parameters: { message_id: Number(part.replyTo) } }),
                     ...(keyboard === undefined ? {} : { reply_markup: { inline_keyboard: keyboard } }),
@@ -578,7 +595,11 @@ async function runTelegramConversation(row, args) {
         try {
             return store.transact(() => {
                 const now = clock();
-                const parts = splitParts(reply).map((text, index) => ({ kind: "reply", text, replyTo: index === 0 ? row.messageId : null }));
+                const parts = shapeReplyParts(reply, PART_CAP, { asked: row.text, appOrigin: options.phoneOrigin?.() ?? null }, shaped => telegramReply(shaped).text.length).map((text, index) => ({ kind: "reply", text, replyTo: index === 0 ? row.messageId : null }));
+                // The lead's question to its owner: one tap per option, then "Something else".
+                const ask = store.mateAsk(turn);
+                if (ask !== null)
+                    parts.push({ kind: "reply", text: phoneText(ask.question, 1_000), keyboard: askKeyboard(ask) });
                 // Only a turn that answered may have its selection sent: a failed or revoked turn's rows were deleted with its drafts, and the state is read again here.
                 const selected = store.getMateTurn(turn)?.state === "answered" ? store.listMateTurnEvidence(turn) : [];
                 for (const image of selected)
@@ -617,7 +638,7 @@ async function runTelegramConversation(row, args) {
             return;
         }
         if (turn.state !== "answered") {
-            await notify(couldNotAnswerText(`the assistant's reply did not complete (${phoneText(turn.failureReason ?? "unknown", 40)})`));
+            await notify(mateFailureText(turn.failureReason));
             finish({ state: "failed", outcome: `replayed:${turn.failureReason ?? "failed"}` });
             report.refused++;
             return;
@@ -677,7 +698,13 @@ async function runTelegramConversation(row, args) {
     const { who, session, thread, config } = resolved;
     const revalidate = async () => {
         const problem = await telegramChannelProblem(store, { botId, bindingId: binding.id, approverGeneration: binding.approverGeneration, repos: who.repos }, readProjects);
-        return problem === null ? { ok: true } : { ok: false, reason: problem };
+        if (problem === null)
+            return { ok: true };
+        const reason = problem === UNREADABLE_REGISTRY ? "projects-unreadable"
+            : problem === "this chat is no longer paired" ? "unpaired"
+                : problem === "the paired account is no longer an approver" ? "not-approver"
+                    : problem === "the connected projects changed" ? "projects-changed" : "access-changed";
+        return { ok: false, reason };
     };
     // Bound BEFORE the dispatch, under the claim: a crash from here on finds
     // the receipt in this session, not in whichever session is live later.
@@ -688,17 +715,23 @@ async function runTelegramConversation(row, args) {
     // crash gets the original turn back, never a second dispatch.
     const heartbeat = setInterval(() => { held(); }, 30_000);
     heartbeat.unref?.();
+    // Once the turn reaches a tool step: a 👍 on the owner's message, and "typing…" while the lead works.
+    const warm = warmTurn({
+        react: () => transport("setMessageReaction", { chat_id: chatId, message_id: Number(row.messageId), reaction: [{ type: "emoji", emoji: WARM_EMOJI }] }),
+        typing: () => transport("sendChatAction", { chat_id: chatId, action: "typing" }),
+    });
     let outcome;
     try {
         outcome = await runMateTurn({
             store, who, session, thread, config, key: null, message: row.text, requestId: row.request,
             ...(row.context === null ? {} : { context: row.context }),
             ...(options.subscriptionRunner === undefined ? {} : { subscriptionRunner: options.subscriptionRunner }),
-            clock, evidenceRoot: options.evidenceRoot, revalidate, mediaDelivery: "documents",
+            clock, evidenceRoot: options.evidenceRoot, revalidate, mediaDelivery: "documents", channel: "telegram", onProgress: warm.onProgress,
         });
     }
     finally {
         clearInterval(heartbeat);
+        warm.stop();
     }
     const receipt = store.mateRequestReceipt(session.id, row.request);
     if (receipt !== null)
@@ -708,7 +741,7 @@ async function runTelegramConversation(row, args) {
             await requeue("busy");
             return;
         }
-        await notify(phoneText(couldNotAnswerText(outcome.message), 1_000));
+        await notify(phoneText(outcome.message, 1_000));
         finish({ state: "failed", outcome: `refused:${outcome.refused}` });
         report.refused++;
         return;
@@ -716,8 +749,7 @@ async function runTelegramConversation(row, args) {
     if (!outcome.ok) {
         // Truthful: what failed, that nothing was kept, and that a new message
         // is a new turn. A failed turn's drafts are already gone.
-        const words = outcome.failed === "revoked" ? `${outcome.message.charAt(0).toUpperCase()}${outcome.message.slice(1)}.` : couldNotAnswerText(`the assistant's reply did not complete (${outcome.message})`);
-        await notify(phoneText(words, 1_000));
+        await notify(phoneText(outcome.message, 1_000));
         finish({ state: "failed", outcome: `failed:${outcome.failed}` });
         report.refused++;
         return;

package/dist/telegram-progress.js

@@ -9,6 +9,7 @@ import { chatResultHref, chatControlHref } from "./chat-controls.js";
 import { phoneText, projectLabel } from "./telegram-status.js";
 import { assignmentStatusFacts, headlineEmoji, pullRequestFactOf, requirementsOf, statusDetailLines, unverifiedWhenRefuted, taskStatusOf } from "./task-status.js";
 import { leadClaimOf } from "./lead-voice.js";
+import { leadNameOf } from "./lead-identity.js";
 import { chatTitle } from "./chat-voice.js";
 import { manualReviewOnly } from "./proof.js";
 import { failedCheckExit } from "./workspace-ui.js";
@@ -79,11 +80,11 @@ export function telegramProgressCard(store, run, taskId, project, now = new Date
     const completer = assignment?.completion?.actor.replace(/^(?:operator|coordinator|lead):/, "") ?? null;
     if (viewer !== undefined && facts.completedBy != null && (completer === viewer || facts.completedBy === viewer))
         facts = { ...facts, completedBy: null };
-    // The person's lead took it on: "Your lead is on it" rather than waiting for them (lead-voice.ts).
+    // The person's lead took it on: "<name> is on it" rather than waiting for them (lead-voice.ts).
     if (facts.lead === undefined) {
         const lead = leadClaimOf(store, taskId, now, viewer);
         if (lead !== null)
-            facts = { ...facts, lead: lead.state };
+            facts = { ...facts, lead: lead.state, leadName: leadNameOf(store, lead.owner) };
     }
     const status = taskStatusOf(facts);
     const checkProgress = store.checkProgress(run.id);

package/dist/telegram-team.js

@@ -1,6 +1,7 @@
+import { renderReply, shapeReplyParts } from "./reply-shape.js";
 import { TeamLeads } from "./team-leads.js";
 import { proposalPreview, tooLongText } from "./chat-channel.js";
-import { mintCardTokens, phoneLinkButton, splitParts } from "./telegram-mate.js";
+import { PART_CAP, mintCardTokens, phoneLinkButton, splitParts } from "./telegram-mate.js";
 import { MATE_MESSAGE_MAX_CHARS } from "./mate.js";
 import { phoneText } from "./telegram-status.js";
 /** `/team` lists, `/team <n>` chooses, `/team off` (or `private`) leaves. Any other slash text is not ours. */
@@ -265,7 +266,9 @@ export async function deliverTeamChats(store, botId, transport, clock, report, p
             const skip = role === "operator" && (ownMessage || status === "cancelled" || String(message["author"] ?? "").length === 0);
             const prefix = `telegram-team:${chat.id}:`;
             if (!skip) {
-                const text = role === "assistant" ? String(message["text"]) : `${phoneText(String(message["author"]), 40)}: ${String(message["text"])}`;
+                // The lead's reply is split as written, then each part shaped and measured as Telegram shows it, so no cut lands
+                // inside a link and no rendered part passes Telegram's ceiling.
+                const text = role === "assistant" ? shapeReplyParts(String(message["text"]), PART_CAP, { appOrigin: phoneOrigin?.() ?? null }, shaped => renderReply(shaped, "telegram").length).map(part => renderReply(part, "telegram")) : `${phoneText(String(message["author"]), 40)}: ${String(message["text"])}`;
                 const sent = await sendParts(store, transport, chat.chatId, text, `${prefix}message:${id}`, clock, access, report);
                 if (sent !== null) {
                     report.problems.push(`team chat ${chat.chatId}: ${sent}`);
@@ -329,7 +332,7 @@ function cardBindingFor(store, botId, chat, turn) {
     return bindings.find(one => members.has(one.approver)) ?? null;
 }
 async function sendParts(store, transport, chatId, text, receipt, clock, access, report, keyboard, tokens = []) {
-    const parts = splitParts(text);
+    const parts = typeof text === "string" ? splitParts(text) : text;
     const delivered = store.serviceCursor(receipt);
     for (const [index, part] of parts.entries()) {
         if (index < delivered)

package/dist/telegram.js

@@ -31,7 +31,7 @@ import { isLifecycleNotification, isTelegramProgressNotification, TELEGRAM_HOLD_
 import { telegramProgressCard } from "./telegram-progress.js";
 import { enqueueEveningDigests, finishedView, isTaskFact, joinsBatch, needsPerson, quietCardView } from "./chat-quiet.js";
 import { BATCH_MS, chatText, chatTitle, factLinkLabel, mentions, nameTelegramBot } 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 { applyTeamInbound, deliverTeamChats, teamCommand } from "./telegram-team.js";
 import { applyFlowReply, applyFlowTap, FLOW_DECIDE_KEY, flowButtons, flowDecisionAt } from "./telegram-flow.js";
 import { connectChannel, FLOW_WORDS, takeChannelMessage, watchedChannel } from "./chat-inbox.js";
@@ -920,7 +920,7 @@ async function deliverOutboxTo(store, botId, binding, transport, owner, clock, r
         };
         /** The lead's words (lead-voice.ts): one message; a later say within two minutes edits it in place. */
         const leadSayOutcome = async (fact) => {
-            const words = leadSayText(fact);
+            const words = leadSayText(store, fact, binding.approver);
             const button = fact.link === null ? null : factButton(phoneOrigin, fact.link);
             const keyboard = button === null ? [] : [button];
             const earlier = leadSayEarlier(store, fact).map(id => store.telegramMessageOf(id, fact.destination)).find(one => one !== null) ?? null;
@@ -1064,7 +1064,7 @@ async function deliverOne(store, botId, binding, sender, notification, clock, ph
         // A short title, never the task's id or a "— revision" suffix (chat-voice.ts).
         const title = notification.taskId === null ? undefined : chatTitle(store, notification.taskId);
         const task = notification.taskId === null ? [] : [{ id: notification.taskId, ...(title === undefined ? {} : { title }) }];
-        const words = chatText(`${alreadyAccepted ? "Acceptance recorded" : notification.subject}${body === "" ? "" : `\n\n${body}`}`, task);
+        const words = chatText(`${alreadyAccepted ? "Acceptance recorded" : leadSubjectOf(store, notification, binding.approver)}${body === "" ? "" : `\n\n${body}`}`, task);
         // The task's title once: in front, unless the words already name it.
         const parts = split(`${notificationIdentity(notification, title !== undefined && mentions(words, title) ? undefined : title)}${words}`);
         const button = notification.link !== null && !alreadyAccepted && current ? factButton(phoneOrigin, notification.link) : null;
@@ -1970,6 +1970,46 @@ function applyCallback(context, update, effects) {
         }
         return;
     }
+    // The lead's question to its owner: an option is sent as their next message; "Something else" asks them to type it.
+    const askTap = /^ask:([1-9][0-9]{0,14}):([0-3]|x)$/.exec(token);
+    if (askTap !== null) {
+        if (tapChat !== binding.chatId || context.conversation === undefined) {
+            report.ignored++;
+            return;
+        }
+        const turn = Number(askTap[1]);
+        const found = store.getMateTurn(turn)?.approver === binding.approver ? store.mateAskState(turn, clock()) : { state: "expired" };
+        if (found.state !== "open") {
+            const line = found.state === "answered" ? "That question was already answered." : "That question expired. Send your answer as a message.";
+            ack(line);
+            editText(`${message.text ?? ""}\n\n${line}`.trim().slice(0, 4000));
+            return;
+        }
+        const ask = found.ask;
+        if (store.telegramConversationWaitingOn(binding.id, String(message.message_id))) {
+            ack("Your answer is on its way.");
+            return;
+        }
+        if (askTap[2] === "x") {
+            ack("Type your answer as a message.");
+            return;
+        }
+        const option = ask.options[Number(askTap[2])];
+        if (option === undefined) {
+            ack("That option is no longer there.");
+            return;
+        }
+        const focused = store.chatFocus("telegram", binding.id);
+        store.enqueueTelegramConversation({
+            binding, updateId: update.update_id, messageId: String(message.message_id), replyTo: null,
+            request: telegramRequestId(botId, binding.id, update.update_id), text: option,
+            context: focused === null ? null : focusContextFor(focused), taskId: focused, sourceRun: null,
+        }, clock());
+        report.chatQueued = (report.chatQueued ?? 0) + 1;
+        ack(`Sent: ${option}`.slice(0, 190));
+        editText(`${message.text ?? ask.question}\n\nYou chose: ${option}`.slice(0, 4000));
+        return;
+    }
     const action = store.getTelegramAction(token);
     if (action === null && context.conversation !== undefined && store.getTelegramProposalAction(token) !== null) {
         // A proposal card's button: the shared confirm door, inside this

package/dist/test-temp.js

@@ -18,7 +18,7 @@ export const TEST_TEMP_PREFIXES = [
     "flow-goal-", "flow-scratch", "flows-chat-", "invoke-attest-", "knowledge-test-", "learning-", "peek-", "phone-origin-",
     "proposal-repo-", "race-", "refresh-migration-", "refresh-refusal-", "release-check-", "shared-chat-", "skills-test-",
     "task-status-surfaces-", "template-repo-", "template-test-", "v14-migrate-", "v17-migrate-", "watch-anchor-",
-    "needs-you-", "deps-lock-", "deps-state-", "upgrade-fresh-", "upgrade-path-", "deploy-restore-", "result-review-", "one-result-page-", "deploy-before-swap-", "one-vocabulary-", "accept-finishes-",
+    "needs-you-", "deps-lock-", "deps-state-", "upgrade-fresh-", "upgrade-path-", "deploy-restore-", "result-review-", "one-result-page-", "deploy-before-swap-", "one-vocabulary-", "accept-finishes-", "lead-promises-", "lead-people-",
     // Playwright's browser profiles and artifacts.
     "playwright_chromiumdev_profile-", "playwright_firefoxdev_profile-", "playwright-artifacts-",
 ];

package/dist/when-html.d.ts

@@ -13,10 +13,15 @@ export declare function deadlineWords(deadline: {
 /** The exact minute in `zone` ("2026-09-30 16:39", with " UTC" when it is UTC): a time's title, one hover away. */
 export declare function fullWhen(iso: string, zone?: string): string;
 /** Every server-rendered stamp (`whenHtml`'s `<time data-when>`) inside `root`, reworded by the one formatter in the
- * viewer's zone: the same words on a desk and a phone, the exact minute in the title. The server's UTC words stay
- * only without script. Times React writes, relative ages ("3 min ago") and exact stamps (the ledger's seconds) carry
- * no `data-when` and are never touched. */
+ * viewer's zone: the same words on a desk and a phone, the exact minute in the title. An exact stamp
+ * (`exactWhenHtml`'s `data-when="exact"`, the ledger's seconds) keeps its seconds, in the viewer's zone, and its
+ * ISO title. The server's UTC words stay only without script. Times React writes and relative ages ("3 min ago")
+ * carry no `data-when` and are never touched. */
 export declare function localizeTimes(root: ParentNode, now?: Date, zone?: string): void;
+/** The exact second in `zone` ("2026-09-30 16:39:12", with " UTC" when it is UTC): an audit record's stamp. */
+export declare function exactWhen(iso: string, zone?: string): string;
+/** The `<time>` for an exact stamp: its seconds in UTC words on the server, the viewer's zone in a browser. */
+export declare function exactWhenHtml(iso: string): string;
 /** The `<time>` for a stamp: `full` is the words a desk shows ("2026-09-30 16:39 UTC"). Empty for no stamp. */
 export declare function whenHtml(iso: string | null, full: string, now?: Date): string;
 /** "2026-09-30 16:39 UTC" — the desk's words for a stamp. */

package/dist/when-html.js

@@ -75,14 +75,21 @@ export function fullWhen(iso, zone = "UTC") {
     return `${p.year}-${String(p.month).padStart(2, "0")}-${String(p.day).padStart(2, "0")} ${p.clock}${zone === "UTC" ? " UTC" : ""}`;
 }
 /** Every server-rendered stamp (`whenHtml`'s `<time data-when>`) inside `root`, reworded by the one formatter in the
- * viewer's zone: the same words on a desk and a phone, the exact minute in the title. The server's UTC words stay
- * only without script. Times React writes, relative ages ("3 min ago") and exact stamps (the ledger's seconds) carry
- * no `data-when` and are never touched. */
+ * viewer's zone: the same words on a desk and a phone, the exact minute in the title. An exact stamp
+ * (`exactWhenHtml`'s `data-when="exact"`, the ledger's seconds) keeps its seconds, in the viewer's zone, and its
+ * ISO title. The server's UTC words stay only without script. Times React writes and relative ages ("3 min ago")
+ * carry no `data-when` and are never touched. */
 export function localizeTimes(root, now = new Date(), zone = viewerZone()) {
     root.querySelectorAll("time[data-when][datetime]").forEach(node => {
         const iso = node.getAttribute("datetime") ?? "";
         if (iso === "" || Number.isNaN(new Date(iso).getTime()))
             return;
+        if (node.getAttribute("data-when") === "exact") {
+            const words = exactWhen(iso, zone);
+            if (node.textContent !== words)
+                node.textContent = words;
+            return;
+        }
         const words = shortWhen(iso, now, zone), full = fullWhen(iso, zone);
         if (node.title !== full)
             node.title = full;
@@ -90,6 +97,19 @@ export function localizeTimes(root, now = new Date(), zone = viewerZone()) {
             node.textContent = words;
     });
 }
+/** The exact second in `zone` ("2026-09-30 16:39:12", with " UTC" when it is UTC): an audit record's stamp. */
+export function exactWhen(iso, zone = "UTC") {
+    const at = new Date(iso);
+    if (Number.isNaN(at.getTime()))
+        return iso;
+    const seconds = String(at.getUTCSeconds()).padStart(2, "0");
+    const minute = fullWhen(iso, zone);
+    return zone === "UTC" ? minute.replace(/ UTC$/, `:${seconds} UTC`) : `${minute}:${seconds}`;
+}
+/** The `<time>` for an exact stamp: its seconds in UTC words on the server, the viewer's zone in a browser. */
+export function exactWhenHtml(iso) {
+    return `<time data-when="exact" datetime="${escape(iso)}" title="${escape(iso)}">${escape(exactWhen(iso))}</time>`;
+}
 /** The `<time>` for a stamp: `full` is the words a desk shows ("2026-09-30 16:39 UTC"). Empty for no stamp. */
 export function whenHtml(iso, full, now = new Date()) {
     if (iso === null || iso === "")

package/dist/work-index.d.ts

@@ -34,6 +34,8 @@ export type WorkIndexItem = {
         digest: string;
     } | null;
     evidence: 'recorded';
+    /** The viewer's own lead took it on (lead-voice.ts): "<name> is on it.", by the name they gave it, read now. */
+    lead?: string;
 };
 export type WorkIndexOptions = {
     view?: WorkView;

package/dist/work-index.js

@@ -1,13 +1,14 @@
 /** Paginated, permission-bound summaries of saved task facts. These reads do
  * not verify artifacts or authorize task operations; a build Toolroll can't
  * yet confirm stopped is read through the store's own read-only probe. */
+import { leadNameOf } from './lead-identity.js';
 import { createHash } from 'node:crypto';
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { readProjectAccess } from './project-access.js';
 import { pauseOnTaskProviders, providerName, signInReason } from './provider-auth.js';
 import { scopeTermsProblem, stopFactOf } from './store.js';
-import { plainReasonOf, replacedWords, stageOfCode, taskStatusOf, workToneOf } from './task-status.js';
+import { leadOnIt, plainReasonOf, replacedWords, stageOfCode, taskStatusOf, workToneOf } from './task-status.js';
 import { isCheckLevel } from './check-levels.js';
 import { MARKER } from './worktree.js';
 import { withFollowUps } from './result-follow-ups.js';
@@ -395,7 +396,9 @@ export function workIndexPage(store, now, access, options = {}) {
         const ref = store.lookupRef(taskId);
         return ref === null ? null : custody.readings.get(ref.id) ?? null;
     };
-    return { items: page.map(row => itemOf(row, access.principal, probe)), projects, totals: rows[0] === undefined ? { ...EMPTY } : counts(rows[0]),
+    // A claimed row says the viewer's own name for their lead.
+    const leadName = page.some(row => n(row, 'lead_claim') !== 0) && access.principal === 'operator' && access.viewer != null ? leadNameOf(store, access.viewer) : undefined;
+    return { items: page.map(row => itemOf(row, access.principal, probe, leadName)), projects, totals: rows[0] === undefined ? { ...EMPTY } : counts(rows[0]),
         groups: rows[0] === undefined ? { ...NO_GROUPS } : groupCounts(rows[0]), nextCursor, limit, view };
 }
 export function workCountsByProject(store, now, access) {
@@ -441,13 +444,13 @@ function listChecksOf(own, level, follows) {
         return null;
     return { status: read.status, exitCode: null, head: null, level: read.level, running: read.running };
 }
-function itemOf(row, principal, probe) {
+function itemOf(row, principal, probe, leadName) {
     const code = String(row['code']), id = String(row['id']);
     const custody = code === 'process-needs-attention' || (code === 'result-needs-attention' && n(row, 'custody_unresolved') === 1);
     const process = custody && probe !== undefined ? processNeedOf(probe(id)) : null;
     const waiting = process !== null && 'wait' in process;
     const need = n(row, 'needs') === 1 && !waiting, running = n(row, 'family_running') === 1;
-    // The lead's claim (lead-voice.ts): the row still reads its own stage, worded "Your lead is on it".
+    // The lead's claim (lead-voice.ts): the row still reads its own stage, worded "<name> is on it".
     const lead = n(row, 'lead_claim') === 1 ? 'on-it' : n(row, 'lead_claim') === 2 ? 'lapsed' : null;
     const personNeed = (n(row, 'person_need') === 1 || need) && !waiting;
     const assignmentState = code === 'complete' ? 'complete' : code === 'ready-to-check' ? 'ready-to-check'
@@ -559,7 +562,7 @@ function itemOf(row, principal, probe) {
         reason: finished ? null : plainReasonOf(reading.stage, code, detail || null), report: s(row, 'result_role') === 'scout',
         checks: !finished ? null : listChecksOf(own, s(row, 'check_level'), row['check_follows']),
         completedBy: code !== 'complete' ? null : n(row, 'completed_by_lead') === 1 ? 'the lead' : String(row['checked_actor']).replace(/^(?:operator|coordinator|lead):/, ''),
-        ...(lead === null ? {} : { lead }) });
+        ...(lead === null ? {} : { lead, ...(leadName === undefined ? {} : { leadName }) }) });
     label = shared.headline;
     detail = shared.sentence;
     // Every Needs you action wears its need's own words.
@@ -584,5 +587,5 @@ function itemOf(row, principal, probe) {
         ask: need ? ASKS[n(row, 'ask_rank')] ?? 'unblock' : null,
         chip: need ? askChipOf({ headline: shared.headline, need: shared.need?.key ?? null, planChanged, mismatch: verdict === 'refuted' && n(row, 'proof_failed_check') !== 1, ask: ASKS[n(row, 'ask_rank')] ?? 'unblock' }) : null,
         primaryAction, completion: code === 'complete' ? { actor: String(row['checked_actor']), at: String(row['checked_at']), digest: String(row['checked_digest']) } : null,
-        evidence: 'recorded' };
+        evidence: 'recorded', ...(lead === 'on-it' ? { lead: leadOnIt(leadName) } : {}) };
 }

package/dist/work-summary.d.ts

@@ -42,7 +42,7 @@ export declare function workDecisionAction(taskId: string, decision: NonNullable
 /** Pure counterpart for callers already holding the same facts. */
 export declare function workSummaryOf(facts: WorkFacts, principal: WorkPrincipal, resultDisplay?: DisplayStatus): WorkSummary;
 export type WorkSummaryAccess = 
-/** `viewer`: the person reading, whose own lead's claim (lead-voice.ts) a task reads as "Your lead is on it". */
+/** `viewer`: the person reading, whose own lead's claim (lead-voice.ts) a task reads as "<name> is on it". */
 {
     principal: "operator";
     repos: readonly string[] | null;

package/dist/workspace-ui.d.ts

@@ -17,8 +17,8 @@
  * claimed without one.
  */
 import type { DispatchDiagnosis } from "./dispatch.js";
-import { ACCEPT_NEEDS_REASON, type AcceptLabel } from "./result-acts.js";
-export { ACCEPT_NEEDS_REASON };
+import { ACCEPT_NEEDS_REASON, cantAcceptYetOf, evidenceProblemOf, type AcceptLabel, type EvidenceProblem } from "./result-acts.js";
+export { ACCEPT_NEEDS_REASON, cantAcceptYetOf, evidenceProblemOf, type EvidenceProblem };
 import { type ProofVerdict } from "./proof.js";
 import type { ReviewRetryState, TaskState } from "./store.js";
 import type { TaskControlView } from "./task-control.js";
@@ -113,14 +113,6 @@ export type DisplayStatus = {
     tone: StatusTone;
     action: NextAction | null;
 };
-/** What kind of evidence problem a verdict records: a check the machine
- * actually ran and saw fail, evidence that contradicts the sealed record
- * (a mismatched changed-path claim, an altered criterion, a caveat that
- * contradicts a met verdict), or evidence that is simply absent. A generic
- * refuted verdict is NOT a failed test claim — only the verify-command
- * reasons say a check failed. */
-export type EvidenceProblem = "checks-failed" | "mismatched" | "missing" | "none";
-export declare function evidenceProblemOf(verdict: ProofVerdict | null, reasons: readonly string[]): EvidenceProblem;
 /** The exit code of the failed check, when the recorded reason names one. */
 export declare function failedCheckExit(reasons: readonly string[]): number | null;
 /** The observed publication record in words. Each state is a distinct
@@ -192,10 +184,6 @@ export declare function dispatchActionLabel(dispatch: DispatchDiagnosis | null):
 /** A finished result's display status in the shared headline's words: a
  * failed project check is Failed, a result missing its record needs a
  * person, every other saved result is Ready for review. Token and action stay. */
-/** Why a result can't be accepted as it stands, in one plain line, or null
- * when nothing refutes it (a person's acceptance settles it). The result page
- * shows it before Request changes, its one ink act. */
-export declare function cantAcceptYetOf(verdict: ProofVerdict | null, reasons: readonly string[], accepted: boolean): string | null;
 /** The result's headline while its report disagrees with its saved changes. */
 export declare const MISMATCH_HEADLINE = "The report doesn't match the changes";
 /** One way the report disagrees with the saved changes, in plain words: the

package/dist/workspace-ui.js

@@ -16,10 +16,11 @@
  * observed" name observed publication records, and deployment is never
  * claimed without one.
  */
-import { ACCEPT_NEEDS_REASON } from "./result-acts.js";
-export { ACCEPT_NEEDS_REASON };
+import { ACCEPT_NEEDS_REASON, FAILED_CHECK, cantAcceptYetOf, evidenceProblemOf } from "./result-acts.js";
+export { ACCEPT_NEEDS_REASON, cantAcceptYetOf, evidenceProblemOf };
 import { GOAL_ASSESSMENT_PENDING, manualReviewOnly, plainReasonWords } from "./proof.js";
 import { OPEN_RESULT, plainReasonOf, stageOfCode, taskStatusOf, workToneOf } from "./task-status.js";
+import { whenUtc } from "./when-html.js";
 export const WORK_VIEWS = [
     { key: "all", label: "All", hint: "Every task in view, most urgent first.", empty: "Nothing is in progress. Describe work in chat or add a task, and it appears here." },
     { key: "needs-you", label: "Needs you", hint: "Tasks waiting on an answer, approval, or your inspection.", empty: "Nothing needs you right now. Queued and running work continues on its own." },
@@ -69,14 +70,6 @@ export function reviewStatusOf(review) {
         return null;
     return { token: "reviewing", label: "Reviewing", detail: "An automatic review is reading this result before it reaches you.", tone: "live", action: { label: OPEN_RESULT, kind: "open-result" } };
 }
-const FAILED_CHECK = /^the repository's approved verification command exited (-?[0-9]+)/;
-export function evidenceProblemOf(verdict, reasons) {
-    if (verdict === "verified" || verdict === "attested")
-        return "none";
-    if (verdict === "refuted")
-        return reasons.some(reason => FAILED_CHECK.test(reason)) ? "checks-failed" : "mismatched";
-    return "missing";
-}
 /** The exit code of the failed check, when the recorded reason names one. */
 export function failedCheckExit(reasons) {
     for (const reason of reasons) {
@@ -314,17 +307,6 @@ const VERIFIED_RESULT = new Set(["ready-to-review", "pr-opened", "merge-observed
 /** A finished result's display status in the shared headline's words: a
  * failed project check is Failed, a result missing its record needs a
  * person, every other saved result is Ready for review. Token and action stay. */
-/** Why a result can't be accepted as it stands, in one plain line, or null
- * when nothing refutes it (a person's acceptance settles it). The result page
- * shows it before Request changes, its one ink act. */
-export function cantAcceptYetOf(verdict, reasons, accepted) {
-    if (accepted || verdict !== "refuted")
-        return null;
-    // A mismatch is the status card's own headline; here only what accepting takes.
-    return evidenceProblemOf(verdict, reasons) === "checks-failed"
-        ? "Can't accept yet: the project's check failed on these changes."
-        : ACCEPT_NEEDS_REASON;
-}
 /** The result's headline while its report disagrees with its saved changes. */
 export const MISMATCH_HEADLINE = "The report doesn't match the changes";
 const OVERCLAIMED = /^claimed changed paths? not in the sealed diff: ([\s\S]+)$/;
@@ -548,7 +530,7 @@ export function learningHtml(view, csrf, canManage, source) {
     const cards = lessons.map(l => `<article class="card" data-lesson="${l.id}"><p><strong>${e(l.payload.observation)}</strong></p><p>${e(l.payload.action)}</p><p class="meta">${l.payload.kind === 'system' ? 'System suggestion · No change applied' : e(l.status === 'adopted' ? 'Adopted advice' : l.status === 'disabled' ? 'Disabled' : 'Proposed lesson')}</p><details><summary>Source and use</summary><p><a href="/r/${l.source}">Result #${l.source}</a> · <a href="/r/${l.reviewer}">Review #${l.reviewer}</a></p><p>${e(l.payload.paths.join(', '))} · ${e(l.payload.phases.join(', '))} · ${e({ darwin: "macOS", win32: "Windows", linux: "Linux" }[l.payload.platform] ?? l.payload.platform)}</p><ul>${evidence(l.payload.evidence, l.source)}</ul>${l.payload.kind !== 'project' ? '' : `<p class="meta">${l.status === 'proposed' ? 'Save permits advisory reuse when enabled and applicable. It does not prove a remedy works.' : 'Disabling affects future runs. Active snapshots, code and approvals stay unchanged.'}</p>${l.status === 'proposed' ? act('adopt', 'Save lesson', l) : ''}`}</details>${l.payload.kind === 'project' && l.status === 'adopted' ? act('disable', 'Disable lesson', l) : ''}</article>`).join('');
     if (source !== undefined)
         return lessons.length ? `<details class="learning result-learning"><summary>Learned from this task</summary>${cards}<a href="/settings/learning?repo=${encodeURIComponent(view.repo)}">Learning settings</a></details>` : '';
-    const history = view.events.map(ev => `<article class="card" data-learning-event="${e(ev.action)}"><p><strong>${e({ assessment: { propose: 'Learning suggested', none: 'No lesson needed', unassessed: 'Learning not assessed', invalid: 'Learning assessment invalid' }[ev.after] ?? 'Learning not assessed', proposal: 'Suggestion recorded', adopt: 'Lesson adopted', disable: 'Lesson disabled', reset: 'Learning reset', enable: 'Reuse enabled', pause: 'Reuse paused', reuse: 'Run context saved', failure: 'Learning issue', capture: 'Capture finished' }[ev.action] ?? ev.action)}</strong>${ev.action === "reuse" ? ` · ${e(ev.after)}` : ""}</p><p class="meta"><time datetime="${e(ev.at)}">${e(ev.at.replace("T", " ").replace(/\.\d+Z$/, " UTC"))}</time> · ${e(ev.actor)}${ev.run === null ? '' : ` · <a href="/r/${ev.run}">Run #${ev.run}</a>${ev.outcome === null ? "" : ` · ${e(ev.outcome)}`}`}</p><details><summary>Details</summary><p>${e(ev.before)} → ${e(ev.after)}</p><p>${e(ev.reason)}</p>${ev.lesson === null ? '' : `<p>Lesson #${ev.lesson}</p>`}<ul>${evidence(ev.evidence, ev.run)}</ul>${ev.snapshot === null ? "" : `<details><summary>Exact context</summary><pre>${e(ev.snapshot)}</pre></details>`}</details></article>`).join('');
+    const history = view.events.map(ev => `<article class="card" data-learning-event="${e(ev.action)}"><p><strong>${e({ assessment: { propose: 'Learning suggested', none: 'No lesson needed', unassessed: 'Learning not assessed', invalid: 'Learning assessment invalid' }[ev.after] ?? 'Learning not assessed', proposal: 'Suggestion recorded', adopt: 'Lesson adopted', disable: 'Lesson disabled', reset: 'Learning reset', enable: 'Reuse enabled', pause: 'Reuse paused', reuse: 'Run context saved', failure: 'Learning issue', capture: 'Capture finished' }[ev.action] ?? ev.action)}</strong>${ev.action === "reuse" ? ` · ${e(ev.after)}` : ""}</p><p class="meta">${whenUtc(ev.at)} · ${e(ev.actor)}${ev.run === null ? '' : ` · <a href="/r/${ev.run}">Run #${ev.run}</a>${ev.outcome === null ? "" : ` · ${e(ev.outcome)}`}`}</p><details><summary>Details</summary><p>${e(ev.before)} → ${e(ev.after)}</p><p>${e(ev.reason)}</p>${ev.lesson === null ? '' : `<p>Lesson #${ev.lesson}</p>`}<ul>${evidence(ev.evidence, ev.run)}</ul>${ev.snapshot === null ? "" : `<details><summary>Exact context</summary><pre>${e(ev.snapshot)}</pre></details>`}</details></article>`).join('');
     return `<section class="learning">${view.damaged ? '<p class="problem" role="alert">Some lessons no longer verify and are excluded from reuse.</p>' : ''}<p>${view.enabled ? 'Use adopted lessons: on' : 'Use adopted lessons: off'}</p>${act(view.enabled ? 'pause' : 'enable', view.enabled ? 'Pause reuse' : 'Enable reuse')}${cards || '<p>No lessons yet. Reviews may suggest useful advice here.</p>'}<details><summary>Reset learning</summary><p>Disable all adopted lessons and future reuse. Keep history, code, approvals and active run snapshots.</p>${act('reset', 'Reset learning')}</details><h2>Changes</h2>${history || '<p>No learning changes yet.</p>'}${view.next === null ? '' : `<a class="button-link" href="/settings/learning?repo=${encodeURIComponent(view.repo)}&before=${view.next}">Older changes</a>`}</section>`;
 }
 /** The first signed requirement a finished attempt missed (failed or unanswered; a person's own check is not a miss),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolroll",
-  "version": "0.9.15",
+  "version": "0.9.17",
   "description": "A control plane for unattended coding agents — queue tasks, walk away, come back to pull requests. Agents build in leased worktrees, never touch your default branch, and interrupt you only for decisions that need a human.",
   "directories": {
     "doc": "docs"