@volter/supercode-orchestrator 0.5.216 → 0.5.218

package/board/cli.mjs

@@ -1913,6 +1913,12 @@ export async function serveBoardGeneration(root, args = {}, argv = ['serve', '--
       finally { board?.close(); }
     }
   });
+  // Hermes's install is located once per process (hermes-cli.mjs), a read of PATH and its files: here, before this
+  // generation is prepared, so its activation does not spend it while the public door routes nowhere.
+  try { (await import('../hermes-cli.mjs')).hermesInstall(); } catch { /* none installed */ }
+  // Each activation and park step in the owner's log (the generation's output is that log), so a reading accounts
+  // for every second the public door routes nowhere (ADR 0080, "Board ownership").
+  const say = text => process.stdout.write(`${new Date().toISOString()} board generation ${process.pid}: ${text}\n`);
   let begin, started = false, controls = Promise.resolve();
   const activation = new Promise(done => { begin = done; });
   const unwatchHealth = watchOwnerHealth(value => tellOwner({ type: 'health', ...value }));
@@ -1926,21 +1932,34 @@ export async function serveBoardGeneration(root, args = {}, argv = ['serve', '--
     if (!['activate', 'park'].includes(frame?.type)) return;
     controls = controls.then(async () => {
       if (frame.type === 'park') {
+        // The epoch's writer is given up at the earliest point that is still single-writer: once admitted work has
+        // drained and the documents it fetched have settled (parkGeneration). Retiring the held boards closes their
+        // handles, nothing more, and the successor takes a fresh epoch that fences any older writer anyway.
+        say('park: dispatching stopped; admission closes');
         stopDispatching();
-        await parkGeneration(async () => { const { settleDocuments } = await import('./git-document.mjs'); await settleDocuments(); });
+        await parkGeneration(async () => {
+          say('park: admitted work drained; settling documents');
+          const { settleDocuments } = await import('./git-document.mjs'); await settleDocuments();
+          say('park: documents settled');
+        });
+        say('park: the writer given up');
         retireHeldBoards();
         tellOwner({ type: 'parked' });
+        say('park: parked');
       } else {
         grantGenerationWriter();
         if (!started) {
+          say('activation: the writer granted; the native board dispatcher starts');
           tellOwner({ type: 'startup-step', phase: 'serving', step: 'starting the native board dispatcher', budget_ms: 65000 });
           started = true; begin();
         }
         else {
-          takeEpoch(root, () => listBoards(root).map(slug => openBoard(root, slug)));
+          const epoch = takeEpoch(root, () => listBoards(root).map(slug => openBoard(root, slug)));
+          say(`activation: writer epoch ${epoch} taken again`);
           await registerGenerationOwner();
           resumeDispatching();
           admitGeneration();
+          say('activation: registered with the machine daemon; the first clean round follows');
           // The loop's next admitted round supplies the serving receipt, also for a resumed predecessor.
           generationServingDue = true;
           wakeGeneration();
@@ -2073,12 +2092,17 @@ async function serve(root, args = {}) {
     if (watched !== undefined && board) heldDocumentsWatched(board, id ?? key, watched);
     else if (uncertain && !board) heldDocumentsChanged();
   } });
+  // A generation's activation steps, each in its owner's log: a reading accounts for the window the public door
+  // routes nowhere (ADR 0080, "Board ownership").
+  const activationSaid = text => { if (inBoardGeneration && generationServingDue) log(`board generation ${process.pid} activation: ${text}`); };
+  activationSaid('board events watched');
   wakeGeneration = () => events?.wake('generation-activated');
   // a machine's panes changing in its record (a session came up under its pane, a pane or its session ended) is what a
   // round binds a launch, verifies an adoption and reads a session's end from: the next round is due then
   const unfollowPanes = onPanesChanged(() => events?.wake('machine-record'));
   // the owner holds its boards only now, its watch installed (watch before load): opened once, changed by events
   holdBoards(root);
+  activationSaid('the boards held');
   // a pause of the collector holds the loop like any synchronous step: each is a step, so a block line names it
   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
@@ -2099,6 +2123,7 @@ async function serve(root, args = {}) {
   registerGenerationOwner = registerOwner;
   await registerOwner();
   onLocalReopen(registerOwner);
+  activationSaid('registered with the machine daemon');
   let listenerRecords = {}, listenerReloading = null, listenerReloadDue = false, listenerReading = null;
   const listenerErrors = new Set();
   const listenerLog = text => { if (!listenerErrors.has(text)) { if (listenerErrors.size >= 128) listenerErrors.clear(); listenerErrors.add(text); log(text); } };
@@ -2160,6 +2185,7 @@ async function serve(root, args = {}) {
   };
   if (inBoardGeneration && generationServingDue) tellOwner({ type: 'startup-step', phase: 'serving', step: 'reading the listener configuration through its orchestration door', budget_ms: 65000 });
   await reloadListeners();
+  activationSaid('the listener configuration read');
   // Retry a failed home decode without waiting for a dispatch sweep. Reading the held stream also enforces its
   // heartbeat deadline and reconnects after local caller loss, even when every board's dispatching is off.
   let nextListenerRead = 0;
@@ -2186,7 +2212,10 @@ async function serve(root, args = {}) {
       let interval = 60;
       let nextMailAt = Infinity;
       const began = Date.now();
-      if (inBoardGeneration && generationServingDue) tellOwner({ type: 'startup-step', phase: 'serving', step: 'completing the first native board round', budget_ms: 65000 });
+      if (inBoardGeneration && generationServingDue) {
+        tellOwner({ type: 'startup-step', phase: 'serving', step: 'completing the first native board round', budget_ms: 65000 });
+        activationSaid('the first native board round begins');
+      }
       if (wakeReason) log(`dispatch wake ${wakeReason.sources.join(', ')}; event age ${began - wakeReason.at}ms`);
       wakeReason = null;
       const loopStep = async (name, fn) => { const at = performance.now(); try { return await fn(); } finally { noteStep(`owner loop: ${name}`, performance.now() - at); } };
@@ -2202,6 +2231,7 @@ async function serve(root, args = {}) {
         const dispatching = listBoards(root).filter((slug) => dispatchingOf(root, slug).on);
         const reports = dispatching.length ? await ownCall(() => tick({ root, lanes: state.lanes, settings, params, slugs: dispatching, deploymentReceipt: true })) : [];
         if (inBoardGeneration && generationServingDue && reports.every(report => !report.error)) {
+          activationSaid(`the first native board round is clean (${dispatching.length} dispatching board(s))`);
           generationServingDue = false;
           tellOwner({ type: 'serving', pid: process.pid, boards: listBoards(root) });
         }

package/board/generation-owner.mjs

@@ -133,6 +133,7 @@ export async function serveBoardOwner(root, args) {
     record(generation);
     generation.events.delete('serving');
     generation.tell({ type: 'activate' });
+    log(`generation ${generation.id} (pid ${generation.process.pid}) activates`);
     const serving = await generation.wait('serving');
     const read = async argv => {
       const proof = await generation.ask(JSON.stringify({ v: 1, argv, cwd: root,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-orchestrator",
-  "version": "0.5.216",
+  "version": "0.5.218",
   "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": {
@@ -36,10 +36,10 @@
     "check-types": "node scripts/generate-types.mjs --check"
   },
   "dependencies": {
-    "@volter/supercode-teams": "^0.3.355",
+    "@volter/supercode-teams": "^0.3.365",
     "@volter/supercode-terminal": "^0.3.12",
     "@volter/supercode-harness-sdk": "^0.3.106",
-    "@volter/teams": "0.2.102",
+    "@volter/teams": "0.2.103",
     "@volter/ztrack": "^2.4.23",
     "yaml": "^2.9.0"
   },