@volter/supercode-orchestrator 0.5.32 → 0.5.33

package/bin/runtime.mjs

@@ -746,7 +746,13 @@ async function main() {
   // binary that spawned this daemon, so the worker doors it opens are that
   // build's, not whatever `supercode` a PATH lookup happens to find.
   const client = new SupercodeHarnessClient(process.env.SUPERCODE_BIN ? { command: process.env.SUPERCODE_BIN } : {});
+  // `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.
+  const boardDispatcher = process.env.SUPERCODE_BOARD_DISPATCHER || null;
+  delete process.env.SUPERCODE_BOARD_DISPATCHER;
   const orchestrator = new Orchestrator({
+    boardDispatcher,
     executeJob: args.executorUrl ? httpJobExecutor({ url: args.executorUrl, tokenFile: args.executorTokenFile, root }) : null,
     state,
     vault,

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.33",
   "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": {