@volter/supercode-orchestrator 0.4.16 → 0.4.18

package/board/dispatch.mjs

@@ -15,7 +15,7 @@
 // subscriber's cursor moves only after its notice was delivered, so two dispatchers over one board never both
 // launch and a crash between the two steps is answered by the next tick.
 import { spawn as spawnChild, spawnSync } from 'node:child_process';
-import { existsSync, mkdirSync, readFileSync, openSync } from 'node:fs';
+import { existsSync, mkdirSync, openSync, readdirSync, readFileSync, renameSync } from 'node:fs';
 import { hostname, tmpdir } from 'node:os';
 import { basename, dirname, join } from 'node:path';
 import { randomUUID } from 'node:crypto';
@@ -106,6 +106,11 @@ export function boardSettings(kanban = {}) {
     grace: pos(kanban.session_grace_seconds) ?? 120,
     machines: Object.fromEntries(Object.entries(kanban.machines ?? {}).map(([name, m]) => [normalMachine(name), { capacity: pos(m?.capacity) }])),
     interval: Math.max(Number(kanban.dispatch_interval_seconds) || 60, 1),
+    staleTimeout: pos(kanban.dispatch_stale_timeout_seconds),
+    autoDecompose: kanban.auto_decompose !== false,
+    autoDecomposePerTick: pos(kanban.auto_decompose_per_tick) ?? 3,
+    goalMaxTurns: pos(kanban.goal_max_turns) ?? 20,
+    rateLimitCooldown: Number.isInteger(Number(process.env.HERMES_KANBAN_RATE_LIMIT_COOLDOWN_SECONDS)) && process.env.HERMES_KANBAN_RATE_LIMIT_COOLDOWN_SECONDS !== '' ? Number(process.env.HERMES_KANBAN_RATE_LIMIT_COOLDOWN_SECONDS) : 300,
   };
 }
 
@@ -141,6 +146,13 @@ function supervise(board, fleet, settings, report) {
         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);
+          return;
+        }
         if (pidAlive(session.pid)) {
           if (Number(task.claim_expires) <= t + 60) extendClaim(db, id, { ttl: settings.ttl, reason: 'pid_alive', extra: { worker_pid: session.pid } });
           return;
@@ -228,6 +240,38 @@ function guard(db, task, lane, fleet, settings) {
   return null;
 }
 
+// Hermes's respawn guard, for a one-shot (headless) worker: no respawn while the last failure is an auth or quota
+// wall, after a completion nobody requeued, or while a pull request is open on the card. A pane session is resumed
+// rather than respawned, so it never runs twice and these do not apply.
+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() {
+  try {
+    const info = Object.fromEntries(readFileSync('/proc/meminfo', 'utf8').split('\n').map((l) => /^(\w+):\s+(\d+)/.exec(l)).filter(Boolean).map((m) => [m[1], Number(m[2])]));
+    const avail = info.MemAvailable;
+    const total = info.MemTotal;
+    if (!Number.isFinite(avail)) return 'unknown';
+    const fraction = total > 0 ? avail / total : null;
+    if (avail < 64 * 1024 || (fraction !== null && fraction < 0.05)) return 'critical';
+    if (avail < 128 * 1024 || (fraction !== null && fraction < 0.15)) return 'elevated';
+    return 'ok';
+  } catch { return 'unknown'; }
+}
+
 /** Record a guard reason once per change, not once per tick. */
 function noteGuard(db, id, reason) {
   const last = db.prepare("SELECT payload FROM task_events WHERE task_id = ? AND kind IN ('respawn_guarded', 'claimed') ORDER BY id DESC LIMIT 1").get(id);
@@ -237,6 +281,8 @@ function noteGuard(db, id, reason) {
 
 function start(board, fleet, lanes, settings, report, { only = null } = {}) {
   const lanesWanted = settings.reviewDispatch ? "('ready', 'review')" : "('ready')";
+  const pressure = memoryPressure();
+  let headlessStarted = 0;
   const rows = board.db.prepare(`SELECT id, status, assignee FROM tasks WHERE status IN ${lanesWanted} AND claim_lock IS NULL ORDER BY priority DESC, created_at ASC`).all();
   for (const row of rows) {
     if (only && row.id !== only) continue;
@@ -248,7 +294,12 @@ function start(board, fleet, lanes, settings, report, { only = null } = {}) {
     const claimed = tx(board, (db) => {
       const task = getTask(db, row.id);
       if (!task || task.status !== row.status || task.claim_lock) return null;
-      const why = guard(db, task, lane, fleet, settings);
+      let why = guard(db, task, lane, fleet, settings);
+      if (!why && lane.surface !== 'pane') {
+        // a one-shot worker runs on this machine: its memory, and Hermes's respawn guard
+        if (pressure === 'critical' || (pressure === 'elevated' && headlessStarted >= 1)) why = `this machine's memory pressure is ${pressure}; the card starts when it eases`;
+        else 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);
@@ -259,7 +310,10 @@ function start(board, fleet, lanes, settings, report, { only = null } = {}) {
     });
     if (!claimed) continue;
     try {
-      const session = lane.surface === 'pane' ? launchPane(board, claimed.task, claimed.runId, lane, fleet) : launchHeadless(board, claimed.task, claimed.runId, lane, settings);
+      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') headlessStarted += 1;
       report.started.push([row.id, session.address ?? `pid ${session.pid}`, session.mode]);
     } catch (error) {
       tx(board, (db) => {
@@ -271,20 +325,65 @@ function start(board, fleet, lanes, settings, report, { only = null } = {}) {
   }
 }
 
+/** 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 door = normalMachine(task.machine) === localMachine()
-    ? `\nYour card is yours to keep current: \`supercode workflow show ${task.id} ${at}\` reads it; \`comment\`, \`block --kind <needs_input|capability|transient|dependency>\` `
-      + `and \`review\` update it; \`create <title> --subtask-of ${task.id}\` files a subtask, and \`complete <subtask>\` marks one done. Its reviewers, not you, mark the card itself done.`
-    : '';
+  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) {
+function launchPane(board, task, runId, lane, fleet, { input = null } = {}) {
   const machine = normalMachine(task.machine);
   const model = task.model_override ?? lane.model;
   const tail = model ? ['--model', model] : [];
@@ -308,7 +407,7 @@ function launchPane(board, task, runId, lane, fleet) {
   } 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', 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 ?? opening(board, task, board.label), '--', '--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 } : {}) };
   }
@@ -341,7 +440,9 @@ 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) {
   const workspace = resolveLocalWorkspace(board, task);
-  const args = ['-p', lane.name, '--cli', '--accept-hooks', ...task.skills.flatMap((s) => ['--skills', s]),
+  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;
+  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}`];
   const logDir = join(dirname(board.path), board.slug === 'default' ? 'kanban' : '', 'logs');
@@ -397,7 +498,7 @@ function resolveLocalWorkspace(board, task) {
  * never as the session describes itself. From then on the board watches it, resumes it when lost, and tells it of
  * its card. `who` is an address, a session id, or a `name@machine` the fleet lists.
  */
-export function attachSession(board, id, who, { workspace = null, ttl } = {}) {
+export function adoptSession(board, id, who, { workspace = null, ttl } = {}) {
   const fleet = observeFleet();
   if (!fleet.ok) throw new Error(`supercode could not read the fleet: ${fleet.error}`);
   const found = fleet.sessions.find((s) => s.address === who || s.address.endsWith(`:${who}`) || s.name === who);
@@ -479,11 +580,19 @@ function send(from, label, to, body, key) {
   if (r.code !== 0 || answer.code !== 0) throw new Error((answer.text || r.stderr || 'no answer').trim().slice(-300));
 }
 
-function notify(board, report) {
-  const from = `sc:${localMachine()}:board:${board.label.replace(/[^A-Za-z0-9_.-]/g, '-')}`;
+/** The board's own address: where its notices come from and where card updates are mailed. */
+export const boardAddress = (label) => `sc:${localMachine()}:board:${label.replace(/[^A-Za-z0-9_.-]/g, '-')}`;
+
+function notify(board, fleet, report) {
+  const from = boardAddress(board.label);
   for (const sub of subscriptions(board.db)) {
     if (sub.platform !== 'supercode') continue;
     const role = ['worker', 'dependency'].includes(sub.delivery_metadata?.role) ? sub.delivery_metadata.role : 'creator';
+    // a session that worked or watched a card and is gone hears nothing more; a creator is retried until it is back
+    if (role !== 'creator' && fleet.ok && !fleet.alive.has(sub.chat_id)) {
+      tx(board, (db) => db.prepare("DELETE FROM kanban_notify_subs WHERE task_id = ? AND platform = 'supercode' AND chat_id = ?").run(sub.task_id, sub.chat_id));
+      continue;
+    }
     const kinds = MAIL_KINDS[role];
     const events = board.db.prepare(`SELECT id, kind, payload, created_at FROM task_events WHERE task_id = ? AND id > ? AND kind IN (${kinds.map(() => '?').join(', ')}) ORDER BY id`)
       .all(sub.task_id, sub.last_event_id, ...kinds);
@@ -516,6 +625,109 @@ function notify(board, report) {
   }
 }
 
+// ------------------------------------------------------------------ the board's mailbox
+
+const ENTRY = fileURLToPath(new URL('../bin/orchestrator.mjs', import.meta.url));
+const NOT_BY_MAIL = new Set(['serve', 'daemon', 'dispatch', 'init', 'adopt', 'boards', 'gc', 'repair', 'watch', 'tail', 'attach']);
+
+/** The board's mailbox on this machine: the directory supercode files mail for `address` in, or null. */
+function mailboxOf(address) {
+  const config = process.env.SUPERCODE_HOME || (process.env.XDG_CONFIG_HOME ? join(process.env.XDG_CONFIG_HOME, 'supercode') : join(process.env.HOME ?? '', '.config', 'supercode'));
+  const root = join(config, 'mail');
+  if (!existsSync(root)) return null;
+  for (const dir of readdirSync(root)) {
+    if (!dir.startsWith('board-')) continue;
+    try { if (readFileSync(join(root, dir, 'address'), 'utf8').trim() === address) return join(root, dir); } catch { /* not a mailbox */ }
+  }
+  return null;
+}
+
+/**
+ * Card updates filed as mail (`supercode workflow <verb> … --at <this board's address>`, from any machine): each is
+ * run as its sender, the session supercode found the command running under, so a card's session gets exactly what
+ * it may do on this machine; the answer goes back as a notice and the envelope is filed as read.
+ */
+function readMailbox(board, address, report) {
+  const box = mailboxOf(address);
+  if (!box || !existsSync(join(box, 'new'))) return;
+  for (const name of readdirSync(join(box, 'new')).filter((n) => n.endsWith('.json')).sort()) {
+    const path = join(box, 'new', name);
+    let envelope;
+    try { envelope = JSON.parse(readFileSync(path, 'utf8')); } catch { continue; }
+    try { renameSync(path, join(box, 'cur', name)); } catch { continue; } // another reader took it
+    const argv = json(envelope.body, {})?.workflow;
+    let answer;
+    if (!Array.isArray(argv) || !argv.length || NOT_BY_MAIL.has(argv[0])) answer = `not applied: a mailed card update is one \`supercode workflow\` verb other than ${[...NOT_BY_MAIL].join(', ')}`;
+    else {
+      const clean = [];
+      for (let i = 0; i < argv.length; i += 1) { if (argv[i] === '--root' || argv[i] === '--board') i += 1; else clean.push(String(argv[i])); }
+      const sid = String(envelope.from ?? '').split(':')[3] ?? '';
+      const r = spawnSync(process.execPath, [ENTRY, 'workflow', ...clean, '--root', board.root, '--board', board.slug], {
+        encoding: 'utf8', timeout: 180_000, env: { ...process.env, CLAUDE_CODE_SESSION_ID: sid, CODEX_THREAD_ID: '' },
+      });
+      answer = `${clean.slice(0, 2).join(' ')}: ${(r.status === 0 ? r.stdout : r.stderr || r.stdout).trim().slice(-600) || `exit ${r.status}`}`;
+    }
+    report.mailed.push([envelope.from, argv?.[0] ?? '?']);
+    try { send(address, board.label, envelope.from, answer, `board-answer-${envelope.id}`); } catch (error) { report.undelivered.push(['mail', envelope.from, String(error.message).slice(-200)]); }
+  }
+}
+
+// ------------------------------------------------------------------ goals and triage
+
+/**
+ * Hermes's goal loop for a pane session: a goal card whose session sits idle while the card is still running is told
+ * to keep going, up to the card's turn budget; when the budget is spent the card is blocked for review. Whether the
+ * work is done is the session's call through its card (`request-review`), not an auxiliary judge's.
+ */
+function pursueGoals(board, fleet, settings, report) {
+  if (!fleet.ok) return;
+  const cards = board.db.prepare("SELECT id FROM tasks WHERE status = 'running' AND goal_mode = 1").all();
+  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}`));
+      if (live?.status !== 'idle') return null;
+      if (session.goal_nudged_at && now() - session.goal_nudged_at < settings.interval * 2) return null;
+      const turns = Number(session.goal_turns ?? 0);
+      const budget = task.goal_max_turns ?? settings.goalMaxTurns;
+      if (turns >= budget) {
+        db.prepare("UPDATE tasks SET status = 'blocked', claim_lock = NULL, claim_expires = NULL WHERE id = ?").run(id);
+        const ended = endRun(db, id, { outcome: 'blocked', summary: `goal turn budget (${budget}) spent` });
+        event(db, id, 'blocked', { reason: `goal turn budget (${budget}) spent; review it`, kind: 'needs_input', source_status: 'ready' }, ended);
+        return null;
+      }
+      setRunSession(db, runRow.id, { ...session, goal_turns: turns + 1, goal_nudged_at: now() });
+      event(db, id, 'goal_continued', { turn: turns + 1, budget }, runRow.id);
+      return { address: live.address, text: `Card ${id} (${task.title}) is not done yet: keep working toward it (goal turn ${turns + 1} of ${budget}). When it is done, \`request-review\` it; if you are stuck, \`block\` it with its kind.` };
+    });
+    if (nudge) {
+      try { send(boardAddress(board.label), board.label, nudge.address, nudge.text, `board-goal-${id}-${now()}`); report.notified.push([id, 'goal_continued', nudge.address]); }
+      catch (error) { report.undelivered.push([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
 
 /** The board's name in notices: the home's owner folder (`…/volter-manager/home` → `volter-manager`), and the slug. */
@@ -533,18 +745,19 @@ export function tick({ root, lanes, settings, only = null, slugs = null, dispatc
   const fleet = needFleet ? observeFleet() : { ok: false, alive: new Set(), online: new Set(), error: 'no pane lanes' };
   const out = [];
   for (const slug of slugs ?? listBoards(root)) {
-    const report = { board: slug, started: [], queued: [], failed: [], lost: [], crashed: [], timed_out: [], reclaimed: [], auto_blocked: [], promoted: 0, unassigned: [], nonspawnable: [], notified: [], undelivered: [], fleet: fleet.ok ? 'read' : fleet.error };
+    const report = { board: slug, mailed: [], started: [], queued: [], failed: [], lost: [], crashed: [], timed_out: [], reclaimed: [], auto_blocked: [], promoted: 0, unassigned: [], nonspawnable: [], notified: [], undelivered: [], fleet: fleet.ok ? 'read' : fleet.error };
     let board;
     try {
       board = openBoard(root, slug);
       board.label = boardLabel(root, slug);
+      readMailbox(board, boardAddress(board.label), report);
       supervise(board, fleet, settings, report);
       report.promoted = recomputeReady(board, settings.failureLimit);
       if (dispatch) start(board, fleet, lanes, settings, report, { only });
-      notify(board, report);
+      if (dispatch && !only) { pursueGoals(board, fleet, settings, report); autoDecompose(board, lanes, settings, report); }
+      notify(board, fleet, report);
       // what a Hermes gateway serves around its dispatcher and this one does not: said by the caller
       report.chat_subscriptions = Number(board.db.prepare("SELECT COUNT(*) AS n FROM kanban_notify_subs WHERE platform != 'supercode'").get().n);
-      report.triage = Number(board.db.prepare("SELECT COUNT(*) AS n FROM tasks WHERE status = 'triage'").get().n);
     } catch (error) {
       report.error = error.message;
     } finally {