@volter/supercode-orchestrator 0.4.37 → 0.4.38

package/board/cli.mjs

@@ -12,7 +12,7 @@ import { read } from '../orchestration.mjs';
 import { holdDispatcherLock } from '../hermes-locks.mjs';
 import { boardPath, DEFAULT_BOARD, event, json, listBoards, now, openBoard, tx } from './store.mjs';
 import * as engine from './engine.mjs';
-import { adoptSession, boardLabel, boardSettings, lanesOf, localMachine, observeFleet, paused, startCard, tick } from './dispatch.mjs';
+import { adoptSession, boardLabel, boardSettings, lanesOf, localMachine, observeFleet, paused, plan, startCard, tick } from './dispatch.mjs';
 import { loadWorkflow, statusOf, useWorkflow, workflowEntry, workflowFor } from './workflow.mjs';
 import { evaluate } from './expr.mjs';
 
@@ -681,8 +681,9 @@ export async function runWorkflow(argv) {
       const { lanes, settings } = await laneState(root);
       const params = { ...(args['failure-limit'] ? { failure_limit: Number(args['failure-limit']) } : {}), ...(args.max ? { max_spawn: Number(args.max) } : {}) };
       if (args['dry-run']) {
-        const would = withBoard((b) => engine.listCards(b.db, { status: 'ready' }).filter((t) => t.assignee && lanes[t.assignee] && !t.subtask_of).map((t) => ({ id: t.id, assignee: t.assignee, machine: t.machine, surface: lanes[t.assignee].surface })));
-        say(args, would.length ? would.map((w) => `would start ${w.id} as ${w.surface} for ${w.assignee}${w.machine ? ` on ${w.machine}` : ''}`).join('\n') : 'nothing would start', would);
+        // planned through the workflow's own dispatch (its start event, eligible, order and limits), writing nothing
+        const would = (await plan({ root, lanes, settings, params, slugs: [slug] })).flatMap((r) => r.would);
+        say(args, would.length ? would.map((w) => `would start ${w.id} (${w.status}${w.role ? `, its ${w.role}` : ''}) as ${w.surface} for ${w.assignee}${w.machine ? ` on ${w.machine}` : ''}`).join('\n') : 'nothing would start', would);
         return 0;
       }
       const reports = await tick({ root, lanes, settings, params });

package/board/dispatch.mjs

@@ -266,7 +266,7 @@ const hostOf = (pressure) => ({ memory_pressure: pressure, max_in_progress: deri
  * 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 } = {}) {
+function startCards(board, fleet, lanes, settings, report, entry, effects, { only = null, hostRunning = 0, dry = false } = {}) {
   const stop = paused(board.root);
   if (stop) { report.paused = stop; return; }
   const { workflow, params } = entry;
@@ -321,10 +321,12 @@ function startCards(board, fleet, lanes, settings, report, entry, effects, { onl
     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));
+  // 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) {
     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; }
+    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);
@@ -335,7 +337,12 @@ function startCards(board, fleet, lanes, settings, report, entry, effects, { onl
     }
     // 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; }
+    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 });
+      for (const l of limits) if (holds(l.counts, scope)) { const g = JSON.stringify(evaluate(l.group, scope)); l.tally.set(g, (l.tally.get(g) ?? 0) + 1); }
+      continue;
+    }
     let moved;
     try {
       moved = tx(board, (db) => {
@@ -1029,14 +1036,25 @@ async function pool(items, n, fn) {
   }));
 }
 
-/**
- * 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). Answers one report per board.
- */
 /** A board file's fingerprint: a corrupt board is skipped until the file changes (Hermes retries it then). */
 const fingerprint = (path) => { try { const st = statSync(path); return `${st.size}:${st.mtimeMs}`; } catch { return 'missing'; } };
 const CORRUPT = /malformed|not a database|corrupt|disk image/i;
 
+/** What a tick would start on each board of the home, planned through the workflow's `dispatch`, writing nothing. */
+export async function plan({ root, lanes, settings, slugs = null, params = {} }) {
+  const loaded = await loadWorkflow(root, { fresh: true });
+  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 = [];
+  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); startCards(board, fleet, lanes, settings, report, entry, [], { dry: true }); } finally { board.close(); }
+    out.push(report);
+  }
+  return out;
+}
+
 /**
  * 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-orchestrator",
-  "version": "0.4.37",
+  "version": "0.4.38",
   "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": {