@volter/supercode-orchestrator 0.5.32 → 0.5.34

package/bin/runtime.mjs

@@ -674,6 +674,15 @@ async function main() {
     return;
   }
   const root = resolve(args.root ?? defaultRoot());
+  // `SUPERCODE_BOARD_DISPATCHER=serve`: whoever started this daemon also runs `workflow serve` on the home, the board's
+  // one dispatcher, so this daemon runs no dispatch round (board.mjs). It is this process's alone: the sessions it
+  // launches do not inherit it. Any other value is refused before this daemon takes its lease or a lock.
+  const boardDispatcher = process.env.SUPERCODE_BOARD_DISPATCHER || null;
+  delete process.env.SUPERCODE_BOARD_DISPATCHER;
+  if (boardDispatcher !== null && boardDispatcher !== 'serve') {
+    say('error', { root, message: `SUPERCODE_BOARD_DISPATCHER is \`${boardDispatcher}\`: the one value it takes is \`serve\` (a \`workflow serve\` beside this daemon dispatches the board); unset, the board workflow's dispatch.serve decides` });
+    process.exit(2);
+  }
   let crashed = false;
   let gatewayLock = null;
   if (!args.once) {
@@ -747,6 +756,7 @@ async function main() {
   // build's, not whatever `supercode` a PATH lookup happens to find.
   const client = new SupercodeHarnessClient(process.env.SUPERCODE_BIN ? { command: process.env.SUPERCODE_BIN } : {});
   const orchestrator = new Orchestrator({
+    boardDispatcher,
     executeJob: args.executorUrl ? httpJobExecutor({ url: args.executorUrl, tokenFile: args.executorTokenFile, root }) : null,
     state,
     vault,

package/board/cli.mjs

@@ -1444,6 +1444,8 @@ async function serve(root, args = {}) {
   const stuck = {};
   const warned = {};
   let pausedSaid = false;
+  // a board whose cards name an assignee that is no profile of this home is said once, until it has none
+  const laneSaid = new Set();
   let wakeReason = null;
   try {
     while (!stopped) {
@@ -1498,6 +1500,8 @@ async function serve(root, args = {}) {
           stuck[r.board] = r.ready_waiting && !r.started.length && !r.paused ? (stuck[r.board] || Date.now()) : 0;
           if (stuck[r.board] && Date.now() - stuck[r.board] >= interval * 6000 && Date.now() - (warned[r.board] ?? 0) >= 300_000) { log(`board ${r.board} stuck: ${r.ready_waiting} ready card(s) and nothing started for ${Math.floor((Date.now() - stuck[r.board]) / 1000)}s; \`supercode workflow diagnostics\``); warned[r.board] = Date.now(); }
           for (const [t, why] of r.queued) log(`  ${t} waits: ${why}`);
+          if (r.nonspawnable?.length && !laneSaid.has(r.board)) { laneSaid.add(r.board); log(`board ${r.board}: ${r.nonspawnable.length} card(s) name an assignee that is no profile of this home, and wait`); }
+          if (!r.nonspawnable?.length) laneSaid.delete(r.board);
           for (const [t, why] of r.failed) log(`  ${t} did not start: ${why}`);
           for (const [t, why] of r.unsettled ?? []) log(`  ${t} could not be read: ${why}`);
           for (const [t, s, m] of r.started) log(`  ${t} started ${s} (${m})`);

package/board.mjs

@@ -3,6 +3,10 @@
 // format and lifecycle, each profile's lane decided by its `worker` in the IR. Where a Hermes gateway would run
 // its dispatcher, the daemon runs this one the same way: when the board's workflow says so (its `dispatch.serve`),
 // taking no file locks, waking on events with `dispatch.tick` as a safety sweep.
+// One dispatcher per board holds by construction, not by a lock: whoever starts the daemon beside a
+// `supercode workflow serve` on the same home (an Open Autonomy install's start) says so (`dispatcher: 'serve'`, from
+// SUPERCODE_BOARD_DISPATCHER), and the daemon then runs no round and no board event relay of its own. Chat-platform
+// subscriptions are delivered here whoever dispatches: the daemon hosts the channel adapters and a serve hosts none.
 // Each tick runs as
 // `workflow dispatch` in a child process: a tick waits on supercode (the fleet, launches, mail), and the daemon's
 // own loop never does.
@@ -32,13 +36,38 @@ function dispatchOnce(root) {
   });
 }
 
-/** Start the board's dispatcher for the home at `root`; answers `{ tick, stop }`, or null when it does not dispatch. */
-export async function startBoard({ root, orchestration = null, log = () => {}, adapters = {}, wake = null }) {
+/**
+ * The chat-platform notices alone, for a daemon that does not dispatch the board: each sweep sends what the board's
+ * subscriptions have not yet been told through this daemon's channel adapters. Null when there is nothing it could send.
+ */
+function startChatNotices({ root, entry, seconds, log, adapters, wake }) {
+  if (!Object.keys(entry.workflow.notify?.chat ?? {}).length) return null;
+  if (!Object.keys(adapters).length) { log('warn', 'board: the board workflow tells chats (notify.chat) and this daemon hosts no channel adapter to tell them'); return null; }
+  let running = false;
+  const sweep = async () => {
+    if (running) return;
+    running = true;
+    try { await notifyChats(root, adapters, log, wake); } catch (error) { log('warn', `board: chat notices failed: ${error.message}`); } finally { running = false; }
+  };
+  const timer = setInterval(() => { void sweep(); }, seconds * 1000);
+  timer.unref?.();
+  void sweep();
+  log('info', `board: chat notices every ${seconds}s through this daemon's channel adapters`);
+  return { tick() { void sweep(); }, stop() { clearInterval(timer); } };
+}
+
+/**
+ * Start the board's dispatcher for the home at `root`; answers `{ tick, stop }`, or null when it neither dispatches
+ * nor has chat notices to send. `dispatcher: 'serve'` says a `supercode workflow serve` dispatches this home's board:
+ * the daemon then runs no round of its own, only the chat notices its adapters deliver.
+ */
+export async function startBoard({ root, orchestration = null, log = () => {}, adapters = {}, wake = null, dispatcher = null }) {
   // whether and how often the served home dispatches is the board workflow's (`dispatch.serve`, `dispatch.tick`)
   let entry;
   try { entry = workflowEntry(orchestration); } catch (error) { log('warn', `board: not dispatched: ${error.message}`); return null; }
-  if (!holds(entry.workflow.dispatch.serve ?? null, { params: entry.params })) { log('info', 'board: not dispatched (the board workflow\'s dispatch.serve)'); return null; }
   const seconds = Math.max(Number(evaluate(entry.workflow.dispatch.tick, { params: entry.params })) || 60, 1);
+  if (dispatcher === 'serve') { log('info', 'board: not dispatched here (its dispatcher is the `workflow serve` beside this daemon)'); return startChatNotices({ root, entry, seconds, log, adapters, wake }); }
+  if (!holds(entry.workflow.dispatch.serve ?? null, { params: entry.params })) { log('info', 'board: not dispatched (the board workflow\'s dispatch.serve)'); return startChatNotices({ root, entry, seconds, log, adapters, wake }); }
   let running = false;
   let stopped = false;
   const said = new Set();

package/loop.mjs

@@ -54,8 +54,10 @@ export class Orchestrator {
    * @param {(profile, worker, env) => object|undefined} [o.launchFor]  launch override per worker (tests)
    * @param {(level, message) => void} [o.log]
    */
-  constructor({ state, vault = new Map(), client, adapters = {}, clock = null, launchFor = null, executeJob = null, log = () => {} }) {
+  constructor({ state, vault = new Map(), client, adapters = {}, clock = null, launchFor = null, executeJob = null, boardDispatcher = null, log = () => {} }) {
     this.state = state;
+    // who dispatches the home's board: 'serve' when a `workflow serve` beside this daemon does (board.mjs)
+    this.boardDispatcher = boardDispatcher;
     this.executeJob = executeJob;
     this.hostedTasks = new Set();
     this.identityRecord = new SenderIdentityRecord();
@@ -96,7 +98,7 @@ export class Orchestrator {
     if (this.autoTick) { this.timer = setInterval(() => { this.tick().catch(() => undefined); }, TICK_MS); this.timer.unref?.(); }
     // the home's board, dispatched as a Hermes gateway dispatches it (docs/plans/hermes-compat.md row 14)
     if (this.autoTick) this.board = await startBoard({
-      root: this.state.root, orchestration: this.state, log: this.log, adapters: this.adapters,
+      root: this.state.root, orchestration: this.state, log: this.log, adapters: this.adapters, dispatcher: this.boardDispatcher,
       // a board notice as a turn in the subscribed chat's own session (Hermes's wake), sent as the subscriber
       wake: (sub, text) => this.dispatchLogged(events.inbound({
         profile: sub.notifier_profile || 'default', key: { platform: sub.platform, kind: sub.chat_type || 'dm', chat_id: sub.chat_id, ...(sub.thread_id ? { thread_id: sub.thread_id } : {}) },

package/package.json

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