toolroll 0.9.104 → 0.9.105

package/dist/chat-admission.js

@@ -1,12 +1,5 @@
 import { channelInbox } from "./chat-inbox.js";
 import { roomCommand } from "./chat-rooms.js";
-/**
- * Whether a received message or tap, already proved to come from this app, may be queued — and under which binding.
- * A room (any conversation that isn't a direct message) is taken only while it follows a conversation, for the words
- * that make it follow one, or when it feeds a flow (v89: anyone's message then, as a card with no say over anything).
- * A pairing message comes only from someone unpaired, in a direct message; everything else only from a live paired
- * member in their own conversation or a followed room. Null when it is not taken.
- */
 export function admitChatEvent(state, app, installation, event) {
     const { kind, member, channel, isRoom, payload } = event;
     const words = "text" in payload ? payload.text ?? "" : "";

package/dist/chat-approval.js

@@ -1,18 +1,5 @@
-/** Approving from chat (owner's decision, docs/plans/toolroll-cards.md): a person with the authority approves from their
- * own linked chat by default, with no limits of their own. This setting is how they say otherwise: off for all their
- * projects or for one, or on with limits (whether a plan may ask for full access, and the most one attempt may cost). A
- * project's own row outranks the all-projects one, and an explicit "off" keeps it off. Turning it off for all projects
- * also disables that owner's saved project rows.
- *
- * A saved row ends with the account: a reset password, revoked access or a lost project ends it, and it must be saved
- * again. Saving limits takes the password; turning it off is one step. Every change is a ledger line.
- *
- * What the setting allows is only that the owner's own two taps in their paired chat count as their yes. Every other
- * rule still applies at the offer and again at the tap (chat-decide.ts planInChat): protected paths, separation of
- * duties, organisation policy, written-for-you plans, unresolved routes, and the limits here. */
 import { createHash } from "node:crypto";
 import { chatApproveChatsOf, chatNames, modeTermsFromJson } from "./modes.js";
-/** The all-projects row's scope. */
 export const ALL_PROJECTS = "*";
 const money = (micro) => `$${(micro / 1_000_000).toFixed(2)}`;
 function digestOf(approver, scope, limits, generation) {
@@ -25,15 +12,12 @@ function readRow(row) {
         digest: String(row["digest"]), updatedBy: String(row["updated_by"]), updatedAt: String(row["updated_at"]),
     };
 }
-/** This person's rows: all projects first, then each project's. */
 export function chatApprovalSettings(store, approver) {
     return store.handle.prepare("SELECT * FROM chat_approval_setting WHERE approver = ? ORDER BY scope = '*' DESC, scope").all(approver).map(row => readRow(row));
 }
-/** The limits in plain words, said once: what a yes in chat may start. */
 export function chatApprovalWords(limits) {
     return `${limits.fullAccess ? "plans may ask for full access" : "plans that ask for full access open in Toolroll"} · ${limits.capMicrousd === null ? "any attempt limit" : `attempts up to ${money(limits.capMicrousd)}`}`;
 }
-/** Whether this person's chat may approve on this project now, under their lasting setting: which row, and its limits. */
 export function effectiveChatApproval(store, repo, approver) {
     const project = store.handle.prepare("SELECT * FROM chat_approval_setting WHERE approver = ? AND scope = ?").get(approver, repo);
     const all = store.handle.prepare("SELECT * FROM chat_approval_setting WHERE approver = ? AND scope = ?").get(approver, ALL_PROJECTS);
@@ -55,30 +39,21 @@ export function effectiveChatApproval(store, repo, approver) {
         return { ok: false, why: "Your chat approval setting can't be read. Turn it on again in Settings." };
     return { ok: true, setting, limits: { fullAccess: setting.fullAccess, capMicrousd: setting.capMicrousd } };
 }
-/** What this person's chat on `channel` may approve on this repository now, and under whose limits: their saved setting,
- * else (only with nothing saved) their own live signed mode that names this chat app, else their standing as an
- * approver. A saved setting that refuses refuses here. `digest` names that for
- * the ledger; the yes itself is the person's tap and is sealed as theirs, so it doesn't lapse when the authority does. */
 export function chatApproveMode(store, repo, approver, now, channel) {
     if (repo === null)
         return { ok: false, why: "Approving from chat isn't turned on for this project." };
     const setting = effectiveChatApproval(store, repo, approver);
-    // A saved setting decides: its "off", a lapse after an access change or an unreadable row refuses before any mode is
-    // looked at, so a signed mode never reopens what the person turned off. The mode counts only when nothing is saved.
     if (!setting.ok)
         return setting;
     const chosen = { ok: true, source: "setting" };
     if (setting.setting.updatedAt !== "")
         return { ...chosen, digest: setting.setting.digest, limits: setting.limits };
-    // Nothing saved: their own signed mode's limits, where it names this chat app; otherwise their standing as an approver.
     const mode = store.activeMode(repo, now);
     const terms = mode === null ? null : modeTermsFromJson(mode.termsJson);
     if (mode !== null && terms !== null && terms.chatApprove && mode.signedBy === approver && store.accountCanAccess(approver, repo) && chatApproveChatsOf(terms).includes(channel))
         return { ok: true, digest: mode.digest, limits: { fullAccess: terms.permissionDefault === "escalated", capMicrousd: terms.perAttemptBudgetMicrousd }, source: "mode" };
     return { ...chosen, digest: setting.setting.digest, limits: setting.limits };
 }
-/** Save and ledger the setting; all-projects off also disables every saved project row for this owner.
- * The caller has proved who is asking, and for "on" the password. */
 export function setChatApproval(store, change, now) {
     const account = store.accountOf(change.approver);
     if (account === null || account.revokedAt !== null || account.role !== "approver")

package/dist/chat-ask.js

@@ -1,8 +1,5 @@
 import { chatHash, partContent } from "./chat-delivery-state.js";
 import { LEAD_ASK_OTHER } from "./store.js";
-/** Whether a task (the execution shown, never only its family's root) moved past a lead's question asked at `since`:
- * its plan was rewritten or approved, or a new attempt of it started. The options answered a state that is gone. A run
- * that merely finishes, or a review beside it, answers nothing, so it never takes the question's buttons. */
 export function taskMovedSince(store, taskId, since) {
     const at = new Date(since).getTime();
     if (Number.isNaN(at))
@@ -14,12 +11,9 @@ export function taskMovedSince(store, taskId, since) {
     const ref = store.lookupRef(taskId);
     return ref !== null && store.runsFor(ref.id).some(run => run.role !== "reviewer" && after(run.startedAt));
 }
-/** The question as text with its options, where no buttons are drawn. */
 export function chatAskText(ask) {
     return [ask.question, ...ask.options.map(one => `• ${one}`), `• ${LEAD_ASK_OTHER}: say it in your own words`].join("\n");
 }
-/** The live buttons on one part, in the order they were minted: the options, then "Something else". None when the part
- * is not in its owner's own chat with Toolroll (a room), where a tap could not be their message. */
 export function chatAskButtons(state, part, now) {
     const row = state.prepare("SELECT p.payload,e.channel,b.channel AS own FROM chat_part p JOIN chat_event e ON e.provider=p.provider AND e.id=p.event JOIN chat_binding b ON b.provider=e.provider AND b.id=e.binding WHERE p.provider=:provider AND p.id=?").get(part);
     if (row === undefined)
@@ -35,11 +29,7 @@ export function chatAskButtons(state, part, now) {
     })
         .filter((one) => one !== null);
 }
-/** How old a part may be and still be sent: older ones are dropped undelivered (slack-chat.ts, discord-chat.ts,
- * teams-chat.ts), so an edit to one would never land. */
 const EDIT_WINDOW_MS = 86_400_000;
-/** Show the question again with what happened, and without its buttons: one edit, under the part's own time. A question
- * too old to edit gets the line once as a new message instead. */
 function repaint(state, part, event, line, now) {
     const row = state.prepare("SELECT payload,created FROM chat_part WHERE provider=:provider AND id=?").get(part);
     if (row === undefined || new Date(String(row["created"])).getTime() + EDIT_WINDOW_MS <= now.getTime()) {
@@ -48,25 +38,21 @@ function repaint(state, part, event, line, now) {
     }
     const before = partContent(String(row["payload"]));
     const content = { text: `${before.text}\n\n${line}`.slice(0, 3400), edit: event.ts, ...(before.channel === undefined ? {} : { channel: before.channel }) };
-    // A question that was dropped isn't brought back: the line goes as a new message, the same as one too old to edit.
     if (!state.repaint(part, content))
         state.plan(event.id, [{ text: line }], now);
     state.finish(event.id);
 }
-/** A tapped ask button, inside the action's transaction; false when the token isn't one. */
 export function applyChatAskTap(options, event, binding, token, now) {
     const { store, state } = options;
     const action = state.prepare("SELECT a.token,a.part,a.turn,a.choice,a.expires,a.consumed,p.message,e.binding AS owner,e.channel FROM chat_ask_action a JOIN chat_part p ON p.provider=a.provider AND p.id=a.part JOIN chat_event e ON e.provider=p.provider AND e.id=p.event WHERE a.provider=:provider AND a.token=?").get(token);
     if (action === undefined)
         return false;
     const say = (text) => state.plan(event.id, [{ text }], now);
-    // Bound to the person, their own chat and the exact message the button rode.
     if (Number(action["owner"]) !== binding.id || action["channel"] !== event.channel || event.channel !== binding.channel || action["message"] !== event.ts) {
         say("That button expired or was already used.");
         return true;
     }
     const turn = Number(action["turn"]), part = Number(action["part"]);
-    // Only the person the lead asked answers it: anyone else's tap changes nothing and says nothing.
     const asker = store.getLeadTurn(turn)?.approver;
     if (asker !== undefined && asker !== binding.approver) {
         state.finish(event.id);
@@ -74,14 +60,12 @@ export function applyChatAskTap(options, event, binding, token, now) {
     }
     const found = asker === undefined ? { state: "expired" } : store.leadAskState(turn, now);
     const expired = found.state === "expired" || String(action["expires"]) <= now.toISOString();
-    // A question already settled was shown so once (or is being): a later tap says nothing more.
     if (action["consumed"] !== null) {
         state.finish(event.id);
         return true;
     }
     if (found.state !== "open" || expired) {
         state.prepare("UPDATE chat_ask_action SET consumed=? WHERE provider=:provider AND part=? AND consumed IS NULL").run(now.toISOString(), part);
-        // The question is shown again without its buttons, so a later tap has nothing to press.
         repaint(state, part, event, found.state === "answered" ? "This question was already answered." : "This question expired. If it still matters, send your answer as a message.", now);
         return true;
     }
@@ -96,7 +80,6 @@ export function applyChatAskTap(options, event, binding, token, now) {
         return true;
     }
     state.prepare("UPDATE chat_ask_action SET consumed=? WHERE provider=:provider AND part=? AND consumed IS NULL").run(now.toISOString(), part);
-    // The option is the owner's next message, answered like one they typed.
     state.enqueue({
         id: chatHash(`${state.provider}:ask:${event.id}`).slice(0, 32), installation: event.installation, binding: binding.id, kind: "message",
         channel: event.channel, member: event.member, ts: event.ts, thread: event.thread,

package/dist/chat-card-part.js

@@ -1,13 +1,10 @@
-/** A card as a chat part: its plain text and link buttons always there, the card beside them. */
 import { cardOfProposal, cardPlainOf } from "./chat-card.js";
 import { cardPlainText } from "./card-render.js";
-/** The buttons of a card, as a part's links. */
 export const cardLinks = (card) => {
     const [first, ...rest] = card.buttons;
     return { ...(first === undefined ? {} : { link: first }), ...(rest.length === 0 ? {} : { also: rest }) };
 };
 export const cardContent = (card) => ({ text: cardPlainText(card), rich: card, ...cardLinks(card) });
-/** A card that can't be read goes out as the plain words kept with it. */
 export function cardPart(proposal) {
     const card = cardOfProposal(proposal);
     return card === null ? { text: cardPlainOf(proposal) } : cardContent(card);

package/dist/chat-card.js

@@ -25,7 +25,6 @@ function factsOf(data, wanted) {
         return "This source has no facts to show now.";
     return { kind: "facts", heading: data.heading, items: items.slice(0, CARD_LIMITS.facts).map(({ label, value }) => ({ label, value })) };
 }
-/** A plan as a card, read now, or why it can't be one. */
 export function buildChatCard(reader, plan, repoOf, buttons) {
     const blocks = [];
     const repos = new Set();
@@ -81,7 +80,6 @@ export function buildChatCard(reader, plan, repoOf, buttons) {
     const card = readChatCard({ version: 1, title: title ?? "Toolroll", asOf: reader.now.toISOString(), repos: [...repos], blocks, buttons: links.slice(0, CARD_LIMITS.buttons), actions: actions.slice(0, CARD_LIMITS.actions) });
     return card === null ? { ok: false, message: "That card doesn't fit. Show fewer parts." } : { ok: true, card };
 }
-/** A card kept on a `control` proposal, as its marker says. */
 export const CARD_CONTROL = "card";
 export function cardOfProposal(proposal) {
     return proposal.kind === "control" && proposal.payload["control"] === CARD_CONTROL ? readChatCard(proposal.payload["card"]) : null;
@@ -89,14 +87,10 @@ export function cardOfProposal(proposal) {
 export function isCardProposal(proposal) {
     return proposal.kind === "control" && proposal.payload["control"] === CARD_CONTROL;
 }
-/** The plain version kept beside a card, for when the card itself can't be read. */
 export const cardPlainOf = (proposal) => typeof proposal.payload["plain"] === "string" ? proposal.payload["plain"] : "This card can't be shown.";
-/** Cards before the proposals they lead to, so each Confirm sits under its card. */
 export function cardsFirst(proposals) {
-    // A Start card goes last (docs/plans/one-step-chat.md C5): nothing Toolroll sends for the turn comes after it.
     const start = (one) => one.kind === "action" && one.payload["operation"] === "task_start";
     const rest = proposals.filter(one => !start(one));
     return [...rest.filter(isCardProposal), ...rest.filter(one => !isCardProposal(one)), ...proposals.filter(start)];
 }
-/** A card goes only where every project behind it is still reachable. */
 export const cardWithin = (card, repos) => card.repos.every(one => repos.includes(one));

package/dist/chat-channel.js

@@ -1,5 +1,4 @@
 import { parseFeedbackImage } from "./result-review.js";
-/** Shared membership-chat identity, proposal previews and result links. Transport adapters never grant authority. */
 import { TYPED_START_LINE } from "./typed-start.js";
 import { FLOW_HREF } from "./flow-engine.js";
 import { closedQuestionWords, LIMITS } from "./decision.js";
@@ -20,7 +19,6 @@ export function channelRepos(store, approver, registry) {
     const repos = [];
     for (const path of registry) {
         let canonical;
-        // A folder the console's gate holds back (folder-gate.ts) is left out, never matched by its spelling.
         try {
             canonical = canonicalProject(path) ?? path;
         }
@@ -36,16 +34,6 @@ export function channelRepos(store, approver, registry) {
     }
     return repos;
 }
-/**
- * The session and thread a paired phone speaks in: the approver's live
- * session when it is compatible (same generation, same membership
- * credential, same ceiling), else a fresh one minted under the very terms
- * the console and CLI state for membership chat (no dollar ceiling, this
- * ceiling digest). An incompatible session or thread left open on the
- * computer is replaced rather than refused, so a message from the phone
- * always gets an answer — except while a turn is still running there,
- * which is "busy": the message waits its turn instead of ending it.
- */
 export function resolveChannelLead(store, binding, repos, now) {
     const config = store.getChatConfig();
     if (config === null) {
@@ -81,7 +69,6 @@ export function resolveChannelLead(store, binding, repos, now) {
             session.credentialKey !== credentialKey ||
             session.ceilingDigest !== who.ceilingDigest);
     const threadMismatch = liveThread !== null && liveThread.ceilingDigest !== who.ceilingDigest;
-    // Replacing either would end a turn still running on the computer.
     if ((sessionMismatch || threadMismatch) && store.liveLeadTurnFor(who.name) !== null)
         return { ok: false, reason: "busy", said: null };
     if (session === null || sessionMismatch) {
@@ -100,7 +87,6 @@ export function resolveChannelLead(store, binding, repos, now) {
         if (session === null)
             return { ok: false, reason: "no-session", said: couldNotAnswerText("a new chat session couldn't be started") };
     }
-    // openLeadThread closes a thread kept under another ceiling.
     const thread = threadMismatch || liveThread === null
         ? store.openLeadThread(who.name, who.ceilingDigest, now).thread
         : liveThread;
@@ -112,10 +98,6 @@ export function resolveChannelLead(store, binding, repos, now) {
         config: config,
     };
 }
-/** A phone exchange about one task (a reply to that task's or result's
- * message) stays in the lead conversation, and is kept in the task's own
- * chat as well, so the task shows everything asked of it wherever it was
- * asked. Best effort: the phone conversation never depends on it. */
 export function mirrorToTaskChat(store, who, taskId, surface, message, reply, now) {
     try {
         const root = store.taskFamilyOf(taskId, who.repos, false)?.root.id ?? taskId;
@@ -126,17 +108,14 @@ export function mirrorToTaskChat(store, who, taskId, surface, message, reply, no
         store.appendLeadMessage({ thread: thread.id, turn: null, role: "assistant", text: reply }, now);
     }
     catch {
-        // The task chat is a copy; the phone's own conversation already has it.
     }
 }
-/** The one short message a person gets when their question could not be answered. */
 export function couldNotAnswerText(reason) {
     return `I couldn't answer that just now: ${reason.replace(/\.$/, "")}. Ask again, or open the console.`;
 }
 export function tooLongText(length) {
     return `That message is ${length.toLocaleString("en-US")} characters; chat takes up to ${LEAD_MESSAGE_MAX_CHARS.toLocaleString("en-US")}. Nothing was sent to the assistant. Send it in shorter parts, or say which part matters most.`;
 }
-/** A reply to a message about several tasks is never guessed: it names them and says how to choose. */
 export function whichTaskText(titles) {
     return [
         "That message is about more than one task:",
@@ -144,7 +123,6 @@ export function whichTaskText(titles) {
         "Reply to a message about just one of them, or send /tasks to pick one.",
     ].join("\n");
 }
-/** The server-authored context a reply to a result message carries into the turn — the exact execution and run, never a guess. */
 export function replyContextFor(taskId, run, image) {
     return [
         `Current task: ${taskId}. Read it with get_task before answering or proposing changes. Read its currentExecution next and bind new actions to that exact execution. Never replace the target of a prior proposal with a newer revision. Keep this turn about that task unless the operator explicitly asks to broaden it.`,
@@ -154,33 +132,25 @@ export function replyContextFor(taskId, run, image) {
         ...(image === undefined ? [] : [`The reply targets screenshot ${image.artifact} on result #${image.run}. Retain image: ${image.artifact} in propose_review so the exact screenshot stays with new feedback; pass image: null only when the feedback is not about it. Read get_result_images for this result first.`]),
     ].join(" ");
 }
-/** The context a chosen task (/tasks, /task <name>) carries into each turn from that chat. */
 export function focusContextFor(taskId) {
     return `Current task: ${taskId}. The operator chose this task in their chat app; their messages there are about it until they switch back. Read it with get_task before answering or proposing changes, and bind new actions to its currentExecution. Read get_task_conversation when they refer to earlier discussion. Keep this turn about that task unless the operator explicitly asks to broaden it.`;
 }
-/** A step the phone cannot take itself: said once; the button (or its absence) says where. */
 const HANDOFF = "This step finishes in Toolroll.";
-/** One Telegram message; a card that cannot fit is never confirmed from a shortened copy. */
 const TELEGRAM_TEXT_MAX = 4_096;
 const PHONE_TOO_LONG = "This is too long to show in full here. It is waiting in your Toolroll chat to review and confirm.";
 const LEAD_CHAT_LINK = { label: "Open chat", path: "/chat" };
-/** No trusted https origin is configured: one honest line, no localhost, no promise. */
 export const NO_PHONE_LINK = "Phone access isn't configured. Open Toolroll on your computer.";
-/** An origin exists but the card's task is not one this phone may reach now: said as that, never as missing setup. */
 export const NO_TASK_LINK = "No phone link: this task is outside your connected projects now, so open Toolroll on the computer.";
-/** Is this task one the phone's ceiling admits right now? A link names a stored identity, never a model's word alone. */
 export function taskInCeiling(store, taskId, repos) {
     const ref = store.lookupRef(taskId);
     return ref !== null && ref.repo !== null && repos.includes(ref.repo);
 }
-/** The recorded scope's standing — none filed yet (a planner is drafting), waiting for approval, or approved (by hand or under a signed mode). Read from the row, never from an outcome's words. */
 function approvalState(store, taskId) {
     const scope = store.getScope(taskId);
     if (scope === null)
         return "none";
     if (scope.approvedDigest != null && scope.approvedDigest === scope.digest)
         return "approved";
-    // Nothing to approve while the planner is still writing the plan.
     return store.lookupRef(taskId)?.plan === "requested" ? "planning" : "waiting";
 }
 function controlLink(control, taskId, run, project) {
@@ -189,29 +159,21 @@ function controlLink(control, taskId, run, project) {
         path: chatControlHref(control, taskId, run, project),
     };
 }
-/**
- * Where a task's next step lives, from its recorded state: the approval
- * control while its scope waits for one, else the task itself.
- */
 function taskLink(store, taskId, repos) {
     if (!taskInCeiling(store, taskId, repos))
         return null;
     return controlLink(approvalState(store, taskId) === "waiting" ? "approval" : "task", taskId);
 }
-/** The card text once its challenge is armed: an irreversible answer or a
- * challenge action, in the same words on every channel. */
 export function armedCardText(proposal, previewText) {
     const body = previewText.split("\n\nConfirm or Dismiss below")[0] ?? previewText;
     if (proposal.kind === "action")
         return `${body}\n\n${armedQuestion(proposal)}`;
     return `⚠ This answer is IRREVERSIBLE.\n\n${body}\n\nConfirm?`;
 }
-/** The second question on an action's card, in words true of what it does. */
 export function armedQuestion(proposal) {
     const action = proposal.kind === "action" ? sharedActionPayload(proposal.payload) : null;
     return action?.operation === "result_accept" ? "This records that you handled this exact result. Confirm?" : "You approve exactly what's written above. Confirm?";
 }
-/** The "yes" button's label for an armed card. */
 export function armedYesLabel(proposal) {
     if (proposal.kind === "action") {
         const action = sharedActionPayload(proposal.payload);
@@ -252,37 +214,25 @@ export function proposalLink(store, proposal, repos, channel = null) {
     }
     return null;
 }
-/** A personal Telegram card fits one message, or it waits, whole, in the person's lead conversation in Toolroll. */
 function fitsPhone(preview) {
     return !preview.buttons || preview.text.length <= TELEGRAM_TEXT_MAX;
 }
-/** The personal Telegram card: the shared preview, or a handoff to the lead conversation when it cannot be shown in full. */
 export function phoneProposalPreview(store, proposal, repos) {
     const preview = proposalPreview(store, proposal, repos, "telegram");
     return fitsPhone(preview)
         ? preview
         : { text: [preview.text.split("\n")[0], PHONE_TOO_LONG, "", HANDOFF].join("\n"), buttons: false };
 }
-/** The personal Telegram card's link: the lead conversation holding a card too long to show, else the shared link. */
 export function phoneProposalLink(store, proposal, repos, channel = null) {
     return fitsPhone(proposalPreview(store, proposal, repos, "telegram"))
         ? proposalLink(store, proposal, repos, channel)
         : LEAD_CHAT_LINK;
 }
-/**
- * The link a CONFIRMED card carries: the exact recorded task the outcome
- * names, where its remaining step lives — the approval control while the
- * scope waits for one (a manual approval), the task otherwise (an
- * automatic approval, a staged resume). Kinds whose outcome is complete
- * carry none.
- */
 export function confirmedLink(store, outcome, proposal, repos) {
-    // A flow change opens its canvas, the card selected.
     if (outcome.ok && proposal.kind === "action" && typeof outcome.href === "string" && FLOW_HREF.test(outcome.href))
         return { label: "Open the flow", path: outcome.href };
     if (!outcome.ok || outcome.taskId === null)
         return null;
-    // A skill test's task, and the task a Start card started: the card opens it.
     if (proposal.kind === "action" &&
         (proposal.payload["operation"] === "skill_test" || proposal.payload["operation"] === "task_start"))
         return taskLink(store, outcome.taskId, repos);
@@ -294,13 +244,11 @@ export function confirmedLink(store, outcome, proposal, repos) {
         (proposal.kind === "review" && proposal.payload["operation"] === "revise");
     return staged ? taskLink(store, outcome.taskId, repos) : null;
 }
-/** One url button: navigation only — it opens the console's own authenticated control and grants nothing. */
 function lines(text, cap) {
     return phoneText(text, cap)
         .split("\n")
         .map((line) => `| ${line}`);
 }
-/** The card: plain words for what confirming does, the exact terms it binds to, and whether a button belongs on it. */
 export function proposalPreview(store, proposal, repos, channel = null) {
     const payload = proposal.payload;
     const t = (key, cap = 200) => typeof payload[key] === "string"
@@ -315,11 +263,8 @@ export function proposalPreview(store, proposal, repos, channel = null) {
             : undefined;
         return path === undefined ? id : projectLabel(path);
     })();
-    // Telegram's card leads with the action and what confirming does, then the exact terms; its buttons say the rest.
     const phone = channel === "telegram";
-    const card = (headline, body = [], consequence = null, 
-    /** Telegram only: a fixed last line outside the terms (a Start card's "reply yes", one-step-chat.md C5). */
-    last = null) => ({
+    const card = (headline, body = [], consequence = null, last = null) => ({
         text: (phone
             ? [
                 headline,
@@ -339,8 +284,6 @@ export function proposalPreview(store, proposal, repos, channel = null) {
         buttons: true,
     });
     const lasting = phone ? " ⚠ can't be undone" : " — IRREVERSIBLE";
-    // A handoff's text is origin-free on purpose: it is persisted before the
-    // send, and the button or the missing-setup line joins it at send time.
     const handoff = (headline, body = []) => ({
         text: [headline, ...body, "", HANDOFF].join("\n"),
         buttons: false,
@@ -351,9 +294,7 @@ export function proposalPreview(store, proposal, repos, channel = null) {
             if (!action)
                 return handoff("This action is unavailable.");
             if (channel !== null && sharedActionAllowsChallenge(action, channel))
-                return card(phoneText(action.title, 200), action.terms.map((term) => phoneText(term, APPROVAL_TERM_CHARS)), "Confirm asks once more before anything is recorded.", 
-                // A Start card on Telegram says what a typed yes does; no part of the lead's reply is ever inspected for it.
-                action.operation === "task_start" && channel === "telegram" ? TYPED_START_LINE : null);
+                return card(phoneText(action.title, 200), action.terms.map((term) => phoneText(term, APPROVAL_TERM_CHARS)), "Confirm asks once more before anything is recorded.", action.operation === "task_start" && channel === "telegram" ? TYPED_START_LINE : null);
             return sharedActionNeedsReview(action)
                 ? handoff(phoneText(action.title, 200), [
                     "Review the full details and confirm this exact action.",
@@ -494,7 +435,6 @@ export function proposalPreview(store, proposal, repos, channel = null) {
             return handoff("This kind of proposal cannot be confirmed from the phone.");
     }
 }
-/** The card after it resolves, from the recorded outcome — the same words every surface shows. */
 export function proposalOutcomeText(proposal) {
     const outcome = proposal.outcome;
     const said = outcome !== null && typeof outcome.said === "string"
@@ -518,14 +458,6 @@ export function proposalOutcomeText(proposal) {
             return "Still waiting for your confirmation.";
     }
 }
-/**
- * One row per lead tool: how the paired phone reaches it. `direct` means
- * the same engine tool or the same confirm door runs from Telegram;
- * `handoff` means the phone shows where the existing authenticated
- * control lives and does nothing itself; `missing` means no phone path
- * yet. The test suite refuses a tool this table does not name, and the
- * committed matrix document must agree with it line for line.
- */
 export const CHAT_ACTION_PARITY = {
     get_brief: {
         support: "direct",
@@ -740,20 +672,12 @@ export const CHAT_ACTION_PARITY = {
         gap: "Incomplete phone action: no phone path to cancel by design; the button only opens the task.",
     },
 };
-/** Every tool the model can call, mapped; a new tool must name its phone road. */
 export function parityGaps() {
     return LEAD_TOOL_SCHEMAS.map((tool) => tool.name).filter((name) => CHAT_ACTION_PARITY[name] === undefined);
 }
 export function handoffCardText(text, note) {
     return note === null ? text : `${text}\n\n${note}`;
 }
-/**
- * The resolved card, from what is RECORDED about the task the outcome
- * names — never from a word search over the door's sentence. A scope that
- * still waits for approval has one next action: approve it (the button, or
- * the console on the computer when no link exists). A scope approved under
- * a signed mode asks for nothing more. A staged resume says what remains.
- */
 export function confirmedCardText(store, outcome, proposal, note) {
     const said = phoneText(outcome.said, 600);
     if (!outcome.ok)
@@ -771,9 +695,6 @@ export function confirmedCardText(store, outcome, proposal, note) {
         return `✓ ${said}`;
     const state = approvalState(store, taskId);
     const approval = state === "waiting";
-    // The door's sentence carries an approval instruction for a filed task or
-    // a revision; under a signed automatic mode the recorded scope is already
-    // approved, and the card says that instead of asking again.
     const words = proposal.kind === "task" && state === "approved"
         ? `${said.split(/ — |\. /)[0]} — approved under your automatic approval settings; nothing more is needed from you.`
         : revise && state === "approved"
@@ -787,8 +708,6 @@ export function confirmedCardText(store, outcome, proposal, note) {
     const setup = (approval || resume) && note !== null ? note : "";
     return [`✓ ${words}`, ...[next, setup].filter((one) => one !== "")].join("\n\n");
 }
-/** The link to a task a Start card just started (a tapped card, and Toolroll's reply to a typed yes): the task's own
- * page, only while the task is one of the person's projects. Navigation only. */
 export function startedTaskLink(store, taskId, repos) {
     return taskLink(store, taskId, repos);
 }

package/dist/chat-continuity.js

@@ -1,34 +1,3 @@
-/** Progressive enhancement for the existing chat, not a second transport.
- * Native POSTs and server-rendered approval forms remain the authority.
- * Only the message draft is kept in this tab, for at most 24 hours.
- *
- * Package 2 (2026-09-13) extends the SAME read-only status poll: the
- * server answers with a version of the displayed facts and, when it
- * differs from the page's, server-rendered fragments for the three safe
- * regions — the thread, what follows the composer, and the task's live
- * region. The page reconciles them by stable keys, so an unchanged card
- * keeps its node, its open disclosures, and its focus; the composer is
- * never touched, so the draft, caret, and focus survive every update.
- * A reader above the latest message keeps their place and gets a
- * keyboard-usable New update button; only that act moves them.
- *
- * Sending goes to the existing endpoint once, with the existing request
- * receipt key and session binding, and is never retried by itself; the
- * draft clears only on the server's receipt for THE REQUEST THAT POLL
- * ASKED ABOUT, never for a newer send or edit that replaced it. A changed
- * or ended session, a lost sign-in, an unavailable task, denied storage,
- * and a lost connection each say so in their own words; sending waits
- * for an explicit reconnection under stale authority, and drafting stays
- * available.
- *
- * Revision (build 1550 annotations): a poll acknowledges only the request
- * it captured when it started; an answer is validated whole before any
- * state changes, so a malformed one retries instead of latching a changed
- * session or advancing a version nothing rendered; a task fragment held
- * back while the reader was inside the region lands after they leave it,
- * even when the server has nothing new; and the words carried across an
- * explicit reconnection are bound to the server-named account, the task,
- * and an expiry, so another account's tab never inherits them. */
 export const CHAT_CONTINUITY_SCRIPT = String.raw `
 (function(){
   var form=document.querySelector('.composer[data-chat-session]');

package/dist/chat-controls.js

@@ -1,6 +1,3 @@
-/** Fixed destinations only. A model cannot supply a URL or an executable action.
- * These open the existing authenticated controls, never grant their authority.
- */
 export const CHAT_CONTROLS = {
     task: { label: "Open task", target: "task" },
     approval: { label: "Review & start", target: "task" },
@@ -8,7 +5,6 @@ export const CHAT_CONTROLS = {
     recovery: { label: "Review recovery options", target: "task" },
     cancel: { label: "Cancel task", target: "task" },
     result: { label: "Open result", target: "task" },
-    // A task's findings, failed checks and evidence: closing a finding and starting a repair happen there.
     findings: { label: "Open findings", target: "task" },
     acceptance: { label: "Inspect result", target: "task" },
     publish: { label: "Review publication", target: "task" },
@@ -18,7 +14,6 @@ export const CHAT_CONTROLS = {
     workers: { label: "Manage workers", href: "/fleet" },
     slack: { label: "Manage Slack", href: "/settings/slack" },
     discord: { label: "Manage Discord", href: "/settings/discord" },
-    // Settings → Lead: the lead's name and persona, changed there by its person.
     lead: { label: "Name your lead", href: "/settings/lead" },
     integrations: { label: "Set up integrations", href: "/settings/integrations" },
     settings: { label: "Open settings", href: "/settings" },
@@ -29,7 +24,6 @@ export const CHAT_CONTROLS = {
     knowledge: { label: "Edit project knowledge", href: "/settings/knowledge" },
     learning: { label: "Review learning history", href: "/settings/learning" },
     mode: { label: "Review automatic approvals", href: "/mode" },
-    // Sprint 8: allowed providers, models and tools, and the permission ceiling. Changed there, with a password.
     policy: { label: "Review organisation policy", href: "/settings/policy" },
 };
 export function isChatControl(value) {
@@ -49,7 +43,6 @@ export function chatControlHref(control, task, run, project) {
     if (control === "result" && Number.isSafeInteger(run) && Number(run) > 0)
         return chatResultHref(task, Number(run));
     const base = "/chat?task=" + encodeURIComponent(task);
-    // Task details owns cancel, retry, publication and other dedicated ceremonies.
     if (control === "cancel" || control === "recovery" || control === "publish")
         return "/t/" + encodeURIComponent(task);
     if (control === "findings")