@volter/supercode-orchestrator 0.4.156 → 0.4.157

package/board/capacity.mjs

@@ -0,0 +1,171 @@
+// The board's capacity language, counted (docs/adr/0009-board-capacity.md). A workflow's `dispatch.capacity` lists its
+// caps; each names where it keeps one count (`scope`), what it counts (`counts`), which cards and sessions it is about
+// (`where`, less `unless`) and its `max`. This module counts what a home holds now and answers whether one more card may start.
+
+import { json } from './store.mjs';
+import { statusOf } from './workflow.mjs';
+
+/** The scope's group a counted thing or a card falls in. */
+const GROUP = {
+  global: () => 'home',
+  board: (x) => x.board,
+  machine: (x) => x.machine,
+  profile: (x) => x.assignee,
+};
+
+/** The fleet statuses of a session in a turn (`waiting`: a turn stopped on a question it asked). */
+const IN_TURN = new Set(['busy', 'waiting']);
+
+/** Whether `thing` (a counted card or session, or a card being started) is one the filter is about. */
+export function matches(filter, thing) {
+  for (const [key, names] of Object.entries(filter ?? {})) {
+    const list = Array.isArray(names) ? names : [names];
+    if (list.length && !list.includes(thing[key] ?? null)) return false;
+  }
+  return true;
+}
+
+/** Whether a cap is about `thing`: its `where` matches and its `unless` (when it names anything) does not. */
+const applies = (cap, thing) => matches(cap.where, thing) && !(Object.keys(cap.unless ?? {}).length && matches(cap.unless, thing));
+
+/** Each slot's latest recorded session on a card (implementer `worker`, `reviewer`, …), newest run first. */
+function sessionsOf(db, taskId) {
+  const out = new Map();
+  for (const row of db.prepare('SELECT metadata FROM task_runs WHERE task_id = ? AND metadata IS NOT NULL ORDER BY id DESC').all(taskId)) {
+    const s = json(row.metadata, {})?.supercode;
+    const slot = s?.slot ?? 'worker';
+    if (s?.session_id && !out.has(slot)) out.set(slot, s);
+  }
+  return out;
+}
+
+/**
+ * What one board holds now, as counted things: each card with a live run (`runs`), each card in any status but
+ * archived, once (`cards`; a cap's `where` names the statuses it counts), each live session its cards hold in any slot (`sessions`, those in a turn also
+ * `turns`). `alive(session)` and `liveRecord(session)` read the fleet; `modelOf(session)` is the model the session's
+ * own transcript reports it runs, or null where none can be read; `machineOf` normalises a machine name; `lanes` gives
+ * a profile's harness and model.
+ */
+export function holdings(board, { lanes, fleetOk, alive, liveRecord, modelOf = () => null, machineOf }) {
+  const out = [];
+  const rows = board.db.prepare("SELECT t.id, t.status, t.assignee, t.current_run_id, t.model_override, c.machine FROM tasks t LEFT JOIN supercode_cards c ON c.task_id = t.id WHERE t.status != 'archived'").all();
+  for (const row of rows) {
+    const lane = lanes[row.assignee] ?? {};
+    const card = {
+      card: row.id, board: board.slug, assignee: row.assignee ?? null, status: statusOf(board.db, row),
+      machine: row.machine ? machineOf(row.machine) : null,
+      model: row.model_override ?? lane.model ?? null, harness: lane.harness ?? null,
+    };
+    // a session's model: what its transcript reports, else what its launch resolved, else the card's
+    const sessionOf = (s, slot) => {
+      const configured = s.model ?? card.model;
+      return { ...card, counts: 'sessions', slot, session: s.session_id ?? null, unconfigured: !configured,
+        machine: s.machine ? machineOf(s.machine) : card.machine, harness: s.harness ?? card.harness ?? 'claude-code',
+        model: (s.session_id ? modelOf(s) : null) ?? configured };
+    };
+    const sessions = fleetOk ? sessionsOf(board.db, row.id) : new Map();
+    const held = [];
+    let current = null;
+    if (row.current_run_id) {
+      current = json(board.db.prepare('SELECT metadata FROM task_runs WHERE id = ?').get(row.current_run_id)?.metadata, {})?.supercode ?? {};
+      out.push({ ...sessionOf(current, current.slot ?? 'worker'), session: undefined, slot: undefined, counts: 'runs' });
+    }
+    for (const [slot, s] of sessions) {
+      if (!alive(s)) continue;
+      const session = sessionOf(s, slot);
+      held.push(session);
+      if (IN_TURN.has(liveRecord(s)?.status)) out.push({ ...session, counts: 'turns' });
+    }
+    // a live run whose session the fleet does not list yet (launching) holds a session's place already
+    if (current && !held.some((x) => x.slot === (current.slot ?? 'worker'))) held.unshift(sessionOf(current, current.slot ?? 'worker'));
+    out.push(...held);
+    // the card itself, whatever its runs and sessions: a cap says which by its status (a started card holds its slot
+    // until it is done); its model and harness are its run's session's, else its newest live session's, else its own
+    out.push({ ...(held[0] ?? { ...card, unconfigured: !card.model }), session: undefined, slot: undefined, counts: 'cards' });
+  }
+  return out;
+}
+
+/**
+ * The model each harness runs when nothing names one (the harness's own default, which its configuration may give only
+ * as an alias such as `opus`): what the transcripts of sessions started with no model report, the most of them. Each
+ * counted thing with no model of its own reads it, and so does a card about to start (`held.defaults`).
+ */
+export function harnessDefaults(held) {
+  const seen = {};
+  for (const x of held) {
+    if (x.counts !== 'sessions' || !x.unconfigured || !x.model) continue;
+    (seen[x.harness] ??= new Map()).set(x.model, (seen[x.harness].get(x.model) ?? 0) + 1);
+  }
+  const defaults = Object.fromEntries(Object.entries(seen).map(([h, m]) => [h, [...m].sort((a, b) => b[1] - a[1])[0][0]]));
+  for (const x of held) if (!x.model && x.harness && defaults[x.harness]) x.model = defaults[x.harness];
+  return defaults;
+}
+
+/**
+ * The caps of a workflow over what a home holds (`held`: every board's `holdings`). `evaluate(expr, scope)` gives a
+ * cap's max (and a reserve's slots) for the card being started. `admit` says whether that card may start and, when not,
+ * which cap holds it and why; `take` counts it once it starts.
+ */
+export function capacity(caps, held, evaluate) {
+  const list = (caps ?? []).map((cap) => ({ ...cap, where: cap.where ?? {} }));
+  // shared by every board of a tick, so what one board starts counts on the next
+  const things = held;
+  const counted = (cap, group) => things.filter((x) => x.counts === cap.counts && applies(cap, x) && GROUP[cap.scope](x) === group);
+  return {
+    caps: list,
+    /** Each cap's groups now: `{ name, scope, counts, where, groups: [{ group, count, cards }] }`. */
+    view() {
+      return list.map((cap) => {
+        const groups = new Map(cap.scope === 'global' ? [['home', []]] : []);
+        for (const x of things) {
+          if (x.counts !== cap.counts || !applies(cap, x)) continue;
+          const g = GROUP[cap.scope](x);
+          if (!groups.has(g)) groups.set(g, []);
+          groups.get(g).push(x.card);
+        }
+        return { name: cap.name, scope: cap.scope, counts: cap.counts, where: cap.where, unless: cap.unless ?? {}, max: cap.max,
+          groups: [...groups].map(([group, cards]) => ({ group, count: cards.length, cards })) };
+      });
+    },
+    /**
+     * Whether `entry` (the card about to start: `{ card, board, machine, assignee, status, model, harness }`) may
+     * start. `scope` evaluates each max; `waiting` is every card still to be planned this tick, for reserves (a waiting card
+     * the cap counts already takes no new place, so none is held for it). A card
+     * that already holds a place in a count (its implementer's live session while its review starts) keeps it: that
+     * cap does not hold it.
+     */
+    admit(entry, scope, waiting = []) {
+      for (const cap of list) {
+        if (!applies(cap, entry)) continue;
+        const max = evaluate(cap.max, scope);
+        if (max === null || max === undefined || max === '') continue;
+        const group = GROUP[cap.scope](entry);
+        const now = counted(cap, group);
+        if (now.some((x) => x.card === entry.card)) continue;
+        const reserved = cap.reserve && !matches(cap.reserve.for, entry) && waiting.some((w) => w.card !== entry.card && matches(cap.reserve.for, w) && GROUP[cap.scope](w) === group && !now.some((x) => x.card === w.card))
+          ? Number(evaluate(cap.reserve.slots, scope) ?? 0) : 0;
+        if (now.length >= Number(max) - reserved) {
+          const where = cap.scope === 'global' ? 'across the home' : `on ${cap.scope} ${group ?? '(none)'}`;
+          return { cap: cap.name, count: now.length, max: Number(max), reserved,
+            why: `waits on cap "${cap.name}": ${now.length} of ${Number(max)} ${cap.counts} ${where}${reserved ? `, ${reserved} held for ${describe(cap.reserve.for)}` : ''}` };
+        }
+      }
+      return null;
+    },
+    /**
+     * Count `entry` as started: its run, its card, its session (in a turn from its first prompt) and its start. What the card
+     * already holds is not counted again: the run takes the place its card holds.
+     */
+    take(entry) {
+      for (const counts of ['runs', 'cards', 'sessions', 'turns', 'starts']) {
+        const had = things.find((x) => x.card === entry.card && x.counts === counts);
+        // the card is counted already: it is now in the status its start moved it to
+        if (had) { if (counts === 'cards') Object.assign(had, { status: entry.status, model: had.model ?? entry.model, harness: had.harness ?? entry.harness }); }
+        else things.push({ ...entry, counts });
+      }
+    },
+  };
+}
+
+const describe = (filter) => Object.entries(filter ?? {}).map(([k, v]) => `${k} ${[].concat(v).join(' or ')}`).join(', ') || 'other cards';

package/board/cli.mjs

@@ -42,6 +42,7 @@ Hermes Kanban's verbs, with their flags:
   decompose <id> [--child "<title>[@<profile>]"]... [--all]
   diagnostics [--task] [--severity]   stats   assignees   log <id> [--tail N]   tail <id>   watch [--assignee] [--kinds]
   notify-subscribe <id> --platform P --chat-id C [--thread-id]   notify-list [<id>]   notify-unsubscribe <id> --platform P --chat-id C
+  capacity   (each cap's count against its max, and why each card waits; docs/adr/0009-board-capacity.md)
   dispatch [--dry-run] [--max N] [--failure-limit N]   daemon [--interval S] [--max N] [--failure-limit N] [--pidfile F] [--verbose]   gc [--event-retention-days] [--log-retention-days]   repair
   pause [reason] · resume   (Hermes's emergency stop, the ESTOP file: new starts stop, running sessions go on)
 
@@ -768,6 +769,25 @@ export async function runWorkflow(argv) {
       else for (const r of reports) process.stdout.write(`${summary(r)}\n`);
       return reports.some((r) => r.error) ? 1 : 0;
     }
+    case 'capacity': {
+      // the home's caps as the dispatcher counts them now, and what a tick would start or hold, writing nothing
+      const { lanes, settings } = await laneState(root);
+      const reports = await plan({ root, lanes, settings });
+      const out = { capacity: reports.capacity, would: reports.flatMap((r) => r.would.map((w) => w.id)), waiting: reports.flatMap((r) => r.queued.map(([id, why]) => ({ id, why }))) };
+      if (args.json) { say(args, '', out); return 0; }
+      const lines = [];
+      for (const cap of out.capacity) {
+        const filter = Object.entries(cap.where ?? {}).map(([k, v]) => `${k} ${[].concat(v).join('|')}`).join(', ');
+        const except = Object.entries(cap.unless ?? {}).map(([k, v]) => `${k} ${[].concat(v).join('|')}`).join(', ');
+        lines.push(`cap "${cap.name}": ${cap.counts} per ${cap.scope}${filter ? `, where ${filter}` : ''}${except ? `, unless ${except}` : ''}, max ${cap.max}`);
+        if (!cap.groups.length) lines.push('    (nothing counted)');
+        for (const g of cap.groups) lines.push(`    ${cap.scope === 'global' ? 'home' : g.group ?? '(none)'}: ${g.count} of ${g.max ?? 'no max'}  ${[...new Set(g.cards)].join(' ')}`);
+      }
+      lines.push(out.would.length ? `would start: ${out.would.join(' ')}` : 'would start: nothing');
+      for (const w of out.waiting) lines.push(`${w.id}  ${w.why}`);
+      process.stdout.write(`${lines.join('\n')}\n`);
+      return 0;
+    }
     case 'daemon': case 'serve': return serve(root, args);
 
     case 'gc': {
@@ -1094,7 +1114,7 @@ function ownCard(db, sessionId) {
   return engine.lastSession(db, hit.task_id)?.session_id === sessionId ? engine.getTask(db, hit.task_id) : null;
 }
 
-const READS = new Set(['list', 'ls', 'show', 'context', 'runs', 'log', 'tail', 'watch', 'stats', 'assignees', 'diagnostics', 'diag', 'attachments', 'notify-list', 'help', 'init']);
+const READS = new Set(['list', 'ls', 'show', 'context', 'runs', 'log', 'tail', 'watch', 'stats', 'assignees', 'diagnostics', 'diag', 'attachments', 'notify-list', 'capacity', 'help', 'init']);
 
 /**
  * Who a caller is on card `cardId`, in the workflow's roles: a caller with no session behind it has no role (the

package/board/dispatch.mjs

@@ -18,14 +18,15 @@
 import { inspectCompletionEvidence, noCodeChange, openReviewPullRequests, reviewDue, withCompletionEvidence, reviewCandidate, workflowRevision, retainWorkflowTick } from './ci.mjs';
 import { createRequire } from 'node:module';
 import { spawn as spawnChild, spawnSync } from 'node:child_process';
-import { existsSync, mkdirSync, openSync, readdirSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
-import { hostname, tmpdir, totalmem } from 'node:os';
+import { closeSync, existsSync, mkdirSync, openSync, readdirSync, readFileSync, readSync, renameSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
+import { homedir, hostname, tmpdir, totalmem } from 'node:os';
 import { basename, dirname, join } from 'node:path';
 import { createHash, randomUUID } from 'node:crypto';
 import { fileURLToPath } from 'node:url';
 import { view, boardCopyOf, boardPath, claimer, copyRefusal, event, json, listBoards, logsDir, now, openBoard, setActor, tx } from './store.mjs';
 import { doors, fire, loadWorkflow, resumeOf, runSpec, runWorkingSeconds, requestSessionClose, retireSupersededRuns, refreshCardInputs, refreshRelationAnswers, transitionsFor, scopeOf, statusOf, templateValue, workflowFor } from './workflow.mjs';
 import { checkWorkspace, assertWorkspaceOwner, notePresence, resolveWorkspace } from './workspace.mjs';
+import { capacity, harnessDefaults, holdings } from './capacity.mjs';
 import { evaluate, holds, render } from './expr.mjs';
 import { identifyNotice } from './notices.mjs';
 import { pendingRequestMail } from './request-mail.mjs';
@@ -462,13 +463,70 @@ export function whereOf(board, task) {
 // what the platform tells expressions about this machine and this tick
 const hostOf = (pressure) => ({ memory_pressure: pressure, max_in_progress: derivedMaxInProgress() });
 
+/** What every board of the home at `root` holds now, counted for its caps (capacity.mjs). */
+function homeHoldings(root, slugs, lanes, fleet) {
+  const live = (s) => fleet.sessions?.find((x) => x.address === addressOf(s)) ?? null;
+  const out = [];
+  for (const slug of slugs) {
+    try {
+      const b = openBoard(root, slug);
+      try { b.slug ??= slug; out.push(...holdings(b, { lanes, fleetOk: fleet.ok, alive: (s) => sessionAlive(fleet, s), liveRecord: live, modelOf: transcriptModel, machineOf: normalMachine })); }
+      finally { b.close(); }
+    } catch { /* its own tick reports it */ }
+  }
+  out.defaults = harnessDefaults(out);
+  return out;
+}
+
+// where each session's transcript is, once found (a session's file does not move)
+const transcripts = new Map();
+
+/**
+ * The model a session on this machine runs, as its own transcript reports it (Claude Code's assistant messages and
+ * Codex's turn contexts both carry `"model"`): the last one written, so a model changed mid-session is the one read.
+ * Null for another machine's session, or one whose transcript cannot be found or names none.
+ */
+function transcriptModel(session) {
+  if (!session?.session_id || normalMachine(session.machine ?? localMachine()) !== localMachine()) return null;
+  const sid = session.session_id;
+  let file = transcripts.get(sid);
+  if (file === undefined) {
+    file = null;
+    try {
+      if ((session.harness ?? 'claude-code') === 'claude-code') {
+        const projects = join(process.env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude'), 'projects');
+        for (const dir of readdirSync(projects)) { const f = join(projects, dir, `${sid}.jsonl`); if (existsSync(f)) { file = f; break; } }
+      } else if (session.harness === 'codex') {
+        // Codex files its rollouts by day: sessions/YYYY/MM/DD/rollout-<time>-<id>.jsonl, newest days first
+        const root = join(process.env.CODEX_HOME || join(homedir(), '.codex'), 'sessions');
+        const sorted = (dir) => readdirSync(dir).sort().reverse();
+        search: for (const y of sorted(root)) for (const m of sorted(join(root, y))) for (const d of sorted(join(root, y, m))) {
+          const hit = readdirSync(join(root, y, m, d)).find((f) => f.endsWith(`-${sid}.jsonl`));
+          if (hit) { file = join(root, y, m, d, hit); break search; }
+        }
+      }
+    } catch { file = null; }
+    if (file) transcripts.set(sid, file);
+  }
+  if (!file) return null;
+  try {
+    const size = statSync(file).size;
+    const fd = openSync(file, 'r');
+    const length = Math.min(size, 512 * 1024);
+    const buf = Buffer.alloc(length);
+    try { readSync(fd, buf, 0, length, size - length); } finally { closeSync(fd); }
+    const models = [...buf.toString('utf8').matchAll(/"model":"([^"]+)"/g)].map((m) => m[1]).filter((m) => !m.startsWith('<'));
+    return models.at(-1) ?? null;
+  } catch { return null; }
+}
+
 /**
  * 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.
+ * that `dispatch.eligible` admits, in `dispatch.order`, under `dispatch.capacity` (the capacity language: every cap
+ * that matches a card must have room; capacity.mjs). Each is sent the start event (its validators are Hermes's respawn
+ * guard) and what its new status runs is launched. `held` is what the home holds (homeHoldings), shared by its boards.
  */
-function startCards(board, fleet, lanes, settings, report, entry, effects, { only = null, hostRunning = 0, dry = false } = {}) {
+function startCards(board, fleet, lanes, settings, report, entry, effects, { only = null, held = [], dry = false } = {}) {
   const stop = paused(board.root);
   if (stop) { report.paused = stop; return; }
   const { workflow, params } = entry;
@@ -518,42 +576,25 @@ function startCards(board, fleet, lanes, settings, report, entry, effects, { onl
     }
     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));
+  // the caps, over what the home holds now; what each candidate would be once started
+  const caps = capacity(d.capacity, held, evaluate);
+  const entryOf = (c) => ({ card: c.task.id, board: board.slug, machine: c.task.machine ? normalMachine(c.task.machine) : null, assignee: c.plan.profile ?? null,
+    status: c.plan.target, model: c.task.model_override ?? c.plan.lane?.model ?? held.defaults?.[c.plan.lane?.harness] ?? null, harness: c.plan.lane?.harness ?? null });
+  const waitingEntries = candidates.map(entryOf);
   // a dry run (dispatch --dry-run) plans the same way and writes nothing: no notes, no moves, no launches
   const note = (id, why) => { if (!dry) tx(board, (db) => noteGuard(db, id, why)); };
-  for (const c of candidates) {
+  for (const [i, c] of candidates.entries()) {
     const { task, plan, scope } = c;
     if (!plan.profile) { report.unassigned.push(task.id); note(task.id, 'no profile runs it (no assignee, and the workflow names none)'); continue; }
     if (!plan.lane) { report.nonspawnable.push(task.id); note(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; }
-    }
+    const capped = caps.admit(waitingEntries[i], scope, waitingEntries);
+    let why = capped?.why ?? null;
     // 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) { note(task.id, why); report.queued.push([task.id, why]); continue; }
     if (dry) {
       report.would.push({ id: task.id, status: plan.target, role: plan.runSpec?.role ?? null, assignee: plan.profile, machine: task.machine ?? null, surface: plan.lane.surface });
-      // a card this tick starts counts toward its groups (its scope was read before the start, with no run yet)
-      for (const l of limits) { const g = JSON.stringify(evaluate(l.group, scope)); l.tally.set(g, (l.tally.get(g) ?? 0) + 1); }
+      caps.take(waitingEntries[i]);
       continue;
     }
     let moved, checked;
@@ -575,7 +616,7 @@ function startCards(board, fleet, lanes, settings, report, entry, effects, { onl
       continue;
     }
     effects.push(...moved.effects);
-    for (const l of limits) { const g = JSON.stringify(evaluate(l.group, scope)); l.tally.set(g, (l.tally.get(g) ?? 0) + 1); }
+    caps.take(waitingEntries[i]);
     try {
       const session = launchRun(board, entry, task.id, plan.lane, fleet, settings);
       if (session) {
@@ -617,7 +658,8 @@ export function launchRun(board, entry, id, lane, fleet, settings) {
     const reviewer = view(board, (db) => lastSession(db, id, slot));
     if (slot === 'worker' || (worker?.session_id && worker.session_id === reviewer?.session_id)) throw new Error('a reviewer must have a different session from the implementer');
   }
-  const meta = { status, role: spec.role, slot, ...(spec.role === 'reviewer' ? { review_candidate: reviewCandidate(board, id) } : {}) };
+  // the model it runs is recorded with the session, for caps that count by model
+  const meta = { status, role: spec.role, slot, model: task.model_override ?? lane.model ?? null, ...(spec.role === 'reviewer' ? { review_candidate: reviewCandidate(board, id) } : {}) };
   try {
     const result = surface === 'pane'
       ? launchPane(board, task, runId, lane, fleet, { input: prompt, slot, meta })
@@ -878,23 +920,7 @@ export async function sessionEffect(board, e) {
 
 // ------------------------------------------------------------------ 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.current_run_id IS NOT NULL ${sql}`).get(...args).n);
-
-/**
- * How many sessions the board has on `machine`: every running card's, and every other card's latest session that is
- * still live (an idle session on a done or blocked card holds its place until it is closed).
- */
-function machineLoad(db, machine, fleet) {
-  let n = 0;
-  for (const card of db.prepare("SELECT t.id, t.status, c.machine FROM tasks t JOIN supercode_cards c ON c.task_id = t.id WHERE c.machine IS NOT NULL AND t.status != 'archived'").all()) {
-    if (normalMachine(card.machine) !== machine) continue;
-    if (card.current_run_id || (fleet.ok && sessionAlive(fleet, lastSession(db, card.id)))) n += 1;
-  }
-  return n;
-}
-
-/** Why a card cannot start now, or null. */
-/** What the launcher itself needs to start this card (the caps are the workflow's `dispatch.limits`). */
+/** What the launcher itself needs to start this card (the caps are the workflow's `dispatch.capacity`). */
 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';
@@ -1845,13 +1871,18 @@ export async function plan({ root, lanes, settings, slugs = null, params = {} })
   const entry = { ...loaded, params: { ...loaded.params, ...params } };
   const fleet = Object.values(lanes).some((l) => l.surface === 'pane') ? observeFleet() : { ok: false, alive: new Set(), online: new Set(), sessions: [], error: 'no pane lanes' };
   const out = [];
+  // the home's caps count every board, whichever boards are planned
+  const held = homeHoldings(root, listBoards(root), lanes, fleet);
+  const caps = capacity(entry.workflow.dispatch?.capacity, held, evaluate);
+  // what each cap counts now, before anything this plan would start
+  Object.defineProperty(out, 'capacity', { value: caps.view().map((cap) => ({ ...cap, groups: cap.groups.map((g) => ({ ...g, max: capMax(cap, g, entry, lanes) })) })) });
   for (const slug of slugs ?? listBoards(root)) {
     const report = { board: slug, would: [], queued: [], unassigned: [], nonspawnable: [] };
     const board = openBoard(root, slug);
     try {
       board.label = boardLabel(root, slug);
       await activatePullRequestReviews(board, entry, report, [], { dry: true });
-      startCards(board, fleet, lanes, settings, report, entry, [], { dry: true });
+      startCards(board, fleet, lanes, settings, report, entry, [], { dry: true, held });
     } finally { board.close(); }
     out.push(report);
   }
@@ -1924,6 +1955,17 @@ async function activatePullRequestReviews(board, entry, report, effects, { only
   }
 }
 
+/**
+ * A cap's max for one of its groups, for the capacity view: what a card in that group would be held to. A max read
+ * from the card or its lane (a machine's or a profile's own capacity) is evaluated for that group's machine or profile.
+ */
+function capMax(cap, group, entry, lanes) {
+  const card = { machine: cap.scope === 'machine' ? group.group : null, assignee: cap.scope === 'profile' ? group.group : null, board: cap.scope === 'board' ? group.group : null };
+  const lane = cap.scope === 'profile' ? lanes[group.group] ?? {} : {};
+  try { const v = evaluate(cap.max, { card, lane, params: entry.params, host: hostOf(memoryPressure()), now: now() }); return v === undefined || v === '' ? null : v; }
+  catch { return null; }
+}
+
 /**
  * One tick over every board of the home at `root`. `lanes` from `lanesOf`, `settings` from `boardSettings`.
  * `only` limits starting to one card (a create that answers whether its card started). Each board is ticked under its
@@ -1939,11 +1981,8 @@ export async function tick({ root, lanes, settings, only = null, slugs = null, d
   const fleet = needFleet ? observeFleet() : { ok: false, alive: new Set(), online: new Set(), sessions: [], error: 'no pane lanes' };
   const fleetMs = Date.now() - fleetAt;
   const boards = slugs ?? listBoards(root);
-  // the running cards of every board of the home, for kanban.max_in_progress (host-wide, as Hermes counts it)
-  let hostRunning = 0;
-  for (const slug of boards) {
-    try { const b = openBoard(root, slug); try { hostRunning += Number(b.db.prepare("SELECT COUNT(*) AS n FROM tasks WHERE current_run_id IS NOT NULL").get().n); } finally { b.close(); } } catch { /* its own tick reports it */ }
-  }
+  // what every board of the home holds, for caps whose scope is the whole home (kanban.max_in_progress counts so)
+  const held = dispatch ? homeHoldings(root, boards, lanes, fleet) : [];
   const out = [];
   for (const slug of boards) {
     const report = { board: slug, ms: { fleet: fleetMs }, mailed: [], started: [], queued: [], failed: [], lost: [], crashed: [], timed_out: [], reclaimed: [], auto_blocked: [], promoted: 0, unassigned: [], nonspawnable: [], notified: [], undelivered: [], fleet: fleet.ok ? 'read' : fleet.error };
@@ -1975,9 +2014,8 @@ export async function tick({ root, lanes, settings, only = null, slugs = null, d
       report.promoted = recomputeReady(board, effects, report.unsettled);
       if (dispatch) await activatePullRequestReviews(board, entry, report, effects, { only });
       await sendBoardMessages(board, report);
-      const before = report.started.length;
-      if (dispatch) startCards(board, fleet, lanes, settings, report, entry, effects, { only, hostRunning });
-      hostRunning += report.started.length - before; phase('start');
+      if (dispatch) startCards(board, fleet, lanes, settings, report, entry, effects, { only, held });
+      phase('start');
       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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-orchestrator",
-  "version": "0.4.156",
+  "version": "0.4.157",
   "type": "module",
   "description": "The orchestrator runtime over the Volter Harness ontology: one typed operational model whose folder is its serialization, read and written through the harness orchestration doors (docs/ORCHESTRATOR-IR.md)",
   "exports": {