@volter/supercode-orchestrator 0.5.72 → 0.5.73

package/board/cli.mjs

@@ -17,6 +17,7 @@ import { notRuntime, ownHome } from './owner-files.mjs';
 import { spawnSync } from 'node:child_process';
 import { holdLock } from './lock-holder.mjs';
 import { takeEpoch } from './fence.mjs';
+import { dispatcherNotice, holdOwnerHealth, holdRound, holdSwitch } from './owner-health.mjs';
 import { boardTool } from './tools.mjs';
 import { recordSlow, takeSteps } from '@volter/supercode-harness-sdk/slow-log';
 import { basename, dirname, join, resolve } from 'node:path';
@@ -374,6 +375,8 @@ export async function runVerb(argv) {
   current().recorded = sid && boardExists(root, slug) ? withBoard((b) => b.db.prepare("SELECT json_extract(metadata, '$.supercode.address') AS address FROM task_runs WHERE json_extract(metadata, '$.supercode.session_id') = ? ORDER BY id DESC LIMIT 1").get(sid)?.address) ?? null : null;
   if (sid) setActor(callerAddress());
   setPrincipal(await callerPrincipal(root, sid, { teams: !sid && !READS.has(verb) }));
+  // the dispatcher as the owner holds it, said once per call (owner-health.mjs; nothing is read for it)
+  if (!current().said.has(`dispatcher:${slug}`)) { current().said.add(`dispatcher:${slug}`); for (const line of dispatcherNotice(slug)) current().err(`${line}\n`); }
   if (sid && !READS.has(verb) && boardExists(root, slug)) {
     // binding the caller's launch is a write: only the owner, answering the caller's own verb, makes it (a local read
     // never writes)
@@ -1487,6 +1490,7 @@ function setDispatching(root, slug, on, reason) {
       db.prepare("INSERT INTO supercode_board_state (key, value) VALUES ('dispatching', ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value").run(JSON.stringify(value));
     });
   } finally { board.close(); }
+  holdSwitch(slug, value);
   return value;
 }
 
@@ -1508,6 +1512,10 @@ async function answerVerbs(root, log) {
   ownHome(home);
   // the lock held, this owner takes its fencing epoch and fences every board, before it answers anything (fence.mjs)
   const epoch = takeEpoch(root, () => listBoards(root).map((slug) => openBoard(root, slug)));
+  // what the owner holds of its dispatcher from here on: each board's switch, and its predecessor's last round, read once
+  let lastRound = null;
+  try { const beat = JSON.parse(readFileSync(join(root, 'dispatcher-heartbeat.json'), 'utf8')); lastRound = { at: beat.at, errors: beat.errors ?? [] }; } catch { /* no round recorded yet */ }
+  holdOwnerHealth(listBoards(root).map((slug) => [slug, dispatchingOf(root, slug)]), lastRound);
   log(`owner epoch ${epoch}`);
   const path = boardOwnerSocket(root);
   try { unlinkSync(path); } catch { /* none left */ }
@@ -1617,7 +1625,9 @@ async function serve(root, args = {}) {
       const heldLine = refused ? [`publishing to the team is held: the team refused ${refused.card}'s ${refused.kind} (sequence ${refused.sequence}) with ${refused.status}${refused.code ? ` ${refused.code}` : ''}: ${String(refused.error ?? '').split('\n')[0].slice(0, 200)} (tried ${refused.attempts} time(s)); nothing of this home after it is published until the team takes it`] : [];
       const temporary = `${heartbeat}.${process.pid}.tmp`;
       try {
-        writeFileSync(temporary, `${JSON.stringify({ at: new Date().toISOString(), round, pid: process.pid, version: installed(), boards: reports.map((r) => ({ board: r.board, started: r.started?.length ?? 0, queued: r.queued?.length ?? 0, failed: r.failed?.length ?? 0, ms: r.ms ?? null })), errors: [...heldLine, ...reports.flatMap((r) => [...(r.failed ?? []), ...(r.unsettled ?? [])].map(([t, why]) => `${r.board} ${t}: ${String(why).split('\n')[0].slice(0, 300)}`))].slice(0, 20) })}\n`);
+        const beat = { at: new Date().toISOString(), round, pid: process.pid, version: installed(), boards: reports.map((r) => ({ board: r.board, started: r.started?.length ?? 0, queued: r.queued?.length ?? 0, failed: r.failed?.length ?? 0, ms: r.ms ?? null })), errors: [...heldLine, ...reports.flatMap((r) => [...(r.failed ?? []), ...(r.unsettled ?? [])].map(([t, why]) => `${r.board} ${t}: ${String(why).split('\n')[0].slice(0, 300)}`))].slice(0, 20) };
+        holdRound(beat.at, beat.errors);
+        writeFileSync(temporary, `${JSON.stringify(beat)}\n`);
         renameSync(temporary, heartbeat);
       } catch { /* the next round writes it */ }
     }

package/board/owner-health.mjs

@@ -0,0 +1,30 @@
+// What the board owner knows of its own dispatcher, held in its memory: each board's dispatching switch (loaded once
+// when the owner starts, then set by the owner's own switch writes) and its last completed round (set as each round
+// completes). A verb's notice is formatted from this; nothing is read per call. Outside the owner nothing is held.
+const switches = new Map(); // board slug → { on, at, by, reason }
+let round = null; // { at, errors }
+let holding = false;
+
+/** The owner starts holding: each board's switch as stored, and the last round its predecessor recorded. */
+export function holdOwnerHealth(boards, lastRound) {
+  holding = true;
+  for (const [slug, state] of boards) switches.set(slug, state);
+  round = lastRound;
+}
+/** The owner wrote a board's switch. */
+export function holdSwitch(slug, state) { if (holding) switches.set(slug, state); }
+/** The owner completed a round. */
+export function holdRound(at, errors) { if (holding) round = { at, errors }; }
+
+/** The notice for a verb on `slug`: dispatching off (a state), or a stalled round and its standing errors (failures). */
+export function dispatcherNotice(slug) {
+  if (!holding) return [];
+  const state = switches.get(slug);
+  if (!state) return [];
+  if (!state.on) return [`board: dispatching is off on ${slug}${state.at ? ` since ${String(state.at).slice(0, 16)}Z` : ''}${state.by ? ` by ${state.by}` : ''}${state.reason ? ` (${state.reason})` : ''}; no round runs until \`supercode workflow dispatching on\``];
+  if (!round) return [];
+  return [
+    ...(Date.now() - Date.parse(round.at) > 300_000 ? [`board: error: the dispatcher has completed no round since ${String(round.at).slice(0, 16)}Z; nothing starts, moves or is supervised`] : []),
+    ...(round.errors ?? []).map((error) => `board: error: ${error}`),
+  ];
+}

package/board/ztrack.mjs

@@ -104,17 +104,6 @@ class ZtrackBoard {
       // A push younger than a minute is still on its way.
       if (late && Date.now() - late.since > 60_000) current().err(`board: warning: ${late.commits} board document commit${late.commits === 1 ? '' : 's'} not published since ${new Date(late.since).toISOString().slice(0, 16)}Z${late.error ? ` (last push: ${late.error})` : ''}; the dispatcher's next round retries\n`);
     }
-    // The dispatcher's standing errors are said the same way, on every workflow call until a round clears them: a round
-    // that has not completed in five minutes, and each card or run the last round could not start, read or sync.
-    if (root && !said.has(`heartbeat:${root}`)) {
-      said.add(`heartbeat:${root}`);
-      try {
-        const beat = JSON.parse(readFileSync(join(root, 'dispatcher-heartbeat.json'), 'utf8'));
-        const age = Date.now() - Date.parse(beat.at);
-        if (age > 300_000) current().err(`board: error: the dispatcher has completed no round since ${String(beat.at).slice(0, 16)}Z; nothing starts, moves or is supervised\n`);
-        for (const error of beat.errors ?? []) current().err(`board: error: ${error}\n`);
-      } catch { /* a board no dispatcher serves yet has no heartbeat */ }
-    }
     this.seed = seed; this.root = root; this.slug = slug; this.init = init;
     this.file = `${marker}.board.db`;
     mkdirSync(dirname(this.path), { recursive: true });

package/package.json

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