toolroll 0.9.104 → 0.9.105

package/dist/memory-tidy.js

@@ -1,19 +1,3 @@
-/**
- * Tidying project memory (docs/plans/learning-loops.md, "Tidy-up pass"): proposals to retire, merge or settle entries,
- * with explicit restore. Proposes; never changes. Nothing happens until a person accepts, and every accept re-reads every
- * affected item in one transaction: any difference and the proposal goes stale.
- *
- * - The scheduled pass (a quiet project, at most weekly, 10 entries or more) is deterministic: it takes no analyzer.
- *   A model is asked for contradictions only on a person's request (`proposeTidy` with an analyzer, D4).
- * - The successor chain of a decision is every decision reachable through ordinary supersession and not-undone merges,
- *   and its active tail the active ones in it. Restoring past an active tail, or undoing a merge built on, is refused
- *   until a person reviews the expanded change: a proposal that names every affected item and says what happens to the
- *   tail. Accepting compare-and-sets each one.
- * - Contradictions and a note that keeps failing have no default: a person's choice is required.
- *
- * The only writer of `memory_tidy_proposal` and `decision_merge`. Decisions change only through project-memory.ts, which
- * keeps their revisions and history. A policy path (release-auto.ts EVAL_POLICY). The lead has no tool for any of this.
- */
 import { createHash } from "node:crypto";
 import { lessonNoteOf, noteAfterwards, watchNote } from "./lesson-notes.js";
 import { currentLocalOwner } from "./local-owner.js";
@@ -27,7 +11,6 @@ const DAY_MS = 86_400_000;
 export const UNUSED_DAYS = 60, UNUSED_RUNS = 20, FAILING_NOTE = 3, TIDY_MIN_ENTRIES = 10;
 export const TIDY_EVERY_MS = 7 * DAY_MS, TIDY_QUIET_MS = DAY_MS;
 const MAX_MODEL_PAIRS = 5;
-/** What a stale proposal says. */
 export const TIDY_STALE = "Changed since proposed. Run Clean up again.";
 const sha = (text) => createHash("sha256").update(text).digest("hex");
 function proposalOf(store, row) {
@@ -45,7 +28,6 @@ function proposalOf(store, row) {
 export function listTidy(store, repo, status = "pending") {
     return store.handle.prepare("SELECT * FROM memory_tidy_proposal WHERE repo = ? AND (? = 'all' OR status = ?) ORDER BY id DESC LIMIT 100").all(repo, status, status).map(row => proposalOf(store, row));
 }
-// ---- current items -------------------------------------------------------------------------------------------------
 function decisionItem(store, repo, id) {
     const row = store.handle.prepare("SELECT revision, status, sha FROM project_decision WHERE id = ? AND repo = ?").get(id, repo);
     return row === undefined ? null : { kind: "decision", id, revision: Number(row["revision"]), status: String(row["status"]), sha: String(row["sha"]) };
@@ -66,7 +48,6 @@ function lessonItem(store, repo, id) {
     const row = store.handle.prepare("SELECT version, sha FROM project_lesson WHERE id = ? AND repo = ?").get(id, repo);
     return row === undefined ? null : { kind: "lesson", id, version: Number(row["version"]), sha: String(row["sha"]) };
 }
-/** Whether an item reads now exactly as it was bound. */
 function itemStands(store, repo, item) {
     if (item.kind === "decision") {
         const now = decisionItem(store, repo, item.id);
@@ -80,17 +61,14 @@ function itemStands(store, repo, item) {
     return ref !== undefined && saved.revision === item.revision && referenceSha(ref) === item.sha;
 }
 const itemKey = (item) => `${item.kind}:${item.id}`;
-// ---- finding -------------------------------------------------------------------------------------------------------
 const normal = (text) => text.toLowerCase().replace(/[^\p{L}\p{N}]+/gu, " ").trim();
 const dayWords = (iso) => iso.slice(0, 10);
-/** Everything the deterministic pass would propose now. Reads only. */
 function deterministicDrafts(store, repo, now) {
     const drafts = [];
     const cutoff = new Date(now.getTime() - UNUSED_DAYS * DAY_MS).toISOString();
     const use = memoryUseOf(store, repo);
     const runs = Number(store.handle.prepare("SELECT COUNT(DISTINCT run) AS n FROM memory_use WHERE repo = ? AND included_at >= ?").get(repo, cutoff)?.["n"] ?? 0);
     const active = store.handle.prepare("SELECT id, claim, decided_at, source_ref FROM project_decision WHERE repo = ? AND status = 'active' ORDER BY id").all(repo);
-    /** Unused: a time older than the window, or never given to a run and older than the window. A row with no time is unknown, so no proposal. */
     const unused = (key, since) => {
         const one = use.get(key);
         if (one === undefined)
@@ -138,7 +116,6 @@ function deterministicDrafts(store, repo, now) {
     }
     return drafts;
 }
-/** Save drafts that aren't waiting already and weren't rejected in this same state. */
 function saveDrafts(store, repo, drafts, now) {
     return store.transact(() => {
         const seen = store.handle.prepare("SELECT kind, status, items_json FROM memory_tidy_proposal WHERE repo = ? AND status IN ('pending','rejected')").all(repo);
@@ -159,10 +136,6 @@ function saveDrafts(store, repo, drafts, now) {
         return made;
     });
 }
-/**
- * The scheduled pass: deterministic, no analyzer in reach. Runs when the project has been quiet for a day, at most
- * weekly, with at least 10 entries. Proposes only.
- */
 export function scheduledTidy(store, repo, now) {
     const key = `memory-tidy:${sha(repo).slice(0, 32)}`;
     if (now.getTime() - store.serviceCursor(key) < TIDY_EVERY_MS)
@@ -179,7 +152,6 @@ export function scheduledTidy(store, repo, now) {
 }
 export const CONTRADICTION_SCHEMA = { type: "object", additionalProperties: false, required: ["contradictions"], properties: { contradictions: { type: "array", items: { type: "object", additionalProperties: false, required: ["a", "b", "why"], properties: { a: { type: "integer" }, b: { type: "integer" }, why: { type: "string" } } } } } };
 const CONTRADICTION_PROMPT = `You read a project's settled decisions. Find pairs that can't both hold. Say nothing about style or overlap. Refer to decisions only by id. Return one JSON object and nothing else, matching this JSON Schema: ${JSON.stringify(CONTRADICTION_SCHEMA)}`;
-/** Read a model's pairs: ids of active decisions only, a clean reason, each pair once. Everything else is dropped. */
 export function parseContradictions(text, active) {
     const start = text.indexOf("{"), end = text.lastIndexOf("}");
     if (start < 0 || end <= start)
@@ -199,7 +171,6 @@ export function parseContradictions(text, active) {
         const { a, b, why } = (one ?? {});
         if (typeof a !== "number" || typeof b !== "number" || a === b || !known.has(a) || !known.has(b) || typeof why !== "string")
             continue;
-        // eslint-disable-next-line no-control-regex
         const reason = why.replace(/[\u0000-\u001f\u007f]+/g, " ").trim().slice(0, 300);
         const key = [a, b].sort((x, y) => x - y).join(",");
         if (reason === "" || scanForSecrets(reason).length > 0 || seen.has(key))
@@ -211,7 +182,6 @@ export function parseContradictions(text, active) {
     }
     return pairs;
 }
-/** Clean up, on a person's request: the deterministic pass with no quiet gate, and contradictions when an analyzer is given. */
 export async function proposeTidy(store, args, now) {
     refuseLeadMemoryWrite();
     if (!store.accountCanAccess(args.actor, args.repo) || store.accountOf(args.actor)?.role !== "approver")
@@ -233,8 +203,6 @@ export async function proposeTidy(store, args, now) {
     }
     return { made: saveDrafts(store, args.repo, drafts, now), problem };
 }
-// ---- chains --------------------------------------------------------------------------------------------------------
-/** Every decision reachable from `id` through ordinary supersession and not-undone merges, transitively (never `id`). */
 export function successorChain(store, repo, id) {
     const seen = new Set([id]), order = [], queue = [id];
     while (queue.length > 0) {
@@ -251,13 +219,9 @@ export function successorChain(store, repo, id) {
     return order;
 }
 const statusOf = (store, repo, id) => { const item = decisionItem(store, repo, id); return item === null || item.kind !== "decision" ? null : item.status; };
-/** The active decisions in `id`'s chain. */
 export function activeTail(store, repo, id) {
     return successorChain(store, repo, id).filter(one => statusOf(store, repo, one) === "active");
 }
-// ---- who, and the writes -------------------------------------------------------------------------------------------
-/** A person who may change this project's memory, re-read inside the write. Lead and remote refused; revoked or lost
- * access refused; the laptop's local owner only in its own act; the proof must be a person's. */
 function proveMemoryPerson(store, repo, actor, proof) {
     refuseLeadMemoryWrite();
     if (!store.accountCanAccess(actor, repo) || store.accountOf(actor)?.role !== "approver")
@@ -276,7 +240,6 @@ const needDecision = (store, repo, actor, id) => {
         throw Error("That decision is unavailable.");
     return found;
 };
-/** Back to active: its note, if it had one, is tracked again. */
 function bringBack(store, repo, actor, id, action, reason, now) {
     const back = reactivateDecision(store, repo, actor, id, action, reason, now);
     const note = /^lesson-note:(\d+)$/.exec(back.sourceRef ?? "");
@@ -286,7 +249,6 @@ function bringBack(store, repo, actor, id, action, reason, now) {
             watchNote(store, { repo, proposal: facts.proposal, identities: facts.identities, decisionRevision: back.revision, now });
     }
 }
-/** One new decision from several; each old one superseded with a "merged into" history row; every member listed. */
 export function mergeDecisions(store, args, now) {
     if (new Set(args.ids).size < 2)
         throw Error("Choose at least two decisions to merge.");
@@ -305,10 +267,6 @@ export function mergeDecisions(store, args, now) {
         return made;
     });
 }
-/**
- * Restore a retired or superseded decision. With no active tail it goes straight back to active. With one, nothing
- * changes: a proposal names every affected item, and a person chooses what happens to the tail.
- */
 export function restoreDecision(store, args, now) {
     return store.transact(() => {
         proveMemoryPerson(store, args.repo, args.actor, args.proof);
@@ -340,11 +298,6 @@ function finishUnmerge(store, repo, actor, rows, now) {
             bringBack(store, repo, actor, row.predecessor, "unmerged", `Unmerged from decision ${successor}.`, now);
     store.handle.prepare("UPDATE decision_merge SET undone_at = ?, undone_by = ? WHERE merge = ? AND undone_at IS NULL").run(now.toISOString(), actor, rows[0].merge);
 }
-/**
- * Undo a merge. Direct only while its successor is active, at the revision recorded at the merge, and not merged on.
- * Otherwise nothing changes: a proposal names every affected item, the later merge included. A merge already undone is
- * refused and changes nothing.
- */
 export function unmergeDecisions(store, args, now) {
     return store.transact(() => {
         proveMemoryPerson(store, args.repo, args.actor, args.proof);
@@ -372,7 +325,6 @@ export function unmergeDecisions(store, args, now) {
         return { restored: false, proposal: Number(inserted.lastInsertRowid), items };
     });
 }
-/** A disabled lesson back in use (re-checks its support, bound to its version and sha). */
 export function restoreLesson(store, root, args, now) {
     store.transact(() => {
         proveMemoryPerson(store, args.repo, args.actor, args.proof);
@@ -383,7 +335,6 @@ export function restoreLesson(store, root, args, now) {
         changeLearning(store, root, { repo: args.repo, actor: args.actor, identity: learningIdentity(args.repo), revision: Number(policy?.["revision"] ?? 0), action: "readopt", lesson: args.id, version: item.version, sha: item.sha }, now);
     });
 }
-/** A reference back from history, as a new knowledge revision bound to the current one. */
 export function restoreReference(store, args, now) {
     store.transact(() => {
         proveMemoryPerson(store, args.repo, args.actor, args.proof);
@@ -467,10 +418,6 @@ function applyTidy(store, root, proposal, args, proof, now) {
         }
     }
 }
-/**
- * Accept or reject one proposal: the one writer of a proposal's outcome. In one transaction, a person's standing, the
- * proposal's state and every bound item are re-read; any difference marks it stale and changes nothing.
- */
 export function decideTidy(store, root, args, now) {
     refuseLeadMemoryWrite();
     const outcome = store.transact(() => {
@@ -499,7 +446,6 @@ export function decideTidy(store, root, args, now) {
         throw Error(TIDY_STALE);
     return outcome;
 }
-/** Merges that can still be undone, for the page. */
 export function undoableMerges(store, repo) {
     const rows = store.handle.prepare("SELECT m.merge, m.successor, m.predecessor FROM decision_merge m JOIN project_decision d ON d.id = m.successor WHERE d.repo = ? AND m.undone_at IS NULL ORDER BY m.merge DESC LIMIT 200").all(repo);
     const merges = new Map();
@@ -510,7 +456,6 @@ export function undoableMerges(store, repo) {
     }
     return [...merges.values()];
 }
-/** Lessons that were disabled and can be used again, for the page. */
 export function disabledLessons(store, repo) {
     return store.handle.prepare("SELECT id, payload FROM project_lesson WHERE repo = ? AND status = 'disabled' ORDER BY id DESC LIMIT 50").all(repo).flatMap(row => {
         try {

package/dist/memory-use.js

@@ -1,24 +1,11 @@
-/**
- * "Last included in a run" (docs/plans/learning-loops.md): one `memory_use` row per lesson, reference and decision in a
- * run's frozen context, written in the transaction that freezes it. The only writer of `memory_use`; release-auto's
- * learning scan (eval-hooks.ts learningWriteProblem) needs a person for any other. A policy path (release-auto.ts
- * EVAL_POLICY).
- *
- * Usage, never benefit: nothing here says a run did better for having an item, and nothing reads it for authority. Old
- * snapshots are backfilled from their own sha-verified bytes and nothing is inferred: a knowledge snapshot from before
- * `capturedAt` has no time and no version, so its rows say so. Lead chat contexts aren't snapshotted and aren't counted.
- */
 import { createHash } from "node:crypto";
 import { readKnowledgeSelection } from "./contracts/project-knowledge.js";
 const sha = (text) => createHash("sha256").update(text).digest("hex");
-/** A run's role as a phase of the work. */
 export const phaseOfRole = (role) => role === "planner" ? "plan" : role === "reviewer" ? "review" : "build";
 function insertUse(store, row) {
     store.handle.prepare(`INSERT INTO memory_use (run, repo, kind, item, version, phase, included_at) VALUES (?, ?, ?, ?, ?, ?, ?) ON CONFLICT (run, kind, item) DO NOTHING`)
         .run(row.run, row.repo, row.kind, row.item, row.version, row.phase, row.at);
 }
-/** Every reference and decision in a run's frozen knowledge. Called in the transaction that freezes it; advisory, so a
- * failure leaves the run's context exactly as it was. */
 export function recordKnowledgeUse(store, input) {
     const { selection } = input, phase = phaseOfRole(input.role), at = selection.capturedAt ?? null;
     try {
@@ -29,9 +16,8 @@ export function recordKnowledgeUse(store, input) {
                 insertUse(store, { run: input.run, repo: input.repo, kind: "decision", item: String(one.id), version: one.revision ?? null, phase, at });
         });
     }
-    catch { /* advisory: the run's context is unchanged */ }
+    catch { }
 }
-/** The lessons in a run's frozen learning payload (its last line is the record). */
 function lessonsOf(payload) {
     try {
         const record = JSON.parse(payload.trim().split("\n").at(-1));
@@ -44,7 +30,6 @@ function lessonsOf(payload) {
         return null;
     }
 }
-/** Every lesson in a run's frozen learning context. As recordKnowledgeUse. */
 export function recordLessonUse(store, input) {
     const read = lessonsOf(input.payload);
     if (read === null)
@@ -53,14 +38,9 @@ export function recordLessonUse(store, input) {
         store.savepoint(() => { for (const one of read.lessons)
             insertUse(store, { run: input.run, repo: input.repo, kind: "lesson", item: String(one.id), version: one.version, phase: read.phase, at: input.at }); });
     }
-    catch { /* advisory: the run's context is unchanged */ }
+    catch { }
 }
 const CURSOR_LESSONS = "memory-use:backfill-lessons", CURSOR_KNOWLEDGE = "memory-use:backfill-knowledge";
-/**
- * Backfill from snapshots older than this feature, a bounded batch at a time (the watch loop's learning pass): each
- * snapshot's sha is verified first. Lesson rows take the snapshot's own time and version; knowledge rows from a snapshot
- * with no `capturedAt` have no version and no time. Returns how many snapshots were read.
- */
 export function backfillMemoryUse(store, now, limit = 200) {
     const lessonFrom = store.serviceCursor(CURSOR_LESSONS), knowledgeFrom = store.serviceCursor(CURSOR_KNOWLEDGE);
     const lessons = store.handle.prepare("SELECT run, repo, payload, sha, created_at FROM learning_snapshot WHERE run > ? ORDER BY run LIMIT ?").all(lessonFrom, limit);
@@ -93,14 +73,12 @@ export function backfillMemoryUse(store, now, limit = 200) {
     });
     return lessons.length + knowledge.length;
 }
-/** A project's usage, by `<kind>:<item>`: its newest run, that run's time and how many runs had it. */
 export function memoryUseOf(store, repo) {
     const rows = store.handle.prepare(`SELECT u.kind, u.item, u.run AS last_run, u.included_at, t.runs FROM memory_use u
     JOIN (SELECT kind, item, MAX(run) AS last_run, COUNT(*) AS runs FROM memory_use WHERE repo = ? GROUP BY kind, item) t ON t.kind = u.kind AND t.item = u.item AND t.last_run = u.run WHERE u.repo = ?`).all(repo, repo);
     return new Map(rows.map(row => [`${String(row["kind"])}:${String(row["item"])}`, { lastRun: Number(row["last_run"]), lastAt: row["included_at"] == null ? null : String(row["included_at"]), runs: Number(row["runs"]) }]));
 }
 const DAY = new Intl.DateTimeFormat("en-US", { month: "short", day: "numeric", timeZone: "UTC" });
-/** "Last included in a run: #4410, Nov 3 · 41 runs"; "#2210 (time not recorded)" for a backfilled row; "Not included yet". */
 export function lastIncludedWords(use) {
     if (use === undefined)
         return "Not included yet";

package/dist/merge-checklist.js

@@ -1,18 +1,12 @@
-/** "Can I merge?" (docs/plans/plain-toolroll.md P1.6): one checklist per task, read from the records the task page,
- * the result page and the pull request row already read, with nothing recomputed and nothing checked live. Each row
- * says one fact about the task's current result; a blocker carries one existing act the person can take: Run checks,
- * Retry, or Ask the agent to fix (Send back with a note naming the blocker). Nothing here acts: it is a read, and every
- * act it names is the person's own post through its usual door.
- *
- * Rows Toolroll keeps no record of (up to date with main; conflicts outside a batch check) say so, rather than guess:
- * GitHub shows them on the pull request. */
 import { assignmentOf } from "./assignment.js";
 import { pullRequestFollowOf, pullRequestViewOf, publishingOf } from "./pull-request-flow.js";
 import { releaseCiHoldOf, releaseCiRunningOf } from "./release-ci-hold.js";
 import { isRevisionFeedback } from "./result-review.js";
 import { approvalOf, deployGateScope } from "./scope.js";
 import { shipChecksForTask } from "./store.js";
-import { approvedCheckStateOf } from "./task-status.js";
+import { approvedCheckStateOf, requirementWordOf } from "./task-status.js";
+import { projectCheckSet } from "./check-levels.js";
+import { projectName } from "./project.js";
 export const CHECKLIST_KEYS = ["plan", "build", "checks", "requirements", "pull-request", "pr-ci", "up-to-date", "conflicts", "comments", "release"];
 export const CHECKLIST_LABELS = {
     plan: "Plan approved",
@@ -26,19 +20,17 @@ export const CHECKLIST_LABELS = {
     comments: "Review comments answered",
     release: "Release check passed",
 };
-/** The one sentence for a row Toolroll keeps no record of. */
 export const NOT_RECORDED = "Toolroll doesn't record this. The pull request on GitHub shows it.";
-/** The act labels, the same words the result page uses. */
+export const NOT_RECORDED_LOCAL = "Toolroll doesn't record this. Your repository shows it.";
 export const CHECKLIST_ACT_LABELS = { "run-checks": "Run checks", retry: "Retry", fix: "Ask the agent to fix" };
 const short = (sha) => sha == null ? "this commit" : sha.slice(0, 7);
-/** The checklist for a task's current result, as `access` may see it; null when the task isn't visible there. */
+export const noCheckSetWords = (repo) => `No check is set for ${projectName(repo)}. Set one in Settings → Projects → ${projectName(repo)} → Checks.`;
 export function mergeChecklistOf(store, taskId, now, access, root) {
     const assignment = assignmentOf(store, taskId, now, access, root);
     if (assignment === null)
         return null;
     return checklistFromAssignment(store, taskId, assignment);
 }
-/** The checklist from an assignment snapshot already read (the task page reads one). */
 export function checklistFromAssignment(store, taskId, assignment) {
     const active = assignment.activeTaskId;
     const scope = store.getScope(active);
@@ -48,14 +40,12 @@ export function checklistFromAssignment(store, taskId, assignment) {
     const head = receipt?.head ?? null;
     const rows = [];
     const row = (key, mark, say, act = null) => rows.push({ key, label: CHECKLIST_LABELS[key], mark, say, act });
-    // Plan approved: the approval as dispatch reads it.
     if (scope === null)
         row("plan", "no", "There's no plan yet.");
     else if (approvalOf(scope).approved)
         row("plan", "yes", scope.approvedBy == null ? "Approved." : `Approved by ${scope.approvedBy}.`);
     else
         row("plan", "no", "The plan waits for your approval.");
-    // Build finished: a result is recorded; a failed task retries.
     if (task?.state === "failed")
         row("build", "no", "The last build failed.", { kind: "retry", taskId: active });
     else if (receipt !== null)
@@ -64,7 +54,6 @@ export function checklistFromAssignment(store, taskId, assignment) {
         row("build", "waiting", "Building now.");
     else
         row("build", "waiting", "Nothing is built yet.");
-    // Project checks on this commit: the approved check as the Checks row reads it.
     const check = receipt === null ? null : approvedCheckStateOf(receipt.checks);
     if (receipt === null || check === null)
         row("checks", "waiting", "Waits for a build.");
@@ -76,9 +65,11 @@ export function checklistFromAssignment(store, taskId, assignment) {
         row("checks", "waiting", "Running now.");
     else if (check === "off")
         row("checks", "waiting", "Checks are off for this project; they run at release.");
+    else if (check === "not-run" && assignment.repo !== null && !projectCheckSet(store, assignment.repo)) {
+        row("checks", "no", noCheckSetWords(assignment.repo));
+    }
     else
         row("checks", "no", check === "unreadable" ? "The check result couldn't be read." : "No check ran on this commit.", { kind: "run-checks", run: receipt.runId });
-    // Requirements: the result's own blockers, as Accept reads them.
     const criteria = assignment.readiness?.blockers.filter(one => one.key === "criteria" || one.key === "high") ?? [];
     if (receipt === null)
         row("requirements", "waiting", "Waits for a build.");
@@ -86,9 +77,14 @@ export function checklistFromAssignment(store, taskId, assignment) {
         row("requirements", "no", criteria[0].message, { kind: "fix", run: receipt.runId, note: criteria.map(one => one.message).join("\n") });
     else if (assignment.readiness?.verdict === "refuted")
         row("requirements", "no", "The result doesn't match its plan.", { kind: "fix", run: receipt.runId, note: "The result doesn't match its plan. Fix it so it does." });
-    else
-        row("requirements", "yes", "Every requirement is met.");
-    // The pull request and its CI, as the task's pull request row reads them.
+    else {
+        const yours = receipt.proofAcceptance !== null ? 0
+            : (receipt.proof?.matrix ?? []).filter(one => requirementWordOf(one, receipt.proof?.verdict ?? null) === "You check").length;
+        if (yours > 0)
+            row("requirements", "waiting", `You check ${yours} requirement${yours === 1 ? "" : "s"}.`);
+        else
+            row("requirements", "yes", "Every requirement is met.");
+    }
     const view = run === null ? null : pullRequestViewOf(store, run);
     const publishing = publishingOf(store, assignment.repo);
     let merged = false;
@@ -123,7 +119,6 @@ export function checklistFromAssignment(store, taskId, assignment) {
         else if (view.state === "failing") {
             const failing = ship?.checks.filter(one => one.state === "failed").map(one => one.workflow === null ? one.name : `${one.workflow} / ${one.name}`) ?? [];
             const said = `Failed on ${short(publication?.headSha)}${failing.length === 0 ? "" : `: ${failing.slice(0, 3).join(", ")}${failing.length > 3 ? ", …" : ""}`}.`;
-            // A revision Toolroll already filed with the failure is the fix under way: no second one from here.
             if (view.revisionTask !== null)
                 row("pr-ci", "no", `${said} Revision ${view.revisionTask} was filed with the failure.`);
             else
@@ -136,15 +131,14 @@ export function checklistFromAssignment(store, taskId, assignment) {
         else
             row("pr-ci", view.state === "failed" || view.state === "closed" ? "skip" : "waiting", view.state === "failed" || view.state === "closed" ? "No open pull request." : "No CI has reported yet.");
     }
-    // Up to date with main and conflicts: Toolroll keeps no record of either, except a batch check's conflict.
-    row("up-to-date", merged ? "yes" : "unknown", merged ? "Merged." : NOT_RECORDED);
+    const notRecorded = publishing.on ? NOT_RECORDED : NOT_RECORDED_LOCAL;
+    row("up-to-date", merged ? "yes" : "unknown", merged ? "Merged." : notRecorded);
     if (merged)
         row("conflicts", "yes", "Merged.");
     else if (receipt?.checks.batch?.state === "conflict")
         row("conflicts", "no", "It conflicted with another result in its batch check.", { kind: "fix", run: receipt.runId, note: "It conflicts with another change. Rebase it on main and resolve the conflict." });
     else
-        row("conflicts", "unknown", NOT_RECORDED);
-    // Review comments: the saved notes and pull request review comments not yet sent back.
+        row("conflicts", "unknown", notRecorded);
     const notes = run === null ? [] : store.liveDiffComments(run).filter(one => isRevisionFeedback(one));
     if (run === null)
         row("comments", "waiting", "Waits for a build.");
@@ -152,7 +146,6 @@ export function checklistFromAssignment(store, taskId, assignment) {
         row("comments", "yes", "None open.");
     else
         row("comments", "no", `${notes.length} note${notes.length === 1 ? "" : "s"} not sent back yet.`, { kind: "fix", run, note: "" });
-    // A release: its own check, as the release card reads it.
     if (scope !== null && deployGateScope(scope)) {
         if (releaseCiHoldOf(store, active) !== null || releaseCiRunningOf(store, active) !== null)
             row("release", "waiting", "GitHub's checks are still running.");
@@ -171,12 +164,11 @@ export function checklistFromAssignment(store, taskId, assignment) {
     const sentence = answer === "merged" ? "Already merged."
         : answer === "no" ? `Not yet: ${first.label.toLowerCase()} — ${first.say}`
             : answer === "not-yet" ? `Not yet: ${rows.find(one => one.mark === "waiting").label.toLowerCase()} — ${rows.find(one => one.mark === "waiting").say}`
-                : `Yes, as far as Toolroll records.${unknown.length === 0 ? "" : ` Check ${unknown.join(" and ")} on GitHub.`}`;
+                : `Yes, as far as Toolroll records.${unknown.length === 0 ? "" : ` Check ${unknown.join(" and ")} ${publishing.on ? "on GitHub" : "in your repository"}.`}`;
     return { taskId, activeTaskId: active, run, head, answer, sentence, rows };
 }
-/** The checklist as plain lines (the CLI, the lead, the TUI): the answer, then one line per row that applies. */
 export function checklistLines(list) {
     const MARK = { yes: "✓", no: "✗", waiting: "…", unknown: "?", skip: "–" };
     return [`Can I merge ${list.activeTaskId}? ${list.sentence}`,
-        ...list.rows.filter(one => one.mark !== "skip").map(one => `  ${MARK[one.mark]} ${one.label}: ${one.say}${one.act === null ? "" : ` [${CHECKLIST_ACT_LABELS[one.act.kind]}]`}`)];
+        ...list.rows.filter(one => one.mark !== "skip").map(one => `  ${MARK[one.mark]} ${one.label}: ${one.say}${one.act === null ? "" : ` Next: ${CHECKLIST_ACT_LABELS[one.act.kind]}, on the task's page.`}`)];
 }

package/dist/metrics.js

@@ -1,9 +1,3 @@
-/**
- * `/metrics` (v104): Toolroll in the Prometheus text format, for the
- * dashboards and alerts a company already runs. Labels are small, fixed
- * sets (state, role, outcome, provider, project, destination), never a task
- * id, a person or a path, so a scrape stays cheap and says nothing private.
- */
 import { createHash } from "node:crypto";
 import { basename } from "node:path";
 import { LATENCY_BUCKETS, QUEUE_BUCKETS, STREAM_FAMILIES } from "./server-telemetry.js";
@@ -12,7 +6,6 @@ const line = (name, sample) => {
     const labels = Object.entries(sample.labels ?? {});
     return `${name}${labels.length === 0 ? "" : `{${labels.map(([key, value]) => `${key}="${label(value)}"`).join(",")}}`} ${Number.isFinite(sample.value) ? sample.value : 0}`;
 };
-/** `repos`: the projects this console serves (null: all); task, run and worker figures count only theirs. */
 export function prometheusMetrics(store, now, repos = null, destinations) {
     const db = store.handle;
     const inProjects = (column) => repos === null ? "1 = 1" : repos.length === 0 ? "1 = 0" : `${column} IN (${repos.map(() => "?").join(",")})`;
@@ -20,7 +13,6 @@ export function prometheusMetrics(store, now, repos = null, destinations) {
     const rows = (sql, ...args) => db.prepare(sql).all(...args);
     const metrics = [];
     const add = (name, help, type, samples) => metrics.push({ name, help, type, samples });
-    // A project's label is its folder name, told apart by a short digest when two share one.
     const names = new Map();
     for (const repo of rows(`SELECT DISTINCT repo FROM watch_lease WHERE ${inProjects("repo")}`, ...scoped).map(row => String(row["repo"])))
         names.set(basename(repo), (names.get(basename(repo)) ?? 0) + 1);
@@ -46,7 +38,6 @@ export function prometheusMetrics(store, now, repos = null, destinations) {
     add("toolroll_ledger_chain_ok", "1 when the action ledger's chain verifies, 0 when it's broken.", "gauge", [{ value: chain.ok ? 1 : 0 }]);
     add("toolroll_ledger_checked_timestamp_seconds", "When the whole chain was last walked.", "gauge", chain.checkedAt === null ? [] : [{ value: Math.floor(Date.parse(chain.checkedAt) / 1000) }]);
     const head = store.ledgerHeadId();
-    // Only destinations set up now, each for its current address (`destinations`: sink → target; all when not given).
     const status = store.monitoringStatus().filter(one => destinations === undefined || destinations.get(one.sink) === one.target);
     add("toolroll_monitoring_lag_entries", "Ledger entries a monitoring destination hasn't been sent yet.", "gauge", status.map(one => ({ labels: { destination: one.sink }, value: Math.max(0, head - one.through) })));
     add("toolroll_monitoring_failures", "Failed deliveries in a row, by destination.", "gauge", status.map(one => ({ labels: { destination: one.sink }, value: one.failures })));
@@ -55,7 +46,6 @@ export function prometheusMetrics(store, now, repos = null, destinations) {
     add("toolroll_checkouts", "Build checkouts on disk, by state.", "gauge", rows(`SELECT CASE WHEN runner IS NOT NULL AND released_at IS NULL THEN 'leased' ELSE 'released' END AS state, COUNT(*) AS n FROM worktree WHERE ${inProjects("repo")} GROUP BY 1`, ...scoped).map(row => ({ labels: { state: String(row["state"]) }, value: Number(row["n"]) })));
     return `${metrics.map(metric => [`# HELP ${metric.name} ${metric.help}`, `# TYPE ${metric.name} ${metric.type}`, ...metric.samples.map(sample => line(metric.name, sample))].join("\n")).join("\n")}\n${performanceMetrics(store.telemetry)}`;
 }
-/** Performance labels are fixed vocabularies only, independent of the store's project labels. */
 export function performanceMetrics(telemetry) {
     const out = [];
     const header = (name, help, type) => out.push(`# HELP ${name} ${help}`, `# TYPE ${name} ${type}`);

package/dist/mobile-viewport.js

@@ -1,9 +1,3 @@
-/** Presentation only: no fields are read, no requests are sent, and no
- * keyboard events are captured. A focused input alone is NOT a keyboard.
- *
- * It publishes the visible area (--viewport-height, --viewport-top): a phone's
- * keyboard shrinks only the visual viewport on iOS (100dvh never moves), so a
- * full-height app shell sized to it is what keeps the composer above the keys. */
 export const MOBILE_VIEWPORT_SCRIPT = String.raw `
 (function(){
   var root=document.documentElement,viewport=window.visualViewport;

package/dist/model-catalog.js

@@ -1,11 +1,3 @@
-/**
- * The live model and tool catalog. OpenRouter's public list (no key, nothing
- * about the person sent) names what Anthropic, OpenAI and Google currently
- * ship and what each costs; the Codex CLI's own cache names what this
- * account may run; `--version` and the npm registry say whether the
- * installed CLIs are current. Everything lands in orders.db so pickers,
- * spend pins and "new model" notices read one saved snapshot.
- */
 import { isAcpProvider } from "./acp-agents.js";
 import { execFile } from "node:child_process";
 import { accessSync, constants, lstatSync, readFileSync, realpathSync } from "node:fs";
@@ -54,11 +46,9 @@ export const RUNTIME_TOOLS = {
     gemini: { name: "Gemini CLI", command: "gemini", pkg: "@google/gemini-cli" },
 };
 export const WATCH_EVERY_MS = 6 * 3_600_000;
-/** A model counts as new for two weeks after its release. */
 const NEW_FOR_MS = 14 * 86_400_000;
 const FAMILIES = ["opus", "sonnet", "haiku", "fable"];
 const ALIAS_WORDS = { opus: "complex tasks", sonnet: "everyday coding", haiku: "smaller tasks" };
-/** The current Claude models by exact id, offered even before the first catalog check has run. */
 export const CLAUDE_EXACT = Object.freeze([
     { value: "claude-opus-5-5", label: "Claude Opus 5.5" },
     { value: "claude-sonnet-5-5", label: "Claude Sonnet 5.5" },
@@ -66,7 +56,6 @@ export const CLAUDE_EXACT = Object.freeze([
 ]);
 const title = (word) => word.charAt(0).toUpperCase() + word.slice(1);
 const stripVendor = (name) => name.replace(/^(Anthropic|OpenAI|Google): /, "");
-/** `anthropic/claude-opus-5.5` → `claude-opus-5-5`, the name the Claude CLI and API use. */
 export function claudeIdOf(openrouterId) {
     const hit = /^anthropic\/(claude-(?:opus|sonnet|haiku|fable)-[0-9][0-9.]*)$/.exec(openrouterId);
     return hit === null ? null : hit[1].replaceAll(".", "-");
@@ -75,7 +64,6 @@ function geminiIdOf(openrouterId) {
     const hit = /^google\/(gemini-[0-9][0-9a-z.-]*)$/.exec(openrouterId);
     return hit === null || /image|tts|audio|embed/.test(hit[1]) ? null : hit[1];
 }
-/** The Codex CLI's own list — account-specific, maintained by the CLI. */
 export function codexCatalog(home = homedir()) {
     try {
         const path = join(home, ".codex", "models_cache.json");
@@ -91,7 +79,6 @@ export function codexCatalog(home = homedir()) {
         return [];
     }
 }
-/** Pure: the catalog rows each source should hold after a fetch. */
 export function catalogRows(openrouter, codex) {
     const released = (model) => model.created === null ? null : new Date(model.created * 1000).toISOString();
     const base = (model) => ({ inputUsd: model.input, outputUsd: model.output, context: model.context, tools: model.tools, releasedAt: released(model) });
@@ -121,8 +108,6 @@ const readRow = (row) => ({
     context: row["context"] == null ? null : Number(row["context"]), tools: Number(row["tools"]) === 1,
     releasedAt: row["released_at"] == null ? null : String(row["released_at"]), firstSeenAt: String(row["first_seen_at"]),
 });
-/** Upsert a fetch. Returns models first seen now, except on a source's first
- * fetch (the baseline would otherwise announce every model at once). */
 export function recordCatalog(store, rows, now) {
     const stamp = now.toISOString();
     return store.transact(() => {
@@ -139,8 +124,6 @@ export function recordCatalog(store, rows, now) {
             if (fresh && had.has(row.source))
                 added.push({ ...row, firstSeenAt: stamp });
         }
-        // A model the source no longer lists stops being offered; its row stays
-        // so a saved choice can still be named.
         return added;
     });
 }
@@ -155,7 +138,6 @@ export function seenModel(store, source, id) {
 export function isNewModel(model, now) {
     return model.releasedAt !== null && now.getTime() - Date.parse(model.releasedAt) < NEW_FOR_MS;
 }
-/** What the Claude CLI's short name currently runs: the newest of its family. */
 export function aliasTarget(store, alias) {
     if (!FAMILIES.includes(alias))
         return null;
@@ -171,7 +153,6 @@ export function dollars(amount) {
 export function priceWords(model) {
     return model.inputUsd === null && model.outputUsd === null ? "price not listed" : `${dollars(model.inputUsd)} / ${dollars(model.outputUsd)} per 1M tokens`;
 }
-/** The friendly name for a saved provider + model, e.g. "opus" → "Claude Opus 5.5". */
 export function modelWords(store, provider, model) {
     if (model === null || model === "" || model === "default")
         return "its default model";
@@ -184,16 +165,13 @@ export function modelWords(store, provider, model) {
     const source = provider === "codex" || provider === "codex-subscription" ? "codex" : provider === "gemini" ? "gemini" : provider === "openrouter" || provider === "openrouter-api" ? "openrouter" : null;
     return source === null ? model : seenModel(store, source, model)?.name ?? model;
 }
-/** Every model a provider can run, newest first, with prices. */
 export function modelOptions(store, provider, now, home = homedir()) {
     const option = (model) => ({ value: model.id, label: `${model.name} · ${priceWords(model)}${isNewModel(model, now) ? " · New" : ""}`, isNew: isNewModel(model, now) });
     if (provider === "claude") {
-        // Exact ids first (Settings → Models presets write only these); the short names float to the newest version.
         const seen = seenModels(store, "claude").slice(0, 20);
         const builtIn = CLAUDE_EXACT.filter(one => !seen.some(model => model.id === one.value)).map(one => ({ ...one, isNew: false }));
         const aliases = ["sonnet", "opus", "haiku"].map(alias => {
             const target = aliasTarget(store, alias);
-            // Short enough that a phone's select still shows which model it means.
             return { value: alias, label: target === null ? `${title(alias)} (floating) — ${ALIAS_WORDS[alias]}` : `${title(alias)} (floating) · now ${target.name.replace(/^Claude /, "")}`, isNew: false };
         });
         return [...seen.map(option), ...builtIn, ...aliases];
@@ -207,22 +185,17 @@ export function modelOptions(store, provider, now, home = homedir()) {
     }
     if (provider === "gemini")
         return seenModels(store, "gemini").slice(0, 20).map(option);
-    // An ACP agent offers only the models its check recorded, on the runner that checked it — read there, never guessed.
     if (isAcpProvider(provider))
         return [];
     return seenModels(store, "openrouter").filter(model => model.tools).sort((a, b) => a.name.localeCompare(b.name)).map(option);
 }
-/** Chat reserves worst-case spend: price per token in whole micro-dollars,
- * rounded UP from the live list price. null = no live price. */
 export function livePin(store, chatProvider, model) {
     const seen = chatProvider === "anthropic-api" ? seenModel(store, "claude", model) : chatProvider === "openrouter-api" ? seenModel(store, "openrouter", model) : null;
     if (seen === null || seen.inputUsd === null || seen.outputUsd === null)
         return null;
-    // USD per million tokens is micro-dollars per token.
     const pin = (usd) => usd === 0 ? 0 : Math.ceil(usd - 1e-9);
     return { inMicrousd: pin(seen.inputUsd), outMicrousd: pin(seen.outputUsd) };
 }
-// ---------------------------------------------------------------- runtimes
 export function compareVersions(a, b) {
     const parts = (v) => v.split(/[.-]/).slice(0, 3).map(part => Number.parseInt(part, 10) || 0);
     const [x, y] = [parts(a), parts(b)];
@@ -247,11 +220,10 @@ function onPath(command, path) {
             accessSync(candidate, constants.X_OK);
             return realpathSync(candidate);
         }
-        catch { /* next */ }
+        catch { }
     }
     return null;
 }
-/** How this copy was installed decides the one safe update command. */
 export function updateCommandFor(tool, resolved) {
     const pkg = RUNTIME_TOOLS[tool].pkg;
     if (tool === "claude" && /\/\.local\/share\/claude\/versions\//.test(resolved))
@@ -319,7 +291,6 @@ export async function checkRuntimes(store, now, seams = {}) {
     }
     return runtimeStates(store);
 }
-/** Update one CLI, only while nothing is running, then read its version again. */
 export async function updateRuntime(store, tool, by, now, seams = {}) {
     const state = runtimeStates(store).find(one => one.tool === tool);
     if (state === undefined)
@@ -352,8 +323,6 @@ export function setWatch(store, enabled, by, now) {
     store.handle.prepare(`INSERT INTO model_watch (id, enabled, changed_by, changed_at) VALUES (1, ?, ?, ?)
     ON CONFLICT(id) DO UPDATE SET enabled = excluded.enabled, changed_by = excluded.changed_by, changed_at = excluded.changed_at`).run(enabled ? 1 : 0, by, now.toISOString());
 }
-/** One full check: the catalog, the CLIs, and a notice for each new model or
- * newly available update. Idempotent per model and per released version. */
 export async function checkModels(store, now, seams = {}) {
     const fetched = await fetchOpenRouterModels(null, seams.fetcher ?? fetch);
     let added = [];
@@ -379,7 +348,6 @@ export async function checkModels(store, now, seams = {}) {
     }
     return { ok: fetched.ok, added, runtimes, problem };
 }
-/** The background pass: runs only when the person turned checks on. */
 export async function modelWatchPass(store, now, seams = {}) {
     const state = watchState(store);
     if (!state.enabled)