toolroll 0.9.104 → 0.9.105

package/dist/chat-migration.js

@@ -1,14 +1,6 @@
-/**
- * The v116 move onto the one set of chat tables (contracts/chat-tables.ts). Until then Telegram kept 21 tables of its
- * own and Slack, Discord and Teams 16 cloned tables each (`slack_binding`, `discord_part`, ...). An older database
- * still has them: openStore creates the ones its version should have had (exactly as earlier builds did), the older
- * migration steps bring them to their last shape, and `convertChatTables` copies every row into the shared tables in
- * one transaction, checks the counts and foreign keys, and drops the old tables. Nothing else reads them.
- */
 import { CHAT_PROVIDERS, CHAT_TABLES } from "./contracts/chat-tables.js";
 import { readChatMessageBody, readChatPart } from "./contracts/chat-content.js";
 export const LEGACY_CHAT_APPS = ["slack", "discord", "teams"];
-/* The per-app template the Slack, Discord and Teams tables were stamped from (v67-v114), kept verbatim. */
 const LEGACY_APP_SCHEMA = `
 CREATE TABLE IF NOT EXISTS chat_binding (
  id INTEGER PRIMARY KEY AUTOINCREMENT, installation TEXT NOT NULL,
@@ -51,8 +43,6 @@ CREATE TABLE IF NOT EXISTS chat_runtime (
  problem TEXT, retry_at TEXT, notification INTEGER NOT NULL DEFAULT 0
 );
 `;
-/** v73: a chat's place in the shared team conversations — a channel follows one
- * conversation, a DM may select one. Rows are revoked, never deleted. */
 const LEGACY_APP_ROOM_SCHEMA = `
 CREATE TABLE IF NOT EXISTS chat_room (
  id INTEGER PRIMARY KEY AUTOINCREMENT, installation TEXT NOT NULL, chat TEXT NOT NULL,
@@ -68,10 +58,6 @@ CREATE TABLE IF NOT EXISTS chat_meta (
  PRIMARY KEY(installation, key)
 );
 `;
-/** v88: flow decisions in the chat app, as on Telegram (telegram-flow.ts).
- * A button is one opaque token for one visit (card, entry) of one card, on
- * the part it rides; Edit and Send back open a prompt the person's next
- * message in their DM answers. */
 const LEGACY_APP_FLOW_SCHEMA = `
 CREATE TABLE IF NOT EXISTS chat_flow_action (
  token TEXT PRIMARY KEY, part INTEGER NOT NULL REFERENCES chat_part(id),
@@ -86,11 +72,6 @@ CREATE TABLE IF NOT EXISTS chat_flow_prompt (
 );
 CREATE INDEX IF NOT EXISTS chat_flow_prompt_open ON chat_flow_prompt(binding, consumed);
 `;
-/** A flow's "Person chooses" zone in the chat app (flow-send.ts): one button per option (choice is its index, label its words
- * when sent) for one visit of one card, on the part it rides. A reply in that notice's thread is the note; chat_flow_note
- * is "Use this as your note?" Yes / No about one other message (held: its event; words: what it said, kept only until
- * answered, as an event's own payload is cleared once it is handled), asked once per visit.
- * Never in CHAT_TABLES: an older database has no such table until this schema creates it. */
 const LEGACY_APP_FLOW_CHOICE_SCHEMA = `
 CREATE TABLE IF NOT EXISTS chat_flow_choice (
  token TEXT PRIMARY KEY, part INTEGER NOT NULL REFERENCES chat_part(id),
@@ -105,10 +86,6 @@ CREATE TABLE IF NOT EXISTS chat_flow_note (
 );
 CREATE INDEX IF NOT EXISTS chat_flow_note_visit ON chat_flow_note(card, entry);
 `;
-/** v93: a subagent's question in the chat app. One button per option (choice)
- * and one to answer in words (choice NULL); that one opens a prompt the
- * person's next message in their DM answers. Never in CHAT_TABLES: an older
- * database has no such tables until this schema creates them. */
 const LEGACY_APP_QUESTION_SCHEMA = `
 CREATE TABLE IF NOT EXISTS chat_question_action (
  token TEXT PRIMARY KEY, part INTEGER NOT NULL REFERENCES chat_part(id),
@@ -121,8 +98,6 @@ CREATE TABLE IF NOT EXISTS chat_question_prompt (
 );
 CREATE INDEX IF NOT EXISTS chat_question_prompt_open ON chat_question_prompt(binding, consumed);
 `;
-/** The lead's question to its owner (ask_owner) in the chat app: one button per option (choice is its index) and one for
- * "Something else" (choice NULL). A tap sends the option as the owner's next message. Never in CHAT_TABLES. */
 const LEGACY_APP_ASK_SCHEMA = `
 CREATE TABLE IF NOT EXISTS chat_ask_action (
  token TEXT PRIMARY KEY, part INTEGER NOT NULL REFERENCES chat_part(id) ON DELETE CASCADE,
@@ -130,13 +105,10 @@ CREATE TABLE IF NOT EXISTS chat_ask_action (
 );
 CREATE INDEX IF NOT EXISTS chat_ask_action_turn ON chat_ask_action(turn);
 `;
-/** One app's old tables, as an older database has (or should have had) them. */
 export const legacyAppSchema = (app) => (LEGACY_APP_SCHEMA + LEGACY_APP_ROOM_SCHEMA + LEGACY_APP_FLOW_SCHEMA + LEGACY_APP_FLOW_CHOICE_SCHEMA + LEGACY_APP_QUESTION_SCHEMA + LEGACY_APP_ASK_SCHEMA).replaceAll("chat_", `${app}_`);
 const LEGACY_APP_TABLE_SUFFIXES = ["binding", "pair", "event", "part", "action", "progress", "runtime", "room", "meta",
     "flow_action", "flow_prompt", "flow_choice", "flow_note", "question_action", "question_prompt", "ask_action"];
-/** One app's 16 old tables, parents first. */
 export const legacyAppTables = (app) => LEGACY_APP_TABLE_SUFFIXES.map(suffix => `${app}_${suffix}`);
-/** Telegram's own tables (v1-v114) and the bridge's lease, kept verbatim. */
 export const LEGACY_TELEGRAM_SCHEMA = `
 CREATE TABLE IF NOT EXISTS telegram_flow_choice (
   token       TEXT PRIMARY KEY,
@@ -514,7 +486,6 @@ CREATE TABLE IF NOT EXISTS telegram_flow_confirm (
 );
 CREATE INDEX IF NOT EXISTS telegram_flow_confirm_visit ON telegram_flow_confirm (card, entry);
 `;
-/** Telegram's 21 old tables and the bridge's lease, children first. */
 export const LEGACY_TELEGRAM_TABLES = [
     "telegram_note_draft", "telegram_decision_message", "telegram_task_message", "telegram_outbound_message",
     "telegram_action", "telegram_proposal_action", "telegram_flow_action", "telegram_flow_confirm", "telegram_flow_choice",
@@ -524,18 +495,12 @@ export const LEGACY_TELEGRAM_TABLES = [
 ];
 const tableExists = (db, table) => db.prepare("SELECT 1 AS hit FROM sqlite_master WHERE type = 'table' AND name = ?").get(table) !== undefined;
 const columnsOf = (db, table) => new Set(db.prepare(`PRAGMA table_info(${table})`).all().map(row => String(row["name"])));
-/** Whether this database already keeps its chats in the shared tables (v116 ran, or it was made at v116 or later). */
 export function chatTablesShared(db) {
     return CHAT_TABLES.every(table => tableExists(db, table)) && columnsOf(db, "chat_binding").has("provider");
 }
-/** Whether any of the old per-app tables is still here. */
 export function legacyChatTablesPresent(db) {
     return [...LEGACY_TELEGRAM_TABLES, ...LEGACY_CHAT_APPS.flatMap(legacyAppTables)].some(table => tableExists(db, table));
 }
-/**
- * The columns every shape of each old table has had since it first existed (later steps add the rest). An old table
- * without them is a shape this build cannot name: openStore refuses before it stamps the migration epoch.
- */
 const LEGACY_BASE_COLUMNS = {
     telegram_binding: ["id", "bot_id", "chat_id", "user_id", "approver", "approver_generation", "paired_at", "paired_by", "revoked_at", "revoked_by"],
     telegram_pairing: ["code_hash", "approver", "approver_generation", "created_at", "created_by", "expires_at", "consumed_at"],
@@ -578,7 +543,6 @@ const LEGACY_APP_COLUMNS = {
     question_prompt: ["id", "binding", "question", "created", "expires", "consumed"],
     ask_action: ["token", "part", "turn", "choice", "expires", "consumed"],
 };
-/** The columns the copy reads, beyond the base ones: added by migration steps that run before it. */
 const LEGACY_LATER_COLUMNS = {
     telegram_action: ["note_digest"],
     telegram_conversation_part: ["task_id", "source_run", "artifact", "sha256"],
@@ -595,10 +559,6 @@ function expectedColumns(table, withLater) {
         return null;
     return LEGACY_APP_COLUMNS[table.slice(app.length + 1)] ?? null;
 }
-/**
- * What is wrong with the old chat tables this database still has, before anything is changed: one that lacks a column
- * its every shape has had is not a table this build knows how to carry. Null when they are fine (or already gone).
- */
 export function legacyChatProblem(db) {
     for (const table of [...LEGACY_TELEGRAM_TABLES, ...LEGACY_CHAT_APPS.flatMap(legacyAppTables)]) {
         if (!tableExists(db, table))
@@ -638,9 +598,7 @@ function appCopies(app) {
     ];
 }
 const TG = P("telegram");
-/** A JSON object of the fields that are not null (top level only: a nested object keeps its own nulls). */
 const withoutNulls = (base, optional) => `json_patch(${base}, ${optional})`;
-/** Telegram's rows, each table into its shared one. Every copy names the count it must reach. */
 function telegramCopies() {
     const copy = (source, target, insert, found, expect = `SELECT COUNT(*) AS n FROM ${source}`) => ({ source, target, insert, expect, found: `SELECT COUNT(*) AS n FROM ${target} WHERE provider = ${TG} AND ${found}` });
     const conversationBody = withoutNulls("json_object('version', 1, 'text', c.text, 'request', c.request)", "json_object('context', c.context)");
@@ -654,13 +612,11 @@ function telegramCopies() {
        SELECT ${TG}, code_hash, NULL, approver, approver_generation, created_at, created_by, expires_at, consumed_at, consumed_chat, consumed_user, CAST(consumed_update AS TEXT) FROM telegram_pairing`, "1"),
         copy("telegram_team_chat", "chat_room", `INSERT INTO chat_room (provider, id, installation, chat, kind, conversation, binding, bound_by, bound, cursor, revoked, revoked_by)
        SELECT ${TG}, id, bot_id, chat_id, kind, conversation, binding, bound_by, bound_at, cursor, revoked_at, revoked_by FROM telegram_team_chat`, "1"),
-        // Every applied update is a receipt; a pushed one still waiting is queued with its body. One row per update id.
         copy("telegram_update", "chat_event", `INSERT INTO chat_event (provider, id, installation, kind, channel, member, ts, thread, payload, created, state, result)
        SELECT ${TG}, CAST(update_id AS TEXT), '', 'update', '', '', '', '', '{}', applied_at, 'done', result FROM telegram_update`, "kind = 'update' AND state = 'done'"),
         copy("telegram_inbox", "chat_event", `INSERT INTO chat_event (provider, id, installation, kind, channel, member, ts, thread, payload, created, state)
        SELECT ${TG}, CAST(update_id AS TEXT), bot_id, 'update', '', '', '', '', payload, received_at, 'queued' FROM telegram_inbox
         WHERE update_id NOT IN (SELECT update_id FROM telegram_update)`, "kind = 'update' AND state = 'queued'", "SELECT COUNT(*) AS n FROM telegram_inbox WHERE update_id NOT IN (SELECT update_id FROM telegram_update)"),
-        // A message the lead answers: its event is m<update id>, and its words, server context and request ride the body.
         copy("telegram_conversation", "chat_event", `INSERT INTO chat_event (provider, id, installation, binding, kind, channel, member, ts, thread, payload, created, session, state,
          next_at, claim_owner, claim_until, attempts, turn, started, finished, result, reply)
        SELECT ${TG}, 'm' || c.update_id, c.bot_id, c.binding, 'message', c.chat_id, c.user_id, c.message_id, COALESCE(c.reply_to, ''),
@@ -698,7 +654,6 @@ function telegramCopies() {
        SELECT ${TG}, id, binding, decision, update_id, message_id, reply_to, note, state, created_at, expires_at FROM telegram_note_draft`, "1"),
         copy("bridge_lease", "chat_runtime", `INSERT INTO chat_runtime (provider, installation, owner, lease_until, generation, cursor, heartbeat, push_url, push_at, push_problem)
        SELECT ${TG}, bot_id, owner, expires_at, generation, cursor, heartbeat_at, push_url, push_at, push_problem FROM bridge_lease`, "lease_until IS NOT NULL"),
-        // A bot with a rate-limit wait but no lease yet gets a runtime row of its own.
         copy("telegram_retry", "chat_runtime", `INSERT INTO chat_runtime (provider, installation, retry_at)
        SELECT ${TG}, bot_id, next_attempt_at FROM telegram_retry WHERE true
        ON CONFLICT (provider, installation) DO UPDATE SET retry_at = excluded.retry_at`, "retry_at IS NOT NULL"),
@@ -706,13 +661,6 @@ function telegramCopies() {
        SELECT ${TG}, every_ms, set_by, set_at, last_sent_at FROM telegram_digest WHERE id = 1`, "1", "SELECT COUNT(*) AS n FROM telegram_digest WHERE id = 1"),
     ];
 }
-/**
- * v116: every old chat table's rows into the shared ones, in one transaction. Each copy is one INSERT ... SELECT (no
- * row passes through this process), then every count is checked against its source, every Telegram message's words
- * against the person its binding names, and every foreign key; only then are the old tables dropped. Anything that
- * doesn't add up rolls the whole move back and the open fails, with the old tables as they were. Run again (a resumed
- * upgrade) it finds no old tables and does nothing.
- */
 export function convertChatTables(db) {
     const apps = LEGACY_CHAT_APPS.filter(app => tableExists(db, `${app}_binding`));
     const telegram = tableExists(db, "telegram_binding");
@@ -733,7 +681,6 @@ export function convertChatTables(db) {
                 if (missing.length > 0)
                     throw new Error(`the ${table} table has an unknown shape (no ${missing.join(", ")}) — refusing to move it`);
             }
-            // A table the shared one already has rows for (a copy made by hand?) is not ours to merge into.
             for (const provider of CHAT_PROVIDERS) {
                 const present = provider === "telegram" ? telegram : apps.includes(provider);
                 if (!present)
@@ -743,8 +690,6 @@ export function convertChatTables(db) {
                     throw new Error(`the shared chat tables already hold ${provider} pairings — refusing to merge the old ${provider} tables into them`);
             }
             if (telegram) {
-                // A message speaks for the person its pairing names, at the generation it was paired under, and every reply
-                // part belongs to a message: what doesn't is named, never dropped or guessed.
                 const strays = Number(db.prepare(`SELECT COUNT(*) AS n FROM telegram_conversation c JOIN telegram_binding b ON b.id = c.binding
           WHERE c.approver <> b.approver OR c.approver_generation <> b.approver_generation`).get()?.["n"] ?? 0);
                 if (strays > 0)
@@ -759,12 +704,10 @@ export function convertChatTables(db) {
                 db.exec(copy.insert);
                 const want = Number(db.prepare(copy.expect).get()?.["n"] ?? 0);
                 const got = Number(db.prepare(copy.found).get()?.["n"] ?? 0) - (copy.target === "chat_runtime" && copy.source === "telegram_retry" ? 0 : before);
-                // telegram_retry merges into the runtime rows the lease made; every other copy adds exactly its source's rows.
                 if (copy.source === "telegram_retry" ? got < want : got !== want)
                     throw new Error(`moving ${copy.source} into ${copy.target} copied ${got} of ${want} rows — refusing to drop it`);
                 copied += want;
             }
-            // Every moved Telegram message and reply part reads by the shared contracts (a page at a time).
             if (telegram) {
                 const unreadable = (sql, read) => {
                     let after = 0, bad = 0;

package/dist/chat-polish.js

@@ -1,6 +1,4 @@
 import { html } from './html.js';
-/** Presentation only. These are recorded completions, not a claim that
- * work happened since the user last visited, or that every result passed. */
 export function completedWorkHtml(snapshot, projectLabels, assignments) {
     const completed = snapshot.tasks.filter(task => assignments === undefined ? task.state === 'done'
         && task.proofVerdict !== 'short' && task.proofVerdict !== 'refuted'
@@ -12,20 +10,15 @@ export function completedWorkHtml(snapshot, projectLabels, assignments) {
         return html `<a class="chat-overview-item" href="/t/${encodeURIComponent(task.rootId ?? task.id)}"><span class="chat-overview-copy"><strong>${task.title}</strong><span>${projectLabels[task.repoIndex] ?? `Project ${task.repoIndex + 1}`}</span></span><span class="chat-completed-action">Open task <span aria-hidden="true">→</span></span></a>`;
     })}</section>`;
 }
-/** Keep activity truthful: the turn's recorded step count is not a
- * percentage or an invented tool phase. Billing detail stays available. */
 export function chatWorkingHtml(input) {
     const activity = html `<span class="activity-dot" aria-hidden="true"></span><details><summary>Working<span class="activity-ellipsis" aria-hidden="true">…</span></summary><p class="meta">${input.details}</p></details>`;
     return html `<div class="chat-thinking chat-activity-row" id="latest" role="status"${input.keyed ? html ` data-key="pending"` : ''}>${activity}${input.stopForm}</div>`;
 }
-/** Recorded activity is inspectable, not a row of performance badges. */
 export function chatActivityDetailsHtml(activity) {
     if (!activity)
         return html ``;
     return html `<details class="chat-activity-details"><summary>Activity</summary><div class="chat-activity" aria-label="work performed">${activity.split(' · ').map(one => html `<span>${one}</span>`)}</div></details>`;
 }
-// Local primitives adapted from the researched interaction patterns. No
-// imported kit, animation runtime, simulated progress, or changed authority.
 export const CHAT_POLISH_CSS = `
   /* Quiet workspace surfaces: color signals state, not an AI aesthetic. */
   body { background: var(--background); }

package/dist/chat-quiet.js

@@ -1,9 +1,3 @@
-/** Quiet chat: a task's whole life is one chat message edited in place, and a
- * new message arrives only when a person is needed. Every transport (Telegram,
- * Slack, Discord, Teams) asks the same questions here: does this fact need a
- * person, what does the task's card say now, and what does the Ready ping say.
- * Delivery receipts, claims and retries stay with each transport; the
- * console's activity keeps every fact whatever a chat showed. */
 import { assignmentOf } from "./assignment.js";
 import { chatControlHref, chatResultHref } from "./chat-controls.js";
 import { telegramProgressCard } from "./telegram-progress.js";
@@ -14,15 +8,10 @@ import { isLifecycleNotification, taskArchived } from "./store.js";
 import { leadSubjectOf } from "./lead-voice.js";
 import { decideFallbackLink, decideTargetOf } from "./chat-decide.js";
 import { YOUIYOUX_CARD_KIND } from "./contracts/youiyoux-request.js";
-/** What always makes a new message, even in quiet mode: a question or approval waiting, a failure or other
- * attention fact, a result Ready for review, a security alert or release, and anything addressed to one person
- * (a sign-in or plan-limit pause, an evening digest). */
 const NEEDED_KINDS = new Set([
     "acceptance-ready", "acceptance-evidence", "flow-decision", "flow-card", "plan-ready", "report-ready",
     "stale-approval", "security-release", "secret-detected", "protected-storage",
 ]);
-/** What still wants a person who pairs after it landed, in every chat app: an open decision or an unresolved attention
- * notice. Routine history is never replayed to a chat that just arrived (store.ts WANTED_BEFORE_PAIRING, the same rule). */
 export function wantedBeforePairing(row) {
     return row.resolvedAt === null && (row.dedupeKey.startsWith("decision:") || row.pushClass === "attention");
 }
@@ -35,18 +24,14 @@ export function needsPerson(row) {
         return true;
     if (NEEDED_KINDS.has(row.kind))
         return true;
-    // A built or unchanged result is Ready: the one lifecycle step that asks for a person.
     return isLifecycleNotification(row) && row.kind === "run-finished";
 }
-/** A fact about one placed task: in quiet mode it lands on that task's card. */
 export function isTaskFact(row) {
     return row.taskRef !== null && row.taskId !== null && row.project !== null;
 }
-/** The attempt a task's card follows: its newest builder attempt. */
 function cardRun(store, taskRef) {
     return store.runsFor(taskRef).find(run => run.role === "builder") ?? null;
 }
-/** Before any attempt starts, the card says where the task stands in the words of its last lifecycle fact. */
 const before = (headline) => ({ icon: headlineEmoji(headline), status: headline });
 const BEFORE_RUN = {
     "task-filed": before("Queued"),
@@ -63,9 +48,7 @@ function taskLine(store, taskRef, now, root, viewer) {
     if (ref === null || ref.repo === null)
         return null;
     const task = store.getTask(ref.externalId);
-    // A short human title: never "— revision" or an id (chat-voice.ts).
     const title = chatTitle(store, ref.externalId);
-    // Replaced, never "Cancelled": the card says a newer task took over and links to it, without either id.
     const successor = task?.state === "cancelled" ? store.replacementOf(ref.externalId) : null;
     if (successor !== null) {
         const words = "Replaced by a newer task";
@@ -92,7 +75,6 @@ function taskLine(store, taskRef, now, root, viewer) {
             link: { label: "Open task", path: chatControlHref("task", ref.externalId) },
         } };
 }
-/** The card's words now: one task's progress card, or one line per task when several were filed together. */
 export function quietCardView(store, taskRefs, now, root, viewer) {
     const lines = taskRefs.map(ref => taskLine(store, ref, now, root, viewer)).filter((one) => one !== null);
     if (lines.length === 0)
@@ -104,15 +86,10 @@ export function quietCardView(store, taskRefs, now, root, viewer) {
     const text = [heading, ...lines.map(one => `${one.icon} ${phoneText(one.title, 60)} · ${one.status}`), "", projects.join(", ")].join("\n");
     return { text, entities: [{ type: "bold", offset: 0, length: heading.length }], link: { label: "Open tasks", path: "/tasks" } };
 }
-/** Facts that carry their own controls or must stand alone (a security alert, a decision, a flow card, a
- * screenshot, an acceptance packet, a youiyoux pass's card) are never folded into a batch. */
 const OWN_MESSAGE_KINDS = new Set(["security-release", "secret-detected", "flow-decision", "flow-card", "acceptance-ready", "acceptance-evidence", YOUIYOUX_CARD_KIND]);
-/** Whether this update for a person joins their two-minute batch: anything about one task that needs them,
- * except a fact that must stand alone. */
 export function joinsBatch(row) {
     return row.taskRef !== null && row.recipient === null && needsPerson(row) && !OWN_MESSAGE_KINDS.has(row.kind) && !/^decision:\d+$/.test(row.dedupeKey);
 }
-/** A few words for an update in a list, and how it counts: "has a plan to review", "failed". */
 function updatePhrase(row) {
     if (row.kind === "plan-ready")
         return { phrase: "has a plan to review", headline: "Needs you" };
@@ -126,8 +103,6 @@ function updatePhrase(row) {
         return { phrase: "failed", headline: "Failed" };
     return { phrase: "needs you", headline: "Needs you" };
 }
-/** One task's line in a batch: a finished result in a person's words with its real next step, or another
- * update in its own words with its own link. */
 function lineOf(store, item, now, root, viewer) {
     const ref = store.refById(item.taskRef);
     if (ref === null || ref.repo === null)
@@ -135,7 +110,6 @@ function lineOf(store, item, now, root, viewer) {
     const summary = chatTitle(store, ref.externalId);
     const row = item.notification === null ? null : store.notificationById(item.notification);
     if (row !== null && row.kind !== "run-finished") {
-        // Never the task's id or a "— revision" suffix; the title once, in front unless the words already name it.
         const subject = leadSubjectOf(store, row, viewer);
         const words = chatText(phoneText(row.body === "" ? subject : `${subject}\n\n${row.body}`, 2500), [{ id: ref.externalId, title: summary }]);
         const { phrase, headline } = updatePhrase(row);
@@ -158,19 +132,15 @@ function lineOf(store, item, now, root, viewer) {
         completedBy: card.facts.completedBy ?? null,
         ...(card.facts.landed ? { landed: card.facts.landed } : {}),
         pullRequest,
-        // The lead speaks as "I" for what it did: the work it filed or approved, or the completion it recorded.
         lead: card.status.headline === "Complete" ? card.completedByLead : store.leadWorkOf(item.taskRef) !== null,
         ...(card.facts.lead === "on-it" ? { leadOnIt: true, ...(card.facts.leadName === undefined ? {} : { leadName: card.facts.leadName }) } : {}),
     };
-    // A result ready for a person offers its real next step, then a look first.
     if (asksToFinish(fact))
         return { fact, also: [{ label: READY_ACTIONS.look, path: chatResultHref(ref.externalId, run.id, "changes") }],
             target: pullRequest ? { kind: "merge", taskId: ref.externalId, run: run.id } : { kind: "result", taskId: ref.externalId, run: run.id },
             link: pullRequest ? { label: READY_ACTIONS.merge, path: `/t/${encodeURIComponent(ref.externalId)}#merge` } : { label: READY_ACTIONS.complete, path: chatResultHref(ref.externalId, run.id) } };
     return { fact, link: card.link, also: [] };
 }
-/** One person's update message: one task says what happened with its next step; several updates within two
- * minutes become "4 tasks finished: …" (or "3 updates: …") with one Open button. Null when none can be read. */
 export function finishedView(store, batch, now, root, viewer) {
     const lines = batch.items.map(one => lineOf(store, one, now, root, viewer)).filter((one) => one !== null);
     if (lines.length === 0)
@@ -181,25 +151,20 @@ export function finishedView(store, batch, now, root, viewer) {
     const target = lines[0].target ?? null;
     return { text, entities: [], link: lines[0].link, ...(lines[0].also.length === 0 ? {} : { also: lines[0].also }), ...(target === null ? {} : { target }) };
 }
-// ---- the evening digest ----------------------------------------------------------
 const FAILURE = /fail|exhausted|fenced/;
 const pad = (n) => String(n).padStart(2, "0");
-/** This computer's local day and time, which is what a person means by "the evening". */
 export function localDay(now) {
     return `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}`;
 }
 export function localTime(now) {
     return `${pad(now.getHours())}:${pad(now.getMinutes())}`;
 }
-/** One person's evening: what finished and what failed in the last day, and what waits for them now. Null when
- * nothing happened, so a quiet day sends nothing. */
 export function eveningDigestText(store, account, now, root) {
     const since = new Date(now.getTime() - 86_400_000).toISOString();
     const recent = new Date(now.getTime() - 14 * 86_400_000).toISOString();
     const visible = (row) => row.project !== null && store.accountCanAccess(account, row.project);
     const title = (taskId) => chatTitle(store, taskId);
     const finished = new Map(), failed = new Map(), waits = new Map();
-    // A put-away task (v145) is out of the digest too: nothing about it waits, finished or failed for anyone now.
     const facts = store.taskFactsSince(recent).filter(visible).filter(row => row.taskId === null || !taskArchived(store, row.taskId));
     for (const row of facts) {
         if (row.createdAt < since || row.taskId === null)
@@ -229,8 +194,6 @@ export function eveningDigestText(store, account, now, root) {
     const section = (name, items) => items.size === 0 ? [] : ["", `${name} (${items.size})`, ...[...items.values()].slice(0, 12).map(one => `• ${one}`), ...(items.size > 12 ? [`• and ${items.size - 12} more`] : [])];
     return [...section("Finished", finished), ...section("Waiting for you", waits), ...section("Failed", failed)].slice(1).join("\n");
 }
-/** Record each due evening digest once per person per local day, as one notification addressed to that person:
- * every chat they paired delivers it with the usual receipts, and the console keeps it. */
 export function enqueueEveningDigests(store, now, root) {
     const day = localDay(now), time = localTime(now);
     let queued = 0;

package/dist/chat-review.js

@@ -3,7 +3,6 @@ import { readVerifiedArtifact } from "./evidence.js";
 import { hasForbiddenControls, validateNote } from "./decision.js";
 import { parseFeedbackImage, isRevisionFeedback, revisionSourceOf } from "./result-review.js";
 import { createResultRevision, feedbackImageProblem } from "./result-actions.js";
-/** Read precisely the result named, never silently substitute a newer version. */
 export function readChatResult(store, who, evidenceRoot, task, run) {
     const ref = store.lookupRef(task);
     if (ref?.repo == null || !who.repos.includes(ref.repo))
@@ -45,9 +44,6 @@ export function reviewInputProblem(note, path, line) {
         return "Write a note before attaching it to a file.";
     return null;
 }
-/** Chat and the result form write the same comments and call the same revision service.
- * A failed combined note+revision rolls back the note too; no half-completed action.
- */
 export function applyChatReview(store, who, evidenceRoot, request, now, allowMode, origin) {
     try {
         return store.transact(() => store.savepoint(() => {

package/dist/chat-rooms.js

@@ -2,9 +2,6 @@ import { TeamLeads } from "./team-leads.js";
 import { tooLongText } from "./chat-channel.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.
- * The bare word works too, because Slack and Discord keep unregistered
- * slash text for themselves. Any other text is not ours. */
 export function roomCommand(text) {
     const trimmed = text.trim();
     if (/^\/?team(?:@\w+)?\s*$/i.test(trimmed))
@@ -64,12 +61,6 @@ function groupListing(rows, current) {
     lines.push("", "Send /team <number> to follow it (managers only), or /team off to stop. Everyone in this room 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 followed room, or a private message while a conversation is selected);
- * false hands the message to the transport's personal path untouched.
- */
 export function applyRoomInbound(input) {
     const { store, backend, chatId, isGroup, sender, now, report, say } = input;
     const command = roomCommand(input.text);
@@ -110,13 +101,11 @@ export function applyRoomInbound(input) {
         return true;
     }
     if (room === null) {
-        // A room the bot merely sits in stays silent; a private chat falls through to the personal assistant.
         if (isGroup)
             report.ignored++;
         return isGroup;
     }
     if (!paired || actor === null) {
-        // Unpaired members' chatter is nobody's message. A slash attempt gets the one hint.
         if (input.text.trimStart().startsWith("/")) {
             say(PAIR_FIRST);
             report.statusReplies = (report.statusReplies ?? 0) + 1;
@@ -141,14 +130,11 @@ export function applyRoomInbound(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.
     if (!roomGrantAllowed(store, domain, backend, room)) {
         say(isGroup ? "This room'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;
         return true;
     }
-    // Membership first, in the domain's own words: a removed person is told so.
     try {
         domain.access(actor, row.conversation, "contributor");
     }
@@ -157,8 +143,6 @@ export function applyRoomInbound(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) {
         say(`${phoneText(row.title, 80)}: enable chat for yourself in Toolroll first (it shows the provider and limits), then send again.`, { label: "Enable chat", path: `/chat?conversation=${encodeURIComponent(row.conversation)}` });
@@ -174,9 +158,6 @@ export function applyRoomInbound(input) {
     report.chatQueued = (report.chatQueued ?? 0) + 1;
     return true;
 }
-/** Whether the pairing a room was granted from still holds: live, the same
- * person, still a manager of a team conversation for a group (a viewer for a
- * private selection). */
 export function roomGrantAllowed(store, domain, backend, room) {
     const grant = backend.grant(room.binding);
     if (grant === null || grant.approver !== room.boundBy || (room.kind === "private" && grant.chatId !== room.chatId))
@@ -190,14 +171,12 @@ export function roomGrantAllowed(store, domain, backend, room) {
     }
 }
 export function teamDomain(store, projects) { return domainFor(store, projects); }
-/** The conversation messages a room has not received yet, oldest first. */
 export function roomMessagesAfter(store, thread, cursor, limit = 20) {
     return store.handle.prepare(`SELECT m.id, m.role, m.text, m.turn, q.author, q.request_id, q.status FROM lead_message m
     LEFT JOIN team_message q ON q.message = m.id WHERE m.thread = ? AND m.id > ? ORDER BY m.id LIMIT ?`).all(thread, cursor, limit)
         .map(row => ({ id: Number(row["id"]), role: row["role"] === "assistant" ? "assistant" : "operator", text: String(row["text"]), turn: row["turn"] === null ? null : Number(row["turn"]),
         author: row["author"] === null || row["author"] === undefined ? null : String(row["author"]), requestId: row["request_id"] === null || row["request_id"] === undefined ? null : String(row["request_id"]), status: row["status"] === null || row["status"] === undefined ? null : String(row["status"]) }));
 }
-/** What a room shows for one message: the lead's reply as is, a teammate's message with its author, this room's own messages and cancelled ones not at all. */
 export function roomMessageText(message, channel, chatId) {
     if (message.role === "assistant")
         return message.text;
@@ -206,7 +185,6 @@ export function roomMessageText(message, channel, chatId) {
         return null;
     return `${phoneText(message.author, 40)}: ${message.text}`;
 }
-/** Whose binding a room card rides: the person the lead was answering, else any paired participant. */
 export function roomCardApprover(store, conversation, turn, paired) {
     const author = store.handle.prepare("SELECT author FROM team_message WHERE turn_id = ?").get(turn);
     if (author !== undefined && paired.includes(String(author["author"])))

package/dist/chat-settings-page.js

@@ -4,13 +4,10 @@ import { html, joinHtml } from "./html.js";
 import { ChatState } from "./chat-delivery-state.js";
 import { acts, btn, chip, codeLine, disclose, formRow, infoLine, input, note, notice, settingsSection } from "./server/kit.js";
 import { kitSectionForm, SECRET_OPT_OUTS } from "./settings-kit.js";
-/** A secret the connect form posts (an app or bot token, a client secret): masked, never given a value, kept out of
- * password managers. */
 export function chatSecretRow(options) {
     return formRow(options.label, null, input({ id: options.id, name: options.name, type: "password",
         attrs: { autocomplete: "off", spellcheck: "false", "data-so-secret": true, ...SECRET_OPT_OUTS, required: true, placeholder: options.placeholder, "aria-label": options.label } }));
 }
-/** Settings → Slack, Discord or Teams: connect the app once, then each teammate pairs their own account. */
 export function chatSettingsHtml(store, dir, options, page) {
     const { provider, label, credentials } = page, state = new ChatState(store, provider), bindings = credentials ? state.bindings(credentials.installation).filter(one => state.live(one)) : [], binding = options.who === undefined ? null : bindings.find(one => one.approver === options.who) ?? null, others = bindings.length - (binding === null ? 0 : 1);
     const runtime = credentials ? state.runtime(credentials.installation) : null;
@@ -39,7 +36,6 @@ export function chatSettingsHtml(store, dir, options, page) {
         ]) }));
     const teammates = others ? `${others} teammate${others === 1 ? " is" : "s are"}` : "";
     if (options.code) {
-        // The code shows once, on this page only: selectable text, never in a link or an address.
         sections.push(settingsSection({ id: "pair", title: "Pair your account", state: " · Code ready",
             lead: `Send this ${page.pairWhere}. It expires in 10 minutes.`,
             body: joinHtml([codeLine(`pair ${options.code}`), note("Once you've sent it, this page says your account is paired."),

package/dist/chat-task-actions.js

@@ -4,15 +4,12 @@ import { requestTaskStop, resumeTaskStop, taskControlOf } from "./task-control.j
 import { authorizePlanUnderMode } from "./plan-auto.js";
 import { fileAddTestsTask, requestFollowUpChecks } from "./result-follow-ups.js";
 export const CHAT_TASK_ACTIONS = {
-    // Build #1604 feedback: one short consequence that still says saved work
-    // remains, other tasks continue, and the pause waits for acknowledgement.
     stop: { label: "Stop task", detail: "Pauses this task once the run acknowledges the stop. Saved work remains; other tasks continue." },
     resume: { label: "Resume task", detail: "Lifts this stop’s hold and continues from saved work. Other holds and approval requirements still apply." },
     retry: { label: "Try again", detail: "Queues another attempt. Existing approvals and holds still apply." },
     plan: { label: "Plan first", detail: "Requests a plan. Building still requires approval." },
     wait_for: { label: "Add dependency", detail: "Waits for the selected task to finish." },
     stop_waiting: { label: "Remove dependency", detail: "Stops waiting for the selected task. Other requirements still apply." },
-    // Follow-ups on a result (result-follow-ups.ts): the same actions as the result page.
     run_checks: { label: "Run checks", detail: "Runs the project's quick check on this result's exact commit. A pass upgrades its status; a failure stays visible." },
     run_full_checks: { label: "Run full checks", detail: "Runs the project's full check on this result's exact commit. A pass upgrades its status; a failure stays visible." },
     add_tests: { label: "Add tests", detail: "Files a small task to write tests for this change. Nothing runs until it is approved." },
@@ -20,7 +17,6 @@ export const CHAT_TASK_ACTIONS = {
 export function isChatTaskAction(value) {
     return typeof value === "string" && Object.hasOwn(CHAT_TASK_ACTIONS, value);
 }
-/** Bind cards to a specific execution and its current state, not the family's moving pointer. */
 export function chatTaskStamp(store, who, task) {
     const ref = store.lookupRef(task), row = store.getTask(task);
     if (!ref?.repo || !who.repos.includes(ref.repo) || row === null)
@@ -31,7 +27,6 @@ export function chatTaskStamp(store, who, task) {
     return JSON.stringify([task, row.state, row.updatedAt, store.getScope(task)?.digest ?? null,
         ref.plan, store.runsFor(ref.id)[0]?.id ?? null, store.blockers(task).sort()]);
 }
-/** Only current, eligible controls can become cards; retain the exact run the reader saw. */
 export function chatTaskRun(store, task, operation, now) {
     const ref = store.lookupRef(task);
     if (ref === null)
@@ -53,11 +48,9 @@ export function applyChatTaskAction(store, who, payload, now, web, controls = {}
         const run = chatTaskRun(store, task, operation, now);
         if (run === null || run !== payload["run"])
             return { ok: false, message: "This attempt changed. Review the current task before confirming." };
-        // Resuming is an approval: a person's own tap or signed-in click lifts the stop; any other road only asks for it.
         if (operation === "resume") {
             if (controls.person !== true)
                 return { ok: true, taskId: task, said: `Resume requested for ${task}. Finish it in your chat or on the task.` };
-            // Resuming is an approval: a person's own off holds here as on every other one.
             const allowed = effectiveChatApproval(store, ref.repo, who.name);
             if (!allowed.ok && controls.via !== "web") {
                 const mode = controls.via === undefined || controls.via === "cli" ? allowed : chatApproveMode(store, ref.repo, who.name, now, controls.via);

package/dist/chat-terms.js

@@ -1,15 +1,8 @@
-/**
- * A scope's terms as a chat card shows them whole, and the digest of exactly those words. A task filed from outside
- * text (a youiyoux change request) approves from chat only on a card that showed every word of its terms, nothing cut:
- * the card binds that digest to its button, and the seal (store.ts, the outside-request quarantine) recomputes it from
- * the live scope and refuses a tap that names anything else. A leaf: the store and the chat road both read it.
- */
 import { createHash } from "node:crypto";
 import { isAcpProfile } from "./acp-agents.js";
 import { checkAccessWords } from "./check-access.js";
 import { sandboxTermsWords } from "./project-sandbox.js";
 import { chainTermsLines } from "./scope.js";
-/** What a plan's yes allows an agent to do, in a few plain words (the approval sheet's "You're allowing"). */
 export function permissionPlainWords(profile) {
     if (profile === null || profile === undefined)
         return null;
@@ -26,8 +19,6 @@ export function permissionPlainWords(profile) {
     return profile.sandboxMode === "danger-full-access" ? full : "file edits and commands inside the project only";
 }
 const money = (micro) => `$${(micro / 1_000_000).toFixed(2)}`;
-/** Every word of the terms a yes agrees to, as the card shows them: the goal, what's excluded, the files (or plainly any
- * file), each requirement with the evidence it needs, and what the agent may do and spend. Nothing is shortened. */
 export function scopeTermsText(scope) {
     const allows = [permissionPlainWords(scope.profile) ?? "agent permissions not known", scope.budgetMicrousd === null ? "no attempt limit" : `up to ${money(scope.budgetMicrousd)} per attempt`];
     return [
@@ -44,16 +35,12 @@ export function scopeTermsText(scope) {
         ...((chain) => chain.length === 0 ? [] : ["", "Fallback agents:", ...chain])(chainTermsLines(scope)),
     ].join("\n");
 }
-/** The digest of the terms shown, bound to the scope's own digest: a changed word, limit or route is another digest. */
 export function shownTermsDigest(scope) {
     return createHash("sha256").update(JSON.stringify({ v: 1, scope: scope.digest, shown: scopeTermsText(scope) })).digest("hex");
 }
-/** The digest of the exact words a card showed, taken when the card was made and kept with it. */
 export function cardTermsDigest(terms) {
     return createHash("sha256").update(JSON.stringify({ v: 2, shown: terms })).digest("hex");
 }
-/** Whether these words show this scope as it is now: its whole terms text, word for word, and what only a person's own
- * yes may agree to (checks past the sandbox, extra services). Part of the terms, or an earlier version's, is not. */
 export function cardShowsScope(scope, terms) {
     if (!terms.includes(scopeTermsText(scope)))
         return false;
@@ -63,14 +50,12 @@ export function cardShowsScope(scope, terms) {
     const access = profile.checkAccess, mach = sandboxTermsWords(profile).mach;
     return (access === undefined || terms.includes(checkAccessWords(access))) && (mach === null || terms.includes(mach));
 }
-/** Whether a scope lets its agent do anything, nothing asking first. */
 export function scopeFullAccess(profile) {
     if (profile === null || profile === undefined)
         return false;
     return profile.provider === "claude" ? profile.permissionArgv === "bypassPermissions"
         : profile.provider === "gemini" ? profile.approvalArgv === "yolo" : isAcpProfile(profile) ? true : profile.sandboxMode === "danger-full-access";
 }
-/** Why a person's own limits refuse this scope, or null. */
 export function chatLimitProblem(scope, limits, yours) {
     if (scopeFullAccess(scope.profile) && !limits.fullAccess)
         return `This plan asks for more access than ${yours} allows.`;
@@ -79,16 +64,10 @@ export function chatLimitProblem(scope, limits, yours) {
         return `This plan has ${scope.budgetMicrousd === null ? "no attempt limit" : `a ${money(scope.budgetMicrousd)} attempt limit`}, more than ${yours === "your mode" ? "your mode's" : "your chat approval limit of"} ${money(cap)}.`;
     return null;
 }
-/** Whether a chat app shows a card's words exactly as they are stored, so a tap there is a yes to those words. Teams
- * draws card text as Markdown, where a link's label hides its address, and Slack turns `:name:` into an emoji: there
- * the words go to the review page and no tap approves them. Telegram's card is plain text and Discord's escapes its
- * presentation syntax. Both approval roads read this one rule (chat-decide.ts shownWhole, chat-actions.ts
- * sharedActionAllowsChallenge), so neither can seal words the other would refuse. */
 export function shownAsWritten(text, channel) {
     switch (channel) {
         case "telegram":
         case "discord": return true;
-        // Emoji names: letters and digits of any script (workspaces add their own), `_`, `+`, `'`, `-`.
         case "slack": return !/:[\p{L}\p{N}_+'-]+:/u.test(text);
         case "teams": return false;
     }