@volter/supercode-orchestrator 0.5.205 → 0.5.207

package/board/doors.mjs

@@ -45,33 +45,63 @@ async function opened(machine) {
  */
 export async function machineCall(machine, method, params = {}, { timeoutMs = 60_000 } = {}) {
   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();
+  const deadline = started + timeoutMs;
+  // The caller's bound covers admission too. Shared openings remain the owner's: a caller that stops waiting must
+  // not close another caller's channel/client. Once its admission wait expires, it never sends the method later.
+  const phase = async (name, work) => {
+    const at = performance.now();
+    const remaining = deadline - at;
+    const expired = () => Object.assign(new Error(`${method} exceeded ${timeoutMs} ms while waiting for ${name}${name === 'request' ? '; whether the method ran is unknown' : '; the method was not sent'}`), {
+      code: 'REQUEST_TIMEOUT', phase: name, requestNotSent: name !== 'request',
+    });
+    if (remaining <= 0) throw expired();
+    const controller = new AbortController();
+    let timer;
+    try {
+      const timeout = new Promise((_, reject) => {
+        timer = setTimeout(() => { const error = expired(); controller.abort(error); reject(error); }, remaining);
+      });
+      return await Promise.race([work({ timeoutMs: remaining, signal: controller.signal }), timeout]);
+    } finally {
+      clearTimeout(timer);
+      noteStep(`door ${method}: ${name}`, performance.now() - at);
+    }
+  };
   let door = null;
   try {
-    door = await opened(machine);
+    door = await phase('machine channel', () => opened(machine));
     if (method.startsWith('harness.v1.sessions.')) {
       // The harness client starts its transport again itself once it ends (a daemon restart there); one that never
       // started is let go, so the next call starts another.
-      if (!door.harness) {
-        const starting = (async () => { const client = new SupercodeHarnessClient({ transport: channelHarness(door.channel, machine) }); await client.start?.(); return client; })();
-        starting.catch(() => { if (door.harness === starting) door.harness = null; });
-        door.harness = starting;
-      }
-      return await (await door.harness).request(method, params, { timeoutMs });
+      const client = await phase('harness admission', () => {
+        if (!door.harness) {
+          const starting = (async () => { const client = new SupercodeHarnessClient({ transport: channelHarness(door.channel, machine) }); await client.start?.(); return client; })();
+          starting.catch(() => { if (door.harness === starting) door.harness = null; });
+          door.harness = starting;
+        }
+        return door.harness;
+      });
+      return await phase('request', (options) => client.request(method, params, options));
     }
     // The node stream ends with the daemon behind it (another machine's daemon restarting, an upgrade) while the channel
     // to it stays open: it is used only while it is open, and opened again once it is not.
-    if (!door.node) {
-      const opening = door.channel.open('node').then((stream) => {
-        stream.on('close', () => { if (door.node === opening) door.node = null; });
-        return new StreamRpc(stream);
-      });
-      opening.catch(() => { if (door.node === opening) door.node = null; });
-      door.node = opening;
-    }
-    return await (await door.node).call(method, params, { timeoutMs });
+    const rpc = await phase('node admission', () => {
+      if (!door.node) {
+        const opening = door.channel.open('node').then((stream) => {
+          stream.on('close', () => { if (door.node === opening) door.node = null; });
+          return new StreamRpc(stream);
+        });
+        opening.catch(() => { if (door.node === opening) door.node = null; });
+        door.node = opening;
+      }
+      return door.node;
+    });
+    return await phase('request', (options) => rpc.call(method, params, options));
   } catch (error) {
-    if (machine && door && (error?.code === 'REQUEST_TIMEOUT' || error?.code === 504)) retireSilent(machine, door, started);
+    // An expired admission sent nothing and retains the shared opening. Retire only an owned remote request channel that stayed silent.
+    if (machine && door && error?.requestNotSent !== true && (error?.code === 'REQUEST_TIMEOUT' || error?.code === 504)) retireSilent(machine, door, started);
     throw error;
   } finally {
     noteStep(`door ${method}${machine ? ' (another machine)' : ''}`, performance.now() - started);

package/board/engine.mjs

@@ -8,15 +8,16 @@
 // 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 { executionOf } from './session-work.mjs';
 import { spawn, execFile } from 'node:child_process';
 import { existsSync, rmSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { checkWorkspace, assertWorkspaceOwner, declareWorkspace, isLocalWorkspace, plainWorkspace } from './workspace.mjs';
 import { DatabaseSync } from 'node:sqlite';
-import { view, actorOf, principalOf, claimer, contention, event, json, newTaskId, now, retryContention, tx } from './store.mjs';
-import { completionPhase, inspectCompletionEvidence, observeCompletionEvidence, withCompletionEvidence } from './ci.mjs';
-import { addDependency, retireSupersededRuns, refreshCardInputs, requestSessionClose, eventTo, fire, validateEvent, loadWorkflow, setStatus, settle, startNew, statusOf, runEvent, workflowFor } from './workflow.mjs';
+import { view, actorOf, principalOf, CARD_NUMBERS, claimer, contention, event, json, newTaskId, now, retryContention, tx } from './store.mjs';
+import { assertSourceReceipt, completionPhase, inspectCompletionEvidence, observeCompletionEvidence, withCompletionEvidence } from './ci.mjs';
+import { addDependency, retireSupersededRuns, refreshCardInputs, requestSessionClose, reviewerOf, eventTo, fire, validateEvent, loadWorkflow, setStatus, settle, startNew, statusOf, runEvent, workflowFor } from './workflow.mjs';
 import { refuseCredentialDump, withheldIfDump } from './credential-guard.mjs';
 import { AGENT_KIND_LIST, compactCardAgentEvents } from './published.mjs';
 
@@ -37,11 +38,22 @@ const one = (db, sql, ...args) => db.prepare(sql).get(...args);
 const all = (db, sql, ...args) => db.prepare(sql).all(...args);
 const run = (db, sql, ...args) => db.prepare(sql).run(...args);
 
+// A card's number (#42): what the store gave it when it was made (store.mjs layOutNumbers). A person names a card by
+// it wherever its id is taken (`42` or `#42`), and every view of a card shows it first, before the 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 number first, then its id (`#42 t_4406c88a`). */
+export const cardLabel = (number, id) => (number ? `#${number} ${id}` : String(id));
+
 export function getTask(db, id) {
   const row = one(db, 'SELECT * FROM tasks WHERE id = ?', id);
   if (!row) return null;
   const ours = one(db, 'SELECT * FROM supercode_cards WHERE task_id = ?', id);
-  return { ...row, workspace_anchor: ours?.workspace_anchor ?? null, blocked_by: json(ours?.blocked_by, []) ?? [], paused: json(ours?.paused, null), archived: Boolean(ours?.archived), every: ours?.every ?? null, skills: json(row.skills, []) ?? [], machine: ours?.machine ?? null, subtask_of: ours?.subtask_of ?? null,
+  return { ...row, number: numberOf(db, id), workspace_anchor: ours?.workspace_anchor ?? null, blocked_by: json(ours?.blocked_by, []) ?? [], paused: json(ours?.paused, null), detached: json(ours?.detached, null), archived: Boolean(ours?.archived), every: ours?.every ?? null, skills: json(row.skills, []) ?? [], machine: ours?.machine ?? null, subtask_of: ours?.subtask_of ?? null,
     tags: json(ours?.tags, null) ?? (row.tenant ? [row.tenant] : []), sponsor: ours?.sponsor ?? null, sponsor_evidence: json(ours?.sponsor_evidence, null), requested_by_unverified: json(ours?.requested_by_unverified, null) };
 }
 
@@ -122,10 +134,11 @@ export function setRunSession(db, runId, session) {
 
 /** The card's latest session the dispatcher recorded, newest run first; null when it never had one. */
 export function lastSession(db, taskId, slot = 'worker') {
+  if (detachedCard(db, taskId)) return null;
   // a session slot's own last session (runs recorded before slots existed are the worker's)
   for (const row of all(db, 'SELECT metadata FROM task_runs WHERE task_id = ? AND metadata IS NOT NULL ORDER BY id DESC', taskId)) {
     const s = json(row.metadata, {})?.supercode;
-    if (s?.session_id && (s.slot ?? 'worker') === slot) return s;
+    if (s?.session_id && (s.slot ?? 'worker') === slot) return detachedSession(db, s) ? null : s;
   }
   return null;
 }
@@ -241,6 +254,9 @@ export function createCard(board, spec) {
     if (missing.length) throw new Error(`unknown parent card(s): ${missing.join(', ')}`);
     const arc = spec.subtaskOf ? getTask(db, spec.subtaskOf) : null;
     const entry = workflowFor(board.root);
+    if (spec.reviewer != null && (typeof spec.reviewer !== 'string' || !spec.reviewer.trim() || !entry.profiles?.[spec.reviewer]?.worker?.harness)) {
+      throw new Error('A card reviewer names a runnable profile in this home.');
+    }
     if (spec.subtaskOf && !arc) throw new Error(`no card ${spec.subtaskOf} to be a subtask of`);
     if (arc?.subtask_of) throw new Error(`${arc.id} is itself a subtask of ${arc.subtask_of}; a subtask belongs to an arc`);
     let id = newTaskId();
@@ -281,7 +297,8 @@ export function createCard(board, spec) {
     // the create's own words: whether it asked to be a goal card (null: the workflow decides), triage, its arc
     const status = startNew(db, board, entry, getTask(db, id), { triage: Boolean(spec.triage), initial_status: initial,
       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, status, parents, tags, ...(spec.sponsor ? { sponsor: spec.sponsor } : {}), ...(spec.requestedByUnverified ? { requested_by_unverified: spec.requestedByUnverified } : {}), ...(machine ? { machine } : {}), ...(arc ? { subtask_of: arc.id } : {}) });
+    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.sponsor ? { sponsor: spec.sponsor } : {}), ...(spec.requestedByUnverified ? { requested_by_unverified: spec.requestedByUnverified } : {}), ...(machine ? { machine } : {}), ...(arc ? { subtask_of: arc.id } : {}) });
     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) {
@@ -290,7 +307,7 @@ export function createCard(board, spec) {
       event(db, arc.id, 'subtask_added', { subtask: id, title });
     }
     if (initial === 'running' && arc && entry.workflow.run) setStatus(db, entry.workflow, id, 'running');
-    else if (initial === 'running') claimIn(db, id, { ttl: claimTtl() });
+    else if (initial === 'running') claimIn(db, id, { ttl: claimTtl(), workflow: entry.workflow });
     // The creation declares its role even when dispatch is held. The existing durable effect queue
     // keeps public-door I/O outside this transaction and retains an offline declaration for retry.
     let declaration;
@@ -333,12 +350,13 @@ function wouldCycle(db, parent, child) {
  * from a native binary released before its `set` (the orchestrator and the native install separately) still has a verb
  * per property: it is answered so until that native is gone from the fleet, then this fallback is deleted (t_530ce43e).
  */
-export const SETTABLE = ['assignee', 'machine', 'model', 'every'];
+export const SETTABLE = ['assignee', 'machine', 'model', 'every', 'reviewer'];
 export function set(board, id, field, value, { provider = null, roles } = {}) {
   if (!SETTABLE.includes(field)) throw new Error(`set takes one of ${SETTABLE.join(', ')}, not ${field}`);
   if (provider && (field !== 'model' || !value)) throw new Error('a provider goes with a model');
   value = value || null;
   if (workflowFor(board.root).workflow.verbs?.set) return act(board, id, 'set', { roles, payload: { field, value, provider } });
+  if (field === 'reviewer') throw new Error('This older workflow declares no reviewer setter; update its workflow before setting a card reviewer.');
   const verb = { assignee: ['assign', { assignee: value }], machine: ['move', { machine: value }], model: ['set_model', { model: value, provider }], every: ['set_every', { every: value }] }[field];
   return act(board, id, verb[0], { roles, payload: verb[1] });
 }
@@ -347,11 +365,12 @@ export function set(board, id, field, value, { provider = null, roles } = {}) {
 
 /** Claim a ready card: running, a claim held until `ttl` from now, a run opened. Answers the run id or null. */
 export function claim(board, id, { ttl, lock = claimer(), expectStatus = 'ready' } = {}) {
-  return tx(board, (db) => claimIn(db, id, { ttl, lock, expectStatus }));
+  const { workflow } = workflowFor(board.root);
+  return tx(board, (db) => claimIn(db, id, { ttl, lock, expectStatus, workflow }));
 }
 
-/** `claim` inside the caller's own transaction (a dispatcher's guard and claim see one state). */
-export function claimIn(db, id, { ttl = claimTtl(), lock = claimer(), expectStatus = null } = {}) {
+/** Manual `claim` inside the caller's transaction; the declared stage and run commit together. */
+export function claimIn(db, id, { ttl = claimTtl(), lock = claimer(), expectStatus = null, workflow } = {}) {
   if (getTask(db, id)?.subtask_of) throw new Error('a subtask is worked by its arc and has no run of its own');
   // a triage card is claimed to be specified, which does not wait on its parents
   if (expectStatus !== 'triage' && !parentsDone(db, id)) {
@@ -360,19 +379,22 @@ export function claimIn(db, id, { ttl = claimTtl(), lock = claimer(), expectStat
     return null;
   }
   const task = must(db, id);
-  if (expectStatus && task.status !== expectStatus) return null;
+  const sourceStatus = statusOf(db, task);
+  if (expectStatus && sourceStatus !== expectStatus) return null;
   if (task.claim_lock) return null;
+  if (!workflow?.statuses?.running) throw new Error('manual claim needs a running status declared by this home\'s workflow');
   const t = now();
   if (task.current_run_id) {
     run(db, "UPDATE task_runs SET status = 'reclaimed', outcome = 'reclaimed', summary = COALESCE(summary, 'invariant recovery on re-claim'), ended_at = ?, claim_lock = NULL, claim_expires = NULL, worker_pid = NULL WHERE id = ? AND ended_at IS NULL", t, task.current_run_id);
   }
   const expires = t + ttl;
-  run(db, 'UPDATE tasks SET status = ?, claim_lock = ?, claim_expires = ?, started_at = COALESCE(started_at, ?) WHERE id = ?', 'running', lock, expires, t, id);
+  setStatus(db, workflow, id, 'running');
+  run(db, 'UPDATE tasks SET claim_lock = ?, claim_expires = ?, started_at = COALESCE(started_at, ?) WHERE id = ?', lock, expires, t, id);
   const r = run(db, "INSERT INTO task_runs (task_id, profile, step_key, status, claim_lock, claim_expires, max_runtime_seconds, started_at) VALUES (?, ?, ?, 'running', ?, ?, ?, ?)",
     id, task.assignee, task.current_step_key, lock, expires, task.max_runtime_seconds, t);
   const runId = Number(r.lastInsertRowid);
   run(db, 'UPDATE tasks SET current_run_id = ? WHERE id = ?', runId, id);
-  event(db, id, 'claimed', { lock, expires, run_id: runId, source_status: ['review', 'triage'].includes(task.status) ? task.status : 'ready' }, runId);
+  event(db, id, 'claimed', { lock, expires, run_id: runId, source_status: ['review', 'triage'].includes(sourceStatus) ? sourceStatus : 'ready' }, runId);
   return runId;
 }
 
@@ -428,6 +450,7 @@ 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 = {} } = {}) {
+  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');
   refuseCredentialDump(name === 'comment' ? `the comment on ${id}` : `${name.replace(/_/g, '-')} on ${id}`, payload);
@@ -455,6 +478,7 @@ export async function act(board, id, name, { roles = null, payload = {}, extra =
 }
 
 export async function requestStateMany(board, ids, payload = {}) {
+  assertSourceReceipt(payload);
   const targets = [...new Set(ids.map(String))];
   if (!targets.length) throw new Error('A state request names at least one card.');
   const entry = await loadWorkflow(board.root);
@@ -485,6 +509,7 @@ export async function requestStateMany(board, ids, payload = {}) {
 
 /** Take card `id` to `status` by the event the workflow says goes there for this caller (`goto`). */
 export async function goto(board, id, status, { roles = null, payload = {} } = {}) {
+  assertSourceReceipt(payload);
   const entry = await loadWorkflow(board.root);
   await refreshCardInputs(board, id, { commits: true });
   await observeCompletionEvidence(board, id, entry, payload);
@@ -552,7 +577,17 @@ export async function runEffects(board, effects = [], { pending: due = false, el
     // the claim: taken only while the row is due and not failed; another pass holding it answers no change
     if (e.durableId && !tx(board, (db) => db.prepare('UPDATE supercode_effects SET next_at = ? WHERE id = ? AND failed_at IS NULL AND next_at <= ?').run(now() + EFFECT_CLAIM, e.durableId, now()).changes)) { did.claimed_elsewhere.push(e.durableId); continue; }
     let done, error = null;
-    try { done = await runEffect(board, e); } catch (thrown) { done = false; error = String(thrown?.message ?? thrown).slice(0, 500); }
+    try {
+      const effectSession = e.runId ? json(board.db.prepare('SELECT metadata FROM task_runs WHERE id=?').get(e.runId)?.metadata, {})?.supercode : null;
+      done = e.id && e.kind !== 'board_message'
+        ? await sessionOperation(board, { taskId: e.id, address: e.address ?? sessionAddress(effectSession), kind: `board effect ${e.kind}` }, () => runEffect(board, e))
+        : await runEffect(board, e);
+    } catch (thrown) {
+      // Pending work no longer owns the person's session or its workspace.
+      done = Boolean(thrown?.sessionDetached);
+      error = done ? null : String(thrown?.message ?? thrown).slice(0, 500);
+      if (done && e.id) tx(board, db => event(db, e.id, 'effect_passed', { effect: e.durableId ?? null, kind: e.kind, reason: 'card detached to a person' }, e.runId ?? null));
+    }
     if (!e.durableId) continue;
     if (done) { tx(board, (db) => db.prepare('DELETE FROM supercode_effects WHERE id = ?').run(e.durableId)); did.done.push(`${e.durableId}:${e.kind}`); continue; }
     did.kept.push(e.durableId);
@@ -602,7 +637,7 @@ function stopWorker(board, runId) {
   if (!runId) return;
   const row = view(board, (db) => one(db, 'SELECT metadata, claim_lock FROM task_runs WHERE id = ?', runId));
   const worker = json(row?.metadata, {})?.supercode;
-  if (worker?.surface === 'headless' && worker.pid) terminate(Number(worker.pid));
+  if (worker?.surface === 'headless' && worker.pid && !detachedSession(board.db, worker)) terminate(Number(worker.pid));
 }
 
 /**
@@ -652,14 +687,20 @@ function invalidateDescendants(db, board, id) {
 
 // each of Hermes's verbs is an event of the workflow; the words it takes are the event's payload
 
-export const complete = async (board, id, { result = null, summary = null, metadata = null, roles, runId = null, commit = null, ci_run = null, branch = null, pr = null, pr_head = null, reviewed_sha = null } = {}) =>
-  await act(board, id, 'complete', { roles, payload: { result, summary, metadata, run_id: runId, commit, ci_run, branch, pr, pr_head, reviewed_sha } });
+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;
+  return await act(board, id, 'complete', { roles, payload: { result, summary, metadata, run_id: runId, commit, branch, pr, pr_head, reviewed_sha } });
+};
 // 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, roles, runId = null } = {}) =>
   await act(board, id, 'block', { roles, payload: { reason, on, 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, { summary = null, metadata = null, reviewer = null, force = false, expectedRunId = null, roles, commit = null, ci_run = null, branch = null, pr = null, pr_head = null } = {}) =>
-  await act(board, id, 'request_review', { roles, payload: { summary, metadata, reviewer, force, run_id: expectedRunId, commit, ci_run, branch, pr, pr_head } });
+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 } });
+};
 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 } });
@@ -752,11 +793,35 @@ export async function comment(board, id, author, body, { roles, pr = null, pr_he
  * starts, completion and blocks) or `worker` (told of updates to the card it works).
  */
 export function subscribeIn(db, id, address, role = 'creator') {
+  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);
 }
 
+/** Reconcile only the current worker's audience, inside the binding transaction. */
+export function replaceWorkerSubscriptions(db, id, address) {
+  const active = currentRun(db, id), session = active?.metadata?.supercode;
+  const bound = session?.address ?? (session?.session_id && session.machine ? `sc:${session.machine}:${session.harness ?? 'claude-code'}:${session.session_id}` : null);
+  if (!address || bound !== address || active.ended_at) return false;
+  const replaces = (session.slot ?? 'worker') === 'worker';
+  const family = all(db, `WITH RECURSIVE family(task_id) AS (
+    SELECT ? UNION SELECT c.task_id FROM supercode_cards c JOIN family f ON c.subtask_of = f.task_id
+  ) SELECT task_id FROM family`, id);
+  const removed = [];
+  for (const { task_id: card } of family) {
+    for (const old of replaces ? all(db, "SELECT chat_id,thread_id FROM kanban_notify_subs WHERE task_id=? AND platform='supercode' AND json_extract(delivery_metadata,'$.role')='worker' AND chat_id!=?", card, address) : []) {
+      run(db, "DELETE FROM kanban_notify_subs WHERE task_id=? AND platform='supercode' AND chat_id=? AND thread_id=? AND json_extract(delivery_metadata,'$.role')='worker'", card, old.chat_id, old.thread_id);
+      removed.push({ card, address: old.chat_id });
+    }
+    // INSERT OR IGNORE preserves an independent creator/manager subscription
+    // and the current worker's existing cursor on repeated reconciliation.
+    subscribeIn(db, card, address, 'worker');
+  }
+  if (removed.length) event(db, id, 'notice_subscriptions_replaced', { address, role: 'worker', superseded: removed, reason: 'the current worker binding replaced its audience' }, active.id);
+  return true;
+}
+
 export function subscribe(board, id, address, role = 'creator') {
   return tx(board, (db) => { must(db, id); subscribeIn(db, id, address, role); });
 }
@@ -767,9 +832,9 @@ export function unsubscribe(board, id, address) {
 
 function dependencyRecipient(db, id) {
   const owner = must(db, id);
-  if (owner.archived || ['done', 'cancelled', 'archived'].includes(owner.status)) return null;
+  if (owner.detached || owner.archived || ['done', 'cancelled', 'archived'].includes(owner.status)) return null;
   const session = currentRun(db, id)?.metadata?.supercode ?? lastSession(db, id);
-  return session?.forgotten || session?.close_confirmed_at ? null : session?.address ?? null;
+  return session?.forgotten || session?.close_confirmed_at || detachedSession(db, session) ? null : session?.address ?? null;
 }
 
 export function subscribeDependency(board, ownerId, sourceId, { remove = false } = {}) {
@@ -800,7 +865,7 @@ export function reconcileDependencySubscriptions(db) {
     const address = owner ? dependencyRecipient(db, owner.id) : null;
     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.archived || ['done', 'cancelled', 'archived'].includes(owner.status)) run(db, `DELETE FROM kanban_notify_subs ${where}`, ...identity);
+    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, waiting_recipient: false, failures: 0 }), ...identity);
     else if (!address && !metadata.waiting_recipient) run(db, `UPDATE kanban_notify_subs SET delivery_metadata=? ${where}`, JSON.stringify({ ...metadata, waiting_recipient: true }), ...identity);
   }
@@ -826,19 +891,19 @@ export const subscriptions = (db, id = null) => (id ? all(db, 'SELECT * FROM kan
 // ------------------------------------------------------------------ reading
 
 export function listCards(db, { status = null, assignee = null, machine = null, includeArchived = false } = {}) {
-  const rows = all(db, `SELECT t.*, c.machine, c.subtask_of, c.stage, c.tags, c.sponsor FROM tasks t LEFT JOIN supercode_cards c ON c.task_id = t.id
+  const rows = all(db, `SELECT t.*, n.number, c.machine, c.subtask_of, c.stage, c.tags, c.sponsor FROM tasks t LEFT JOIN supercode_cards c ON c.task_id = t.id LEFT JOIN ${CARD_NUMBERS} n ON n.task_id = t.id
     WHERE (? IS NULL OR t.status = ? OR c.stage = ?) AND (? IS NULL OR t.assignee = ?) AND (? IS NULL OR c.machine = ?) AND (? OR t.status != 'archived')
     ORDER BY t.priority DESC, t.created_at ASC`, status, status, status, assignee, assignee, machine, machine, includeArchived ? 1 : 0);
   return rows.map((r) => ({ ...r, skills: json(r.skills, []) ?? [], execution: executionOf(r.current_run_id ? one(db, 'SELECT metadata,ended_at FROM task_runs WHERE id=?', r.current_run_id) : null) }));
 }
 
 export function showCard(db, id) {
-  const task = must(db, id);
+  const task = { ...must(db, id), reviewer: reviewerOf(db, id) };
   return {
     task,
     parents: parentsOf(db, id),
     children: childrenOf(db, id),
-    subtasks: all(db, 'SELECT t.id, t.status, t.title FROM tasks t JOIN supercode_cards c ON c.task_id = t.id WHERE c.subtask_of = ? ORDER BY t.created_at', id),
+    subtasks: all(db, `SELECT t.id, n.number, t.status, t.title FROM tasks t JOIN supercode_cards c ON c.task_id = t.id LEFT JOIN ${CARD_NUMBERS} n ON n.task_id = t.id WHERE c.subtask_of = ? ORDER BY t.created_at`, id),
     comments: all(db, 'SELECT author, body, created_at FROM task_comments WHERE task_id = ? ORDER BY id', id),
     runs: all(db, 'SELECT * FROM task_runs WHERE task_id = ? ORDER BY id', id).map((r) => ({ ...r, metadata: json(r.metadata, null) })),
     events: all(db, 'SELECT id, kind, payload, created_at, run_id FROM task_events WHERE task_id = ? ORDER BY id', id).map((e) => ({ ...e, payload: json(e.payload, null) })),
@@ -1011,7 +1076,7 @@ export function diagnose(db, task, { failureLimit = DEFAULT_FAILURE_LIMIT, stran
     const cycles = events.filter((e) => e.kind === 'unblocked' && t - e.created_at < 24 * 3600).length;
     if (cycles >= 3) out.push({ kind: 'block_unblock_cycling', severity: 'warning', title: `block→unblock cycled ${cycles}x in 24h`, data: { cycles }, actions: [] });
   }
-  if (task.status === 'ready' && task.assignee) {
+  if (!task.detached && task.status === 'ready' && task.assignee) {
     const since = [...events].reverse().find((e) => ['created', 'promoted', 'unblocked', 'reclaimed', 'session_lost', 'promoted_manual'].includes(e.kind))?.created_at ?? task.created_at;
     const age = t - since;
     if (age >= strandedSeconds) {

package/board/files.mjs

@@ -11,6 +11,7 @@
 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 { createHash } from 'node:crypto';
 import { join } from 'node:path';
 import { DatabaseSync } from 'node:sqlite';
@@ -98,6 +99,9 @@ class FilesBoard {
     const state = this.stateText === null ? null : JSON.parse(this.stateText);
     for (const sql of state?.schema ?? []) mem.exec(sql);
     this.init(mem, { fresh: !state?.schema?.length });
+    // the schema as the directory keeps it: a layout this load added (a table, a column, the card numbers) is written to
+    // every card's file by the next write (persist)
+    this.keptSchema = state?.schema ?? [];
     const columns = (table) => new Set(mem.prepare(`PRAGMA table_info(${quote(table)})`).all().map((c) => c.name));
     const insert = (table, rows) => {
       const have = columns(table);
@@ -108,17 +112,26 @@ class FilesBoard {
     };
     const previous = this.texts;
     this.texts = new Map();
+    const cards = [];
     for (const name of readdirSync(this.dir)) {
       if (!name.endsWith('.json') || name.startsWith('_')) continue;
       const text = readFileSync(join(this.dir, name), 'utf8');
       const card = JSON.parse(text);
       this.texts.set(card.id, text);
-      for (const [table, rows] of Object.entries(card.tables ?? {})) insert(table, rows);
+      cards.push(card);
     }
-    for (const [table, rows] of Object.entries(state?.tables ?? {})) insert(table, rows);
+    // The id counters first: a number handed out before stays handed out.
     for (const { name, seq } of state?.sequence ?? []) {
       if (mem.prepare('UPDATE sqlite_sequence SET seq = MAX(seq, ?) WHERE name = ?').run(seq, name).changes === 0) mem.prepare('INSERT INTO sqlite_sequence (name, seq) VALUES (?, ?)').run(name, seq);
     }
+    // Inserting a card's row numbers it when it has no number yet (store.mjs layOutNumbers): every number a card file
+    // holds loads first, so each card keeps its own and a new one is past them all, and then the cards load in the
+    // order they were made.
+    for (const card of cards) if (card.tables?.[CARD_NUMBERS]) insert(CARD_NUMBERS, card.tables[CARD_NUMBERS]);
+    const madeAt = (card) => Number(card.tables?.tasks?.[0]?.created_at ?? 0);
+    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);
     // 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
@@ -172,7 +185,8 @@ class FilesBoard {
   /** Write the files of the cards the transaction touched, then `_board.json`; writes compare the content hash. */
   persist(schemaBefore) {
     const schema = this.schema();
-    const reshaped = schema.join('\n') !== schemaBefore.join('\n');
+    // reshaped by this transaction, or by the load it runs on (a layout the directory does not keep yet)
+    const reshaped = schema.join('\n') !== schemaBefore.join('\n') || schema.join('\n') !== (this.keptSchema ?? []).join('\n');
     const touched = new Set(this.mem.prepare('SELECT DISTINCT id FROM _touched').all().map((r) => r.id).filter((id) => id !== null));
     if (reshaped) this.watch(); // a table made in the transaction gets its triggers; every card is written again
     const keys = this.keys;