toolroll 0.9.104 → 0.9.105

package/dist/lead-answer-eval.js

@@ -1,30 +1,3 @@
-/**
- * The `lead-answer` eval: the gate on quick answers (docs/plans/responsive-chat.md §8). Quick answers ship OFF and are
- * turned on by default only once this eval's real mode passes.
- *
- * A seeded world (tasks in every state, one decision waiting on the owner) and 40 questions:
- * - 30 read questions, each with an oracle computed from the world's records: the task titles, states and counts its
- *   answer must name, and the titles it must not claim;
- * - 10 act-intent questions, which must stay on the main model or be handed to it (escalated): 8 carry an act word, and
- *   2 ask for a change without one, so only the quick step's own escalation can catch them.
- * Each read question runs k = 3 times on the main model (quick answers off) and k = 3 on the quick route (on); a question
- * passes on a model only when all three answers do (pass^k, the eval harness's rule). An act question that the router
- * already keeps on the main model needs no model call; one it routes quick runs k = 3 and must escalate every time.
- *
- * Pass: quick pass^k ≥ main pass^k (no regression), quick false claims ≤ main's, 10/10 act questions on the main model
- * or escalated, and the quick route's median turn time at least 30% below the main model's.
- *
- * Modes: `scripted` (CI: a deterministic stand-in model with simulated per-model latency proves the harness, the
- * router, escalation and grading end to end, with no provider call) and `real` (the owner or the release runs it:
- * every turn goes to this computer's signed-in Claude). Real mode spends subscription usage: about 30×3×2 + 2×3 turns.
- *
- *   npm run build && node scripts/lead-answer-eval.mjs            # scripted
- *   npm run build && node scripts/lead-answer-eval.mjs --real     # real model calls
- *
- * Kept outside src/evals.ts's canonical campaigns: those run build and ask cases through a world's CLI and are sealed
- * as release policy (`evals/`); this eval drives runLeadTurn directly over an in-memory world. Folding it in as a third
- * case kind is a follow-up.
- */
 import { createHash } from "node:crypto";
 import { openStore, setLeadQuickAnswers } from "./store.js";
 import { fileTaskProposal } from "./proposal.js";
@@ -49,13 +22,11 @@ export const LEAD_ANSWER_TASKS = Object.freeze([
     { id: "backup-check", title: "Repair the nightly backup check", state: "failed" },
     { id: "dark-emails", title: "Try a dark theme for emails", state: "cancelled" },
 ]);
-/** The task whose run waits on the owner's decision. */
 const DECIDING = "search-index";
 const titles = (state) => LEAD_ANSWER_TASKS.filter(one => one.state === state).map(one => one.title);
 const facts = (state) => titles(state).map(title => [title.toLowerCase()]);
 const NUMBER_WORDS = ["zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten"];
 const count = (state) => { const n = titles(state).length; return [String(n), NUMBER_WORDS[n]]; };
-/** The 40 questions, each read question's oracle computed from LEAD_ANSWER_TASKS (the world's records). */
 export function leadAnswerQuestions() {
     const read = (topic, texts, mustName, mustNot) => texts.map((text, index) => ({ id: `${topic}-${index + 1}`, text, kind: "read", mustName, mustNot, topic }));
     const settled = [...titles("done"), ...titles("cancelled")];
@@ -81,12 +52,10 @@ export function leadAnswerQuestions() {
         act("act-pause", "pause the search index work"),
         act("act-approve", "approve rebuilding the index tonight"),
         act("act-release", "release the shop project"),
-        // No act word: only the quick step's own escalation keeps these off the quick route.
         act("act-soft-order", "Could the French translation go before the invoices?"),
         act("act-soft-revive", "The dark theme idea for emails, can we bring it back?"),
     ];
 }
-/** The seeded world: its store, its owner, the conversation config. */
 export function seedLeadAnswerWorld(now = T0) {
     const store = openStore(":memory:");
     store.saveApprover("owner", createHash("sha256").update("lead-answer-eval").digest("hex"), now);
@@ -111,16 +80,10 @@ export function seedLeadAnswerWorld(now = T0) {
     const config = { provider: "claude-subscription", model: MAIN_MODEL, dailyTurns: 1_000, weeklyCeilingMicrousd: 0, priceInMicrousd: 0, priceOutMicrousd: 0, updatedAt: now.toISOString(), updatedBy: "owner" };
     return { store, who: verified.who, config };
 }
-/** How an answer did against its question's oracle. */
 export function gradeAnswer(question, answer) {
     const text = answer.toLowerCase();
     return { named: question.mustName.every(fact => fact.some(spelling => text.includes(spelling))), falseClaims: question.mustNot.filter(claim => text.includes(claim.toLowerCase())).length };
 }
-/**
- * The scripted stand-in model (CI): reads with list_tasks and list_decisions, then answers from those results alone; a
- * request without proposal tools (a quick step) asked to change something calls find_tools, as the contract tells a
- * model to search before saying something can't be done. Each step advances `clock` by the model's simulated latency.
- */
 export function scriptedLeadAnswerRunner(questions, clock, quickModel) {
     const byText = new Map(questions.map(one => [one.text, one]));
     return async (request) => {
@@ -167,7 +130,6 @@ const median = (values) => {
     const mid = Math.floor(sorted.length / 2);
     return sorted.length % 2 === 1 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
 };
-/** Run the eval. `runner` absent: this computer's signed-in Claude (real mode). */
 export async function runLeadAnswerEval(options) {
     const k = options.k ?? LEAD_ANSWER_K;
     const world = seedLeadAnswerWorld();
@@ -180,7 +142,6 @@ export async function runLeadAnswerEval(options) {
     const runs = [];
     const once = async (question, model) => {
         setLeadQuickAnswers(store, model === "quick", "owner", clock());
-        // A fresh conversation per run: no earlier answer leaks into the next.
         const session = store.getLeadSession(store.mintLeadSession({ approver: "owner", approverGeneration: who.generation, credentialKey: subscriptionCredentialKey("claude-subscription"),
             ceilingMicrousd: 0, ceilingDigest: who.ceilingDigest, termsDigest: "e".repeat(64) }, clock()));
         store.closeLeadThreadsFor("owner", clock());

package/dist/lead-capabilities.js

@@ -1,10 +1,3 @@
-/**
- * What the lead can rely on right now, in one read (get_capabilities): the agents a project's route would run, the
- * workers that would run them, the project's tools and skills, the integrations, and the project's checks. Every entry
- * says what it lets the lead do and, when it can't, the one next step and the settings control (show_control) that
- * takes the owner there. Everything here reads what is already recorded — runner readiness reports, sign-in pauses,
- * plan-limit readings, tool tests, skill tests, integration checks — and never probes anything that spends.
- */
 import { isAcpProvider } from "./acp-agents.js";
 import { projectBatchChecks } from "./batch-policy.js";
 import { resolveRouteCandidates } from "./agentconfig.js";
@@ -17,7 +10,6 @@ import { CHECK_LEVEL_WORDS, liveQuickCommand, projectCheckLevel } from "./check-
 import { STATE_WORDS } from "./integrations.js";
 const ROLE_WORDS = { plan: "plan", build: "build", repair: "fix failed checks", review: "review" };
 const MAX_LISTED = 12;
-/** The exact provider and model pairs a project's route would use, with the roles each would play. */
 function routePairs(store, repo) {
     const pairs = new Map();
     const resolved = resolveRouteCandidates(store, repo);
@@ -39,7 +31,6 @@ function routePairs(store, repo) {
     }
     return { pairs, problem: null };
 }
-/** A provider's plan or quota running out, from the last readings (provider_limit and the runners' quota rows). */
 function outOfBudget(store, provider, now) {
     const stamp = now.toISOString();
     const window = store.providerLimits().find(one => one.provider === provider && one.reached && (one.resetsAt === null || one.resetsAt > stamp));
@@ -58,8 +49,6 @@ function agentsOf(store, repo, now, authMode) {
         const name = `${providerName(pair.provider)} · ${pair.model}`;
         const lets = `${pair.roles.join(", ")} this project's tasks`;
         const base = { provider: pair.provider, model: pair.model, roles: pair.roles, name, lets };
-        // Signed out only on a real sign-in failure: a sign-in pause from a run, the worker's login check saying not logged
-        // in, or the key a key-only provider needs missing. A provider on an API key gets the key step, never the sign-in.
         const pause = authPauseOf(store, pair.provider);
         const mode = pause?.authMode ?? (isAcpProvider(pair.provider) ? "agent-login" : SUBSCRIPTION_CAPABLE[pair.provider] ? authMode(pair.provider) : "api-key");
         const key = mode === "api-key";
@@ -79,7 +68,6 @@ function agentsOf(store, repo, now, authMode) {
             return { ...base, state: "Out of plan budget", ok: false, next: spent.until === null ? "Wait for the plan to reset, or choose another agent." : `Wait until ${spent.until}, when the plan resets, or choose another agent.`, link: "providers" };
         if (seen === null)
             return { ...base, state: "Not checked yet", ok: false, next: "No worker has reported this agent yet: start a worker for this project.", link: "workers" };
-        // On an API key, only a key check speaks for it: a CLI login check (passed or not) says nothing about the key.
         if (seen.state !== "ready" || (key && seen.probe !== "key")) {
             return { ...base, state: "Not checked yet", ok: false, next: key ? "Its API key has not been checked without spending; the first task shows whether it works." : "A worker could not check it without spending; the first task shows whether it works.", link: "providers" };
         }
@@ -108,7 +96,6 @@ function toolsOf(store, repo) {
         return { name: tool.name, state: "Working", ok: true, lets, next: null, link: null };
     });
 }
-/** The newest test of one skill version in a project: passed, failed or still running; null when never tested. */
 function lastSkillTest(store, repo, sha) {
     const row = store.handle.prepare("SELECT skill_test.task_ref AS ref FROM skill_test JOIN task_ref ON task_ref.id = skill_test.task_ref WHERE task_ref.repo = ? AND skill_test.package = ? ORDER BY skill_test.task_ref DESC LIMIT 1").get(repo, sha);
     if (row === undefined)
@@ -145,7 +132,6 @@ function checksOf(store, repo) {
         return { ...base, state: "Off", ok: false, next: "Builds are not checked. Turn checks on for the project if results need them.", link: "projects" };
     if (!releaseCheck)
         return { ...base, state: `${CHECK_LEVEL_WORDS[level]} · no release check`, ok: false, next: "No release check is set up, so no result can show a passing check. Set one for the project.", link: "projects" };
-    // Batch checks are changed in Settings → Projects → Checks (or `project checks --batch on|off`), never from chat.
     const batched = level === "full" && projectBatchChecks(store, repo).on ? " · batched with results that finish together" : "";
     return { ...base, state: level === "quick" && !quickCheck ? "Quick · runs the release check" : `${CHECK_LEVEL_WORDS[level]} · release check set${batched}`, ok: true, next: null, link: null };
 }
@@ -176,7 +162,6 @@ function workersOf(store, repos, now) {
     return workers;
 }
 const INTEGRATION_LINK = { slack: "slack", discord: "discord" };
-/** The integrations exactly as get_integrations reads them, with what each lets the lead do and the next step. */
 export function integrationCapabilities(list) {
     return list.map(one => {
         const link = one.group === "agents" ? "providers" : one.group === "tools" ? "tools" : INTEGRATION_LINK[one.key.replace(/^.*:/, "").toLowerCase()] ?? INTEGRATION_LINK[one.name.toLowerCase()] ?? "integrations";
@@ -186,7 +171,6 @@ export function integrationCapabilities(list) {
         return { name: one.name, kind: one.group, state: STATE_WORDS[one.state], ok: one.state === "connected", account: one.account, usedBy: one.usedBy, lastError: one.lastError, lets, next, link: next === null ? null : link };
     });
 }
-/** Every capability, for one project or every admitted one. Read-only and spends nothing. */
 export function capabilitiesOf(store, input) {
     const authMode = input.authMode ?? (provider => readAuthMode(provider));
     return {
@@ -195,9 +179,6 @@ export function capabilitiesOf(store, input) {
         integrations: integrationCapabilities(input.integrations),
     };
 }
-/** Whether a call depends on an agent, a worker or an integration, and so needs get_capabilities read first this turn:
- * a task always does (a worker runs it with an agent); a flow change that sets up or starts work does; a promise to
- * report on a task, attempt or check does (crew work must run), and a timed one does when it is reported on a chat app. */
 const FLOW_WORK = new Set(["create", "edit", "kit", "starter", "add_trigger", "resume_trigger", "add_card"]);
 export function needsCapabilities(name, args, channel) {
     if (name === "propose_task" || name === "propose_start" || name === "propose_sweep")

package/dist/lead-cli-live.js

@@ -1,20 +1,16 @@
 import { createLiveReply, createLiveSender } from "./live-reply.js";
 import { renderReply } from "./reply-shape.js";
 import { terminalText } from "./terminal-text.js";
-/** At most this many rows of the reply show under the status line. */
 export const LIVE_TERMINAL_ROWS = 6;
-/** The least time between two redraws. */
 const REDRAW_MS = 50;
 const STOPPED = "Stopped.";
 const graphemes = new Intl.Segmenter(undefined, { granularity: "grapheme" });
-/** East Asian wide and fullwidth ranges: these take two columns. */
 const WIDE = [
     [0x1100, 0x115f], [0x231a, 0x231b], [0x2329, 0x232a], [0x23e9, 0x23ec], [0x23f0, 0x23f0], [0x23f3, 0x23f3],
     [0x2e80, 0x303e], [0x3041, 0x33ff], [0x3400, 0x4dbf], [0x4e00, 0x9fff], [0xa000, 0xa4cf], [0xa960, 0xa97f],
     [0xac00, 0xd7a3], [0xf900, 0xfaff], [0xfe10, 0xfe19], [0xfe30, 0xfe6f], [0xff00, 0xff60], [0xffe0, 0xffe6],
     [0x1f300, 0x1f64f], [0x1f900, 0x1f9ff], [0x20000, 0x2fffd], [0x30000, 0x3fffd],
 ];
-/** The columns one grapheme takes: 0 for a lone combining or format mark, 2 for wide and emoji, else 1. */
 export function graphemeWidth(cluster) {
     if (cluster === "")
         return 0;
@@ -27,14 +23,12 @@ export function graphemeWidth(cluster) {
     const point = cluster.codePointAt(0);
     return WIDE.some(([low, high]) => point >= low && point <= high) ? 2 : 1;
 }
-/** The columns a line of text takes on a terminal. */
 export function displayWidth(text) {
     let width = 0;
     for (const { segment } of graphemes.segment(text))
         width += graphemeWidth(segment);
     return width;
 }
-/** One line cut to fit `width` columns, ending in "…" when it was cut. */
 function fitRow(text, width) {
     if (displayWidth(text) <= width)
         return text;
@@ -49,7 +43,6 @@ function fitRow(text, width) {
     }
     return `${shown}…`;
 }
-/** Text wrapped to rows of at most `width` columns: at the last space where there is one, else mid-word. */
 export function wrapRows(text, width) {
     const rows = [];
     for (const line of text.split("\n")) {
@@ -59,7 +52,6 @@ export function wrapRows(text, width) {
         for (const { segment } of graphemes.segment(line)) {
             const next = graphemeWidth(segment);
             if (used + next > width && row.length > 0) {
-                // A space that doesn't fit ends the row there; it is not carried to the next one.
                 if (segment === " ") {
                     rows.push(row.join("").trimEnd());
                     row = [];
@@ -89,23 +81,15 @@ export function wrapRows(text, width) {
     }
     return rows;
 }
-/**
- * Start one turn's live block: the status line shows at once. `shape` is the final reply's shaping (the owner's
- * message and this app's origins), so a partial reads as the final will.
- */
 export function startTerminalLive(out, shape = {}, options = {}) {
     const reply = createLiveReply(shape);
-    /** The turn this block follows, once the engine has said it started. */
     let turn = null;
-    /** The rows on screen now, as drawn (without the dim styling); empty when nothing is. */
     let drawn = [];
     let ended = false;
     const columns = () => {
         const known = out.columns();
         return known !== undefined && Number.isFinite(known) && known > 0 ? Math.floor(known) : 80;
     };
-    /** Back to the block's first row and clear to the end of the screen. Rows are measured at the width now, as a
-     * terminal that reflows on resize has rewrapped them. */
     const eraseSequence = () => {
         if (drawn.length === 0)
             return "";
@@ -118,7 +102,6 @@ export function startTerminalLive(out, shape = {}, options = {}) {
         if (ended)
             return;
         if (options.standing !== undefined && !options.standing(turn)) {
-            // Standing lost: clear what is shown and close the preview; the turn's own outcome says why.
             ended = true;
             void sender.close();
             stopResize();
@@ -127,8 +110,6 @@ export function startTerminalLive(out, shape = {}, options = {}) {
                 out.write(erase);
             return;
         }
-        // Three columns short of the edge: a full row never leaves the cursor waiting to wrap, and the "^C" a terminal
-        // echoes after the last row on Ctrl-C never wraps it, so the erase's height stays right.
         const width = Math.max(10, columns() - 3);
         const view = reply.view();
         const status = view.phase === "working" || view.phase === "writing" ? view.status : reply.status();
@@ -152,7 +133,6 @@ export function startTerminalLive(out, shape = {}, options = {}) {
     return {
         progress(event) {
             turn ??= event.turn;
-            // Model text is made terminal-safe before it is settled and shaped, on the whole text written so far.
             if (reply.push(event.kind === "text" ? { ...event, text: terminalText(event.text) } : event))
                 sender.offer(null);
         },
@@ -169,7 +149,6 @@ export function startTerminalLive(out, shape = {}, options = {}) {
         },
     };
 }
-/** The real terminal: stdout, its resize events, and Ctrl-C (which still ends the process, after the block is gone). */
 export function processTerminal(env = process.env) {
     return {
         write: chunk => { process.stdout.write(chunk); },
@@ -194,7 +173,6 @@ export function processTerminal(env = process.env) {
         dim: env["NO_COLOR"] === undefined || env["NO_COLOR"] === "",
     };
 }
-/** A live block only on a real terminal that can move its cursor, and never for an agent driving the CLI. */
 export function liveTerminalWanted(json, env, tty, agent) {
     return !json && tty && env["TERM"] !== "dumb" && !agent();
 }

package/dist/lead-cli.js

@@ -3,14 +3,6 @@ import { currentLocalOwner } from "./local-owner.js";
 import { parseFeedbackImage } from "./result-review.js";
 import { configureLeadFollow, leadFollowStatus } from './lead-follow.js';
 import { closedQuestionWords } from "./decision.js";
-/**
- * `toolroll chat` (mate arc §6): the same thread the console shows,
- * driven from a terminal. The password is typed once — it mints the lead
- * session, the one ceremony a conversation gets — and every later turn
- * debits that session without asking again. Confirming a card runs the
- * same doors the console runs; password-class acts (approving a scope,
- * cancelling) print where to do them instead of doing them here.
- */
 import { createHash } from "node:crypto";
 import { readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
@@ -41,11 +33,6 @@ function keyFor(config, databaseFile, env) {
         return null;
     }
 }
-/**
- * What a terminal must show before an answer is confirmed (v3 review,
- * finding 4): the question, every option with its consequence, which one
- * the builder recommends, which one is proposed — the card's content.
- */
 export function answerContextLines(store, payload) {
     const id = typeof payload["decision"] === "number" ? payload["decision"] : null;
     const decision = id === null ? null : store.getDecision(id);
@@ -59,7 +46,6 @@ export function answerContextLines(store, payload) {
         ...decision.options.map(one => `     ${one.id === pick ? "→" : " "} ${one.label}${one.reversible ? "" : " (irreversible)"}${one.id === decision.recommendation ? " — the builder recommends this" : ""}: ${one.consequence}`),
     ];
 }
-/** One line per proposal, numbered in thread order, for the operator to name. */
 export function proposalLines(proposals, repos, ordinal = (_p) => 0) {
     return proposals.map((one, index) => {
         const number = ordinal(one) || index + 1;
@@ -103,7 +89,6 @@ export function proposalLines(proposals, repos, ordinal = (_p) => 0) {
         return `  ${number}. ${what}${state}`;
     });
 }
-/** The lines for one proposal, its answer context included when it is an answer. */
 export function proposalBlock(store, proposal, repos, number) {
     const [line] = proposalLines([proposal], repos, () => number);
     if (proposal.kind === "review") {
@@ -137,8 +122,6 @@ export async function runLeadCli(input) {
     const seams = input.seams ?? {};
     const clock = seams.clock ?? (() => new Date());
     const env = seams.env ?? process.env;
-    // Everything said to a person's terminal passes the terminal filter: replies, cards and asks carry model-written
-    // text, and only Toolroll's own renderer may move the cursor. (`--json` escapes control characters itself.)
     const say = (line) => {
         if (!json)
             write(terminalText(line));
@@ -187,8 +170,6 @@ export async function runLeadCli(input) {
     let session = store.activeLeadSession(who.name);
     const credentialKey = direct ? credentialKeyOf(directProvider, key) : subscriptionCredentialKey(subscriptionProvider);
     if (session !== null && session.credentialKey !== credentialKey) {
-        // A session minted under another provider key cannot be spent by this
-        // one (slice-2 review, finding 9): say so, never loop on `not-yours`.
         return refuse("key-mismatch", "The open conversation was started with a different provider key. Use that key, or end it with --end and start a new one.");
     }
     if (session !== null && session.ceilingDigest !== who.ceilingDigest) {
@@ -224,9 +205,6 @@ export async function runLeadCli(input) {
         emit({ ok: true, follow: leadFollowStatus(store, who.name) });
     }
     const pendingProposals = () => store.listLeadProposals(thread.id, ["pending"]);
-    // Ordinals are assigned once per proposal and never reused within this
-    // run (slice-2 review, finding 4): `confirm 2` means the card printed as
-    // 2, whatever the console did to its neighbours meanwhile.
     const ordinals = new Map();
     const ordinalOf = (proposal) => {
         const known = ordinals.get(proposal.id);
@@ -259,8 +237,6 @@ export async function runLeadCli(input) {
             const outcome = { ok: false, refused: "session-ended", message: "This conversation has ended. Run chat again to start a new one." };
             return outcome;
         }
-        // Before every draw: this approver as verified, this conversation and thread still open under the same projects,
-        // and the turn still running under the generation it was admitted with (as the engine's own guard re-proves).
         let admitted = null;
         const standing = (turnId) => {
             if (!reproveApprover(store, who).ok)
@@ -278,7 +254,6 @@ export async function runLeadCli(input) {
             admitted ??= row.generation;
             return row.generation === admitted;
         };
-        // The live block draws only on a real terminal; its last draw is erased before the answer or failure is printed.
         const watch = input.liveTerminal === undefined || json ? null : startTerminalLive(input.liveTerminal, { appOrigin: input.appOrigin ?? null, asked: message }, { standing });
         try {
             return await runLeadTurn({ store, who, session: live, thread, config, key, message, channel: "terminal", ...(watch === null ? {} : { onProgress: watch.progress }), ...(seams.fetcher === undefined ? {} : { fetcher: seams.fetcher }), ...(seams.subscriptionRunner === undefined ? {} : { subscriptionRunner: seams.subscriptionRunner }), ...(input.evidenceRoot === undefined ? {} : { evidenceRoot: input.evidenceRoot }), clock });
@@ -299,7 +274,6 @@ export async function runLeadCli(input) {
                 ...(ask === null ? {} : { ask: { question: ask.question, options: [...ask.options, LEAD_ASK_OTHER] } }) });
             say(`  ${outcome.activity}`);
             say(voiceReply(terminalText(outcome.reply), "terminal", { appOrigin: input.appOrigin ?? null, ...(message === undefined ? {} : { asked: message }) }));
-            // The lead's question: the terminal has no buttons, so the options are listed to type back.
             if (ask !== null)
                 say(`${ask.question}\n${ask.options.map(one => `  · ${one}`).join("\n")}\n  · ${LEAD_ASK_OTHER} (type your answer)`);
             printProposals();
@@ -313,7 +287,6 @@ export async function runLeadCli(input) {
         report(outcome, input.say);
         return { code: outcome.ok ? LEAD_CLI_EXIT.ok : LEAD_CLI_EXIT.refused };
     }
-    // The REPL. Text is a turn; a few words are acts on the cards.
     say("say something, or: proposals · confirm N · dismiss N · open N · end · quit");
     const openTask = (proposal) => {
         if (proposal.kind === "control" && isChatControl(proposal.payload["control"])) {

package/dist/lead-commitments.js

@@ -1,17 +1,13 @@
 import { assignmentOf } from './assignment.js';
 import { LEAD_SAY_KIND } from './lead-voice.js';
 import { leadNameOf } from './lead-identity.js';
-/** The table: `LEAD_COMMITMENT_SCHEMA` in store.ts (additive, no version bump). */
 export const COMMITMENT_DAYS = 7;
 const DAY_MS = 86_400_000;
-/** How long an unmet condition waits before it is looked at again. */
 const RECHECK_MS = 30_000;
 const PASS_LIMIT = 50;
 export const TASK_STATES = ['working', 'checking', 'needs-decision', 'ready-to-check', 'complete', 'cancelled'];
 export const RUN_OUTCOMES = ['finished', 'built', 'failed'];
 export const CHECK_RESULTS = ['passed', 'failed', 'either'];
-/** Where a promise was made, and so where it is reported: `chat` is the console or terminal conversation; a phone
- * or team chat also gets the line as the lead's own message, on that chat only. */
 export const COMMITMENT_CHANNELS = ['chat', 'telegram', 'slack', 'discord', 'teams'];
 const PROMISE_KEY = 'lead-promise:';
 const STATE_WORDS = { working: 'being worked on', checking: 'being checked', 'needs-decision': 'waiting for you',
@@ -29,7 +25,7 @@ function readCondition(text) {
         if (value?.kind === 'time' && typeof value.at === 'string' && STAMP.test(value.at))
             return value;
     }
-    catch { /* unreadable: the row stays visible and is never acted on */ }
+    catch { }
     return null;
 }
 function readCommitment(row) {
@@ -42,7 +38,6 @@ function readCommitment(row) {
         state: String(row['state']), createdAt: String(row['created_at']), checkedAt: text('checked_at'),
         closedAt: text('closed_at'), closedBy: text('closed_by'), outcome: text('outcome') };
 }
-/** The condition in a few words, for Settings and for the lead's own catch-up. */
 export function conditionWords(store, condition) {
     const title = (task) => `“${store.getTask(task)?.title ?? task}”`;
     if (condition.kind === 'task')
@@ -55,12 +50,10 @@ export function conditionWords(store, condition) {
     }
     return `at ${condition.at.slice(0, 16).replace('T', ' ')} UTC`;
 }
-/** The task an attempt belongs to, by title. */
 function attemptOf(store, run) {
     const task = store.refById(store.getRun(run)?.taskRef ?? -1)?.externalId;
     return task === undefined ? 'that attempt' : `“${store.getTask(task)?.title ?? task}”`;
 }
-/** Record a promise. The caller has already proved the task, attempt or project is within the owner's access. */
 export function recordCommitment(store, input, now) {
     const what = input.what.trim().replace(/\s+/g, ' ');
     if (what.length < 3 || what.length > 240)
@@ -87,34 +80,24 @@ export function getCommitment(store, id) {
     const row = store.handle.prepare('SELECT * FROM lead_commitment WHERE id = ?').get(id);
     return row === undefined ? null : readCommitment(row);
 }
-/** The reply that made a promise was shown: its turn is over, and it was answered or its text reached the conversation
- * before it failed. A turn still running has shown nothing yet, whatever it has written so far. */
 const SHOWN = (turn) => `EXISTS (SELECT 1 FROM mate_turn t WHERE t.id = ${turn} AND (t.state = 'answered'
   OR t.state = 'failed' AND EXISTS (SELECT 1 FROM lead_message m WHERE m.turn = t.id AND m.role = 'assistant')))`;
-/** A promise only counts once the reply that made it was shown: one from a reply still being written, or one that
- * failed without reaching the owner, was never heard. */
 const HEARD = `(c.turn IS NULL OR ${SHOWN('c.turn')})`;
-/** The owner's open promises that they heard, oldest first. */
 export function openCommitments(store, owner, limit = 20) {
     return store.handle.prepare(`SELECT c.* FROM lead_commitment c WHERE c.owner = ? AND c.state = 'open' AND ${HEARD} ORDER BY c.id LIMIT ?`).all(owner, limit)
         .map(readCommitment).filter((one) => one !== null);
 }
-/** The phone or team chat a lead message is for, when it is a met promise (`lead-promise:<channel>:<id>`); null for
- * every other notification, which goes wherever it always went. */
 export function promiseChannelOf(row) {
     return row.dedupeKey.startsWith(PROMISE_KEY) ? row.dedupeKey.slice(PROMISE_KEY.length).split(':')[0] ?? null : null;
 }
-/** Stop following up. Only the owner (from Settings or through their lead) cancels; a closed one stays as it was. */
 export function cancelCommitment(store, owner, id, by, reason, now) {
     const changed = store.handle.prepare("UPDATE lead_commitment SET state = 'cancelled', closed_at = ?, closed_by = ?, outcome = ? WHERE id = ? AND owner = ? AND state = 'open'")
         .run(now.toISOString(), by, reason.trim().slice(0, 240) || 'Cancelled.', id, owner);
     return Number(changed.changes) === 1;
 }
-/** The newest result run for a task, for a check condition's baseline. */
 export function latestResultRun(store, task, repos, now) {
     return assignmentOf(store, task, now, { principal: 'operator', repos })?.receipt?.runId ?? 0;
 }
-/** What was observed when the condition is met, in one sentence; null while it is not. */
 function observe(store, one, now, root) {
     const c = one.condition, repos = one.repo === null ? [] : [one.repo];
     const title = (task) => `“${store.getTask(task)?.title ?? task}”`;
@@ -146,20 +129,14 @@ function observe(store, one, now, root) {
         return null;
     return `The checks on ${attemptOf(store, c.run)} ${check.status}.`;
 }
-/** The promise as the end of "I said I would …": "I'll tell you when…" and "Tell you when…" both read "tell you when…". */
 function promised(what) {
     const bare = what.replace(/^I(?:'ll| will)\s+/i, '').replace(/[.!]+$/, '');
     return /^[A-Z][a-z]/.test(bare) ? bare.charAt(0).toLowerCase() + bare.slice(1) : bare;
 }
-/** One deterministic pass over due promises (no model): expire, drop what can no longer be delivered or seen,
- * and report a met condition once — the state change and the message share one transaction. Returns how many reported. */
 export function checkLeadCommitments(store, now, root) {
     const at = now.toISOString();
     let reported = 0;
     store.handle.prepare("UPDATE lead_commitment SET state = 'expired', closed_at = ?, outcome = 'Expired after 7 days without the condition being met.' WHERE state = 'open' AND expires_at <= ?").run(at, at);
-    // A promise made in a reply that was not delivered (it failed before any text was shown, or its turn is gone) was
-    // never heard: drop it now, whenever it was next due, so nothing waits on it. An interrupted reply whose text was
-    // shown keeps its promises.
     store.handle.prepare(`UPDATE lead_commitment SET state = 'cancelled', closed_at = ?, closed_by = 'lead', outcome = 'The reply that made this promise was not delivered.'
     WHERE state = 'open' AND turn IS NOT NULL AND NOT EXISTS (SELECT 1 FROM mate_turn t WHERE t.id = lead_commitment.turn AND t.state IN ('queued', 'running'))
       AND NOT ${SHOWN('lead_commitment.turn')}`).run(at);
@@ -172,7 +149,6 @@ export function checkLeadCommitments(store, now, root) {
             close('cancelled', 'Its condition could not be read.');
             continue;
         }
-        // A reply still being written may yet be delivered; one that was not is dropped above.
         const turn = one.turn === null ? null : store.getLeadTurn(one.turn);
         if (turn !== null && (turn.state === 'queued' || turn.state === 'running'))
             continue;
@@ -201,8 +177,6 @@ export function checkLeadCommitments(store, now, root) {
         store.transact(() => {
             if (!close('done', seen))
                 return;
-            // The shared conversation always keeps the line; a promise made on a phone or team chat is also said there, as
-            // the lead's own message to its owner, on that chat alone (the usual delivery receipts apply).
             store.appendLeadMessage({ thread: one.thread, turn: null, role: 'assistant', text: line }, now);
             if (one.channel !== 'chat')
                 store.enqueueNotification({ dedupeKey: `${PROMISE_KEY}${one.channel}:${one.id}`, kind: LEAD_SAY_KIND, subject: leadNameOf(store, one.owner),