toolroll 0.9.103 → 0.9.105

package/dist/telegram-live.js

@@ -1,22 +1,12 @@
 import { createLiveReply, createLiveSender, LIVE_STATUS } from "./live-reply.js";
 import { shapedWindow, telegramReply } from "./reply-shape.js";
-/** The acknowledgement on the owner's message: "seen, working on it". Removed once the answer or the failure notice is
- * delivered; never replaced by a "done" mark (an answer isn't finished work). */
 export const ACK_EMOJI = "👀";
-/** At most one reaction change per chat this often; a burst waits its turn, in order. */
 export const ACK_GAP_MS = 1_000;
-/** A reaction change that meets Telegram's pause waits it out when it is this short; a longer pause skips it. */
 const ACK_MAX_WAIT_MS = 30_000;
-/** Drafts start this far apart and widen (doubling, up to the cap) whenever Telegram asks for a pause. */
 export const DRAFT_SPACING_MS = 1_200;
 const DRAFT_MAX_SPACING_MS = 10_000;
-/** Telegram keeps a draft about 30 seconds: one that has not changed is sent again after this long. */
 export const DRAFT_KEEPALIVE_MS = 25_000;
-/** Telegram's message limit, counted after entities (UTF-16 units, as JS strings are). */
 export const TELEGRAM_TEXT_MAX = 4_096;
-/** The body of a writing draft within `budget` characters once rendered: cut at a safe place in the shaped text first
- * (never inside code, a link, a bold anchor or an emoji), rendered, measured, and cut smaller if it still doesn't fit.
- * A body that can't fit (a single link longer than the budget) shows nothing. */
 export function draftBody(shaped, budget) {
     if (budget <= 0)
         return { text: "", entities: [] };
@@ -32,10 +22,6 @@ export function draftBody(shaped, budget) {
     }
     return { text: "", entities: [] };
 }
-/**
- * One live view as a draft: the status line in italics, then (once text exists) the partial reply as text plus
- * entities, never Markdown. Plain "Thinking…" is Telegram's own empty-text placeholder. Closed views send nothing.
- */
 export function telegramDraftOf(view) {
     if (view.phase === "closed")
         return null;
@@ -57,7 +43,6 @@ export function telegramDraftOf(view) {
         entities: [{ type: "italic", offset: 0, length: head.length }, ...body.entities.map(one => ({ ...one, offset: one.offset + shift }))],
     };
 }
-/** One draft on the wire, under the shared pause. A retry_after is recorded for every sender of this bot. */
 async function sendDraft(store, botId, transport, clock, chatId, draftId, payload) {
     if (store.telegramRetryAt(botId) > clock().toISOString())
         return "paused";
@@ -77,21 +62,13 @@ async function sendDraft(store, botId, transport, clock, chatId, draftId, payloa
     }
     return answer.uncertain === true ? "lost" : "refused";
 }
-// ---- the 👀 acknowledgement ----------------------------------------------------------
-/** One lane per chat: reaction changes go out in order (an ack never lands after its own removal), spaced. */
 const ackLanes = new Map();
 const pause = (ms) => new Promise(resolve => { const timer = setTimeout(resolve, ms); timer.unref?.(); });
-/**
- * Put 👀 on the owner's message (`on`) or take it off. Best effort and never awaited by the caller's durable work: a
- * missing pairing, a failure or a long pause skips it silently. `paired` is re-checked at the moment of sending; a
- * reaction carries no project data, so the pairing alone fences it. Resolves once this change was tried.
- */
 export function telegramAck(args) {
     const key = `${args.botId}:${args.chatId}`;
     const lane = ackLanes.get(key) ?? { tail: Promise.resolve(), lastAt: Number.NEGATIVE_INFINITY };
     ackLanes.set(key, lane);
     const gap = args.gapMs ?? ACK_GAP_MS;
-    // Never throws: a store closed meanwhile (a stop) or anything else skips the change.
     const run = () => change().catch(() => undefined);
     const change = async () => {
         const spaced = lane.lastAt + gap - Date.now();
@@ -114,25 +91,16 @@ export function telegramAck(args) {
             if (typeof retry === "number" && Number.isFinite(retry) && retry > 0)
                 args.store.deferTelegram(args.botId, new Date(args.clock().getTime() + Math.ceil(retry) * 1_000).toISOString());
         }
-        catch { /* skipped silently */ }
+        catch { }
     };
     const done = lane.tail.then(run, run);
     lane.tail = done;
-    // A finished lane is forgotten; the next change starts a fresh one (spacing restarts from now).
     void done.then(() => { if (ackLanes.get(key) === lane && lane.tail === done && Date.now() - lane.lastAt >= gap)
         ackLanes.delete(key); });
     return done;
 }
-// ---- the draft --------------------------------------------------------------------------
-/** Chats (bot:binding) whose turn has a live draft in this process: a waiting message's draft never covers it. */
 const liveChats = new Set();
-/** When each waiting message last had its "Waiting for your earlier messages…" draft (bot:row). */
 const waitingDrafts = new Map();
-/**
- * One running turn's draft. `standing` is the caller's full proof for a draft that carries words (it may await; the
- * close is re-checked after it); `paired` is enough for Telegram's empty "Thinking…". A draft Telegram refuses outright
- * (not a pause, not a lost answer) turns this turn's drafts off; previews are best effort.
- */
 export function createTelegramLiveDraft(args) {
     const reply = createLiveReply(args.shape);
     const keepAlive = args.timing?.keepAliveMs ?? DRAFT_KEEPALIVE_MS;
@@ -142,7 +110,6 @@ export function createTelegramLiveDraft(args) {
     let lastSentAt = Date.now();
     let off = false;
     liveChats.add(chat);
-    /** What the draft shows now: a preview closed as a possible password or key keeps only the status line. */
     const current = () => {
         const view = reply.view();
         if (view.phase !== "closed")
@@ -181,7 +148,6 @@ export function createTelegramLiveDraft(args) {
     return {
         get turn() { return reply.turn; },
         onProgress: event => {
-            // The first event names the turn: Telegram's "Thinking…" shows at once, even before the view changes.
             const first = reply.turn === null;
             if (!reply.push(event) && !first)
                 return;
@@ -196,11 +162,6 @@ export function createTelegramLiveDraft(args) {
         },
     };
 }
-/**
- * A message waiting for the lead (busy, or behind the owner's earlier messages): "Waiting for your earlier messages…"
- * as a draft, refreshed only after the keep-alive interval, and never while this chat's running turn has its own
- * draft. Carries no project data: the pairing and the claim fence it.
- */
 export async function telegramWaitingDraft(args) {
     const key = `${args.botId}:${args.draftId}`;
     if (liveChats.has(`${args.botId}:${args.binding}`))
@@ -214,11 +175,9 @@ export async function telegramWaitingDraft(args) {
     if (await sendDraft(args.store, args.botId, args.transport, args.clock, args.chatId, args.draftId, payload) !== "sent")
         return;
     waitingDrafts.set(key, Date.now());
-    // Bounded: the oldest entries go first.
     while (waitingDrafts.size > 500)
         waitingDrafts.delete(waitingDrafts.keys().next().value);
 }
-/** The message is answered or failed: its waiting draft is forgotten. */
 export function forgetWaitingDraft(botId, draftId) {
     waitingDrafts.delete(`${botId}:${draftId}`);
 }

package/dist/telegram-progress.js

@@ -1,9 +1,3 @@
-/** A compact projection of saved work, never a percentage or an ETA. The
- * headline, sentence and detail rows come from the shared task status
- * (task-status.ts), read from the same assignment record the console and the
- * CLI show: Ready for review once the saved result can be inspected, Complete
- * once the lead or a person has marked that exact result. Slack, Discord and
- * Teams send this same card. */
 import { machineChecked } from "./machine-check.js";
 import { wasInterrupted } from "./run-ending.js";
 import { assignmentOf } from "./assignment.js";
@@ -15,8 +9,6 @@ import { leadNameOf } from "./lead-identity.js";
 import { chatTitle } from "./chat-voice.js";
 import { manualReviewOnly } from "./proof.js";
 import { failedCheckExit } from "./workspace-ui.js";
-/** The saved assignment for this exact result, or null when the run is not
- * the family's current result (an older attempt keeps its own plain words). */
 function assignmentFor(store, run, taskId, project, now, root) {
     try {
         const assignment = assignmentOf(store, taskId, now, { principal: "operator", repos: [project] }, root);
@@ -26,7 +18,6 @@ function assignmentFor(store, run, taskId, project, now, root) {
         return null;
     }
 }
-/** `viewer`: the person whose chat shows the card. Their own act is never told back to them. */
 export function telegramProgressCard(store, run, taskId, project, now = new Date(), root, viewer) {
     const built = run.finishedAt !== null && (run.outcome === "built" || run.outcome === "no-change");
     const assignment = built ? assignmentFor(store, run, taskId, project, now, root) : null;
@@ -36,19 +27,15 @@ export function telegramProgressCard(store, run, taskId, project, now = new Date
     const holds = store.activeHolds(run.taskRef, now);
     const operatorHold = holds.find(hold => hold.ownerKind === "operator");
     const accessBlocked = run.reason === "retryable-infra" && /^could not re-read (?:the branch|HEAD) in /i.test(run.handoff ?? "");
-    // The one shared status: the same headline, sentence and rows as the console.
     let facts;
     if (assignment !== null && assignment.state !== "working" && assignment.state !== "checking") {
         facts = assignmentStatusFacts(assignment, pullRequest === undefined ? {} : { pullRequest });
     }
     else if (built) {
-        // A saved result is Ready even in the moment before its worker lets go of
-        // the task. Without its receipt yet, the stored machine verdict speaks.
         const recorded = assignment?.receipt?.checks ?? null;
         const proof = store.proofVerdictFor(run.id);
         const machine = proof?.machineVerdict ?? proof?.verdict ?? null;
         const exit = failedCheckExit(proof?.reasons ?? []);
-        // The one answer (task-status.ts approvedCheckOf) when a saved check was read; a verdict alone claims no pass.
         const checks = recorded !== null ? approvedCheckOf(machine, proof?.reasons ?? [], checksFactOf(recorded, run.headRevision))
             : exit !== null ? { status: "failed", exitCode: exit, head: run.headRevision }
                 : machine === "attested" ? { status: "not-run", exitCode: null, head: null } : null;
@@ -79,11 +66,9 @@ export function telegramProgressCard(store, run, taskId, project, now = new Date
     else {
         facts = { stage: "failed", reason: "The build stopped before it finished. Inspect the blocker, then retry." };
     }
-    // "Marked complete by <you>" (or by your lead, which signs in as you) is never told back to you.
     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: "<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)
@@ -92,11 +77,9 @@ export function telegramProgressCard(store, run, taskId, project, now = new Date
     const status = taskStatusOf(facts);
     const checkProgress = store.checkProgress(run.id);
     const progress = status.headline === "Building" && checkProgress !== null ? [`● ${checkProgress.line}`] : [];
-    // A short human title: never "— revision" or an id (chat-voice.ts).
     const title = chatTitle(store, taskId);
     const heading = `${headlineEmoji(status.headline)} ${status.headline}`;
     const next = phoneText(status.sentence, 200);
-    // A person's acceptance is its own recorded decision; it never changes a check.
     const acceptance = store.proofAcceptance(run.id) === null ? [] : [manualReviewOnly(store.proofVerdictFor(run.id))
             ? "Accepted by a person · Recorded checks unchanged" : "Accepted with an exception · Recorded checks unchanged"];
     const rows = [...statusDetailLines(status), ...progress, ...acceptance];
@@ -104,7 +87,6 @@ export function telegramProgressCard(store, run, taskId, project, now = new Date
     const failedChecks = status.details.some(one => one.key === "checks" && (one.mark === "failed" || one.mark === "note"));
     const recovery = operatorHold !== undefined || accessBlocked || (!built && run.outcome !== null);
     return { text, next, status, facts, completedByLead: assignment?.completion?.lead === true, entities: [{ type: "bold", offset: 0, length: title.length }, { type: "bold", offset: title.length + 1, length: heading.length }],
-        // Needs you: the button names the action that resolves it.
         link: { label: status.need != null && status.need.key !== "other" && status.need.key !== "review-result" ? status.need.action.label : built ? "Open result" : "Open task", path: recovery
                 ? chatControlHref("recovery", taskId) : built ? chatResultHref(taskId, run.id, failedChecks ? "checks" : "summary") : chatControlHref("task", taskId) } };
 }

package/dist/telegram-settings.js

@@ -1,12 +1,7 @@
-/** The person's own Telegram pairing, from the console: one private chat per
- * teammate with the installation's bot (v72). The bot token itself stays on
- * Chat apps and alerts; this page only mints or revokes the signed-in person's
- * pairing, never anyone else's. Laid out as three steps: token, pair, check. */
 import { settingsSubPage } from "./settings-groups-ui.js";
 import { html, joinHtml, postForm } from "./html.js";
 import { acts, btn, codeLine, note, notice, settingsRecord, settingsSection } from "./server/kit.js";
 import { kitSectionForm } from "./settings-kit.js";
-/** How long a written reply may wait to be sent before it shows here with a Retry. */
 export const UNSENT_REPLY_MS = 2 * 60_000;
 export function telegramSettingsHtml(store, botId, who, options = {}) {
     const problem = options.problem === undefined ? "" : notice(options.problem);
@@ -31,7 +26,6 @@ export function telegramSettingsHtml(store, botId, who, options = {}) {
     let pair;
     let check;
     if (options.code !== undefined) {
-        // The code shows once, on this page only: selectable text, never in a link or an address.
         pair = settingsSection({ id: "telegram-pair", title: "2. Pair your phone", state: " · Code ready",
             lead: "Send this to the bot in a private Telegram chat within 10 minutes:",
             body: joinHtml([codeLine(`/pair ${options.code}`), note("The code works once. That chat then answers as you, so treat it like your sign-in.")]) });
@@ -47,7 +41,6 @@ export function telegramSettingsHtml(store, botId, who, options = {}) {
                     confirm: "Unpair your phone from Telegram", body: note("This phone will lose access. Its existing Telegram buttons will stop working.") })
                 : kitSectionForm({ proof: "telegram-pair", action: "/settings/telegram/pair", id: "telegram-pair-form", native: true, save: { label: "Pair my phone" },
                     confirm: "Pair your phone with Telegram", body: note("You get a one-time code to send to the bot.") }) });
-        // A reply the assistant wrote that has not reached this person's phone for two minutes.
         const unsent = store.unsentTelegramReplies(botId, who, new Date((options.now ?? new Date()).getTime() - UNSENT_REPLY_MS));
         const oldest = unsent[0];
         check = settingsSection({ id: "telegram-check", title: "3. Check it works",

package/dist/telegram-status.js

@@ -1,8 +1,6 @@
 import { publicChatText } from './chat-display.js';
 import { machineChecked } from "./machine-check.js";
 import { manualReviewOnly } from "./proof.js";
-/** Read-only phone views over the same dispatch and proof records as chat.
- * No provider calls, repository access, new workflow state, or inferred success. */
 import { diagnoseTaskDispatch, withDispatchDiagnoses } from "./dispatch.js";
 import { familyCompleted } from "./result-completion.js";
 import { approvedCheckOf, approvedCheckStateOf, assignmentStatusFacts, checksFactOf, plainReasonOf, stageOfDispatch, taskStatusOf } from "./task-status.js";
@@ -11,25 +9,18 @@ import { CHAT_CONTROLS, chatControlHref, chatResultHref } from "./chat-controls.
 import { homeFiguresLine, homeFiguresOf } from "./home-groups.js";
 import { workIndexPage } from "./work-index.js";
 export function phoneCommand(text) {
-    // Slash forms everywhere; the bare words too, because Slack and Discord
-    // keep unregistered slash text for themselves. Only a whole message that
-    // is exactly the command counts — prose never is.
     const t = text.trim();
     if (/^\/?(?:help|start)$/i.test(t))
         return { kind: "help" };
     if (/^\/?status$/i.test(t))
         return { kind: "status" };
-    // The picker: /tasks (or /task alone) lists them to choose from; /lead
-    // goes back to the lead conversation.
     if (/^\/?tasks?$/i.test(t))
         return { kind: "tasks" };
     if (/^\/?lead$/i.test(t))
         return { kind: "lead" };
-    // An id, a number from the list, or words from the title.
     const task = /^\/?task\s+([A-Za-z0-9][A-Za-z0-9 ._'-]{0,63})$/i.exec(t);
     if (task !== null)
         return { kind: "task", id: task[1].trim() };
-    // A mistyped slash command gets help, but arbitrary prose is not a command.
     return /^\/(?:status|tasks?|lead|help|start)(?:\s|$)/i.test(t) ? { kind: "help" } : null;
 }
 export const PHONE_HELP = [
@@ -43,25 +34,18 @@ export const PHONE_HELP = [
     "/task <name or number> — the same, by a word from its name",
     "/lead — back to talking about everything",
     "/status — what's happening across your projects",
-    // D5: /team (the central team service's conversations) is deprecated: it still answers this release, unlisted.
     "/help — this message",
     "",
     "To answer an agent's question, tap its buttons; reply to the question to add a note. Approvals that need your password, cancelling and publishing finish in the Toolroll console, and a console button only takes you there. The computer must be awake and connected to reply.",
 ].join("\n");
-/** A third-party transport receives a small display copy, not logs, paths,
- * credentials, or arbitrary markup. Scan BEFORE truncation/normalization. */
 const plain = publicChatText;
-/** The same display scrub for every phone-bound string a person or a model authored. */
 export const phoneText = plain;
 export function projectLabel(repo) {
     return plain(repo.split(/[\\/]/).filter(Boolean).pop() ?? "project", 48);
 }
-/** The shared headline (task-status.ts) for a dispatch diagnosis on the phone. */
 function headlineFor(store, id, d, read_ = {}) {
-    // Any version of a completed family reads Complete, as taskWaitSnapshot says.
     const completed = d.code === "complete" && familyCompleted(store, id);
     const read = stageOfDispatch(d, { completed });
-    // A finished result reads the console's own facts: its requirements, checks Off at release, and what holds it back.
     if (read.stage === "finished" && read_.root !== undefined && read_.now !== undefined && read_.repos !== undefined) {
         const assignment = assignmentOf(store, id, read_.now, { principal: "operator", repos: read_.repos }, read_.root);
         if (assignment !== null && assignment.state === "ready-to-check")
@@ -104,15 +88,11 @@ function nextStep(d) {
         case null: return d.condition === "running" ? "No action needed from you right now." : d.code === "cancelled" ? "Nothing else will run for this task." : "Toolroll can reconsider this task when its waiting condition clears.";
     }
 }
-/** repos is the transport's explicit enrollment ceiling, never opened-project
- * history. This snapshot is intentionally bounded and advertises that bound. */
 export function phoneStatus(store, repos, now, focused = null, root) {
     if (repos.length === 0)
         return "No projects are connected here yet. Add a project in Toolroll, then send /status again.";
     return store.transact(() => {
         const snapshot = withDispatchDiagnoses(store, store.chatSnapshot(repos, now), now);
-        // It opens with Home's figures, from the work index totals over these projects (the Tasks lists' own counts);
-        // the groups below are dispatch diagnoses, which are not the work index's families, so they keep their headings.
         const figures = homeFiguresOf(workIndexPage(store, now, { principal: "operator", repos, includeUnplaced: false }, { limit: 1, ...(root === undefined ? {} : { root }) }).totals);
         const lines = [homeFiguresLine(figures), "", ...(focused === null ? [] : [`Talking about: ${focused} · /lead to switch back`, ""]), "Recent work", `As of ${now.toISOString().replace("T", " ").slice(0, 19)} UTC · ${repos.length} project(s)`, ""];
         if (snapshot.tasksSaturated)
@@ -136,10 +116,6 @@ export function phoneStatus(store, repos, now, focused = null, root) {
     });
 }
 const PICK_GROUPS = ["Needs attention", "Working", "Waiting / next up", "Finished"];
-/** The tasks a paired chat can pick from: what needs the person first,
- * then work in progress, waiting work and recent results; one entry per
- * task (its revisions share it), optionally narrowed by words in the id or
- * title. Bounded, within the chat's own project ceiling. */
 export function phoneTaskChoices(store, repos, now, query = null, limit = 8, root) {
     if (repos.length === 0)
         return [];
@@ -163,8 +139,6 @@ export function phoneTaskChoices(store, repos, now, query = null, limit = 8, roo
         return choices;
     });
 }
-/** `/task <what>`: an exact task id, a number from the /tasks list, or
- * words from a title — one match is chosen, several are offered. */
 export function resolvePhoneTask(store, repos, now, query) {
     const ref = store.lookupRef(query);
     if (ref?.repo != null && repos.includes(ref.repo)) {
@@ -179,7 +153,6 @@ export function resolvePhoneTask(store, repos, now, query) {
     const matches = phoneTaskChoices(store, repos, now, query);
     return matches.length === 0 ? { kind: "none" } : matches.length === 1 ? chosen(matches[0]) : { kind: "many", choices: matches };
 }
-/** The picker as text, for chat apps without buttons. */
 export function phoneTaskListText(choices, focused) {
     if (choices.length === 0)
         return "No open or recent tasks in your connected projects. Describe what you want done and the lead will draft one.";
@@ -191,24 +164,13 @@ export function phoneTaskListText(choices, focused) {
         "Send /task <number or name> to talk about one. /lead goes back to the lead.",
     ].join("\n");
 }
-/** Said under a task's status when a chat app chooses it. */
 export const PHONE_FOCUS_LINE = "Talking about this task now: ask anything or say what to change. Reply to this message later to come back to it; /lead goes back to the lead.";
-/** A chosen task's status, then the line that says the chat now talks about it. */
 export function phoneFocusText(view) {
     return `${view}\n\n${PHONE_FOCUS_LINE}`;
 }
 export const PHONE_NO_MATCH = "No such task in your connected projects. Send /tasks to pick one.";
 export const PHONE_BACK_TO_LEAD = "Back to the lead. Your messages here are about all your work again.";
-/** Where the rest lives when no button can say so: the closing line of an unlinked `/task`. */
 export const PHONE_CONSOLE_FOOTER = "Read-only status. Saved files and full actions are in the console.";
-/**
- * Where `/task`'s one button goes, from the recorded diagnosis: the exact
- * saved result's checks (a recorded verdict) or changes (none yet) for a
- * finished task; the approval control while the scope waits; the task's
- * own page for retry, hold, dependency and resume ceremonies; the task lens
- * otherwise (a worker that must be started is not a browser step, and the
- * lens says so). Only a task inside the phone's ceiling gets here.
- */
 function taskLinkFor(id, d, result) {
     const control = (name) => ({ label: CHAT_CONTROLS[name].label, path: chatControlHref(name, id) });
     if (result !== null)
@@ -227,12 +189,9 @@ function taskLinkFor(id, d, result) {
 export function phoneTask(store, repos, id, now, root) {
     return phoneTaskView(store, repos, id, now, root).text;
 }
-/** One task's status for a chat app: the words, its one console link, and
- * the saved result it shows (a reply to it is about that result). */
 export function phoneTaskView(store, repos, id, now, root) {
     return store.transact(() => {
         const ref = store.lookupRef(id);
-        // Check admission before reading a title, run, proof, or diagnosis.
         const task = ref?.repo != null && repos.includes(ref.repo) ? store.getTask(id) : null;
         if (task === null || ref?.repo == null)
             return { text: "No such task in your connected projects. Send /status for task IDs.", link: null, run: null };
@@ -251,7 +210,6 @@ export function phoneTaskView(store, repos, id, now, root) {
         const latest = result ?? runs[0];
         if (latest !== undefined) {
             lines.push("", `${result === undefined ? "Latest recorded attempt" : "Saved result"}: #${latest.id} · ${plain(latest.provider, 40)}${latest.model === null ? "" : ` / ${plain(latest.model, 80)}`}`);
-            // Terminal status wins; a leftover internal phase must never read as activity.
             if (latest.finishedAt !== null)
                 lines.push(`Attempt ended: ${plain(latest.finishedAt, 40)}`);
             else if (d.condition === "running") {
@@ -264,7 +222,6 @@ export function phoneTaskView(store, repos, id, now, root) {
             const proof = store.proofVerdictFor(result.id);
             link = taskLinkFor(id, d, { run: result.id, verdict: proof !== null });
             const accepted = store.proofAcceptance(result.id) !== null;
-            // Did the approved check pass (task-status.ts approvedCheckOf): read with the saved files, else no claim at all.
             const checkNow = root === undefined || proof?.verdict !== "verified" ? null
                 : approvedCheckStateOf(approvedCheckOf(proof.verdict, proof.reasons, checksFactOf(assignmentChecksForRun(store, root, result.id, now), result.headRevision)));
             const verifiedWords = root === undefined ? "Open the result to see its checks" : checkNow === "passed" ? "Checks passed at completion"
@@ -284,13 +241,10 @@ export function phoneTaskView(store, repos, id, now, root) {
         }
         if (result === undefined)
             link = taskLinkFor(id, d, null);
-        // Said once: the button is where; the sender adds the closing line when no button can ride.
         lines.push("", `Next: ${nextStep(d)}`);
         return { text: lines.join("\n"), link, run: result?.id ?? null };
     });
 }
-/** Concise display only: authorization uses the stored full project identity. */
-/** Where a fact belongs: its project and, given one, the task's short title — never the task's id. */
 export function notificationIdentity(row, title) {
     if (row.project === null)
         return "";

package/dist/telegram-team.js

@@ -4,7 +4,6 @@ import { proposalPreview, tooLongText } from "./chat-channel.js";
 import { PART_CAP, mintCardTokens, phoneLinkButton, splitParts } from "./telegram-lead.js";
 import { LEAD_MESSAGE_MAX_CHARS } from "./lead.js";
 import { phoneText } from "./telegram-status.js";
-/** `/team` lists, `/team <n>` chooses, `/team off` (or `private`) leaves. Any other slash text is not ours. */
 export function teamCommand(text) {
     const trimmed = text.trim();
     if (/^\/team(?:@\w+)?\s*$/.test(trimmed))
@@ -27,7 +26,6 @@ function conversationRow(store, id) {
     const row = store.handle.prepare("SELECT c.id, c.title, c.thread, c.lead, c.visibility, l.name FROM team_conversation c JOIN team_lead l ON l.id = c.lead WHERE c.id = ?").get(id);
     return row === undefined ? null : { conversation: String(row["id"]), title: String(row["title"]), thread: Number(row["thread"]), lead: String(row["lead"]), leadName: String(row["name"]), visibility: String(row["visibility"]) };
 }
-/** The conversations a person may talk in, with their lead's name, as the console lists them. */
 function conversationsFor(store, domain, actor) {
     try {
         const snapshot = domain.snapshot(actor);
@@ -48,7 +46,6 @@ function managerOf(domain, actor, conversationId) {
 function audience(conversation) {
     return conversation.visibility === "team" ? "Team" : "Private";
 }
-/** The `/team` listing for a private chat: everything the person can talk in, the current choice marked. */
 function privateListing(rows, current) {
     if (rows.length === 0)
         return "You are not in any team conversation yet. Join one in Toolroll under Chat → Team chat, then send /team again.";
@@ -69,12 +66,6 @@ function groupListing(rows, current) {
     lines.push("", "Send /team <number> to follow it (managers only), or /team off to stop. Everyone in this group will read its replies.");
     return lines.join("\n");
 }
-/**
- * Handle one inbound message that belongs to the team layer. Returns true
- * when it was consumed here (a `/team` command in any chat, any message in
- * a group, or a private message while a conversation is selected); false
- * hands the update to the older personal paths untouched.
- */
 export function applyTeamInbound(input) {
     const { store, botId, now, report, message, say } = input;
     const chat = message.chat;
@@ -135,13 +126,11 @@ export function applyTeamInbound(input) {
         return true;
     }
     if (teamChat === null) {
-        // A group the bot merely sits in stays silent; a private chat falls through to the personal assistant.
         if (isGroup)
             report.ignored++;
         return isGroup;
     }
     if (!paired || binding === null) {
-        // Unpaired members' chatter is nobody's message. A slash attempt gets the one hint.
         if (text.trimStart().startsWith("/")) {
             say(chatId, PAIR_FIRST);
             report.statusReplies = (report.statusReplies ?? 0) + 1;
@@ -150,8 +139,6 @@ export function applyTeamInbound(input) {
             report.ignored++;
         return true;
     }
-    // A current sender must not queue into a destination whose sharing grant
-    // ended: it could run successfully while every reply is withheld.
     const grant = store.liveTelegramBindingById(teamChat.binding);
     let connected = false;
     try {
@@ -161,7 +148,7 @@ export function applyTeamInbound(input) {
             connected = !isGroup || access.conversation.visibility === "team";
         }
     }
-    catch { /* Give a reconnect instruction without disclosing conversation content. */ }
+    catch { }
     if (!connected) {
         say(chatId, isGroup ? "This group's connection ended. Ask a conversation manager to send /team and connect it again." : "This chat's connection ended. Send /team and choose the conversation again.");
         report.chatRefused = (report.chatRefused ?? 0) + 1;
@@ -184,7 +171,6 @@ export function applyTeamInbound(input) {
         report.ignored++;
         return true;
     }
-    // Membership first, in the domain's own words: a removed person is told so.
     try {
         domain.access(actor, row.conversation, "contributor");
     }
@@ -193,8 +179,6 @@ export function applyTeamInbound(input) {
         report.chatRefused = (report.chatRefused ?? 0) + 1;
         return true;
     }
-    // Consent is the person's own, per conversation, and is checked before the
-    // message is saved: an unconsented message must not sit in the shared queue.
     const session = store.teamMateSession(actor.name, row.thread);
     if (session === null || session.approverGeneration !== actor.generation || session.endedAt !== null) {
         const origin = input.phoneOrigin?.() ?? null;
@@ -212,22 +196,11 @@ export function applyTeamInbound(input) {
     report.chatQueued = (report.chatQueued ?? 0) + 1;
     return true;
 }
-/** The request identity a Telegram message carries into the team queue: the chat and the update, so the same update never saves twice and delivery can tell its own messages apart. */
 export function teamRequestId(chatId, updateId) {
     return `telegram:${chatId}:${updateId}`;
 }
-/**
- * Carry new conversation messages to every chat that follows one: the
- * lead's replies, teammates' messages (never this chat's own), and each
- * reply's pending cards. Read from the cursor on every cycle; a failed send
- * leaves the cursor where it was, so the next cycle retries the same
- * message rather than skipping it.
- */
 export async function deliverTeamChats(store, botId, transport, clock, report, projects, phoneOrigin, options = {}) {
     for (const chat of store.listTelegramTeamChats(botId)) {
-        // Selection is a grant from an exact pairing. Current membership, scope,
-        // and the selection itself are rechecked after each await and before each
-        // send; another person's new pairing cannot inherit this destination.
         const access = async () => {
             try {
                 if (options.canDeliver !== undefined && !options.canDeliver())
@@ -266,8 +239,6 @@ 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) {
-                // 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) {
@@ -310,8 +281,6 @@ export async function deliverTeamChats(store, botId, transport, clock, report, p
             }
             if (!complete || await access() === null)
                 break;
-            // Commit only after the body and every card are delivered. Confirmed
-            // parts survive a retry, so a failed card does not repeat the body.
             store.transact(() => {
                 if (store.advanceTelegramTeamCursor(chat.id, id))
                     store.handle.prepare("DELETE FROM service_cursor WHERE key LIKE ?").run(`${prefix}%`);
@@ -319,7 +288,6 @@ export async function deliverTeamChats(store, botId, transport, clock, report, p
         }
     }
 }
-/** Whose binding a group card's tokens ride: the person the lead was answering, else any paired member of the conversation. */
 function cardBindingFor(store, botId, chat, turn) {
     const author = store.handle.prepare("SELECT author FROM team_message WHERE turn_id = ?").get(turn);
     const bindings = store.liveTelegramBindings(botId);