toolroll 0.9.103 → 0.9.105

package/dist/work-index.js

@@ -1,6 +1,3 @@
-/** Paginated, permission-bound summaries of saved task facts. These reads do
- * not verify artifacts or authorize task operations; a build Toolroll can't
- * yet confirm stopped is read through the store's own read-only probe. */
 import { authorityStandsSql } from "./approval-authority.js";
 import { vanishedStopSentence } from "./vanished-retry.js";
 import { leadNameOf } from './lead-identity.js';
@@ -8,7 +5,7 @@ import { createHash } from 'node:crypto';
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { readProjectAccess } from './project-access.js';
-import { pauseOnTaskProviders, providerName, signInReason } from './provider-auth.js';
+import { pauseOnTaskProviders, signInReason } from './provider-auth.js';
 import { scopeTermsProblem, stopFactOf } from './store.js';
 import { assignmentChecksForRun } from './assignment.js';
 import { approvedCheckOf, checkBackingOf, completionBlockersOf, leadOnIt, plainReasonOf, replacedWords, requirementsOf, stageOfCode, taskStatusOf, unverifiedWhenRefuted, workToneOf } from './task-status.js';
@@ -20,7 +17,7 @@ import { MARKER } from './worktree.js';
 import { withFollowUps } from './result-follow-ups.js';
 import { LANDED_ACTOR, landedReasonOf } from './result-completion.js';
 import { ASKS, CODE_READING, STORAGE_HOLD_PREFIX, NEED_ASK, NEEDS, askChipOf, failedAttemptSentence, isWaitCode, processNeedOf, resultHoldUpSentence } from './needs-you.js';
-import { retryWhenWords } from './dispatch.js';
+import { agentlessCommand, NO_AGENT_TITLE, noAgentWords, retryWhenWords, signInAgainWords } from './dispatch.js';
 import { releaseTaskOf } from './release-approval.js';
 import { LEAD_CLAIM_SQL, LEAD_IDLE_MS } from './lead-voice.js';
 export const WORK_ASK_GROUPS = ['release', 'approve', 'answer', 'wrong', 'review', 'other'];
@@ -31,38 +28,25 @@ const NO_GROUPS = { decide: 0, review: 0, unblock: 0, building: 0, rest: 0 };
 const NO_ASKS = { release: 0, approve: 0, answer: 0, wrong: 0, review: 0, other: 0 };
 const FAMILY_PROBLEM = 'Task history is unavailable or incomplete. This task is shown separately.';
 const VIEWS = ['all', 'needs-you', 'ready', 'running', 'queued', 'completed', 'archived'];
-/** The family's current version is put away (v145): it waits on nobody and only the Archived view lists it. */
 const ARCHIVED = `EXISTS(SELECT 1 FROM task_archive ta WHERE ta.task_ref=c.ref_id)`;
 const n = (row, key) => Number(row[key] ?? 0);
 const s = (row, key) => row[key] == null ? null : String(row[key]);
-/** The running agent's oldest open question (agent-board.ts), from its open newest attempt only. */
 const AGENT_ASK = `(SELECT q.id FROM agent_question q JOIN run qr ON qr.id=q.run WHERE q.task_ref=a.ref_id AND q.closed_at IS NULL
       AND qr.outcome IS NULL AND qr.attempt_key=q.attempt_key ORDER BY q.id LIMIT 1)`;
-/** Keep the lineage predicates identical to Store.taskFamilyProjection: an
- * admitted child needs its parent's exact revision brief, in the same repo.
- * All subsequent reads are scalar/indexed metadata, never artifact bytes.
- * MATERIALIZED prevents counts + page selection repeating correlated reads. */
-/** A gate note counts only while its pause is on one of the task's current providers. */
 const GATE_PAUSE_ON_TASK = pauseOnTaskProviders('p', 'c.ref_id');
-/** Index codes that wait on a person, as their need, where the index reads one the dispatch codes don't. */
 const INDEX_NEED = Object.fromEntries(['earlier-active', 'process-needs-attention', 'invalid-scope', 'decision-queue', 'history-problem']
     .map(code => [code, CODE_READING[code].need]));
-/** Every index code that can wait on a person. A wait (stopping, waiting its turn, a retry later) is never one. */
 const PERSON_CODES = ['finding-held', 'history-problem', 'earlier-active', 'ready-to-check', 'waiting-decision', 'decision-queue', 'result-needs-attention',
     'process-needs-attention', 'failed', 'vanished-run', 'stopped', 'held', 'waiting-incident', 'terminal-dependency', 'needs-project',
     'needs-scope', 'invalid-scope', 'needs-agent-profile', 'needs-approval', 'missing-requirement', 'no-worker-registered', 'no-worker-online', 'signed-out', 'storage-blocked'];
-/** A family's findings held for a person (findings.ts). A database not yet at v155 has no such table: see registerValidators. */
 const HELD_FINDINGS = `(SELECT COUNT(*) FROM finding fd WHERE fd.family_root=root.id AND fd.state='with-person')`;
-/** The index codes that wait on nobody: finished or running work, and every wait (needs-you.ts CODE_READING). */
 export const WAITING_CODES = ['cancelled', 'complete', 'running', 'queued',
     ...['stopping', 'updating', 'retry-scheduled', 'waiting-dependency', 'worker-at-capacity', 'planning-ready', 'scouting-ready'].filter(code => isWaitCode(code))];
 const WAITING_SQL = WAITING_CODES.map(code => `'${code}'`).join(',');
-/** The words on a state's own act (a need's act wears its need's label). */
 const STATE_ACT_LABEL = {
     'ready-to-check': 'Open result', complete: 'Open result', cancelled: 'View task details', failed: 'Review and retry', 'waiting-incident': 'Review and retry',
     stopped: 'Review pause', held: 'Review hold', 'result-needs-attention': 'Open the build', 'process-needs-attention': 'Open the build',
 };
-/** A code's ask: a saved result is Review (unless its build may still run), otherwise its need's ask. */
 export function askOfCode(code, custody = false) {
     if (custody)
         return 'unblock';
@@ -71,16 +55,10 @@ export function askOfCode(code, custody = false) {
     return NEED_ASK[INDEX_NEED[code] ?? stageOfCode(code, { needsPerson: true }).need ?? 'other'];
 }
 const codesOf = (ask) => PERSON_CODES.filter(code => askOfCode(code) === ask).map(code => `'${code}'`).join(',');
-/** The ask as its place in the list (ASKS order), read by the same code the row's status reads. */
 const ASK_RANK = `CASE WHEN code IN (${codesOf('decide')}) THEN 0 WHEN code IN (${codesOf('review')}) AND NOT custody_unresolved THEN 1 ELSE 2 END`;
-/** Home's ask group of a row, by its code alone, so a row's group and its group's count are one rule: a plan waiting
- * for its yes, a question, a build that failed or stopped unexpectedly, a saved result to review (ASK_RANK's Review),
- * and everything else that waits on a person. Read on Needs you rows only. */
 const ASK_GROUP_SQL = `CASE WHEN code='needs-approval' AND c.id IN (SELECT value FROM json_each($releaseTasks)) THEN 'release' WHEN code='needs-approval' THEN 'approve' WHEN code IN ('waiting-decision','decision-queue') THEN 'answer'
       WHEN code IN ('failed','waiting-incident','vanished-run') THEN 'wrong' WHEN code IN (${codesOf('review')}) AND NOT custody_unresolved THEN 'review' ELSE 'other' END`;
-/** Where a row sits in the list: Decide, Review, Unblock, then building, then the rest by recency. */
 const ORDER = `(CASE WHEN rank=0 THEN ask_rank WHEN rank=1 THEN 3 ELSE 4 END)`;
-/** A row whose build may still be running (the store's reading, custodyReadings): Waiting, not Needs you. */
 const CUSTODY_WAITS = `(custody_unresolved AND code IN ('process-needs-attention','result-needs-attention') AND ref_id IN (SELECT value FROM json_each($waitingCustody)))`;
 const PROJECTION = `WITH RECURSIVE admitted AS MATERIALIZED (
   SELECT t.id, t.title, t.state, t.created_at, t.updated_at, r.id ref_id, r.repo,
@@ -182,6 +160,18 @@ const PROJECTION = `WITH RECURSIVE admitted AS MATERIALIZED (
     (SELECT COUNT(*) FROM workers w WHERE w.repo=c.repo AND (c.assigned_runner IS NULL OR w.name=c.assigned_runner)) worker_count,
     (SELECT COUNT(*) FROM workers w WHERE w.repo=c.repo AND (c.assigned_runner IS NULL OR w.name=c.assigned_runner) AND w.heartbeat_at>$alive) online_count,
     (SELECT COUNT(*) FROM workers w WHERE w.repo=c.repo AND (c.assigned_runner IS NULL OR w.name=c.assigned_runner) AND w.heartbeat_at>$alive AND w.occupied<w.capacity) available_count,
+    -- The first run with no coding agent signed in (dispatch.ts agentlessFirstRun): no planner pinned, no models chosen
+    -- anywhere, and on every live builder for it Claude Code and Codex were each seen not installed or not signed in,
+    -- with no agent ready or unknown. 2: Claude Code is installed there, 3: only Codex is, 1: neither. Read only while
+    -- the task waits for its plan (classified below).
+    CASE WHEN (SELECT plan_provider FROM task_ref WHERE id=c.ref_id) IS NULL
+      AND NOT EXISTS(SELECT 1 FROM phase_config) AND NOT EXISTS(SELECT 1 FROM phase_tier_config) AND NOT EXISTS(SELECT 1 FROM phase_tier_alternate)
+      AND EXISTS(SELECT 1 FROM workers w WHERE w.repo=c.repo AND (c.assigned_runner IS NULL OR w.name=c.assigned_runner) AND w.heartbeat_at>$alive)
+      AND NOT EXISTS(SELECT 1 FROM workers w WHERE w.repo=c.repo AND (c.assigned_runner IS NULL OR w.name=c.assigned_runner) AND w.heartbeat_at>$alive AND NOT (EXISTS(SELECT 1 FROM provider_readiness pr WHERE pr.runner=w.name AND pr.provider='claude' AND pr.state='unavailable' AND pr.probe IN ('path','login')) AND EXISTS(SELECT 1 FROM provider_readiness pr WHERE pr.runner=w.name AND pr.provider='codex' AND pr.state='unavailable' AND pr.probe IN ('path','identity')) AND NOT EXISTS(SELECT 1 FROM provider_readiness pr WHERE pr.runner=w.name AND pr.state<>'unavailable')))
+    THEN CASE WHEN EXISTS(SELECT 1 FROM workers w JOIN provider_readiness pr ON pr.runner=w.name WHERE w.repo=c.repo AND (c.assigned_runner IS NULL OR w.name=c.assigned_runner) AND w.heartbeat_at>$alive AND pr.provider='claude' AND pr.probe='login') THEN 2
+      WHEN EXISTS(SELECT 1 FROM workers w JOIN provider_readiness pr ON pr.runner=w.name WHERE w.repo=c.repo AND (c.assigned_runner IS NULL OR w.name=c.assigned_runner) AND w.heartbeat_at>$alive AND pr.provider='codex' AND pr.probe='identity') THEN 3 ELSE 1 END ELSE 0 END no_agent,
+    -- Models chosen here once and cleared (dispatch.ts modelsEverChosen): the no-agent line then promises no start by itself.
+    EXISTS(SELECT 1 FROM models_generation) models_cleared,
     CASE WHEN NOT json_valid(c.capability_requirements) THEN 1 ELSE EXISTS(
       SELECT 1 FROM json_each(c.capability_requirements) req WHERE req.type<>'text' OR instr(req.value,':')<2
         OR NOT EXISTS(SELECT 1 FROM capability cap WHERE cap.repo=c.repo AND cap.kind=substr(req.value,1,instr(req.value,':')-1)
@@ -255,6 +245,7 @@ const PROJECTION = `WITH RECURSIVE admitted AS MATERIALIZED (
     WHEN online_count=0 THEN 'no-worker-online'
     WHEN available_count=0 THEN 'worker-at-capacity'
     WHEN signed_out IS NOT NULL AND (gate_signed_out OR NOT (plan='requested' AND NOT COALESCE(approved AND dispatch_approval,0))) THEN 'signed-out'
+    WHEN no_agent>0 AND plan='requested' AND NOT COALESCE(approved AND dispatch_approval,0) THEN 'signed-out'
     WHEN (plan='requested' OR park_rate>0) AND (SELECT COUNT(*) FROM decision WHERE state<>'answered' AND answered_at IS NULL)>=5 THEN 'decision-queue'
     WHEN plan='requested' AND NOT COALESCE(approved AND dispatch_approval,0) THEN 'planning-ready'
     WHEN deliverable='report' THEN 'scouting-ready'
@@ -276,7 +267,6 @@ const PROJECTION = `WITH RECURSIVE admitted AS MATERIALIZED (
 )`;
 const registered = new WeakMap();
 const statements = new WeakMap();
-/** The page query is long and has one text per view filter: compile each once per connection. */
 function prepared(store, sql) {
     let cache = statements.get(store.handle);
     if (cache === undefined)
@@ -286,8 +276,6 @@ function prepared(store, sql) {
         cache.set(sql, statement = store.handle.prepare(sql));
     return statement;
 }
-/** Connection-local pure parsing, with exactly the authoritative stored-scope
- * validator. The callback cannot query, inspect files or grant authority. */
 function registerValidators(store) {
     const db = store.handle;
     const cached = registered.get(db);
@@ -307,27 +295,18 @@ function registerValidators(store) {
         const projects = readProjectAccess(raw);
         return projects === null || (typeof repo === 'string' && projects.includes(repo)) ? 1 : 0;
     });
-    // Same-schema non-migrating readers may predate these optional indexes.
-    // Discover once per connection; never initialize/migrate on a list read.
     const available = new Set(db.prepare(`SELECT name FROM sqlite_master WHERE type='index'
     AND name IN ('work_open_decision','work_spawned_run','work_unsettled_custody','work_result')`)
         .all().map(row => String(row['name'])));
     const indexed = available.size === 4 ? PROJECTION : PROJECTION.replace(/ INDEXED BY (work_open_decision|work_spawned_run|work_unsettled_custody|work_result)\b/g, (hint, name) => available.has(name) ? hint : '');
-    // A same-schema reader whose file has not taken the Agents board's tables yet reads no agent questions.
     const asks = db.prepare("SELECT 1 AS hit FROM sqlite_master WHERE type='table' AND name='agent_question'").get() !== undefined;
     const projection = asks ? indexed : indexed.replace(AGENT_ASK, 'NULL')
         .replace(`'agent_ask_run',(SELECT run FROM agent_question WHERE id=page.agent_ask),'agent_ask_text',(SELECT substr(question,1,300) FROM agent_question WHERE id=page.agent_ask),`, '');
-    // Nor, before v155, any held findings: readingFleet's rule for a list read.
     const findings = db.prepare("SELECT 1 AS hit FROM sqlite_master WHERE type='table' AND name='finding'").get() !== undefined;
     const read = findings ? projection : projection.replace(HELD_FINDINGS, '0');
     registered.set(db, read);
     return read;
 }
-/** The list can't see processes: each task whose build Toolroll can't yet
- * confirm stopped, as the store reads it now (the task page's own reading).
- * Null when it has since settled; `open` runs are the classification's own.
- * `workspace`: a finished task whose last build's workspace note is still
- * there, which only the store can read (a held or unreadable workspace). */
 function custodyReadings(store) {
     const refs = store.handle.prepare(`SELECT r.task_ref FROM run r WHERE r.provider_started_at IS NOT NULL AND NOT EXISTS(SELECT 1 FROM run_process p WHERE p.run=r.id) AND NOT EXISTS(SELECT 1 FROM run_process_summary s WHERE s.run=r.id)
     UNION SELECT r.task_ref FROM run_process p JOIN run r ON r.id=p.run WHERE p.exited_at IS NULL AND p.container_empty_at IS NULL`).all().map(row => Number(row['task_ref']));
@@ -349,9 +328,6 @@ function custodyReadings(store) {
     }
     return { readings, workspace: new Set(noted) };
 }
-/** The list can't read a release's sealed state in SQL: each queued task (the only state a plan waiting for a yes is in)
- * whose scope carries a release form, kept only where release-approval.ts releaseTaskOf names it a release, the one
- * rule the release sheet reads (never a title or a task id). */
 function releaseTaskIds(store) {
     const sealed = store.handle.prepare(`SELECT s.task_id FROM task_scope s JOIN task t ON t.id=s.task_id
     WHERE t.state='queued' AND (s.release_terms_json IS NOT NULL OR s.release_check_json IS NOT NULL)`).all().map(row => String(row['task_id']));
@@ -371,16 +347,12 @@ function parameters(store, now, access, options, custody) {
 function counts(row) {
     return { all: n(row, 'all_count'), 'needs-you': n(row, 'needs_count'), ready: n(row, 'ready_count'), running: n(row, 'running_count'), queued: n(row, 'queued_count'), completed: n(row, 'completed_count'), archived: n(row, 'archived_count') };
 }
-// Put-away families (v145) count only as archived.
-// Queued: waits on someone or something else (rank 2), not a person and not a build of its own family.
 const QUEUED = `rank=2 AND family_running=0 AND archived=0`;
-// Ready (P1.4): what waits on a person to accept or send back, the Needs you rows under Review.
 const READY = `needs AND rank=0 AND ask_rank=1 AND archived=0`;
 const TOTALS = `COALESCE(SUM(archived=0),0) all_count,COALESCE(SUM(needs),0) needs_count,COALESCE(SUM(${READY}),0) ready_count,COALESCE(SUM(family_running AND archived=0),0) running_count,`
     + `COALESCE(SUM(${QUEUED}),0) queued_count,COALESCE(SUM(code='complete' AND archived=0),0) completed_count,COALESCE(SUM(archived),0) archived_count`;
 const GROUP_TOTALS = `COALESCE(SUM(rank=0 AND ask_rank=0 AND archived=0),0) decide_count,COALESCE(SUM(rank=0 AND ask_rank=1 AND archived=0),0) review_count,COALESCE(SUM(rank=0 AND ask_rank=2 AND archived=0),0) unblock_count,`
     + `COALESCE(SUM(rank=1 AND archived=0),0) building_count,COALESCE(SUM(rank>1 AND archived=0),0) rest_count`;
-/** The exact Needs you totals per ask group, and what was completed since the page's `completedSince`: page reads only. */
 const ASK_TOTALS = WORK_ASK_GROUPS.map(group => `COALESCE(SUM(needs AND ask_group='${group}'),0) ask_${group}_count`).join(',')
     + `,COALESCE(SUM(code='complete' AND archived=0 AND $completedSince IS NOT NULL AND sort_at>=$completedSince),0) completed_since_count`
     + `,COALESCE(SUM(needs AND code IN ('no-worker-registered','no-worker-online')),0) builder_wait_count`;
@@ -416,18 +388,9 @@ function readCursor(value, scope) {
         throw new WorkIndexCursorError();
     }
 }
-/** A single SQLite statement gives rows and exact totals one read snapshot.
- * Completion is a recorded acknowledgment of the latest run/scope/family by
- * its current lead or an admitted approver, invalidated by newer source facts.
- * Its historical receipt hash also binds disk state, which is deliberately
- * rechecked only on opening/acting. This query grants no completion authority.
- * Project counters share the page's admitted project/state filter.
- * Cursors bind the admitted scope, project and view, never broaden access. */
 export function workIndexPage(store, now, access, options = {}) {
     return readWorkIndexPage(store, now, access, options);
 }
-/** An exact family lookup through the list's saved-fact projection. It remains
- * permission-bound and bypasses pagination, never action-time verification. */
 export function workIndexTask(store, taskId, now, access, root) {
     return readWorkIndexPage(store, now, access, { limit: 1, ...(root === undefined ? {} : { root }) }, taskId).items[0] ?? null;
 }
@@ -463,7 +426,7 @@ function readWorkIndexPage(store, now, access, options, taskId = null) {
     'proof_failed_check',(SELECT verdict='refuted' AND reasons_json LIKE '%approved verification command exited%' FROM proof_verdict WHERE run=page_result_id),'code',code,'ask_group',ask_group,'needs',needs,'person_need',person_need,'lead_claim',lead_claim,'family_running',family_running,'rank',rank,'ask_rank',ask_rank,'list_order',${ORDER},'sort_at',sort_at,
     'checked_actor',checked_actor,'checked_at',checked_at,'checked_digest',checked_digest,'checked_detail',checked_detail,'question_id',question_id,
     'dependency_id',dependency_id,'dependency_state',dependency_state,'hold_until',hold_until,'attempt_run',(SELECT id FROM run WHERE task_ref IN (SELECT ref_id FROM members WHERE root_ref=page.root_ref) AND (finished_at IS NOT NULL OR outcome IS NOT NULL) AND role NOT IN ('planner','reviewer') ORDER BY id DESC LIMIT 1),'custody_unresolved',custody_unresolved,'hold_kind',hold_kind,'hold_reason',substr(hold_reason,1,600),'hold_id',hold_id,'live_lease',live_lease IS NOT NULL,'approved',COALESCE(approved,0),
-    'plan_changed',scope_digest IS NOT NULL AND digest IS NOT scope_digest,'head_ok',length(head_revision)=40 AND head_revision NOT GLOB '*[^a-f0-9]*','stop_run',stop_run,'unfinished',unfinished,'signed_out',signed_out,
+    'plan_changed',scope_digest IS NOT NULL AND digest IS NOT scope_digest,'head_ok',length(head_revision)=40 AND head_revision NOT GLOB '*[^a-f0-9]*','stop_run',stop_run,'unfinished',unfinished,'signed_out',signed_out,'no_agent',no_agent,'models_cleared',models_cleared,
     'question_run',(SELECT run FROM decision WHERE id=page.question_id),'agent_ask',page.agent_ask,
     'agent_ask_run',(SELECT run FROM agent_question WHERE id=page.agent_ask),'agent_ask_text',(SELECT substr(question,1,300) FROM agent_question WHERE id=page.agent_ask),'replaced_by',(SELECT successor FROM task_replacement WHERE task_ref=page.ref_id),
     'completed_by_lead',(SELECT lead FROM task_act WHERE task_ref=page.root_ref AND act='completed' ORDER BY id DESC LIMIT 1),'machine_check',COALESCE(machine_check,0),
@@ -474,15 +437,11 @@ function readWorkIndexPage(store, now, access, options, taskId = null) {
     const nextCursor = selected.length > limit && last !== undefined ? Buffer.from(JSON.stringify({ version: 2, scope,
         rank: n(last, 'list_order'), at: s(last, 'sort_at'), root: n(last, 'root_ref') })).toString('base64url') : null;
     const projects = JSON.parse(String(rows[0]?.['row_json'] ?? '[]')).map(row => ({ repo: s(row, 'repo'), totals: counts(row), queued: n(row, 'queued'), doneRecently: n(row, 'done_recently') }));
-    // A row whose build Toolroll can't confirm stopped reads the store's own answer, as the task page does.
     const probe = (taskId) => {
         const ref = store.lookupRef(taskId);
         return ref === null ? null : custody.readings.get(ref.id) ?? null;
     };
-    // A claimed row says the viewer's own name for their lead.
     const leadName = page.some(row => n(row, 'lead_claim') !== 0) && access.principal === 'operator' && access.viewer != null ? leadNameOf(store, access.viewer) : undefined;
-    // A finished result reads the same readiness the task page does (task-status.ts): its requirements, acceptance,
-    // automatic review and, with checks Off, the release check that covers it.
     const memo = new Map();
     const readiness = (row, checks) => resultReadinessFacts(store, now, options.root, row, checks, memo);
     return { items: page.map(row => itemOf(row, access.principal, probe, leadName, readiness, options.root !== undefined, now)), projects, totals: rows[0] === undefined ? { ...EMPTY } : counts(rows[0]),
@@ -510,9 +469,6 @@ export function workStateRows(store, now, access) {
         leadClaim: n(row, 'lead_claim') === 1, liveRun: row['live_run'] == null ? null : n(row, 'live_run'), unfinished: row['unfinished'] == null ? null : n(row, 'unfinished'),
         resultRun: row['result_id'] == null ? null : n(row, 'result_id'), waits: Number(row['rank']) === 2, version: String(row['version']), at: String(row['ask_at'] ?? ''), askRun: row['ask_run'] == null ? null : n(row, 'ask_run'), members: JSON.parse(String(row['members'] ?? '[]')).map(Number) }));
 }
-/** Activity uses the Tasks list's exact family admission and saved completion rules.
- * Only the requested project enters the projection. The extra row signals truncation;
- * attempts are aggregated in SQLite, never loaded as an unbounded history. */
 export function workOutcomeRows(store, now, access, project, since, limit) {
     return store.handle.prepare(`${registerValidators(store)}, selected AS MATERIALIZED (
     SELECT * FROM ranked WHERE archived=0 AND (code='ready-to-check' OR code='history-problem'
@@ -542,9 +498,6 @@ export function workOutcomeRows(store, now, access, project, since, limit) {
     FROM selected f LEFT JOIN attempts a ON a.root_ref=f.root_ref ORDER BY f.sort_at DESC,f.root_ref DESC`)
         .all({ ...parameters(store, now, access, { project }, custodyReadings(store)), $since: since, $outcomeLimit: limit + 1 });
 }
-/** Families whose headline is Ready for review, newest first: the Tasks
- * list's own rows, so a completed family (root or any revision), a failed
- * check and a superseded version never count. */
 export function workReadyForReview(store, now, access, limit = 5) {
     const ready = [];
     let cursor = null;
@@ -555,13 +508,9 @@ export function workReadyForReview(store, now, access, limit = 5) {
     } while (cursor !== null);
     return { count: ready.length, results: ready.slice(0, Math.max(0, limit)).map(one => ({ rootId: one.rootId, taskId: one.activeTaskId, run: one.resultRunId })) };
 }
-/** Labels stay navigation, never an authorization to mutate. Full task
- * opening re-proves process custody, receipt bytes and approval terms. */
-/** The list's Checks: the build's own result, its level, and follow-up checks on the same commit (result-follow-ups.ts). */
 function listChecksOf(own, level, follows) {
     let done = [];
     try {
-        // The row's JSON already holds the list; an older reader may hand over its text.
         done = (typeof follows === 'string' ? JSON.parse(follows) : Array.isArray(follows) ? follows : []).flatMap(one => {
             const [ask, said] = String(one).split(' ');
             if (ask !== 'quick' && ask !== 'full')
@@ -578,22 +527,17 @@ function listChecksOf(own, level, follows) {
         return null;
     return { status: read.status, exitCode: null, head: null, level: read.level, running: read.running };
 }
-/** A check as a read without the evidence files may show it: only what never claims a pass it can't prove. */
 function unreadChecksOf(checks) {
     if (checks === null)
         return null;
     return checks.status === 'failed' || (checks.level === 'off' && checks.status !== 'passed' && checks.release == null) ? checks : null;
 }
-/** A ready result's requirements, acceptance and completion blockers from its saved records, as assignmentOf reads them. */
 function resultReadinessFacts(store, now, root, row, recorded, memo) {
     const run = n(row, 'result_id'), repo = s(row, 'repo');
     if (!run)
         return { checks: root === undefined ? unreadChecksOf(recorded) : recorded };
     const report = s(row, 'result_role') === 'scout';
-    // Read its saved receipt, as the page does: a recorded result (or a verdict alone) is not a check that can still be
-    // read, and the row must never say passed while the task page says the check couldn't be read.
     const read = root !== undefined && !report ? assignmentChecksForRun(store, root, run, now) : null;
-    // A recorded failure is never lost because its saved files can't be read now (fail closed: negatives stand).
     const saved = read !== null && recorded?.status === 'failed' && (read.status === 'unavailable' || read.status === 'not-run')
         ? { ...read, status: 'failed', exitCode: recorded.exitCode } : read;
     const listed = saved === null ? recorded : { status: saved.status, exitCode: saved.exitCode, head: s(row, 'result_head'),
@@ -601,9 +545,6 @@ function resultReadinessFacts(store, now, root, row, recorded, memo) {
     const covered = listed?.level === 'off' && listed.status !== 'passed' && listed.status !== 'failed'
         ? { ...listed, release: releaseCoverageOf(store, root, repo, s(row, 'result_head'), { memo }) } : listed;
     const proof = store.proofVerdictFor(run), accepted = store.proofAcceptance(run) !== null;
-    // The approved check as the task page reads it (task-status.ts): a recorded pass with no readable check doesn't count.
-    // Without the evidence root nothing can be read, so the row makes no claim about the check at all: a recorded
-    // failure or checks Off still say so; a pass, or a missing check, is the result's own page to say.
     const checks = report ? covered : root === undefined ? unreadChecksOf(covered) : approvedCheckOf(proof?.verdict ?? null, proof?.reasons ?? [], covered);
     const review = buildReviewOf(store, run);
     const high = review === null || review.sentBackAs !== null || review.state !== 'reviewed' ? 0 : review.high.length;
@@ -621,13 +562,10 @@ function itemOf(row, principal, probe, leadName, readiness, readable = false, no
     const process = custody && probe !== undefined ? processNeedOf(probe(id)) : null;
     const waiting = (process !== null && 'wait' in process) || (custody && probe === undefined);
     const need = n(row, 'needs') === 1 && !waiting, running = n(row, 'family_running') === 1;
-    // The lead's claim (lead-voice.ts): the row still reads its own stage, worded "<name> is on it".
     const lead = n(row, 'lead_claim') === 1 ? 'on-it' : n(row, 'lead_claim') === 2 ? 'lapsed' : null;
     const personNeed = (n(row, 'person_need') === 1 || need) && !waiting;
     const assignmentState = code === 'complete' ? 'complete' : code === 'ready-to-check' ? 'ready-to-check'
         : code === 'cancelled' ? 'cancelled' : need ? 'needs-decision' : 'working';
-    // What the code means (needs-you.ts CODE_READING, the one table): its act is the one it has always had; a need's
-    // words and label come from NEEDS, a wait's from WAITS. Only facts the row itself holds are added here.
     const meaning = CODE_READING[code];
     let label = '';
     let detail = '';
@@ -645,7 +583,6 @@ function itemOf(row, principal, probe, leadName, readiness, readable = false, no
     }
     if (code === 'stopped')
         detail = 'Paused by a person. The work so far is kept.';
-    // The storage check couldn't finish (dispose.ts holdForStorage): its own words, when it retries, and Try again.
     if (code === 'storage-blocked') {
         const until = s(row, 'hold_until');
         detail = `${(s(row, 'hold_reason') ?? '').slice(STORAGE_HOLD_PREFIX.length)}${until === null ? '' : ` It tries again on its own ${retryWhenWords(until, now)}.`}`;
@@ -654,23 +591,25 @@ function itemOf(row, principal, probe, leadName, readiness, readable = false, no
     }
     if (code === 'cancelled')
         detail = 'This task was cancelled.';
-    // The same failure again and again: what failed, and the two ways on.
     if (code === 'waiting-incident')
         detail = `The last attempts failed the same way (${failedAttemptSentence(s(row, 'attempt_reason')).replace(/[.\s]+$/, '').replace(/^./, first => first.toLowerCase())}). Retry, or change the plan.`;
-    /** The build, the task or the time a sentence names. */
     const context = code === 'stopping' ? { build: n(row, 'stop_run') || null }
         : code === 'retry-scheduled' ? { build: n(row, 'attempt_run') || null, retry: s(row, 'hold_until') === null ? null : retryWhenWords(s(row, 'hold_until'), now) }
             : code === 'vanished-run' ? { build: n(row, 'unfinished') || null }
                 : code === 'earlier-active' ? { task: s(row, 'earlier_id') }
                     : code === 'waiting-dependency' ? { task: s(row, 'dependency_id') } : {};
-    if (code === 'signed-out') {
+    if (code === 'signed-out' && n(row, 'no_agent') > 0 && s(row, 'signed_out') === null) {
+        label = NO_AGENT_TITLE;
+        detail = noAgentWords(agentlessCommand(n(row, 'no_agent') === 2, n(row, 'no_agent') === 3), n(row, 'models_cleared') === 1);
+    }
+    else if (code === 'signed-out') {
         const [provider = '', authMode = 'subscription'] = (s(row, 'signed_out') ?? '').split(':');
-        label = signInReason({ provider: provider, authMode: authMode === 'api-key' ? 'api-key' : 'subscription' });
-        detail = `${label}. It starts again on its own once ${providerName(provider)} works.`;
+        const pause = { provider: provider, authMode: authMode === 'api-key' ? 'api-key' : 'subscription' };
+        label = signInReason(pause);
+        detail = signInAgainWords(pause);
     }
     if (code === 'running' && n(row, 'version_count') > 1)
         label = 'Building again';
-    // Replaced, never "Cancelled": the successor is one tap away.
     const successor = code === 'cancelled' ? s(row, 'replaced_by') : null;
     if (successor !== null) {
         detail = `${replacedWords(successor)}.`;
@@ -678,14 +617,11 @@ function itemOf(row, principal, probe, leadName, readiness, readable = false, no
     }
     if (code === 'terminal-dependency' && s(row, 'dependency_id') !== null)
         detail = `${s(row, 'dependency_id')} ${s(row, 'dependency_state') === 'cancelled' ? 'was cancelled' : 'failed'} before it finished.`;
-    // A failed task says the latest finished attempt across its whole family, whatever its outcome: its recorded reason, or that none was recorded.
     if (code === 'failed')
         detail = s(row, 'retry_stopped') === null ? failedAttemptSentence(s(row, 'attempt_reason'))
             : vanishedStopSentence({ why: s(row, 'retry_stopped'), run: n(row, 'retry_stopped_run') || null });
-    // A new route waiting for its one Approve says what changed (route-change.ts).
     if (code === 'needs-approval' && s(row, 'route_change') !== null)
         detail = s(row, 'route_change');
-    // A saved result that can't be accepted yet says its own reason, never one line for every such row.
     const planChanged = code === 'result-needs-attention' && n(row, 'plan_changed') === 1;
     if (code === 'result-needs-attention')
         detail = resultHoldUpSentence({ hold: s(row, 'hold_id') === null ? null : s(row, 'hold_reason') ?? '', planChanged,
@@ -698,14 +634,13 @@ function itemOf(row, principal, probe, leadName, readiness, readable = false, no
         actionCode = 'open-result';
         actionLabel = 'Open result';
     }
-    // Toolroll proves a build stopped itself; only a stop it can't prove from here offers "Check again", never a vouch.
     if (process !== null && 'need' in process) {
         actionCode = 'recheck-stopped';
         actionLabel = NEEDS[process.need].action.label;
     }
     if (code === 'signed-out') {
         actionCode = 'sign-in';
-        actionLabel = NEEDS['sign-in'].action.label;
+        actionLabel = n(row, 'no_agent') > 0 && s(row, 'signed_out') === null ? 'Sign in' : NEEDS['sign-in'].action.label;
     }
     if (actionCode === null) {
         actionCode = code === 'running' ? 'inspect-run' : 'inspect-task';
@@ -720,22 +655,17 @@ function itemOf(row, principal, probe, leadName, readiness, readable = false, no
             decisionId: actionCode === 'answer-decision' ? n(row, 'question_id') || null : null },
         access: read ? 'read' : principal === 'operator' ? 'operator-control' : ['answer-decision', 'answer-agent', 'write-scope', 'unhold'].includes(actionCode) ? 'proposal-only' : 'operator-handoff',
         retry: actionCode === 'reconcile-run' ? 'reconcile-before-retry' : read ? 'read-again' : 'refresh-before-acting' };
-    // The one shared status: the headline and sentence every surface uses.
     const coded = stageOfCode(code, { needsPerson: personNeed, planning: s(row, 'live_role') === 'planner', operatorHold: s(row, 'hold_kind') === 'operator' });
     const reading = process !== null
         ? 'wait' in process ? { stage: 'waiting', wait: process.wait } : { stage: 'needs-you', need: process.need }
-        // Not read here (no process probe): Toolroll's own stop check settles it, so it waits on no one.
         : custody ? { stage: 'waiting', wait: 'build-checking' }
             : coded.stage === 'needs-you' && (coded.need === undefined || coded.need === 'other') && INDEX_NEED[code] !== undefined ? { stage: 'needs-you', need: INDEX_NEED[code] } : coded;
     const checkStatus = s(row, 'check_status'), verdict = s(row, 'proof_verdict');
     const finished = reading.stage === 'finished' || reading.stage === 'complete';
-    // Only a recorded check is a pass; a verdict alone isn't one (task-status.ts approvedCheckOf reads it with the receipt).
     const own = checkStatus === 'failed' || n(row, 'proof_failed_check') === 1 ? 'failed' : checkStatus === 'passed' ? 'passed' : null;
     const recordedChecks = !finished ? null : listChecksOf(own, s(row, 'check_level'), row['check_follows']);
-    // A read without the evidence files claims no pass (unreadChecksOf); the readiness read below says the rest.
     const listedChecks = readable ? recordedChecks : unreadChecksOf(recordedChecks);
     const ready = reading.stage === 'finished' && readiness !== undefined ? readiness(row, recordedChecks) : null;
-    // Toolroll marked it complete because its work landed: the reason, said once.
     const landed = code === 'complete' ? landedReasonOf(s(row, 'checked_actor'), s(row, 'checked_detail')) : null;
     const shared = taskStatusOf({ stage: reading.stage, ...(reading.need === undefined ? {} : { need: reading.need }), ...(reading.wait === undefined ? {} : { wait: reading.wait }),
         ...(process === null ? (Object.keys(context).length === 0 ? {} : { needContext: context }) : { needContext: { build: process.build } }),
@@ -748,12 +678,10 @@ function itemOf(row, principal, probe, leadName, readiness, readable = false, no
         ...(lead === null ? {} : { lead, ...(leadName === undefined ? {} : { leadName }) }) });
     label = shared.headline;
     detail = shared.sentence;
-    // Every Needs you action wears its need's own words.
     if (shared.need != null && shared.need.key !== 'other' && shared.need.key !== 'review-result' && primaryAction !== null) {
         actionLabel = shared.need.action.label;
         primaryAction.label = actionLabel;
     }
-    // A running agent's own question (agent-board.ts): its words, and Reply on the Agents board.
     if (actionCode === 'answer-agent' && primaryAction !== null) {
         actionLabel = 'Reply';
         primaryAction.label = actionLabel;
@@ -783,7 +711,7 @@ function itemOf(row, principal, probe, leadName, readiness, readable = false, no
             action: primaryAction === null ? null : { label: actionLabel, kind: actionCode === 'open-result' ? 'open-result' : 'open-task' }, views, rank: n(row, 'rank') },
         ask: need ? ASKS[n(row, 'ask_rank')] ?? 'unblock' : null,
         askGroup: need ? WORK_ASK_GROUPS.find(group => group === s(row, 'ask_group')) ?? 'other' : null,
-        chip: need ? askChipOf({ headline: shared.headline, need: shared.need?.key ?? null, planChanged, mismatch: verdict === 'refuted' && n(row, 'proof_failed_check') !== 1, ask: ASKS[n(row, 'ask_rank')] ?? 'unblock' }) : null,
+        chip: need ? askChipOf({ headline: shared.headline, need: shared.need?.key ?? meaning?.need ?? null, planChanged, mismatch: verdict === 'refuted' && n(row, 'proof_failed_check') !== 1, ask: ASKS[n(row, 'ask_rank')] ?? 'unblock' }) : null,
         primaryAction, completion: code === 'complete' ? { actor: String(row['checked_actor']), at: String(row['checked_at']), digest: String(row['checked_digest']), ...(landed === null ? {} : { landed }) } : null,
         evidence: 'recorded', ...(lead === 'on-it' ? { lead: leadOnIt(leadName) } : {}), ...(archived === null ? {} : { archived }) };
 }

package/dist/work-summary.js

@@ -1,20 +1,12 @@
-/** Read-only work context shared by console, CLI, and agent adapters.
- * State, decisions, approval, process custody and proof still belong to
- * their existing owners. Action hints are navigation/proposal guidance,
- * never credentials or permission to bypass an owning operation. */
 import { heldFindingCount } from "./findings.js";
 import { machineChecked } from "./machine-check.js";
 import { resultCheckLevel } from "./result-follow-ups.js";
+import { projectCheckSet } from "./check-levels.js";
 import { diagnoseTaskDispatch } from "./dispatch.js";
 import { isAlive } from "./runner.js";
 import { taskControlOf } from "./task-control.js";
 import { buildReviewOf } from "./review-switch.js";
 import { reviewFactsOf, workStatusOf } from "./workspace-ui.js";
-/** Call only after admitting the task's project. Keep the question's
- * exact run and id; never substitute a family's newest attempt. Expiry
- * is attention metadata in the decision owner, so overdue stays open.
- * Finishing a result does not answer its questions: only the normal
- * decision operation settles them, including on earlier family versions. */
 export function openWorkDecisionOf(store, taskRef, now) {
     const decision = store.decisionsForTask(taskRef).find(one => one.state !== "answered" && one.answeredAt === null);
     return decision === undefined ? null : {
@@ -22,15 +14,12 @@ export function openWorkDecisionOf(store, taskRef, now) {
         overdue: decision.state === "expired" || (decision.deadline !== null && Date.parse(decision.deadline) <= now.getTime()),
     };
 }
-/** One exact answer target across task and family projections. This is
- * still only a proposal for a coordinator, never approval authority. */
 export function workDecisionAction(taskId, decision, principal) {
     return { code: "answer-decision", label: "Answer question", target: { taskId, runId: decision.runId, decisionId: decision.id },
         access: principal === "operator" ? "operator-control" : "proposal-only", retry: "refresh-before-acting" };
 }
 const PROPOSABLE = new Set(["answer-decision", "write-scope", "unhold"]);
 const READ_ACTIONS = new Set(["open-result", "open-pr", "inspect-task", "inspect-findings", "inspect-run", "inspect-stop", "inspect-decisions"]);
-/** Pure counterpart for callers already holding the same facts. */
 export function workSummaryOf(facts, principal, resultDisplay) {
     const status = workStatusOf(facts, resultDisplay);
     const target = { taskId: facts.id, runId: null, decisionId: null };
@@ -59,8 +48,6 @@ export function workSummaryOf(facts, principal, resultDisplay) {
             primary = make("open-pr", status.action.label, { runId: facts.result?.runId ?? null });
         else if (status.action.kind === "open-run")
             primary = make("inspect-run", status.action.label, { runId: facts.liveRunId ?? facts.result?.runId ?? null });
-        // A full decision queue can block a task that asked no question of
-        // its own. Do not invent a decision target on that task.
         else if (facts.dispatch?.action === "answer-decision")
             primary = make("inspect-decisions", "Review open questions");
         else
@@ -78,9 +65,6 @@ export function workSummaryOf(facts, principal, resultDisplay) {
         status, primaryAction: primary, nextActions, diagnostics, evidence: resultDisplay === undefined ? "recorded" : "receipt-checked",
     };
 }
-/** Admission precedes reading question/proof bodies. Missing and foreign
- * tasks share the same result. The caller must authenticate/revalidate
- * its principal; this allowlist is not a credential. */
 export function taskWorkSummaryOf(store, taskId, now, access) {
     const ref = store.lookupRef(taskId);
     if (ref === null || (ref.repo === null
@@ -106,6 +90,7 @@ export function taskWorkSummaryOf(store, taskId, now, access) {
             runId: result.id, role: result.role, outcome: result.outcome,
             verdict: proof?.verdict ?? null, reasons: proof?.reasons ?? [], accepted: store.proofAcceptance(result.id) !== null,
             checkLevel: resultCheckLevel(store, result.id, now),
+            ...(ref.repo == null ? {} : { checkSet: projectCheckSet(store, ref.repo) }),
             review: reviewFactsOf(store.reviewRetryStateOf(result.id), name => {
                 const runner = store.getRunner(name)?.runner;
                 return runner !== undefined && isAlive(runner, now);

package/dist/workspace-motion.js

@@ -1,5 +1,3 @@
-/** Motion adapts presentation only. Native navigation, forms and tab state
- * remain owned by their existing handlers. No network or credential access. */
 export const WORKSPACE_MOTION_CSS = String.raw `
 :root {
   --panel-open-dur: 250ms;

package/dist/workspace-revision.js

@@ -1,24 +1,17 @@
 import { DEFAULT_LIVENESS_MS } from './runner.js';
-/** The service_cursor row every meaningful commit moves (live-bus.ts listens for it). */
 export const WORKSPACE_REVISION_KEY = 'workspace-content:v1';
 const KEY = WORKSPACE_REVISION_KEY;
 const MAX_AGE_MS = 60_000;
 const OMIT = new Set(['schema_version', 'service_cursor', 'wake', 'notification_delivery', 'sqlite_sequence',
     'team_read', 'team_request', 'push_delivery', 'chat_message_ref',
-    // Who is watching an agent right now: renewed by every open page's keep-alive, never news.
     'agent_view',
-    // A run's How it ran, derived from its own records on first view (run-efficiency.ts): a cache, never news.
     'run_efficiency',
-    // v137: lifecycle heartbeats, latency timelines and the continuous copy's record are bookkeeping, never news.
     'service_lifecycle', 'latency_timeline', 'live_backup']);
 const QUIET = {
     runner: ['heartbeat_at'], claim: ['heartbeat_at', 'expires_at'], watch_lease: ['heartbeat_at', 'expires_at'],
     watch_episode: ['ticks'], provider_readiness: ['observed_at'],
-    // A chat worker's lease, poll cursor and rate-limit wait are its own bookkeeping; its connection and problem are news.
     chat_runtime: ['owner', 'lease_until', 'generation', 'cursor', 'heartbeat', 'retry_at'],
 };
-/** A quiet beat that revives what a view already rendered as gone: the rows a beat may move, read before and after.
- * A runner beat after its liveness window (or backwards) is a revival; a lease renewed at or past its expiry is one. */
 const REVIVAL = {
     runner: { rows: 'SELECT rowid AS id, heartbeat_at AS h, NULL AS e FROM runner',
         revived: (before, after) => after.h < before.h || Date.parse(after.h) >= Date.parse(before.h) + DEFAULT_LIVENESS_MS },
@@ -37,7 +30,6 @@ function tableAt(text) {
     const table = match[4] ?? match[5] ?? match[6];
     return { schema: schema?.toLowerCase() ?? null, table: table.replaceAll('""', '"').toLowerCase(), rest: text.slice(match[0].length) };
 }
-/** The columns an UPDATE's SET clause assigns, or null when it can't be read (then the write counts). */
 function assigned(rest) {
     const set = /^\s+SET\s+/i.exec(rest);
     if (set === null)
@@ -98,7 +90,6 @@ export function statementEffect(sql) {
     match = /^RELEASE\s+(?:SAVEPOINT\s+)?(\S+?)\s*;?\s*$/i.exec(text);
     if (match !== null)
         return { kind: 'release', name: match[1].toLowerCase() };
-    // WITH … is only ever a prefix to one data statement here; its CTEs cannot write.
     const body = /^WITH\b/i.test(text) ? text.replace(/^WITH\b[\s\S]*?(?=\b(?:INSERT|REPLACE|UPDATE|DELETE)\b)/i, '') : text;
     match = /^(?:(?:INSERT|REPLACE)(?:\s+OR\s+\w+)?\s+INTO|DELETE\s+FROM)\s+/i.exec(body);
     const update = match === null ? /^UPDATE(?:\s+OR\s+\w+)?\s+/i.exec(body) : null;
@@ -116,10 +107,7 @@ export function statementEffect(sql) {
     const columns = assigned(target.rest);
     return { kind: 'write', table: target.table, quiet: columns !== null && columns.every(column => quietColumns.includes(column)) };
 }
-/** How many times this connection has moved the revision; read through any wrapper around it. */
 const BUMPS = Symbol('workspace revision bumps');
-/** Wrap one connection so each committed meaningful write moves the workspace revision exactly once. Native
- * extensions (scalar functions, isTransaction) pass through; a test spy on prepare/exec replaces only the facade's. */
 export function trackWorkspaceWrites(db) {
     const state = { bumps: 0 };
     const effects = new Map();
@@ -144,10 +132,9 @@ export function trackWorkspaceWrites(db) {
             db.exec(BUMP);
             state.bumps++;
         }
-        catch { /* a file without the cursor (an old shape opened bare) has no revision to move */ }
+        catch { }
     };
     const reset = () => { open = false; dirty = false; bySavepoint = false; savepoints = []; };
-    /** A meaningful write changed a row: its transaction's commit moves the revision, or this autocommit does now. */
     const wrote = () => { if (inTransaction())
         dirty = true;
     else
@@ -195,7 +182,6 @@ export function trackWorkspaceWrites(db) {
             }
             case 'release': {
                 const at = savepoints.map(one => one.name).lastIndexOf(effect.name);
-                // Releasing the savepoint that began the transaction commits it.
                 if (at === 0 && bySavepoint && dirty) {
                     bump();
                     dirty = false;
@@ -210,7 +196,6 @@ export function trackWorkspaceWrites(db) {
             default: run();
         }
     };
-    /** Run one data statement and report whether it changed the workspace. */
     const measured = (effect, body) => {
         if (effect.kind !== 'write')
             return body();
@@ -238,7 +223,6 @@ export function trackWorkspaceWrites(db) {
     const methods = {
         exec(sql) {
             let effect = effectOf(sql);
-            // A script of several statements is read by its first; past a quiet first one, any row it changes counts.
             if (effect.kind === 'none' && /;\s*\S/.test(sql))
                 effect = { kind: 'write', table: '', quiet: false };
             if (effect.kind === 'write' || effect.kind === 'none')
@@ -278,8 +262,6 @@ function passThrough(inner, methods) {
         getPrototypeOf: () => Object.getPrototypeOf(inner),
     });
 }
-/** Per-server response metadata. Reads preserve insertion order; writes at
- * capacity discard the oldest key before storing the supplied validator. */
 export class WorkspaceValidatorCache {
     entries = new Map();
     get(key) { return this.entries.get(key); }
@@ -293,8 +275,6 @@ export function prepareWorkspaceRevision(store) {
     const db = store.raw();
     db.prepare('INSERT OR IGNORE INTO service_cursor(key,value,updated_at) VALUES (?,0,?)').run(KEY, new Date().toISOString());
     const cursor = db.prepare('SELECT CAST(value AS TEXT) AS value FROM service_cursor WHERE key = ?');
-    // Another connection's commit moves data_version; this connection's own moves its bump count. Neither moved: the
-    // revision read last is still the revision.
     const dataVersion = db.prepare('PRAGMA data_version');
     const counted = db[BUMPS];
     let seen = null;