@volter/supercode-orchestrator 0.4.29 → 0.4.30

package/board/dispatch.mjs

@@ -20,11 +20,13 @@ import { hostname, tmpdir } from 'node:os';
 import { basename, dirname, join } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { fileURLToPath } from 'node:url';
-import { boardPath, event, json, listBoards, now, openBoard, tx } from './store.mjs';
+import { boardPath, claimer, event, json, listBoards, now, openBoard, tx } from './store.mjs';
 import { holdBoardTickLock } from '../hermes-locks.mjs';
+import { doors, fire, loadWorkflow, resumeOf, scopeOf, statusOf, templateValue, workflowFor } from './workflow.mjs';
+import { evaluate, holds, render } from './expr.mjs';
 import {
-  blockIn, cardContext, claimIn, claimTtl, currentRun, DEFAULT_FAILURE_LIMIT, extendClaim, getTask, lastSession,
-  recomputeReady, recordFailure, release, setRunSession, subscribeIn, subscriptions,
+  cardContext, claimTtl, currentRun, DEFAULT_FAILURE_LIMIT, extendClaim, getTask, lastSession,
+  recomputeReady, runEffects, setRunSession, subscribeIn, subscriptions,
 } from './engine.mjs';
 
 const WORKER = fileURLToPath(new URL('../bin/hermes-worker.mjs', import.meta.url));
@@ -145,9 +147,8 @@ export function lanesOf(profiles = {}) {
 
 // ------------------------------------------------------------------ supervise
 
-function supervise(board, fleet, settings, report) {
+function supervise(board, fleet, settings, report, entry, effects) {
   const rows = board.db.prepare("SELECT id FROM tasks WHERE status = 'running'").all();
-  const stop = [];
   for (const { id } of rows) {
     tx(board, (db) => {
       const task = getTask(db, id);
@@ -155,28 +156,34 @@ function supervise(board, fleet, settings, report) {
       const runRow = currentRun(db, id);
       const session = runRow?.metadata?.supercode ?? null;
       const t = now();
+      // what the dispatcher saw becomes a platform event; the card's workflow says what it does
+      const observe = (name, payload, bucket) => {
+        try {
+          const r = fire(db, board, entry, id, name, { roles: ['platform'], payload });
+          effects.push(...r.effects);
+          if (bucket) report[bucket].push(id);
+          if (r.to !== r.from && entry.workflow.statuses[r.to]?.stored_as === 'blocked') report.auto_blocked.push(id);
+        } catch (error) {
+          // an observation no transition takes is nothing to do (a guard the workflow keeps, such as a grace)
+          if (!error.noTransition) report.failed.push([id, `${name}: ${String(error.message).slice(-200)}`]);
+        }
+      };
+      const limits = limitsOf(db, board, entry, task, session);
       // Hermes's orphan reconciliation: a running card whose claim bookkeeping is broken, with nothing live behind it
       const live = session?.surface === 'headless' ? pidAlive(session.pid) : session?.session_id ? (fleet.ok ? sessionAlive(fleet, session) : true) : false;
       if (settings.reconcileOrphans && (!task.claim_lock || !task.claim_expires) && !live) {
-        release(db, id, { outcome: 'reclaimed', error: 'orphaned running card (broken claim bookkeeping)', kind: 'reconciled', payload: { reason: 'orphaned_running', claim_lock: task.claim_lock, claim_expires: task.claim_expires } });
-        db.prepare('INSERT INTO task_comments (task_id, author, body, created_at) VALUES (?, ?, ?, ?)').run(id, 'dispatcher', 'Requeued: the card was running with no claim and nothing live behind it.', t);
-        report.reclaimed.push(id);
+        observe('orphaned', { reason: 'orphaned_running', claim_lock: task.claim_lock, claim_expires: task.claim_expires, error: 'orphaned running card (broken claim bookkeeping)' }, 'reclaimed');
         return;
       }
-      // a card past its max runtime is stopped and counted, as Hermes times its workers out
-      if (task.max_runtime_seconds && runRow && t - Number(runRow.started_at) > Number(task.max_runtime_seconds)) {
-        stop.push(session);
-        release(db, id, { outcome: 'timed_out', error: `ran past max_runtime ${task.max_runtime_seconds}s`, kind: 'timed_out', payload: { limit_seconds: task.max_runtime_seconds } });
-        if (recordFailure(db, id, `timed out after ${task.max_runtime_seconds}s`, { failureLimit: settings.failureLimit, outcome: 'timed_out' })) report.auto_blocked.push(id);
-        report.timed_out.push(id);
+      // a run past its runtime limit (the status's `run.limits.runtime`), as Hermes times its workers out
+      if (limits.runtime && runRow && t - Number(runRow.started_at) > Number(limits.runtime)) {
+        observe('timed_out', { limit_seconds: limits.runtime, error: `ran past max_runtime ${limits.runtime}s` }, 'timed_out');
         return;
       }
       if (session?.surface === 'headless') {
-        // Hermes's stale check: a worker running past the timeout with no heartbeat in the last hour is stopped
-        if (settings.staleTimeout && runRow && t - Number(runRow.started_at) >= settings.staleTimeout && !(task.last_heartbeat_at && t - Number(task.last_heartbeat_at) < 3600)) {
-          stop.push(session);
-          release(db, id, { outcome: 'stale', error: `no heartbeat after ${t - Number(runRow.started_at)}s running`, kind: 'stale', payload: { timeout_seconds: settings.staleTimeout, pid: session.pid } });
-          report.reclaimed.push(id);
+        // Hermes's stale check: a worker running past the limit with no heartbeat in the last hour is stopped
+        if (limits.stale && runRow && t - Number(runRow.started_at) >= Number(limits.stale) && !(task.last_heartbeat_at && t - Number(task.last_heartbeat_at) < 3600)) {
+          observe('stale', { timeout_seconds: limits.stale, pid: session.pid, error: `no heartbeat after ${t - Number(runRow.started_at)}s running` }, 'reclaimed');
           return;
         }
         if (pidAlive(session.pid)) {
@@ -186,39 +193,32 @@ function supervise(board, fleet, settings, report) {
         if (t - Number(session.launched_at ?? 0) < settings.crashGrace) return;
         // how the worker ended, from the exit code its wrapper wrote (Hermes reads its reaped children's)
         const code = session.exit_file && existsSync(session.exit_file) ? Number(readFileSync(session.exit_file, 'utf8').trim()) : null;
-        if (code === 75) {
-          // a quota wall: back to ready with no failure counted; the respawn guard waits out the cooldown
-          release(db, id, { outcome: 'rate_limited', error: 'worker hit a rate limit (exit 75)', kind: 'rate_limited', payload: { worker_pid: session.pid, exit_code: 75 } });
-          report.crashed.push(id);
-          return;
-        }
-        const clean = code === 0;
-        const why = clean ? `worker ${session.pid} exited cleanly (rc=0) without completing or blocking the card` : `worker ${session.pid} exited${code === null ? '' : ` with ${code}`} without completing the card`;
-        release(db, id, { outcome: 'crashed', error: why, kind: 'crashed', payload: { worker_pid: session.pid, exit_code: code, protocol_violation: clean } });
-        // a clean exit that left the card running is a protocol violation: Hermes trips the breaker on the first
-        if (clean) db.prepare('UPDATE tasks SET consecutive_failures = ? WHERE id = ?').run(Math.max(0, (task.max_retries ?? settings.failureLimit) - 1), id);
-        if (recordFailure(db, id, why, { failureLimit: settings.failureLimit })) report.auto_blocked.push(id);
-        report.crashed.push(id);
+        const why = code === 75 ? 'worker hit a rate limit (exit 75)' : code === 0 ? `worker ${session.pid} exited cleanly (rc=0) without completing or blocking the card` : `worker ${session.pid} exited${code === null ? '' : ` with ${code}`} without completing the card`;
+        observe('exited', { code, worker_pid: session.pid, exit_code: code, protocol_violation: code === 0, error: why }, 'crashed');
         return;
       }
       if (session?.session_id) {
         if (!fleet.ok) return; // no reading, no verdict
         const alive = sessionAlive(fleet, session);
         const machineUp = fleet.online.has(session.machine);
-        const young = t - Number(session.launched_at ?? 0) < settings.grace;
+        const young = t - Number(session.launched_at ?? 0) < Number(limits.grace ?? settings.grace);
         const missing = !alive && machineUp && !young;
         const next = { ...session };
+        // a machine that is off the fleet: how long, for the workflow's machine_offline (the claim is kept meanwhile)
+        if (machineUp) delete next.offline_since; else next.offline_since ??= t;
+        if (!machineUp) {
+          setRunSession(db, runRow.id, next);
+          observe('machine_offline', { machine: session.machine, seconds: t - next.offline_since }, null);
+          if (getTask(db, id)?.current_run_id !== runRow.id) return; // the workflow moved it
+        }
         if (alive) { next.seen_at ??= t; delete next.missing_since; }
         if (missing) next.missing_since ??= t;
-        if (missing && t - next.missing_since >= settings.grace) {
-          // lost: gone from an online machine for the whole grace. A resume that never came up is not resumable;
-          // a fresh start that never came up is a failure. The card goes back to ready and the spawn resumes it.
+        if (missing && t - next.missing_since >= Number(limits.grace ?? settings.grace)) {
+          // lost: gone from an online machine for the whole grace. A resume that never came up is not resumable.
           if (next.mode === 'resume' && !next.seen_at) next.resumable = false;
-          const whole = { ...(runRow.metadata ?? {}), supercode: next };
-          release(db, id, { outcome: 'reclaimed', error: `session ${next.session_id} is gone from ${next.machine}`, metadata: whole, kind: 'session_lost',
-            payload: { session_id: next.session_id, machine: next.machine, pane: next.pane, mode: next.mode, seen: Boolean(next.seen_at) } });
-          report.lost.push(id);
-          if (next.mode === 'fresh' && !next.seen_at && recordFailure(db, id, `session ${next.session_id} never came up on ${next.machine}`, { failureLimit: settings.failureLimit, outcome: 'crashed' })) report.auto_blocked.push(id);
+          setRunSession(db, runRow.id, next);
+          observe('session_lost', { session_id: next.session_id, machine: next.machine, pane: next.pane, mode: next.mode, seen: Boolean(next.seen_at),
+            never_came_up: next.mode === 'fresh' && !next.seen_at, error: `session ${next.session_id} is gone from ${next.machine}` }, 'lost');
           return;
         }
         if (JSON.stringify(next) !== JSON.stringify(session)) setRunSession(db, runRow.id, next);
@@ -229,13 +229,21 @@ function supervise(board, fleet, settings, report) {
       }
       // claimed with nothing launched (a dispatcher that died between the two, or another implementation's claim):
       // the claim's own expiry answers it, as Hermes's does
-      if (task.claim_expires && Number(task.claim_expires) < t) {
-        release(db, id, { outcome: 'reclaimed', error: `stale_lock=${task.claim_lock}`, kind: 'reclaimed', payload: { stale_lock: task.claim_lock, claim_expires: task.claim_expires } });
-        report.reclaimed.push(id);
-      }
+      if (task.claim_expires && Number(task.claim_expires) < t) observe('orphaned', { stale_lock: task.claim_lock, claim_expires: task.claim_expires, error: `stale_lock=${task.claim_lock}` }, 'reclaimed');
     });
   }
-  for (const session of stop) stopSession(session); // after the transaction: a close is a network call
+}
+
+/** A running card's limits: its status's `run.limits`, each evaluated for the card (seconds; null for none). */
+function limitsOf(db, board, entry, task, session) {
+  const status = statusOf(db, task);
+  const scope = scopeOf(db, board, task, { params: entry.params, extra: { run: { surface: session?.surface ?? null, local: true } } });
+  const out = {};
+  for (const [name, expr] of Object.entries(entry.workflow.statuses[status]?.run?.limits ?? {})) {
+    const v = evaluate(expr, scope);
+    out[name] = v === null || v === undefined || v === '' ? null : Number(v);
+  }
+  return out;
 }
 
 function stopSession(session) {
@@ -251,6 +259,208 @@ function stopSession(session) {
   if (session.pane) sc(['teams', 'panes', 'close', session.pane, ...(session.machine ? ['--machine', session.machine] : [])], { timeout: 60_000 });
 }
 
+// ------------------------------------------------------------------ starting, as the workflow's dispatch says
+
+/** The command form a card's session uses to reach its board: `--root` on the board's machine, `--at` elsewhere. */
+export function whereOf(board, task) {
+  const local = !task.machine || normalMachine(task.machine) === localMachine();
+  return local ? `--root ${board.root}${board.slug !== 'default' ? ` --board ${board.slug}` : ''}` : `--at ${boardAddress(board.label)}`;
+}
+
+// what the platform tells expressions about this machine and this tick
+const hostOf = (pressure) => ({ memory_pressure: pressure, max_in_progress: derivedMaxInProgress() });
+
+/**
+ * Start what the workflow's dispatcher may start this tick: cards whose status has a transition for `dispatch.start`,
+ * that `dispatch.eligible` admits, in `dispatch.order`, under `dispatch.limits` (a cap per group, slots reserved for
+ * the cards a reserve names while any waits). Each is sent the start event (its validators are Hermes's respawn
+ * guard) and what its new status runs is launched.
+ */
+function startCards(board, fleet, lanes, settings, report, entry, effects, { only = null, hostRunning = 0 } = {}) {
+  const stop = paused(board.root);
+  if (stop) { report.paused = stop; return; }
+  const { workflow, params } = entry;
+  const d = workflow.dispatch;
+  const pressure = memoryPressure();
+  const tickState = { local_started: 0 };
+  const startable = new Set(Object.entries(workflow.statuses).filter(([, st]) => st.on?.[d.start]).map(([name]) => name));
+  const everyCard = board.db.prepare("SELECT id FROM tasks WHERE status != 'archived'").all().map((r) => getTask(board.db, r.id));
+  const scopeFor = (task, extra = {}) => scopeOf(board.db, board, task, { params, extra: { host: hostOf(pressure), tick: tickState, ...extra } });
+  // who would run it: the role of the status its start moves it to, and that role's lane
+  const planOf = (task, scope) => {
+    const status = statusOf(board.db, task);
+    const t = (workflow.statuses[status]?.on?.[d.start] ?? []).find((x) => (!x.by?.length || x.by.includes('platform')) && holds(x.guard ?? null, scope));
+    if (!t?.target) return null;
+    const target = String(templateValue(t.target, scope));
+    const runSpec = workflow.statuses[target]?.run ?? null;
+    const profile = runSpec ? evaluate(workflow.roles?.[runSpec.role] ?? 'card.assignee', scope) : null;
+    return { target, runSpec, profile, lane: profile ? lanes[profile] ?? null : null };
+  };
+  const candidates = [];
+  for (const task of everyCard) {
+    if (only && task.id !== only) continue;
+    if (!startable.has(statusOf(board.db, task))) continue;
+    const plan = planOf(task, scopeFor(task));
+    if (!plan) continue;
+    const scope = scopeFor(task, { lane: plan.lane ?? {}, run: { surface: plan.lane?.surface ?? null, local: plan.lane?.surface !== 'pane' || normalMachine(task.machine ?? '') === localMachine() } });
+    if (!holds(d.eligible ?? null, scope)) continue;
+    candidates.push({ task, plan, scope });
+  }
+  const keyOf = (c) => (d.order ?? []).map((o) => { const desc = o.startsWith('-'); const v = evaluate(desc ? o.slice(1) : o, c.scope); return { v, desc }; });
+  candidates.sort((a, b) => {
+    const ka = keyOf(a); const kb = keyOf(b);
+    for (let i = 0; i < ka.length; i += 1) {
+      if (ka[i].v === kb[i].v) continue;
+      const lt = (ka[i].v ?? -Infinity) < (kb[i].v ?? -Infinity);
+      return (lt ? -1 : 1) * (ka[i].desc ? -1 : 1);
+    }
+    return 0;
+  });
+  // the caps: how many counted cards each group holds now
+  const limits = (d.limits ?? []).map((l) => ({ ...l, tally: new Map() }));
+  const cardScope = new Map(everyCard.map((c) => [c.id, scopeFor(c, { lane: lanes[c.assignee] ?? {}, fleet_alive: fleet.ok ? sessionAlive(fleet, lastSession(board.db, c.id)) : false })]));
+  for (const l of limits) {
+    for (const [, sc] of cardScope) {
+      sc.card.session_live = sc.fleet_alive;
+      if (!holds(l.counts, sc)) continue;
+      const g = JSON.stringify(evaluate(l.group, sc));
+      l.tally.set(g, (l.tally.get(g) ?? 0) + 1);
+    }
+    // the home's other boards count toward a group that is the whole home (kanban.max_in_progress across boards)
+    const here = [...cardScope.values()].filter((sc) => holds(l.counts, sc)).length;
+    if (evaluate(l.group, { card: {} }) === 'home') l.tally.set(JSON.stringify('home'), (l.tally.get(JSON.stringify('home')) ?? 0) + Math.max(0, hostRunning - here));
+  }
+  const reserveWaits = (l) => l.reserve && candidates.some((c) => holds(l.reserve.for, c.scope));
+  for (const c of candidates) {
+    const { task, plan, scope } = c;
+    if (!plan.profile) { report.unassigned.push(task.id); tx(board, (db) => noteGuard(db, task.id, 'no profile runs it (no assignee, and the workflow names none)')); continue; }
+    if (!plan.lane) { report.nonspawnable.push(task.id); tx(board, (db) => noteGuard(db, task.id, `${plan.profile} is no lane of this home`)); continue; }
+    let why = null;
+    for (const l of limits) {
+      const max = evaluate(l.max, scope);
+      if (max === null || max === undefined || max === '') continue;
+      const g = JSON.stringify(evaluate(l.group, scope));
+      const held = reserveWaits(l) && !holds(l.reserve.for, scope) ? Number(evaluate(l.reserve.slots, scope) ?? 0) : 0;
+      if ((l.tally.get(g) ?? 0) >= Number(max) - held) { why = `${l.description ?? 'a cap'} (${max}${held ? `, ${held} held for others` : ''})`; break; }
+    }
+    // the launcher's own conditions: a lane that can start this card where it names
+    if (!why) why = launcherCheck(board.db, task, plan.lane, fleet);
+    if (why) { tx(board, (db) => noteGuard(db, task.id, why)); report.queued.push([task.id, why]); continue; }
+    let moved;
+    try {
+      moved = tx(board, (db) => {
+        if (!task.assignee && plan.profile) {
+          db.prepare('UPDATE tasks SET assignee = ? WHERE id = ?').run(plan.profile, task.id);
+          event(db, task.id, 'assigned', { assignee: plan.profile, source: 'workflow role' });
+        }
+        return fire(db, board, entry, task.id, d.start, { roles: ['platform'], payload: { lock: claimer() }, extra: { host: hostOf(pressure), tick: tickState } });
+      });
+    } catch (error) {
+      const reason = error.refusal ?? String(error.message).slice(-300);
+      tx(board, (db) => noteGuard(db, task.id, reason));
+      report.queued.push([task.id, reason]);
+      continue;
+    }
+    effects.push(...moved.effects);
+    for (const l of limits) if (holds(l.counts, cardScope.get(task.id) ?? scope)) { const g = JSON.stringify(evaluate(l.group, scope)); l.tally.set(g, (l.tally.get(g) ?? 0) + 1); }
+    try {
+      const session = launchRun(board, entry, task.id, plan.lane, fleet, settings);
+      if (session) {
+        if (session.surface !== 'pane' || normalMachine(task.machine ?? '') === localMachine()) tickState.local_started += 1;
+        report.started.push([task.id, session.address ?? `pid ${session.pid}`, session.mode]);
+      }
+    } catch (error) {
+      try { const r = tx(board, (db) => fire(db, board, entry, task.id, 'spawn_failed', { roles: ['platform'], payload: { error: String(error.message).slice(-500) } })); effects.push(...r.effects); } catch { /* no transition for it */ }
+      report.failed.push([task.id, String(error.message).slice(-300)]);
+    }
+  }
+}
+
+/** Launch what the card's status runs: its role's lane, in the run's session slot, told the run's prompt and doors. */
+export function launchRun(board, entry, id, lane, fleet, settings) {
+  const task = getTaskNow(board, id);
+  const status = tx(board, (db) => statusOf(db, task));
+  const spec = entry.workflow.statuses[status]?.run;
+  if (!spec) return null;
+  const runId = task.current_run_id;
+  const surface = lane.surface === 'pane' ? 'pane' : 'headless';
+  const scope = tx(board, (db) => scopeOf(db, board, task, { params: entry.params }));
+  const where = whereOf(board, task);
+  const prompt = render(spec.prompt, { ...scope, where, context: tx(board, (db) => cardContext(db, id)), doors: doors(entry.workflow, status, spec.role, id, where, surface) });
+  // the run's session record knows its status, role and slot (a reviewer's slot is never the implementer's)
+  const meta = { status, role: spec.role, slot: spec.session };
+  return surface === 'pane'
+    ? launchPane(board, task, runId, lane, fleet, { input: prompt, slot: spec.session, meta })
+    : launchHeadless(board, task, runId, lane, settings, { prompt, skills: spec.skills ?? [], meta });
+}
+
+/** Start one card now by a person's word (a triage card's session, a manager's start): the workflow's start event. */
+export async function startCard(board, id, { roles = ['manager'], lanes, settings } = {}) {
+  const entry = await loadWorkflow(board.root);
+  const fleet = observeFleet();
+  const moved = tx(board, (db) => fire(db, board, entry, id, entry.workflow.dispatch.start, { roles, payload: { lock: claimer() } }));
+  const task = getTaskNow(board, id);
+  const spec = entry.workflow.statuses[moved.to]?.run;
+  const profile = spec ? tx(board, (db) => evaluate(entry.workflow.roles?.[spec.role] ?? 'card.assignee', scopeOf(db, board, task, { params: entry.params }))) : null;
+  const lane = profile ? lanes[profile] : null;
+  if (spec && !lane) throw new Error(`${id} is ${moved.to}, run by ${spec.role} (${profile ?? 'nobody'}), which is no lane of this home`);
+  return lane ? launchRun(board, entry, id, lane, fleet, settings) : null;
+}
+
+/**
+ * The heartbeat, observed: a running pane session whose last message is a whole tick old is sent `session_idle` with
+ * how many times it has been asked this run and whether it worked since the last ask; the workflow decides the rest.
+ */
+function observeIdle(board, fleet, settings, report, entry, effects) {
+  if (!fleet.ok) return;
+  for (const { id } of board.db.prepare("SELECT id FROM tasks WHERE status = 'running'").all()) {
+    tx(board, (db) => {
+      const task = getTask(db, id);
+      const status = statusOf(db, task);
+      if (!(entry.workflow.statuses[status]?.on?.session_idle || entry.workflow.on?.session_idle)) return;
+      const runRow = currentRun(db, id);
+      const session = runRow?.metadata?.supercode;
+      if (!session?.session_id || session.surface !== 'pane') return;
+      const live = fleet.sessions.find((x) => x.address?.endsWith(`:${session.session_id}`));
+      // a supercode that reports no last message time gives no reading, and no reading gives no verdict
+      const lastAt = Math.floor(Number(live?.last_message_at_ms) / 1000);
+      if (!(lastAt > 0)) return;
+      if (now() - lastAt < settings.interval) return;
+      if (session.goal_nudged_at && now() - session.goal_nudged_at < settings.interval * 2) return;
+      const worked = Boolean(session.goal_nudged_at) && lastAt >= session.goal_nudged_at + settings.interval;
+      try {
+        const r = fire(db, board, entry, id, 'session_idle', { roles: ['platform'], payload: { turns: Number(session.goal_turns ?? 0), worked }, extra: { where: whereOf(board, task) } });
+        effects.push(...r.effects);
+        const after = currentRun(db, id);
+        if (after?.id === runRow.id) setRunSession(db, runRow.id, { ...(after.metadata?.supercode ?? session), goal_nudged_at: now() });
+        report.notified.push([id, 'session_idle', live.address]);
+      } catch (error) { report.failed.push([id, `session_idle: ${String(error.message).slice(-200)}`]); }
+    });
+  }
+}
+
+/** A session effect a committed move asked for: a message to the card's current actor, or closing a slot's pane. */
+export async function sessionEffect(board, e) {
+  if (e.kind === 'send_to_actor') {
+    const run = tx(board, (db) => currentRun(db, e.id));
+    const session = run?.metadata?.supercode;
+    const address = session?.address ?? (session?.session_id && session.machine ? `sc:${session.machine}:claude-code:${session.session_id}` : null);
+    if (!address) return;
+    await send(boardAddress(board.label), board.label, address, e.text, `board-actor-${e.id}-${now()}`);
+    return;
+  }
+  if (e.kind === 'close_session') {
+    const rows = tx(board, (db) => db.prepare('SELECT id, metadata FROM task_runs WHERE task_id = ? ORDER BY id DESC').all(e.id));
+    for (const row of rows) {
+      const session = json(row.metadata, {})?.supercode;
+      if ((session?.slot ?? 'worker') !== e.slot || !session?.pane || session.closed_at) continue;
+      stopSession(session);
+      tx(board, (db) => setRunSession(db, row.id, { ...session, closed_at: now() }));
+      return;
+    }
+  }
+}
+
 // ------------------------------------------------------------------ start
 
 const running = (db, sql, ...args) => Number(db.prepare(`SELECT COUNT(*) AS n FROM tasks t LEFT JOIN supercode_cards c ON c.task_id = t.id WHERE t.status = 'running' ${sql}`).get(...args).n);
@@ -269,15 +479,11 @@ function machineLoad(db, machine, fleet) {
 }
 
 /** Why a card cannot start now, or null. */
-function guard(db, task, lane, fleet, settings, budget = null) {
-  if (budget && budget.left <= 0) return budget.why;
-  const cap = lane.capacity ?? settings.perProfile;
-  if (cap && running(db, 'AND t.assignee = ?', lane.name) >= cap) return `${lane.name} is at capacity (${cap}); the card starts when one of its sessions ends`;
+/** What the launcher itself needs to start this card (the caps are the workflow's `dispatch.limits`). */
+function launcherCheck(db, task, lane, fleet) {
   if (lane.surface !== 'pane') return null;
   if (!task.machine) return 'the card names no machine; a pane session runs on the machine its card names';
   const machine = normalMachine(task.machine);
-  const mcap = settings.machines[machine]?.capacity;
-  if (mcap && machineLoad(db, machine, fleet) >= mcap) return `machine ${machine} holds ${mcap} of the board's sessions (its capacity); the card starts when one is closed`;
   if (!fleet.ok) return `supercode could not read the fleet: ${fleet.error}`;
   if (!fleet.online.has(machine)) return `machine ${machine} is offline; the card starts when it is back`;
   // a card on this machine gets its workspace made here (scratch, dir or worktree, as Hermes makes it); another
@@ -293,17 +499,6 @@ function guard(db, task, lane, fleet, settings, budget = null) {
 const BLOCKER = /\b(quota|rate[\s_-]?limit|429|403|auth\w*|unauthorized|forbidden|billing|subscription|access[\s_]denied|permission[\s_]denied|invalid[\s_]api[\s_]key)\b/i;
 const PR_URL = /https?:\/\/github\.com\/[^/\s]+\/[^/\s]+\/pull\/\d+/i;
 
-function respawnGuard(db, task, settings, lane) {
-  const t = now();
-  const last = db.prepare('SELECT outcome, ended_at FROM task_runs WHERE task_id = ? AND ended_at IS NOT NULL ORDER BY ended_at DESC LIMIT 1').get(task.id);
-  if (last?.outcome === 'rate_limited') return settings.rateLimitCooldown > 0 && t - Number(last.ended_at) < settings.rateLimitCooldown ? 'rate_limit_cooldown' : null;
-  if (task.last_failure_error && BLOCKER.test(task.last_failure_error)) return 'blocker_auth';
-  if (lane === 'review') return null;
-  const done = db.prepare("SELECT ended_at FROM task_runs WHERE task_id = ? AND outcome = 'completed' AND ended_at >= ? ORDER BY ended_at DESC LIMIT 1").get(task.id, t - 3600);
-  if (done && !db.prepare("SELECT 1 FROM task_events WHERE task_id = ? AND created_at >= ? AND kind IN ('status', 'promoted', 'unblocked', 'reclaimed') LIMIT 1").get(task.id, done.ended_at)) return 'recent_success';
-  for (const c of db.prepare('SELECT body FROM task_comments WHERE task_id = ? AND created_at >= ?').all(task.id, t - 86400)) if (PR_URL.test(c.body ?? '')) return 'active_pr';
-  return null;
-}
 
 /** This machine's memory pressure as Hermes reads it (Linux's MemAvailable; `unknown` elsewhere, which restricts nothing). */
 function memoryPressure() {
@@ -331,135 +526,15 @@ export function paused(root) {
   return [join(root, 'ESTOP'), join(process.env.HOME ?? '', '.hermes', 'ESTOP')].find((p) => existsSync(p)) ?? null;
 }
 
-/**
- * The tick's spawn budget, as Hermes counts it: `kanban.max_spawn` against this board's running cards, and
- * `kanban.max_in_progress` against every board of the home (workers share one machine's memory).
- */
-function spawnBudget(board, settings, hostRunning) {
-  const here = Number(board.db.prepare("SELECT COUNT(*) AS n FROM tasks WHERE status = 'running'").get().n);
-  const limits = [];
-  if (settings.maxSpawn) limits.push([settings.maxSpawn - here, `the board runs ${settings.maxSpawn} cards at most (kanban.max_spawn)`]);
-  if (settings.maxInProgress) limits.push([settings.maxInProgress - hostRunning, `the home runs ${settings.maxInProgress} cards at most across its boards (kanban.max_in_progress)`]);
-  if (!limits.length) return null;
-  const [left, why] = limits.sort((a, b) => a[0] - b[0])[0];
-  return { left, why };
-}
 
-function start(board, fleet, lanes, settings, report, { only = null, hostRunning = 0 } = {}) {
-  const stop = paused(board.root);
-  if (stop) { report.paused = stop; return; }
-  const pressure = memoryPressure();
-  let localStarted = 0;
-  const order = 'ORDER BY priority DESC, created_at ASC';
-  const ready = board.db.prepare(`SELECT id, status, assignee FROM tasks WHERE status = 'ready' AND claim_lock IS NULL ${order}`).all();
-  const review = settings.reviewDispatch ? board.db.prepare(`SELECT id, status, assignee FROM tasks WHERE status = 'review' AND claim_lock IS NULL ${order}`).all() : [];
-  const budget = spawnBudget(board, settings, hostRunning);
-  // Hermes's review reservation: while review work waits, one slot of the budget is held back from the ready lane
-  const reviewWaits = review.some((r) => lanes[r.assignee || settings.defaultAssignee]);
-  const readyBudget = budget && budget.left > 0 && reviewWaits ? { left: budget.left - 1, why: `${budget.why}; one slot is held for review` } : budget;
-  for (const row of [...ready, ...review]) {
-    const lanesBudget = row.status === 'review' ? budget : readyBudget;
-    if (only && row.id !== only) continue;
-    if (board.db.prepare('SELECT subtask_of FROM supercode_cards WHERE task_id = ?').get(row.id)?.subtask_of) continue; // worked by its arc's session
-    const assignee = row.assignee || settings.defaultAssignee;
-    if (!assignee) { report.unassigned.push(row.id); continue; }
-    const lane = lanes[assignee];
-    if (!lane) { report.nonspawnable.push(row.id); continue; }
-    const claimed = tx(board, (db) => {
-      const task = getTask(db, row.id);
-      if (!task || task.status !== row.status || task.claim_lock) return null;
-      let why = guard(db, task, lane, fleet, settings, lanesBudget);
-      // this machine's memory bounds what starts here: every one-shot worker, and a pane session on this machine
-      const here = lane.surface !== 'pane' || normalMachine(task.machine ?? '') === localMachine();
-      if (!why && here && (pressure === 'critical' || (pressure === 'elevated' && localStarted >= 1))) why = `this machine's memory pressure is ${pressure}; the card starts when it eases`;
-      // Hermes's respawn guard, on every lane (a pane card whose session is still live is kept, never started twice)
-      if (!why) why = respawnGuard(db, task, settings, row.status);
-      if (why) { noteGuard(db, row.id, why); report.queued.push([row.id, why]); return null; }
-      if (!row.assignee) {
-        db.prepare('UPDATE tasks SET assignee = ? WHERE id = ?').run(assignee, row.id);
-        event(db, row.id, 'assigned', { assignee, source: 'kanban.default_assignee' });
-      }
-      const runId = claimIn(db, row.id, { ttl: settings.ttl, expectStatus: row.status });
-      return runId ? { task: getTask(db, row.id), runId } : null;
-    });
-    if (!claimed) continue;
-    try {
-      const session = lane.surface === 'pane'
-        ? launchPane(board, claimed.task, claimed.runId, lane, fleet, { input: row.status === 'review' ? reviewAsk(board, claimed.task) : null })
-        : launchHeadless(board, claimed.task, claimed.runId, lane, settings);
-      if (lane.surface !== 'pane' || normalMachine(claimed.task.machine ?? '') === localMachine()) localStarted += 1;
-      if (budget) budget.left -= 1;
-      if (readyBudget && readyBudget !== budget) readyBudget.left -= 1;
-      report.started.push([row.id, session.address ?? `pid ${session.pid}`, session.mode]);
-    } catch (error) {
-      tx(board, (db) => {
-        release(db, row.id, { outcome: 'spawn_failed', error: String(error.message).slice(-500), kind: 'spawn_failed', payload: { error: String(error.message).slice(-300) } });
-        if (recordFailure(db, row.id, error.message, { failureLimit: settings.failureLimit, outcome: 'spawn_failed' })) report.auto_blocked.push(row.id);
-      });
-      report.failed.push([row.id, String(error.message).slice(-300)]);
-    }
-  }
-}
 
-/** What a session started from the review lane is asked to do: verify the handoff and give the verdict. */
-function reviewAsk(board, task) {
-  const local = normalMachine(task.machine) === localMachine();
-  const where = local ? `--root ${board.root}${board.slug !== 'default' ? ` --board ${board.slug}` : ''}` : `--at ${boardAddress(board.label)}`;
-  return `You are reviewing card ${task.id} on the ${board.label} board: its implementer asked for review. Verify the handoff against the card's acceptance, `
-    + `then give the verdict: \`supercode workflow complete ${task.id} --summary "<what you verified>" ${where}\` approves it, and `
-    + `\`supercode workflow request-changes ${task.id} "<what must change>" ${where}\` sends it back.\n\n${tx(board, (db) => cardContext(db, task.id))}`;
-}
 
-/** What a session started on a triage card is asked to do: write its spec, or split it into cards it waits on. */
-function triageAsk(board, task, label, purpose) {
-  const local = normalMachine(task.machine) === localMachine();
-  const where = local ? `--root ${board.root}${board.slug !== 'default' ? ` --board ${board.slug}` : ''}` : `--at ${boardAddress(label)}`;
-  const context = tx(board, (db) => cardContext(db, task.id));
-  return purpose === 'decompose'
-    ? `Card ${task.id} on the ${label} board is in triage: a rough idea to split. Read it, then file the cards it breaks into and make it wait on them: `
-      + `\`supercode workflow decompose ${task.id} --child "<title>[@<profile>]" --child "..." ${where}\` (each child gets this card's machine and directory). `
-      + `The card itself stays and wakes when they are done.\n\n${context}`
-    : `Card ${task.id} on the ${label} board is in triage: a rough idea. Write its spec (the goal, the approach, what will show it is done), then file it: `
-      + `\`supercode workflow specify ${task.id} --title "<a tightened title>" --body "<the spec>" ${where}\`. The card then waits for its parents and starts.\n\n${context}`;
-}
 
-/**
- * Start a session on a triage card to specify or decompose it (where Hermes asks an auxiliary model, supercode asks a
- * session in the card's lane, which then keeps the card's memory when the card starts). Answers the session.
- */
-export function startTriageSession(board, id, lanes, settings, purpose) {
-  const fleet = observeFleet();
-  const task = tx(board, (db) => getTask(db, id));
-  if (!task) throw new Error(`no card ${id}`);
-  if (task.status !== 'triage') throw new Error(`${id} is ${task.status}; only a triage card is ${purpose === 'decompose' ? 'decomposed' : 'specified'}`);
-  const lane = lanes[task.assignee || settings.defaultAssignee];
-  if (!lane || lane.surface !== 'pane') throw new Error(`${id} has no pane lane to start a session in; give its spec directly (${purpose === 'decompose' ? '--child' : '--title/--body'})`);
-  const runId = tx(board, (db) => {
-    const why = guard(db, task, lane, fleet, settings);
-    if (why) throw new Error(`${id} cannot start a session now: ${why}`);
-    return claimIn(db, id, { ttl: settings.ttl, expectStatus: 'triage' });
-  });
-  if (!runId) throw new Error(`${id} could not be claimed`);
-  return launchPane(board, getTaskNow(board, id), runId, lane, fleet, { input: triageAsk(board, task, board.label, purpose) });
-}
 
 const getTaskNow = (board, id) => tx(board, (db) => getTask(db, id));
 
-function opening(board, task, label) {
-  const context = tx(board, (db) => cardContext(db, task.id));
-  const skills = task.skills?.length ? `\nSkills pinned to this card: ${task.skills.join(', ')}.` : '';
-  const at = `--root ${board.root}${board.slug !== 'default' ? ` --board ${board.slug}` : ''}`;
-  // the board's own door is on the machine that keeps it; a session elsewhere writes to its card through its manager
-  const local = normalMachine(task.machine) === localMachine();
-  const where = local ? at : `--at ${boardAddress(label)}`;
-  const door = `\nYour card is yours to keep current: \`supercode workflow comment ${task.id} "<text>" ${where}\`, \`block ${task.id} "<why>" --kind <needs_input|capability|transient|dependency> ${where}\` `
-    + `and \`request-review ${task.id} --summary "<what>" ${where}\` update it; \`create "<title>" --subtask-of ${task.id} ${where}\` files a subtask, and \`complete <subtask> ${where}\` marks one done`
-    + `${local ? '' : ' (each is filed with the board and answered by a board notice)'}. Its reviewers, not you, mark the card itself done.`;
-  return `You are the session working card ${task.id} on the ${label} board. The board started you; updates to the card `
-    + `(comments, reassignment, blocks, completion) and to the cards it waits on reach you as board notices.${door}${skills}\n\n${context}`;
-}
 
-function launchPane(board, task, runId, lane, fleet, { input = null } = {}) {
+function launchPane(board, task, runId, lane, fleet, { input = null, slot = 'worker', meta = {} } = {}) {
   const machine = normalMachine(task.machine);
   if (machine === localMachine() && !(task.workspace_kind === 'dir' && task.workspace_path && existsSync(task.workspace_path))) {
     const made = resolveLocalWorkspace(board, task);
@@ -469,7 +544,8 @@ function launchPane(board, task, runId, lane, fleet, { input = null } = {}) {
   const model = task.model_override ?? lane.model;
   const tail = model ? ['--model', model] : [];
   const base = ['open', '--new', 'claude', '--detach', '--on', task.machine, '--cwd', task.workspace_path];
-  const prev = tx(board, (db) => lastSession(db, task.id));
+  // the slot's last session: kept when live, resumed when lost, never another slot's (a reviewer's is its own)
+  const prev = tx(board, (db) => lastSession(db, task.id, slot));
   let session = null;
   let replaced = null;
   if (prev && prev.machine === machine) {
@@ -477,6 +553,8 @@ function launchPane(board, task, runId, lane, fleet, { input = null } = {}) {
       // the session is kept; the heartbeat's count belongs to the run that ended, so the new run starts it again
       const { missing_since: _m, goal_turns: _t, goal_nudged_at: _n, ...kept } = prev;
       session = { ...kept, mode: 'adopt', launched_at: now(), seen_at: now() };
+      // a kept session is told what this run is for (its card came back to it, with what happened since)
+      if (input) deliverNow(board, prev.address ?? `sc:${prev.machine}:claude-code:${prev.session_id}`, input, `board-run-${task.id}-r${runId}`);
     } else if (prev.resumable !== false) {
       const r = sc([...base, '--key', `board-${task.id}-r${runId}-resume`, '--input',
         `The board resumed this session after it was lost; you are still on card ${task.id}: ${task.title}. Carry on.`, '--', '--resume', prev.session_id, ...tail], { timeout: 180_000 });
@@ -489,12 +567,13 @@ function launchPane(board, task, runId, lane, fleet, { input = null } = {}) {
   } else if (prev) replaced = { session_id: prev.session_id, why: `the card moved from ${prev.machine} to ${machine}` };
   if (!session) {
     const sid = randomUUID();
-    const r = sc([...base, '--key', `board-${task.id}-r${runId}-${sid.slice(0, 8)}`, '--input', input ?? opening(board, task, board.label), '--', '--session-id', sid, ...tail], { timeout: 180_000 });
+    const r = sc([...base, '--key', `board-${task.id}-r${runId}-${sid.slice(0, 8)}`, '--input', input ?? `Card ${task.id}: ${task.title}`, '--', '--session-id', sid, ...tail], { timeout: 180_000 });
     if (r.code !== 0) throw new Error(`supercode open --on ${task.machine}: ${(r.stderr || r.stdout).trim().slice(-500)}`);
     session = { surface: 'pane', session_id: sid, machine, pane: lastJson(r.stdout)?.pane ?? null, mode: 'fresh', launched_at: now(), ...(replaced ? { replaces: replaced.session_id } : {}) };
   }
   session.harness = 'claude-code';
   session.address = `sc:${machine}:claude-code:${session.session_id}`;
+  Object.assign(session, meta);
   const kind = { adopt: 'session_adopted', resume: 'session_resumed', fresh: replaced ? 'session_replaced' : 'session_started' }[session.mode];
   tx(board, (db) => {
     setRunSession(db, runId, session);
@@ -520,10 +599,10 @@ function paneSurvives(machine, pane) {
 }
 
 /** Hermes's own worker argv and task environment, run on this machine; watched by its pid. */
-function launchHeadless(board, task, runId, lane, settings) {
+function launchHeadless(board, task, runId, lane, settings, { prompt = null, skills: runSkills = [], meta = {} } = {}) {
   const workspace = resolveLocalWorkspace(board, task);
-  const reviewing = tx(board, (db) => json(db.prepare("SELECT payload FROM task_events WHERE task_id = ? AND run_id = ? AND kind = 'claimed'").get(task.id, runId)?.payload, {})?.source_status === 'review');
-  const skills = reviewing ? [...new Set([...task.skills, 'sdlc-review'])] : task.skills;
+  // the card's own skills and the ones its status's run names (a reviewer's, for one)
+  const skills = [...new Set([...task.skills, ...runSkills])];
   const args = ['-p', lane.name, '--cli', '--accept-hooks', ...skills.flatMap((s) => ['--skills', s]),
     ...(task.model_override ? ['-m', task.model_override, ...(task.provider_override ? ['--provider', task.provider_override] : [])] : []),
     ...(task.reasoning_effort ? ['--reasoning', task.reasoning_effort] : []), 'chat', '-q', `work kanban task ${task.id}`];
@@ -541,12 +620,12 @@ function launchHeadless(board, task, runId, lane, settings) {
       ...(task.goal_mode ? { HERMES_KANBAN_GOAL_MODE: '1', ...(task.goal_max_turns ? { HERMES_KANBAN_GOAL_MAX_TURNS: String(task.goal_max_turns) } : {}) } : {}),
       ...process.env, HERMES_HOME: lane.dir, HERMES_PROFILE: lane.name, HERMES_KANBAN_TASK: task.id, HERMES_KANBAN_WORKSPACE: workspace,
       HERMES_KANBAN_RUN_ID: String(runId), HERMES_KANBAN_DB: board.path, HERMES_KANBAN_BOARD: board.slug, HERMES_SESSION_SOURCE: 'kanban',
-      HERMES_KANBAN_CLAIM_LOCK: `${hostname()}:${process.pid}`, ...(task.tenant ? { HERMES_TENANT: task.tenant } : {}),
+      HERMES_KANBAN_CLAIM_LOCK: claimer(), ...(prompt ? { SUPERCODE_BOARD_PROMPT: prompt } : {}), ...(task.tenant ? { HERMES_TENANT: task.tenant } : {}),
       ...(task.branch_name ? { HERMES_KANBAN_BRANCH: task.branch_name } : {}),
     },
   });
   child.unref();
-  const session = { surface: 'headless', pid: child.pid, machine: localMachine(), mode: 'fresh', launched_at: now(), exit_file: exitFile };
+  const session = { surface: 'headless', pid: child.pid, machine: localMachine(), mode: 'fresh', launched_at: now(), exit_file: exitFile, ...meta };
   tx(board, (db) => {
     db.prepare('UPDATE tasks SET worker_pid = ? WHERE id = ?').run(child.pid, task.id);
     db.prepare('UPDATE task_runs SET worker_pid = ? WHERE id = ?').run(child.pid, runId);
@@ -620,20 +699,18 @@ export function adoptSession(board, id, who, { workspace = null, ttl, assignee =
     if (task.machine && normalMachine(task.machine) !== host) throw new Error(`${id} runs on ${task.machine}, and ${found.address} is on ${host}; move the card first`);
     const was = lastSession(db, id);
     if (was && was.session_id !== sessionId && sessionAlive(fleet, was)) throw new Error(`${id} already has a live session, ${was.address}`);
-    if (!task.machine) db.prepare('INSERT OR REPLACE INTO supercode_cards (task_id, machine, subtask_of) VALUES (?, ?, ?)').run(id, host, task.subtask_of);
+    if (!task.machine) db.prepare('INSERT INTO supercode_cards (task_id, machine) VALUES (?, ?) ON CONFLICT(task_id) DO UPDATE SET machine = excluded.machine').run(id, host);
     // the lane that resumes it if it is lost, set in the same transaction (assigning first would let a tick start another)
     if (assignee && assignee !== task.assignee) { db.prepare('UPDATE tasks SET assignee = ? WHERE id = ?').run(assignee, id); event(db, id, 'assigned', { assignee }); }
     if (dir && !(task.workspace_kind === 'dir' && task.workspace_path)) {
       db.prepare("UPDATE tasks SET workspace_kind = 'dir', workspace_path = ? WHERE id = ?").run(dir.replace(/^dir:/, ''), id);
     }
-    if (task.status !== 'ready') {
-      if (!['todo', 'blocked', 'scheduled', 'triage', 'review'].includes(task.status)) throw new Error(`${id} is ${task.status}; only an open card takes a session`);
-      db.prepare("UPDATE tasks SET status = 'ready' WHERE id = ?").run(id);
-    }
-    const runId = claimIn(db, id, { ttl, expectStatus: 'ready' });
+    // the workflow's adopt event: the card is claimed for its implementer, whose session this now is
+    fire(db, board, workflowFor(board.root), id, 'adopt', { roles: ['manager'], payload: { lock: claimer() } });
+    const runId = getTask(db, id).current_run_id;
     if (!runId) throw new Error(`${id} waits on parents that are not done`);
     const session = { surface: 'pane', session_id: sessionId, harness, machine: host, pane: found.pane ?? null, address: found.address, mode: 'adopt', launched_at: now(), seen_at: now() };
-    setRunSession(db, runId, session);
+    setRunSession(db, runId, { ...(currentRun(db, id)?.metadata?.supercode ?? {}), ...session, slot: 'worker' });
     event(db, id, 'session_adopted', { session_id: sessionId, machine: host, pane: session.pane, address: found.address, mode: 'adopt' }, runId);
     subscribeIn(db, id, found.address, 'worker');
     for (const p of db.prepare('SELECT parent_id FROM task_links WHERE child_id = ?').all(id)) subscribeIn(db, p.parent_id, found.address, 'dependency');
@@ -677,6 +754,13 @@ function notice(kind, task, p, role) {
   }
 }
 
+// a notice sent within a transaction's caller that cannot await (the launcher): the same door, synchronously
+function deliverNow(board, to, body, key) {
+  const request = { op: 'send', from: boardAddress(board.label), from_name: `${board.label} board`, to, queue: false, id: key,
+    body: `[Board notice from the ${board.label} board] ${body}\n\n(An automated notice from the board's dispatcher; replies to this address go nowhere.)` };
+  sc(['message', 'remote-deliver'], { input: JSON.stringify(request), timeout: 120_000 });
+}
+
 async function send(from, label, to, body, key, { queue = false } = {}) {
   const request = {
     op: 'send', from, from_name: `${label} board`, to, queue, id: key,
@@ -913,79 +997,7 @@ function readMailbox(board, address, report) {
 
 // ------------------------------------------------------------------ goals and triage
 
-/**
- * The board's heartbeat for a pane session: a running card's session never sits idle without deciding. Each tick, a
- * session that is idle while its card is still running is asked to decide: `request-review` when the work is done,
- * `block` with its kind when it cannot go on (waiting on a person, a capability, another card), or keep working. A
- * goal card (Hermes's goal loop) is told to keep going. Idle is judged by the session's last message time (supercode
- * reads it from the transcript), never by its status label: a session is asked once its last message is a whole tick
- * old; one whose messages ran on a whole tick past the last ask answered it by working, and its count starts again
- * (a reply to the ask alone is not work). After the turn budget (`goal_max_turns`, else
- * `kanban.goal_max_turns`) of asks in a row with no work and no decision (a goal card: of turns), the card is blocked `needs_input` and its creator is told.
- * Whether the work is done is the session's call through its card, not an auxiliary judge's.
- */
-async function pursueGoals(board, fleet, settings, report) {
-  if (!fleet.ok) return;
-  const cards = board.db.prepare("SELECT id FROM tasks WHERE status = 'running'").all();
-  const nudges = [];
-  for (const { id } of cards) {
-    const nudge = tx(board, (db) => {
-      const task = getTask(db, id);
-      const runRow = currentRun(db, id);
-      const session = runRow?.metadata?.supercode;
-      if (!session?.session_id || session.surface !== 'pane') return null;
-      const live = fleet.sessions.find((x) => x.address?.endsWith(`:${session.session_id}`));
-      // a supercode that reports no last message time gives no reading, and no reading gives no verdict
-      const lastAt = Math.floor(Number(live.last_message_at_ms) / 1000);
-      if (!(lastAt > 0)) return null;
-      // a message within the last tick is a session working or between turns, not idle
-      if (now() - lastAt < settings.interval) return null;
-      if (session.goal_nudged_at && now() - session.goal_nudged_at < settings.interval * 2) return null;
-      // messages that ran on a whole tick past the last ask answered it by working: the count starts again (a goal
-      // card keeps Hermes's budget of turns)
-      const worked = Boolean(session.goal_nudged_at) && lastAt >= session.goal_nudged_at + settings.interval;
-      const turns = worked && !task.goal_mode ? 0 : Number(session.goal_turns ?? 0);
-      const budget = task.goal_max_turns ?? settings.goalMaxTurns;
-      if (turns >= budget) {
-        blockIn(db, id, { reason: `its session went idle ${budget} times without deciding done or blocked; review it`, kind: 'needs_input' });
-        return null;
-      }
-      setRunSession(db, runRow.id, { ...session, goal_turns: turns + 1, goal_nudged_at: now() });
-      event(db, id, task.goal_mode ? 'goal_continued' : 'decision_asked', { turn: turns + 1, budget }, runRow.id);
-      const local = normalMachine(task.machine) === localMachine();
-      const where = local ? `--root ${board.root}${board.slug !== 'default' ? ` --board ${board.slug}` : ''}` : `--at ${boardAddress(board.label)}`;
-      const decide = `When it is done, \`supercode workflow request-review ${id} --summary "<what>" ${where}\`; if you cannot go on, \`supercode workflow block ${id} "<why>" --kind <needs_input|capability|transient|dependency> ${where}\`.`;
-      const text = task.goal_mode
-        ? `Card ${id} (${task.title}) is not done yet: keep working toward it (goal turn ${turns + 1} of ${budget}). ${decide}`
-        : `Card ${id} (${task.title}) is still running and you are idle: decide (${turns + 1} of ${budget}). If there is more to do, keep working. ${decide} `
-          + `A session that stays idle without deciding has its card blocked for its creator after ${budget}.`;
-      return { address: live.address, text, kind: task.goal_mode ? 'goal_continued' : 'decision_asked' };
-    });
-    if (nudge) nudges.push({ id, ...nudge });
-  }
-  await pool(nudges, SEND_CONCURRENCY, async (nudge) => {
-    try { await send(boardAddress(board.label), board.label, nudge.address, nudge.text, `board-goal-${nudge.id}-${now()}`); report.notified.push([nudge.id, nudge.kind, nudge.address]); }
-    catch (error) { report.undelivered.push([nudge.id, nudge.address, String(error.message).slice(-200)]); }
-  });
-}
 
-/** Hermes's auto-decompose: triage cards with a pane lane get a session that splits them, a few per tick. */
-function autoDecompose(board, lanes, settings, report) {
-  if (!settings.autoDecompose) return;
-  let started = 0;
-  for (const { id, assignee } of board.db.prepare("SELECT id, assignee FROM tasks WHERE status = 'triage' ORDER BY priority DESC, created_at ASC").all()) {
-    if (started >= settings.autoDecomposePerTick) break;
-    const lane = lanes[assignee || settings.defaultAssignee];
-    if (lane?.surface !== 'pane') continue;
-    try {
-      const session = startTriageSession(board, id, lanes, settings, 'decompose');
-      report.started.push([id, session.address, 'decompose']);
-      started += 1;
-    } catch (error) {
-      report.queued.push([id, String(error.message).slice(-300)]);
-    }
-  }
-}
 
 // ------------------------------------------------------------------ the tick
 
@@ -1035,6 +1047,7 @@ const CORRUPT = /malformed|not a database|corrupt|disk image/i;
  * per-tick lock (Hermes's `.dispatch.lock`), skipped when another dispatcher holds it. Answers one report per board.
  */
 export async function tick({ root, lanes, settings, only = null, slugs = null, dispatch = true }) {
+  const entry = await loadWorkflow(root, { fresh: true });
   const needFleet = Object.values(lanes).some((l) => l.surface === 'pane');
   const fleetAt = Date.now();
   const fleet = needFleet ? observeFleet() : { ok: false, alive: new Set(), online: new Set(), sessions: [], error: 'no pane lanes' };
@@ -1063,12 +1076,15 @@ export async function tick({ root, lanes, settings, only = null, slugs = null, d
       let mark = Date.now();
       const phase = (name) => { const t = Date.now(); report.ms[name] = t - mark; mark = t; };
       readMailbox(board, boardAddress(board.label), report); phase('mailbox');
-      supervise(board, fleet, settings, report); phase('supervise');
-      report.promoted = recomputeReady(board, settings.failureLimit);
+      const effects = [];
+      supervise(board, fleet, settings, report, entry, effects); phase('supervise');
+      report.promoted = recomputeReady(board);
       const before = report.started.length;
-      if (dispatch) start(board, fleet, lanes, settings, report, { only, hostRunning });
+      if (dispatch) startCards(board, fleet, lanes, settings, report, entry, effects, { only, hostRunning });
       hostRunning += report.started.length - before; phase('start');
-      if (dispatch && !only && !report.paused) { await pursueGoals(board, fleet, settings, report); autoDecompose(board, lanes, settings, report); }
+      if (dispatch && !only && !report.paused) observeIdle(board, fleet, settings, report, entry, effects);
+      // what the moves asked for, once they are committed (messages to actors, closed panes, cleaned workspaces)
+      await runEffects(board, effects);
       phase('goals');
       await notify(board, fleet, report); phase('notify');
       fireHooks(board, settings, report);