@volter/supercode-orchestrator 0.5.225 → 0.5.227

package/board/doors.mjs

@@ -43,7 +43,9 @@ async function opened(machine) {
  * harness's own service, spoken by its SDK over the machine's harness stream; every other door is the daemon's node
  * service. Throws the door's refusal (with its code).
  */
-export async function machineCall(machine, method, params = {}, { timeoutMs = 60_000 } = {}) {
+// `signal`: a caller that stops wanting the answer (a parked board generation's read) ends the call at once: the phase in
+// progress is aborted with the signal's reason, as its own deadline would abort it.
+export async function machineCall(machine, method, params = {}, { timeoutMs = 60_000, signal = null } = {}) {
   if (!method.startsWith('harness.v1.')) throw new Error('a machine door is a harness.v1 method');
   if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) throw new Error('a machine door timeout is a positive finite number of milliseconds');
   const started = performance.now();
@@ -57,15 +59,18 @@ export async function machineCall(machine, method, params = {}, { timeoutMs = 60
       code: 'REQUEST_TIMEOUT', phase: name, requestNotSent: name !== 'request',
     });
     if (remaining <= 0) throw expired();
+    if (signal?.aborted) throw signal.reason;
     const controller = new AbortController();
-    let timer;
+    let timer, onAbort;
     try {
       const timeout = new Promise((_, reject) => {
         timer = setTimeout(() => { const error = expired(); controller.abort(error); reject(error); }, remaining);
+        if (signal) { onAbort = () => { controller.abort(signal.reason); reject(signal.reason); }; signal.addEventListener('abort', onAbort, { once: true }); }
       });
       return await Promise.race([work({ timeoutMs: remaining, signal: controller.signal }), timeout]);
     } finally {
       clearTimeout(timer);
+      if (onAbort) signal.removeEventListener('abort', onAbort);
       noteStep(`door ${method}: ${name}`, performance.now() - at);
     }
   };

package/board/engine.mjs

@@ -1,4 +1,4 @@
-import { allocateReadableId } from './readable-id.mjs';
+import { allocateReadableId, cardReadableId, requireReadableId, validateReadableId } from './readable-id.mjs';
 // The board's transitions (docs/architecture/orchestrator.md §2.9): what a card may do, written for supercode and
 // kept to Hermes Kanban's lifecycle so the two read each other's boards. Statuses: triage · todo · scheduled ·
 // ready · running · blocked · review · done · archived. A card with a parent that is not done waits in `todo`
@@ -9,7 +9,7 @@ import { allocateReadableId } from './readable-id.mjs';
 // Each function takes an open board (`store.mjs`) and runs in one write transaction. Nothing here launches,
 // observes or sends: the dispatcher (`dispatch.mjs`) does, and records what it did through these.
 import { current } from './call.mjs';
-import { detachedCard, detachedSession, personCustody, sessionAddress, sessionOperation } from './custody.mjs';
+import { detachedCard, detachedSession, personCustody, personOf, sessionAddress, sessionOperation } from './custody.mjs';
 import { executionOf, readingContext } from './session-work.mjs';
 import { cardState, cardStateSql, holdDescription } from './card-state.mjs';
 import { spawn, execFile } from 'node:child_process';
@@ -18,9 +18,9 @@ import { join, resolve } from 'node:path';
 import { checkWorkspace, assertWorkspaceOwner, declareWorkspace, isLocalWorkspace, plainWorkspace } from './workspace.mjs';
 import { DatabaseSync } from 'node:sqlite';
 import { CARD_VISIBILITY_SQL } from './visibility.mjs';
-import { view, actorOf, principalOf, boardKey, cardBranch, cardHandle, CARD_NUMBERS, claimer, contention, event, json, newTaskId, now, retryContention, tx } from './store.mjs';
+import { view, actorOf, principalOf, cardBranch, CARD_NUMBERS, claimer, contention, event, json, newTaskId, now, retryContention, tx } from './store.mjs';
 import { arcRepositories, arcSources, assertSourceReceipt, completionPhase, outsideArcRepositories, inspectCompletionEvidence, observeCompletionEvidence, recordedArcRepositories, withCompletionEvidence } from './ci.mjs';
-import { addDependency, retireSupersededRuns, refreshCardInputs, requestSessionClose, reviewerOf, eventTo, fire, validateEvent, loadWorkflow, setStatus, settle, startNew, statusOf, runEvent, workflowFor } from './workflow.mjs';
+import { addDependency, retireSupersededRuns, refreshCardInputs, requestSessionClose, reviewerOf, eventTo, fire, validateEvent, loadWorkflow, setStatus, settle, startNew, statusOf, runEvent, transitionsFor, workflowFor } from './workflow.mjs';
 import { refuseCredentialDump, withheldIfDump } from './credential-guard.mjs';
 import { AGENT_KIND_LIST, compactCardAgentEvents } from './published.mjs';
 
@@ -42,16 +42,29 @@ const all = (db, sql, ...args) => db.prepare(sql).all(...args);
 const run = (db, sql, ...args) => db.prepare(sql).run(...args);
 
 // A card's number: what the store gave it when it was made (store.mjs layOutNumbers), read with its board's key
-// (`VO-42`, store.mjs boardKey). A person names a card by it wherever its id is taken (`VO-42`, `vo-42`, `#42`, `42`),
-// and every view of a card shows it first, before the id.
+// (`VO-42`, store.mjs boardKey). A person names a card by it, or by its readable id, wherever its id is taken (`VO-42`,
+// `vo-42`, `#42`, `42`, `voice-calls`), and every view of a card shows its readable id first, then its number and id.
 /** Card `n`'s id on this board, or null when no card here has that number. */
 export const cardByNumber = (db, n) => one(db, `SELECT t.id FROM ${CARD_NUMBERS} n JOIN tasks t ON t.id = n.task_id WHERE n.number = ?`, Number(n))?.id ?? null;
 /** The number of card `id`, or null. */
 export const numberOf = (db, id) => one(db, `SELECT number FROM ${CARD_NUMBERS} WHERE task_id = ?`, id)?.number ?? null;
-/** The numbers of cards `ids`: id → number. */
-export const numbersOf = (db, ids) => new Map(ids.length ? all(db, `SELECT task_id, number FROM ${CARD_NUMBERS} WHERE task_id IN (SELECT value FROM json_each(?))`, JSON.stringify([...new Set(ids)])).map((r) => [r.task_id, r.number]) : []);
-/** A card as a person reads it: its keyed number first (store.mjs boardKey), then its id (`VO-42 t_4406c88a`). */
-export const cardLabel = (key, number, id, readableId = null) => `${number ? `${key}-${number} ${id}` : String(id)}${readableId ? ` (${readableId})` : ''}`;
+/** A card as a person reads it: its readable id first, then its keyed number (store.mjs boardKey) and its id
+ *  (`voice-calls (VO-42 t_4406c88a)`); one with no readable id by its number and id (`VO-42 t_4406c88a`). */
+export const cardLabel = (key, number, id, readableId = null) => {
+  const ref = number ? `${key}-${number} ${id}` : String(id);
+  return readableId ? `${readableId} (${ref})` : ref;
+};
+/** Cards `ids` as a person reads them (cardLabel): id → label. A subtask, which no person named, by its number and id. */
+export const labelsOf = (db, key, ids) => new Map(ids.length ? all(db, `SELECT t.id, t.readable_id, n.number, c.subtask_of FROM tasks t LEFT JOIN ${CARD_NUMBERS} n ON n.task_id = t.id
+  LEFT JOIN supercode_cards c ON c.task_id = t.id WHERE t.id IN (SELECT value FROM json_each(?))`, JSON.stringify([...new Set(ids)]))
+  .map((r) => [r.id, cardLabel(key, r.number, r.id, r.subtask_of ? null : r.readable_id)]) : []);
+/** The card named `readableId` on this board: the open one holding it, else the one card that ever did; null otherwise. */
+export const cardByReadableId = (db, readableId) => {
+  const open = one(db, "SELECT id FROM tasks WHERE readable_id = ? AND status NOT IN ('done','cancelled','archived')", readableId)?.id;
+  if (open) return open;
+  const ever = all(db, 'SELECT id FROM tasks WHERE readable_id = ? LIMIT 2', readableId);
+  return ever.length === 1 ? ever[0].id : null;
+};
 
 export function getTask(db, id) {
   const row = one(db, 'SELECT * FROM tasks WHERE id = ?', id);
@@ -205,6 +218,7 @@ export function bodyTasks(body) {
  * before the card is filed: the filing (createCard) is one write that asks no machine. Answers the spec to file.
  */
 export async function prepareCard(board, spec) {
+  if (!spec.subtaskOf) requireReadableId(spec.readableId);
   const ws = parseWorkspace(spec.workspace ?? 'scratch');
   const project = spec.project ? projectOf(board.root, spec.project) : null;
   if (project) {
@@ -222,6 +236,8 @@ export async function prepareCard(board, spec) {
 export function createCard(board, spec) {
   const title = String(spec.title ?? '').trim();
   if (!title) throw new Error('a card has a title');
+  // A card is named by its creator (readable-id.mjs); a subtask, a row under its card that no person names, by its title.
+  if (!spec.subtaskOf) requireReadableId(spec.readableId);
   refuseCredentialDump('the card', { title, body: spec.body ?? null });
   const steps = spec.subtaskOf ? [] : bodyTasks(spec.body).tasks;
   if (steps.length) spec = { ...spec, body: bodyTasks(spec.body).body };
@@ -275,8 +291,9 @@ export function createCard(board, spec) {
     assertWorkspaceOwner(db, workspaceTask, checked);
     // The repository declaration stays separate from the resolved worktree path.
     if (project && ws.kind === 'scratch') ws.kind = 'worktree';
-    // A worktree card's branch is named for it once the store has numbered it (below), unless its creator named one.
-    const namedBranch = ws.kind === 'worktree' && !spec.branch ? (handle) => `${project ? `${project.slug}/` : ''}${cardBranch(handle, readableId)}` : null;
+    // A worktree card's branch is named by its readable id (below; store.mjs cardBranch), unless its creator named one; a
+    // subtask's, which no person names, by its id.
+    const namedBranch = ws.kind === 'worktree' && !spec.branch;
     spec = { ...spec, project: project?.id ?? null };
     const t = now();
     run(db, `INSERT INTO tasks (id, title, body, assignee, status, priority, created_by, created_at, workspace_kind, workspace_path, branch_name,
@@ -295,10 +312,10 @@ export function createCard(board, spec) {
       run(db, `DELETE FROM ${CARD_NUMBERS} WHERE task_id = ?`, id);
       if (taken != null) run(db, 'UPDATE sqlite_sequence SET seq = ? WHERE name = ? AND seq = ?', taken - 1, CARD_NUMBERS, taken);
     }
-    const readableId = allocateReadableId(db, title, spec.readableId ?? null, id);
+    const readableId = arc ? allocateReadableId(db, title, spec.readableId ?? null, id) : cardReadableId(db, spec.readableId, id);
     run(db, 'UPDATE tasks SET readable_id=? WHERE id=?', readableId, id);
-    const handle = cardHandle(boardKey(board.root, board.slug), numberOf(db, id));
-    if (namedBranch) run(db, 'UPDATE tasks SET branch_name = ? WHERE id = ?', handle ? namedBranch(handle) : `wt/${id}`, id);
+    const named = namedBranch && !arc ? cardBranch(db, id, readableId, project ? `${project.slug}/` : '') : null;
+    if (namedBranch) run(db, 'UPDATE tasks SET branch_name = ? WHERE id = ?', named ?? `wt/${id}`, id);
     const machine = spec.machine ?? arc?.machine ?? null;
     run(db, 'INSERT OR REPLACE INTO supercode_cards (task_id,machine,subtask_of,workspace_anchor,workspace_root,tags,requested_by_unverified) VALUES (?,?,?,?,?,?,?)', id, machine, arc?.id ?? null, declared.repository, checked?.workspaceRoot ?? null,
       tags.length ? JSON.stringify(tags) : null, spec.requestedByUnverified ? JSON.stringify(spec.requestedByUnverified) : null);
@@ -309,11 +326,15 @@ export function createCard(board, spec) {
       every: spec.every ?? null, goal: spec.goal === undefined || spec.goal === null ? null : spec.goal !== false, subtask_of: arc?.id ?? null });
     event(db, id, 'created', { creator: actorOf(), created_by: one(db, 'SELECT created_by FROM tasks WHERE id=?', id)?.created_by ?? null, assignee: spec.assignee || null,
       ...(spec.reviewer != null ? { reviewer: spec.reviewer } : {}), status, parents, tags, ...(spec.requestedByUnverified ? { requested_by_unverified: spec.requestedByUnverified } : {}), ...(machine ? { machine } : {}), ...(arc ? { subtask_of: arc.id } : {}) });
+    // its branch is claimed until its worktree is made: its machine takes none of that name that already exists
+    // (workspace.mjs branchClaim)
+    if (named) event(db, id, 'branch_named', { branch: named, repository: declared.repository ?? null });
     if ((spec.noStart || spec.adopt) && !arc) event(db, id, 'dispatch_held', { session: spec.adopt ?? null, reason: spec.adopt ? 'awaiting adoption' : 'created with --no-start' });
     if (parents.length) inheritSubscriptions(db, id, parents);
     if (arc) {
-      // the arc's subscribers hear its subtasks, and the arc's session works them
-      inheritSubscriptions(db, id, [arc.id], { workers: true });
+      // the arc's session works its subtasks and hears them; the arc's other followers follow the arc, not each subtask
+      // (a subtask's watchers are its own: its creator, its worker, whoever comments on it or is mentioned there)
+      inheritSubscriptions(db, id, [arc.id], { workers: true, only: 'worker' });
       event(db, arc.id, 'subtask_added', { subtask: id, title });
     }
     if (initial === 'running' && arc && entry.workflow.run) setStatus(db, entry.workflow, id, 'running');
@@ -421,12 +442,14 @@ export function extendClaim(db, id, { ttl, reason, extra = {} }) {
 
 /**
  * A completed card's workspace goes, as Hermes cleans up on completion: a scratch directory under the board's own
- * workspaces, or a worktree (its branch stays); never while a child still waits on it, never a `dir`.
+ * workspaces, or a worktree (its branch stays); never while a child still waits on it or another open card works in
+ * it, never a `dir`.
  */
 async function cleanupWorkspace(board, id) {
   const task = view(board, (db) => getTask(db, id));
   if (!task?.workspace_path || !isLocalWorkspace(task) || !['scratch', 'worktree'].includes(task.workspace_kind)) return;
-  const waiting = view(board, (db) => one(db, "SELECT 1 FROM task_links l JOIN tasks t ON t.id = l.child_id WHERE l.parent_id = ? AND t.status NOT IN ('done', 'archived') LIMIT 1", id));
+  const waiting = view(board, (db) => one(db, "SELECT 1 FROM task_links l JOIN tasks t ON t.id = l.child_id WHERE l.parent_id = ? AND t.status NOT IN ('done', 'archived') LIMIT 1", id)
+    ?? one(db, "SELECT 1 FROM tasks WHERE workspace_path = ? AND id <> ? AND status NOT IN ('done', 'archived', 'cancelled') LIMIT 1", task.workspace_path, id));
   if (waiting || !existsSync(task.workspace_path)) return;
   // awaited, never a wait that holds the event loop
   if (task.workspace_kind === 'worktree') { await new Promise((resolve) => execFile('git', ['-C', task.workspace_path, 'worktree', 'remove', '--force', task.workspace_path], { encoding: 'utf8' }, () => resolve())); return; }
@@ -459,7 +482,12 @@ async function cleanupWorkspace(board, id) {
 export function setCaller(fn) { current().roles = fn; }
 const callerRoles = (db, cardId) => current().roles(db, cardId);
 
-export async function act(board, id, name, { roles = null, payload = {}, extra = {} } = {}) {
+/**
+ * Fire `name` on card `id` as its caller (or `roles`), in one board write with what the move settles around it.
+ * `instead(db, error)`, when given, is asked in that same write when the event is refused: it answers another event's
+ * name to fire in its place (read and decided against the same state the refusal was), or null to keep the refusal.
+ */
+export async function act(board, id, name, { roles = null, payload = {}, extra = {}, instead = null } = {}) {
   assertSourceReceipt(payload);
   const entry = await loadWorkflow(board.root);
   if (name === 'comment' && (!String(payload.body ?? '').trim() || !String(payload.author ?? '').trim())) throw new Error('a comment has an author and body');
@@ -472,9 +500,18 @@ export async function act(board, id, name, { roles = null, payload = {}, extra =
   if (payload.ci?.required && !payload.ci.ready && (name !== 'request_state' || evidencePhase === 'review_verdict')) throw new Error(payload.ci.reason ?? 'The PR candidate could not be verified.');
   const result = tx(board, (db) => {
     roles ??= callerRoles(db, id);
-    const r = fire(db, board, entry, id, name, { roles, payload, extra });
+    let r;
+    try { r = fire(db, board, entry, id, name, { roles, payload, extra }); }
+    catch (error) {
+      const other = (error.refusal || error.noTransition) && instead ? instead(db, error, entry) : null;
+      if (!other) throw error;
+      r = { ...fire(db, board, entry, id, other.name, { roles, payload, extra }), instead: other };
+    }
     // Authorization and the comment row share one transaction: a refusal stores nothing.
-    if (name === 'comment') r.commentId = Number(run(db, 'INSERT INTO task_comments (task_id, author, body, created_at) VALUES (?, ?, ?, ?)', id, payload.author.trim(), payload.body.trim(), now()).lastInsertRowid);
+    if (name === 'comment') {
+      r.commentId = Number(run(db, 'INSERT INTO task_comments (task_id, author, body, created_at) VALUES (?, ?, ?, ?)', id, payload.author.trim(), payload.body.trim(), now()).lastInsertRowid);
+      joinThread(db, entry, id, payload.author.trim(), payload.body);
+    }
     // the cards that wait on it, and its subtasks, see it change
     // Card blockers are mirrored to task_links by relation writes and document imports. Its parent key is the reverse
     // lookup; reading every card's blocked_by JSON on each public verb only rediscovers the same children.
@@ -485,7 +522,7 @@ export async function act(board, id, name, { roles = null, payload = {}, extra =
   await runEffects(board, result.effects);
   // A card this verb closed ends its agents' assignments; the verb hands the ends on itself (agent-declarations.mjs).
   if (result.moved) { const { endFinishedAgents } = await import('./agent-declarations.mjs'); await endFinishedAgents(board, [id]); }
-  return { from: result.from, to: result.to, moved: result.moved, ...(result.commentId ? { commentId: result.commentId } : {}) };
+  return { from: result.from, to: result.to, moved: result.moved, ...(result.commentId ? { commentId: result.commentId } : {}), ...(result.instead ? { instead: result.instead } : {}) };
 }
 
 export async function requestStateMany(board, ids, payload = {}) {
@@ -496,6 +533,8 @@ export async function requestStateMany(board, ids, payload = {}) {
   const prepared = new Map(await Promise.all(targets.map(async id => {
     const roles = callerRoles(board.db, id);
     const phase = completionPhase(board, id, entry, 'request_state', payload, roles);
+    // As in complete: only a reviewer's verdict reads PRs from a state request; anyone else's would be dropped unread.
+    if (phase !== 'review_verdict' && [].concat(payload.pr ?? [], payload.pr_head ?? []).length) throw new Error(`A state request records no PRs: declare the arc's PRs on it with comment <arc> "<why>" --pr URL --pr-head SHA (one pair per PR), then request the state without them. Nothing was requested.`);
     view(board, db => validateEvent(db, board, entry, id, 'request_state', { roles, payload, localOnly: true }));
     const evidence = await inspectCompletionEvidence(board, id, entry, payload, phase);
     // An ordinary request mails a decision to the manager, not a completion.
@@ -686,7 +725,8 @@ function invalidateDescendants(db, board, id) {
   for (const row of rows) {
     if (!['ready', 'review', 'running', 'done'].includes(row.status)) continue;
     const resume = row.status === 'review' ? 'review' : row.status === 'running' ? retryStatus(db, row.id) : 'ready';
-    const runId = row.status === 'running' ? endRun(db, row.id, { outcome: 'reclaimed', status: 'todo', summary: `ancestor ${id} reopened` }) : null;
+    // a card holds a current run in review as well as in running: whichever it holds is ended with the card's pull back
+    const runId = endRun(db, row.id, { outcome: 'reclaimed', status: 'todo', summary: `ancestor ${id} reopened` });
     run(db, 'UPDATE tasks SET completed_at = NULL, claim_lock = NULL, claim_expires = NULL, worker_pid = NULL, current_run_id = NULL, consecutive_failures = 0 WHERE id = ?', row.id);
     setStatus(db, workflow, row.id, 'todo');
     event(db, row.id, 'descendant_invalidated', { ancestor: id, prior_status: row.status, new_status: 'todo', resume_status: resume }, runId);
@@ -702,20 +742,75 @@ function invalidateDescendants(db, board, id) {
 export const complete = async (board, id, options = {}) => {
   assertSourceReceipt(options);
   const { result = null, summary = null, metadata = null, roles, runId = null, commit = null, branch = null, pr = null, pr_head = null, reviewed_sha = null } = options;
+  // Only a reviewer's verdict reads PRs from a completion (ci.completionPhase); anyone else's would be dropped unread,
+  // so it is refused: an arc's PRs are declared on the arc with comment --pr URL --pr-head SHA.
+  // A person's card closes only on that person's completion (personDone, as the board's platform event): no session,
+  // creator or manager completes it through this verb.
+  const person = view(board, (db) => personOf(getTask(db, id)?.assignee));
+  if (person) throw Object.assign(new Error(`${id} is assigned to ${person}: it closes when that person completes it in the Workplace (person-done), never by complete. Nothing was completed.`), { refusal: true });
+  if ([].concat(pr ?? [], pr_head ?? []).length && !view(board, (db) => roles ?? callerRoles(db, id)).includes('reviewer')) {
+    const arc = view(board, (db) => one(db, 'SELECT subtask_of FROM supercode_cards WHERE task_id = ?', id))?.subtask_of ?? id;
+    throw new Error(`complete records no PRs: declare the arc's PRs on it with comment ${arc} "<why>" --pr URL --pr-head SHA (one pair per PR), then complete ${id} without them. Nothing was completed.`);
+  }
   return await act(board, id, 'complete', { roles, payload: { result, summary, metadata, run_id: runId, commit, branch, pr, pr_head, reviewed_sha } });
 };
+/**
+ * A person completed the card assigned to them (`person:<Teams principal>`), as the Workplace reported it: the board sends
+ * its own `complete` as the platform with the person and their answer, and the workflow closes the card only when that
+ * person is the one it is assigned to. The cards blocked on it are released by `dependency_resolved`. The same report
+ * again (a retried delivery) answers `already`.
+ */
+export const personDone = async (board, id, { person, result, task = null } = {}) => {
+  const refused = (message) => Object.assign(new Error(message), { refusal: message });
+  if (!/^person:\S+$/.test(String(person ?? ''))) throw refused('a person\'s completion names the person: --person person:<principal>');
+  if (!String(result ?? '').trim()) throw refused('a person\'s completion carries their answer (--result)');
+  const done = view(board, (db) => {
+    const card = getTask(db, id);
+    if (!card) throw refused(`no card ${id}`);
+    // done, or archived after it (stored as archived): the person's own completion recorded on it is the same report
+    if (!['done', 'archived'].includes(card.status)) return false;
+    const completed = db.prepare("SELECT payload FROM task_events WHERE task_id = ? AND kind = 'completed' ORDER BY id DESC LIMIT 1").get(id);
+    return json(completed?.payload, {})?.person === person;
+  });
+  if (done) return { already: true };
+  return { already: false, ...await act(board, id, 'complete', { roles: ['platform'], payload: { person, result: String(result).trim(), task } }) };
+};
 // a block names the one thing that ends it: a card it waits on (`on`), or the message whose answer it waits for (`waiting_on`)
 export const block = async (board, id, { reason = null, on = null, waitingOn = null, kind = 'needs_input', roles, runId = null } = {}) =>
   await act(board, id, 'block', { roles, payload: { reason, on, kind, waiting_on: waitingOn, run_id: runId } });
 export const unblock = (board, id, { reason = null, on = null, roles } = {}) => act(board, id, 'unblock', { roles, payload: { reason, on } });
 export const requestReview = async (board, id, options = {}) => {
   assertSourceReceipt(options);
-  const { summary = null, metadata = null, reviewer = null, force = false, expectedRunId = null, roles, commit = null, branch = null, pr = null, pr_head = null } = options;
-  return await act(board, id, 'request_review', { roles, payload: { summary, metadata, reviewer, force, run_id: expectedRunId, commit, branch, pr, pr_head } });
+  const { summary = null, metadata = null, reviewer = null, force = false, expectedRunId = null, roles, commit = null, branch = null, pr = null, pr_head = null, plan = false } = options;
+  // What a session's request asks for is what it says, never its summary's words: `--plan` asks the plan review of the
+  // proposed ADR's PR it names, and one PR named with its head (--pr, --pr-head) is that PR's review. The workflow's
+  // clauses read `review`; a request naming several PRs asks neither.
+  const one = [].concat(pr ?? []).length === 1 && [].concat(pr_head ?? []).length === 1;
+  const review = plan ? 'plan' : one ? 'pr' : null;
+  return await act(board, id, 'request_review', { roles, payload: { summary, metadata, reviewer, force, run_id: expectedRunId, commit, branch, pr, pr_head, review, plan: Boolean(plan) } });
 };
 export const requestChanges = (board, id, { reason = null, reviewer = null, roles } = {}) => act(board, id, 'request_changes', { roles, payload: { reason, reviewer } });
 export const reopen = (board, id, { author = 'user', reason = null, roles } = {}) => act(board, id, 'reopen', { roles, payload: { author, reason } });
-export const reopenReview = (board, id, { roles, reason = null } = {}) => act(board, id, 'reopen_review', { roles, payload: { reason } });
+/** The manager's door out of review: the card goes back to its coder with no verdict, its review run ending as returned
+ *  (the workflow's `return_review`, where it declares one). */
+export const returnReview = (board, id, { reason = null, roles } = {}) => act(board, id, 'return_review', { roles, payload: { reason } });
+/**
+ * Void the latest verdict so the board reviews again; or, for a review whose run is still open with no verdict (its
+ * reviewer stalled, VO-3259 run 2408), restart that run: the workflow's own `reclaim` ends it and closes its reviewer
+ * session, the card stays in review, and the board's next review run resumes that same reviewer session with the
+ * round's brief. Nothing is voided there, because no verdict was given. Answers the move, with `restarted_run` when it
+ * restarted one.
+ */
+export async function reopenReview(board, id, { roles, reason = null } = {}) {
+  // the refusal, the check that the open run is a reviewer's and the restart are one write: no verdict lands between
+  const moved = await act(board, id, 'reopen_review', { roles, payload: { reason }, instead: (db, _error, entry) => {
+    const run = currentRun(db, id);
+    const stays = transitionsFor(entry.workflow, 'review', 'reclaim').some((t) => !t.target || t.target === 'review');
+    return run && run.ended_at == null && run.metadata?.supercode?.slot === 'reviewer' && stays ? { name: 'reclaim', run: run.id } : null;
+  } });
+  const { instead, ...rest } = moved;
+  return instead ? { ...rest, restarted_run: instead.run } : rest;
+}
 export const schedule = (board, id, reason = null, { roles } = {}) => act(board, id, 'schedule', { roles, payload: { reason } });
 export const promote = (board, id, { actor = 'user', reason = null, force = false, roles } = {}) => act(board, id, 'promote', { roles, payload: { actor, reason, force } });
 export const reclaim = (board, id, reason = null, { roles } = {}) => act(board, id, 'reclaim', { roles, payload: { reason } });
@@ -734,8 +829,13 @@ export async function specify(board, id, { title = null, body = null, readableId
     if (branch != null && ws.kind === 'scratch') throw new Error('a scratch workspace has no repository branch');
     declaration = { kind: ws.kind, ...(await declareWorkspace(ws.kind, ws.path, target, branch)), ...(machine != null && target !== task.machine ? { machine: target } : {}) };
     if (declaration.repository === task.workspace_anchor) declaration.branch ??= task.branch_name;
-    const handle = cardHandle(boardKey(board.root, board.slug), task.number);
-    if (declaration.kind === 'worktree') declaration.branch ??= handle ? cardBranch(handle, task.readable_id) : `wt/${id}`;
+    const named = task.subtask_of ? null : readableId ?? task.readable_id;
+    // a retarget's new branch is named as a new card's is, under its project's `<slug>/` (createCard)
+    if (declaration.kind === 'worktree' && declaration.branch == null && named) {
+      const project = task.project_id ? projectOf(board.root, task.project_id) : null;
+      Object.assign(declaration, { branch: cardBranch(board.db, id, named, project ? `${project.slug}/` : ''), named: true });
+    }
+    if (declaration.kind === 'worktree') declaration.branch ??= `wt/${id}`;
     if (declaration.kind === 'dir') declaration.path = (await checkWorkspace(board, { ...task, machine: target, workspace_kind: declaration.kind, workspace_anchor: declaration.repository, workspace_path: declaration.path, branch_name: declaration.branch })).path;
   }
   // an arc's new task lines are filed as its subtasks once the specify itself is accepted
@@ -851,11 +951,120 @@ export async function comment(board, id, author, body, { roles, pr = null, pr_he
  * Subscribe `address` (a supercode session address) to a card's events from now on. `role` is `creator` (told of
  * starts, completion and blocks) or `worker` (told of updates to the card it works).
  */
-export function subscribeIn(db, id, address, role = 'creator') {
+export function subscribeIn(db, id, address, role = 'creator', { explicit = false, own = false } = {}) {
+  // a session that is an agent's main follows a card under its agent's address: one follower, one subscription
+  if (!['worker', 'dependency'].includes(role)) address = followerAddress(address);
   if (personCustody(db, address)) return;
   const cursor = one(db, 'SELECT COALESCE(MAX(id), 0) AS c FROM task_events WHERE task_id = ?', id).c;
   run(db, `INSERT OR IGNORE INTO kanban_notify_subs (task_id, platform, chat_id, thread_id, chat_type, delivery_mode, delivery_metadata, created_at, last_event_id)
-           VALUES (?, 'supercode', ?, '', 'dm', 'notify+wake', ?, ?, ?)`, id, address, JSON.stringify({ role }), now(), cursor);
+           VALUES (?, 'supercode', ?, '', 'dm', 'notify+wake', ?, ?, ?)`, id, address, JSON.stringify({ role, ...(own ? { own: true } : {}) }), now(), cursor);
+  // the card's own creator's subscription says so (`own`): it is the card's, never a copy of its arc's followers
+  // (so does an explicit notify-subscribe: a follower who asked for this card follows it, not its arc)
+  own ||= explicit;
+  if (own) run(db, `UPDATE kanban_notify_subs SET delivery_metadata = json_set(delivery_metadata, '$.own', json('true'))
+    WHERE task_id = ? AND platform = 'supercode' AND chat_id = ? AND thread_id = ''`, id, address);
+  // opting in again (notify-subscribe) ends an unsubscribe, from now on: what it missed meanwhile is not told
+  if (explicit) run(db, `UPDATE kanban_notify_subs SET delivery_metadata = json_remove(delivery_metadata, '$.unsubscribed'), last_event_id = MAX(last_event_id, ?)
+    WHERE task_id = ? AND platform = 'supercode' AND chat_id = ? AND thread_id = '' AND json_extract(delivery_metadata, '$.unsubscribed')`, cursor, id, address);
+  // A follower that takes a stronger role on the card hears it in that role from now on (its unsubscribe stands): a
+  // participant or creator that is the board's manager hears it as the manager, never as both. What the new role hears
+  // is told from now on, never the card's history (the cursor moves to the card's last event).
+  // A worker or a dependency follower takes over a participant's subscription, as before.
+  const outranked = FOLLOWER_RANKS.includes(role) ? FOLLOWER_RANKS.slice(FOLLOWER_RANKS.indexOf(role) + 1) : ['participant'];
+  // the role it held is kept beside it (`also`): what that role heard, the follower still hears (a manager that created
+  // a card is told its audit rounds as its creator was)
+  // (only a follower's role is kept so, appended to what it kept before; a worker or dependency hears its own kinds)
+  if (!outranked.length) return;
+  const held = all(db, `SELECT delivery_metadata FROM kanban_notify_subs WHERE task_id = ? AND platform = 'supercode' AND chat_id = ? AND thread_id = ''
+    AND json_extract(delivery_metadata, '$.role') IN (${outranked.map(() => '?').join(', ')})`, id, address, ...outranked)[0];
+  if (!held) return;
+  const meta = json(held.delivery_metadata, {}) ?? {};
+  const also = FOLLOWER_RANKS.includes(role) ? [...new Set([...[].concat(meta.also ?? []), meta.role ?? 'creator'])].filter((r) => r !== role) : [].concat(meta.also ?? []);
+  run(db, `UPDATE kanban_notify_subs SET delivery_metadata = ?, last_event_id = MAX(last_event_id, ?) WHERE task_id = ? AND platform = 'supercode' AND chat_id = ? AND thread_id = ''`,
+    JSON.stringify({ ...meta, role, ...(also.length ? { also } : {}) }), cursor, id, address);
+}
+
+/** The roles a follower of a card holds, strongest first; a follower holds one (subscribeIn). */
+const FOLLOWER_RANKS = ['manager', 'creator', 'participant'];
+
+/**
+ * The one address a follower is subscribed under: a session that is the main session of an agent this call read (the
+ * board's managers, read before each verb: cli readAgentMains) follows as its agent's address, so a manager commenting
+ * or mentioned from its main session is not a second follower beside its agent (sc:<machine>:agent:manager). Any other
+ * address is itself.
+ */
+export function followerAddress(address) {
+  for (const [agent, main] of current().agentMains ?? []) if (typeof main === 'string' && main === address) return agent;
+  return address;
+}
+
+/**
+ * A card's thread is followed as an issue tracker's is: its author and everyone it @mentions follow the card from this
+ * comment on (`participant`, unless they already follow it in another role), and a follower who had unsubscribed and is
+ * mentioned, or comments, follows it again. Every comment then reaches every follower but its author (notify).
+ */
+function joinThread(db, entry, id, author, body) {
+  const said = one(db, "SELECT MAX(id) AS id FROM task_events WHERE task_id = ? AND kind = 'commented'", id)?.id ?? null;
+  // the board's own comments (an unsubscribe's) bring no one in, whoever they name
+  if (said == null || author === 'board') return;
+  if (/^sc:/.test(author)) follow(db, id, author, said);
+  for (const address of mentioned(db, entry, body)) if (address !== author) follow(db, id, address, said - 1);
+}
+
+/** Follow card `id` from event `cursor` on: a new follower as a participant, an unsubscribed one again. */
+function follow(db, id, address, cursor) {
+  address = followerAddress(address);
+  if (personCustody(db, address)) return;
+  const row = one(db, "SELECT delivery_metadata, last_event_id FROM kanban_notify_subs WHERE task_id = ? AND platform = 'supercode' AND chat_id = ? AND thread_id = ''", id, address);
+  if (!row) {
+    run(db, `INSERT INTO kanban_notify_subs (task_id, platform, chat_id, thread_id, chat_type, delivery_mode, delivery_metadata, created_at, last_event_id)
+             VALUES (?, 'supercode', ?, '', 'dm', 'notify+wake', ?, ?, ?)`, id, address, JSON.stringify({ role: 'participant' }), now(), cursor);
+    return;
+  }
+  const meta = json(row.delivery_metadata, {}) ?? {};
+  if (!meta.unsubscribed) return;
+  const { unsubscribed: _u, ...kept } = meta;
+  run(db, "UPDATE kanban_notify_subs SET delivery_metadata = ?, last_event_id = ? WHERE task_id = ? AND platform = 'supercode' AND chat_id = ? AND thread_id = ''",
+    JSON.stringify(kept), Math.max(Number(row.last_event_id), cursor), id, address);
+}
+
+/** The addresses a comment @mentions: `@manager` (the board's managers), a session's or agent's full address
+ *  (`@sc:<machine>:<kind>:<name>`), or an agent's name (`@<name>`) that a board address already names. Other words
+ *  after an @ (a package scope, an e-mail) name no one. */
+export function mentioned(db, entry, body) {
+  const managers = [].concat(entry?.params?.managers ?? []).map(String);
+  const found = new Set();
+  for (const [, name] of String(body ?? '').matchAll(/(?:^|[^\w@/.-])@([A-Za-z0-9_][\w.:-]*[\w])/g)) {
+    if (name === 'manager') { managers.forEach((m) => found.add(m)); continue; }
+    if (/^sc:[^:\s]+:[^:\s]+:[^:\s]+$/.test(name)) { found.add(name); continue; }
+    const known = [...managers, ...all(db, "SELECT DISTINCT chat_id FROM kanban_notify_subs WHERE platform = 'supercode' AND chat_id LIKE ?", `%:agent:${name}`).map((r) => r.chat_id)]
+      .filter((address) => address.endsWith(`:agent:${name}`));
+    for (const address of new Set(known)) found.add(address);
+  }
+  return [...found];
+}
+
+/** How a follower is mentioned: an agent by its name (`manager`), a session by its address. */
+export const mentionName = (address) => /^sc:[^:]+:agent:([^:]+)$/.exec(String(address))?.[1] ?? String(address);
+
+/**
+ * `address` stops following card `id`: its subscription is kept, marked unsubscribed, so no round subscribes it again
+ * (a manager or a worker is subscribed each round), and the board says so on the card with how to bring it back, a
+ * comment every remaining follower hears. A mention or its own comment makes it follow again (follow).
+ */
+export function unsubscribe(board, id, address) {
+  return tx(board, (db) => {
+    const row = one(db, "SELECT delivery_metadata FROM kanban_notify_subs WHERE task_id = ? AND platform = 'supercode' AND chat_id = ? AND thread_id = ''", id, address);
+    const meta = json(row?.delivery_metadata, {}) ?? {};
+    if (!row || meta.unsubscribed) return false;
+    run(db, "UPDATE kanban_notify_subs SET delivery_metadata = ? WHERE task_id = ? AND platform = 'supercode' AND chat_id = ? AND thread_id = ''", JSON.stringify({ ...meta, unsubscribed: true }), id, address);
+    // the board's own comment, written with the mark: no workflow's comment verb stands between them
+    const name = mentionName(address), body = `${name} unsubscribed; mention @${name} to bring them back.`;
+    // the event first, as a verb's comment is: its notice reads the comment written at or after it
+    event(db, id, 'commented', { author: 'board', len: body.length, by: 'board' });
+    run(db, 'INSERT INTO task_comments (task_id, author, body, created_at) VALUES (?, ?, ?, ?)', id, 'board', body, now());
+    return true;
+  });
 }
 
 /** Reconcile only the current worker's audience, inside the binding transaction. */
@@ -881,12 +1090,8 @@ export function replaceWorkerSubscriptions(db, id, address) {
   return true;
 }
 
-export function subscribe(board, id, address, role = 'creator') {
-  return tx(board, (db) => { must(db, id); subscribeIn(db, id, address, role); });
-}
-
-export function unsubscribe(board, id, address) {
-  return tx(board, (db) => run(db, "DELETE FROM kanban_notify_subs WHERE task_id = ? AND platform = 'supercode' AND chat_id = ?", id, address).changes > 0);
+export function subscribe(board, id, address, role = 'creator', { own = false } = {}) {
+  return tx(board, (db) => { must(db, id); subscribeIn(db, id, address, role, { explicit: true, own }); });
 }
 
 function dependencyRecipient(db, id) {
@@ -925,20 +1130,27 @@ export function reconcileDependencySubscriptions(db) {
     const where = "WHERE task_id=? AND platform='supercode' AND chat_id=? AND thread_id=?";
     const identity = [row.task_id, row.chat_id, row.thread_id];
     if (!owner || owner.detached || owner.archived || ['done', 'cancelled', 'archived'].includes(owner.status)) run(db, `DELETE FROM kanban_notify_subs ${where}`, ...identity);
-    else if (address && (address !== row.chat_id || metadata.waiting_recipient)) run(db, `UPDATE kanban_notify_subs SET chat_id=?,delivery_metadata=? ${where}`, address, JSON.stringify({ ...metadata, notice_wait: undefined, waiting_recipient: false, failures: 0 }), ...identity);
+    // a subscription moved to its arc's new session starts from the card's last event: the new session is told what
+    // happens from now on, never the card's history the old one was told or missed
+    // (a subscription that waited for its arc to have a session keeps its cursor: what it waited to tell is still told)
+    else if (address && (address !== row.chat_id || metadata.waiting_recipient)) run(db, `UPDATE kanban_notify_subs SET chat_id=?,delivery_metadata=?,last_event_id=CASE WHEN ? THEN MAX(last_event_id,(SELECT COALESCE(MAX(id),0) FROM task_events WHERE task_id=?)) ELSE last_event_id END ${where}`,
+      address, JSON.stringify({ ...metadata, notice_wait: undefined, waiting_recipient: false, failures: 0 }), address !== row.chat_id ? 1 : 0, row.task_id, ...identity);
     else if (!address && !metadata.waiting_recipient) run(db, `UPDATE kanban_notify_subs SET delivery_metadata=? ${where}`, JSON.stringify({ ...metadata, waiting_recipient: true }), ...identity);
   }
 }
 
-/** A child hears what its parents' subscribers hear (Hermes copies them at link time); a subtask its arc's session too. */
-function inheritSubscriptions(db, child, parents, { workers = false } = {}) {
+/** A child hears what its parents' subscribers hear (Hermes copies them at link time); a subtask only its arc's session. */
+function inheritSubscriptions(db, child, parents, { workers = false, only = null } = {}) {
   const cursor = one(db, 'SELECT COALESCE(MAX(id), 0) AS c FROM task_events WHERE task_id = ?', child).c;
   for (const p of parents) {
     for (const s of all(db, 'SELECT * FROM kanban_notify_subs WHERE task_id = ?', p)) {
       const metadata = json(s.delivery_metadata, {}) ?? {}, role = metadata.role;
       if ((role === 'worker' && !workers) || role === 'dependency') continue; // a parent's session does not work the child
+      if (only && role !== only) continue;
       // A child's subscription is a new wait, not the parent's retained delivery state.
       delete metadata.notice_wait;
+      // a parent's own creator or kept roles are not the child's
+      delete metadata.own; delete metadata.also;
       run(db, `INSERT OR IGNORE INTO kanban_notify_subs (task_id, platform, chat_id, thread_id, user_id, user_id_alt, chat_type, notifier_profile, delivery_mode, delivery_metadata, created_at, last_event_id)
                VALUES (?, ?, ?, ?, ?, ?, COALESCE(?, 'dm'), ?, COALESCE(?, 'notify'), ?, ?, ?)`,
         child, s.platform, s.chat_id, s.thread_id, s.user_id, s.user_id_alt, s.chat_type, s.notifier_profile, s.delivery_mode, JSON.stringify(metadata), now(), cursor);
@@ -1014,22 +1226,25 @@ export function cardContext(db, id, options = {}) {
 
 
 
-/** Hermes's swarm: a completed root as the shared blackboard, workers after it, a verifier after them all, a synthesizer last. */
-export function swarm(board, { goal, workers, verifier, synthesizer, tenant = null, createdBy = null, priority = 0, idempotencyKey = null }) {
+/** Hermes's swarm: a completed root as the shared blackboard, workers after it, a verifier after them all, a synthesizer last.
+ *  Its cards are named by the swarm's readable id: the root by it, then `<id>-worker-<n>`, `<id>-verify`, `<id>-synthesis`. */
+export function swarm(board, { goal, readableId, workers, verifier, synthesizer, tenant = null, createdBy = null, priority = 0, idempotencyKey = null }) {
   if (!String(goal ?? '').trim()) throw new Error('a swarm has a goal');
   if (!workers.length) throw new Error('a swarm has at least one --worker PROFILE:TITLE[:SKILL,SKILL]');
+  requireReadableId(readableId);
+  for (const name of [...workers.map((_, n) => `${readableId}-worker-${n + 1}`), `${readableId}-verify`, `${readableId}-synthesis`]) validateReadableId(name);
   const protocol = (root) => `\n\n## Swarm protocol\n- Swarm root / shared blackboard: \`${root}\`.\n- Read sibling/parent handoffs from the board's context before working.\n`
     + `- Put machine-readable facts in completion metadata.\n- Put cross-worker notes on the root card as comments.\n- Goal: ${goal.trim()}\n`;
-  const root = createCard(board, { title: `Swarm: ${goal.trim()}`.slice(0, 200), body: goal, tenant, createdBy, priority, idempotencyKey, initialStatus: 'blocked' });
+  const root = createCard(board, { title: `Swarm: ${goal.trim()}`.slice(0, 200), readableId, body: goal, tenant, createdBy, priority, idempotencyKey, initialStatus: 'blocked' });
   if (root.existing) return { root_id: root.id, existing: true };
   tx(board, (db) => {
     run(db, "UPDATE tasks SET status = 'done', completed_at = ? WHERE id = ?", now(), root.id);
     const runId = synthesizeRun(db, root.id, { outcome: 'completed', summary: 'swarm blackboard', metadata: { swarm: true } });
     event(db, root.id, 'completed', { result_len: 0, summary: 'swarm blackboard' }, runId);
   });
-  const workerIds = workers.map((w) => createCard(board, { title: w.title, body: `${w.title}${protocol(root.id)}`, assignee: w.profile, skills: w.skills, parents: [root.id], tenant, createdBy, priority }).id);
-  const verifierId = createCard(board, { title: 'Verify swarm outputs', body: `Verify the workers' outputs.${protocol(root.id)}`, assignee: verifier, parents: workerIds, tenant, createdBy, priority }).id;
-  const synthesizerId = createCard(board, { title: 'Synthesize swarm outputs', body: `Synthesize the verified outputs.${protocol(root.id)}`, assignee: synthesizer, parents: [verifierId], tenant, createdBy, priority }).id;
+  const workerIds = workers.map((w, n) => createCard(board, { title: w.title, readableId: `${readableId}-worker-${n + 1}`, body: `${w.title}${protocol(root.id)}`, assignee: w.profile, skills: w.skills, parents: [root.id], tenant, createdBy, priority }).id);
+  const verifierId = createCard(board, { title: 'Verify swarm outputs', readableId: `${readableId}-verify`, body: `Verify the workers' outputs.${protocol(root.id)}`, assignee: verifier, parents: workerIds, tenant, createdBy, priority }).id;
+  const synthesizerId = createCard(board, { title: 'Synthesize swarm outputs', readableId: `${readableId}-synthesis`, body: `Synthesize the verified outputs.${protocol(root.id)}`, assignee: synthesizer, parents: [verifierId], tenant, createdBy, priority }).id;
   return { root_id: root.id, worker_ids: workerIds, verifier_id: verifierId, synthesizer_id: synthesizerId };
 }
 
@@ -1081,13 +1296,14 @@ export function runs(db, id, { stateType = null, stateName = null } = {}) {
   return all(db, `SELECT * FROM task_runs WHERE task_id = ?${where} ORDER BY id`, ...(where ? [id, stateName] : [id])).map((r) => ({ ...r, metadata: json(r.metadata, null) }));
 }
 
-/** Retain assignment facts in checkpoints, then delete old thread events of done and archived cards. */
+/** Retain assignment facts in checkpoints, then delete old thread events of done and archived cards; their creation and
+ *  branch records (branch_named, worktree_made) stay, by which a reopened card finds its worktree folder. */
 export function gcEvents(board, seconds) {
   return tx(board, db=>{
     const cut=now()-seconds;
     const cards=all(db,`SELECT DISTINCT task_id FROM task_events WHERE kind IN (${AGENT_KIND_LIST.map(()=>'?').join(',')}) AND created_at<? AND task_id IN (SELECT id FROM tasks WHERE status IN ('done','archived'))`,...AGENT_KIND_LIST,cut);
     let compacted=0;for(const card of cards)compacted+=compactCardAgentEvents(db,card.task_id);
-    return compacted+Number(run(db,"DELETE FROM task_events WHERE kind!='created' AND created_at<? AND task_id IN (SELECT id FROM tasks WHERE status IN ('done','archived'))",cut).changes);
+    return compacted+Number(run(db,"DELETE FROM task_events WHERE kind NOT IN ('created','branch_named','worktree_made') AND created_at<? AND task_id IN (SELECT id FROM tasks WHERE status IN ('done','archived'))",cut).changes);
   });
 }
 

package/board/files.mjs

@@ -12,7 +12,7 @@ import { fillReadableIds } from './readable-id.mjs';
 import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
 import { fenced } from './fence.mjs';
 import { markRemovedHeads } from './published.mjs';
-import { CARD_NUMBERS } from './store.mjs';
+import { CARD_NUMBERS, unnumberTasks } from './store.mjs';
 import { createHash } from 'node:crypto';
 import { join } from 'node:path';
 import { DatabaseSync } from 'node:sqlite';
@@ -133,6 +133,9 @@ class FilesBoard {
     cards.sort((a, b) => madeAt(a) - madeAt(b) || (String(a.id) < String(b.id) ? -1 : String(a.id) > String(b.id) ? 1 : 0));
     for (const card of cards) for (const [table, rows] of Object.entries(card.tables ?? {})) if (table !== CARD_NUMBERS) insert(table, rows);
     for (const [table, rows] of Object.entries(state?.tables ?? {})) insert(table, rows);
+    // A task whose file names no number keeps none: only cards are numbered.
+    unnumberTasks(mem, new Set(cards.filter((card) => card.tables?.[CARD_NUMBERS]?.length).map((card) => card.id)),
+      (state?.sequence ?? []).find((row) => row.name === CARD_NUMBERS)?.seq ?? 0);
     // Loading inserts every card, which marks every card changed (published.mjs). The first load of this projection keeps
     // those marks: its next write compares each card with its published head once (a named limit: each projection opened
     // compares every card once, as each load already reads every card's file). A reload keeps the marks not yet

package/board/fleet-listeners.mjs

@@ -1,5 +1,6 @@
 // Fleet facts are mail obligations, independent of card transitions and dispatch ticks. Intent comes only from the
 // canonical workflow IR. The sender supplies observations from its admitted sources; this router grants nothing.
+import { GENERATION_STOPPED } from './generation.mjs';
 import { DatabaseSync } from 'node:sqlite';
 import { chmodSync, mkdirSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
@@ -213,7 +214,8 @@ export class FleetListenerRouter {
     }
   }
 
-  wake() { if (!this.closed) void this.flush().catch(error => this.log(`fleet listener filing: ${String(error.message).slice(0, 300)}`)); }
+  // A flush its stopping board generation refused never ran (GENERATION_STOPPED, generation.mjs): said as that.
+  wake() { if (!this.closed) void this.flush().catch(error => this.log(error?.code === GENERATION_STOPPED ? `fleet listener filing not run: ${error.message}` : `fleet listener filing: ${String(error.message).slice(0, 300)}`)); }
 
   /** A lost filing answer leaves the obligation pending. Retrying its stable id goes through the mailbox's own
    *  idempotent filing. This receipt proves filing only; native turn delivery remains the mailbox's responsibility. */

package/board/fleet-observer.mjs

@@ -48,8 +48,9 @@ export function observeRoleFleet(root, router, records, log = () => {}, { waitin
     }
     if (!waiting) continue;
     // The existing pane activity grant is still required (operator plus whole-machine view on a peer). A lost index,
-    // unread activity or absent record never clears a wait. Waiting on a live native session is not inferred from idle.
-    if (record.unread?.panes || record.unread?.sessions_index || record.unread?.sessions_index_parts
+    // unread activity or absent record never clears a wait (a part the index could not read is not a lost index: it
+    // keeps its rows, machine-fleet.mjs). Waiting on a live native session is not inferred from idle.
+    if (record.unread?.panes || record.unread?.sessions_index
       || record.unread?.sessions_activity || record.unread?.claude_registry_watch || record.panes?.activities_omitted || record.panes?.sessions_unread) continue;
     const grouped = new Map();
     for (const { pid, activity } of record.panes?.activities ?? []) {