@volter/supercode-orchestrator 0.5.116 → 0.5.117

package/board/cli.mjs

@@ -4,7 +4,7 @@
 // `serve`, `--at`) are added beside them. The Rust CLI hands every verb but `load` to `bin/orchestrator.mjs workflow`,
 // which lands here. The home is `--root`, else `SUPERCODE_ORCHESTRATOR_HOME`; the board is
 // `--board <slug>`, else `HERMES_KANBAN_BOARD`, else the home's current board (`kanban/current`), else `default`.
-import { machineCall, closeDoors } from './doors.mjs';
+import { machineCall, closeDoors, onLocalReopen } from './doors.mjs';
 import { createHash } from 'node:crypto';
 import { DatabaseSync } from 'node:sqlite';
 import { homeOf, parse } from './args.mjs';
@@ -1699,14 +1699,21 @@ async function serve(root, args = {}) {
   try { const { PerformanceObserver } = await import('node:perf_hooks'); new PerformanceObserver((list) => { for (const entry of list.getEntries()) noteStep('gc', entry.duration); }).observe({ entryTypes: ['gc'] }); } catch { /* no gc entries here */ }
   // The board's events are published by this machine's connector, not by the dispatcher (D137, D138 step 4): the home is
   // named to the daemon once, and the connector follows its `workflow events` from then on, with or without this serve.
-  { let named = null, refusal = null;
-    // this process is the home's owner: it names its pid (its claim), which the daemon takes only if it holds the home's lock
+  // This process is the home's owner: it names its pid (its claim), which the daemon takes only if it holds the home's
+  // lock. It names it again to each daemon that starts while it serves: the owner a restarted daemon restores from its
+  // file stands only if the kernel probe at its start agreed, and an owner it dropped lost the board's authority over the
+  // panes the board launched (a close refused as "not started by this command").
+  const registerOwner = async () => {
+    let named = null, refusal = null;
     try { named = await machineCall(null, 'harness.v1.boards.register', { root, claim: { pid: process.pid, ppid: process.ppid } }, { timeoutMs: 30_000 }); } catch (error) { refusal = error.message; }
     const refused = named?.refused ?? null;
     log(refusal ? `board events: not published; the machine daemon did not take this home: ${refusal}`
       : refused ? `board events: registered, but the team refused this machine's credential (${refused.status}); nothing is published until it is re-enrolled`
       : named?.published === false ? `board ownership: registered locally; this machine has no team connector to publish events`
-      : `board events: this home is published by the machine's connector`); }
+      : `board events: this home is published by the machine's connector`);
+  };
+  await registerOwner();
+  onLocalReopen(registerOwner);
   log('dispatch wakes on board writes, document edits and board mail; the interval sweep reads each machine\'s own door');
   const stuck = {};
   const warned = {};

package/board/doors.mjs

@@ -9,6 +9,12 @@ import { SupercodeHarnessClient } from '@volter/supercode-harness-sdk';
 import { noteStep } from '@volter/supercode-harness-sdk/slow-log';
 
 const held = new Map(); // machine name, '' for this one → Promise<{ channel, node, harness }>
+// Called each time a channel to this machine's daemon opens again after one closed (the daemon restarted): what this
+// process told the daemon it had held only while that daemon ran.
+const reopened = new Set();
+let localOpened = false;
+/** Run `fn` each time the channel to this machine's daemon opens again (a daemon restart). */
+export function onLocalReopen(fn) { reopened.add(fn); }
 
 async function opened(machine) {
   const key = machine ?? '';
@@ -25,6 +31,7 @@ async function opened(machine) {
     return door;
   })();
   held.set(key, opening);
+  if (!key) opening.then(() => { if (localOpened) for (const fn of reopened) Promise.resolve().then(fn).catch(() => {}); localOpened = true; }, () => {});
   try { return await opening; } catch (error) { held.delete(key); throw error; }
 }
 

package/package.json

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