@volter/supercode-orchestrator 0.5.116 → 0.5.118

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/dispatch.mjs

@@ -2053,9 +2053,23 @@ export async function completeAdoptions(board, fleet, settings, report, lanes =
         report.queued.push([row.task_id, `adoption of ${asked.session} waits: ${message}`]);
         continue;
       }
+      // A reading that was not taken (the fleet or the machine's harness door did not answer) is no answer about the
+      // session, before this round wrote anything outside the board: the request stays open and the next round reads again
+      if ((error.unread || error.launchDeferred) && !progress.claimed) {
+        report.queued.push([row.task_id, `adoption of ${asked.session} waits for a reading: ${message}`]);
+        continue;
+      }
       // the failure answers the request only while it is still open, or claimed by this round: an adoption that bound and
       // then failed after (its agent run not recorded) is bound, and a request another round claimed is that round's
-      const answered = !error.superseded && tx(board, db => adoptionOpenTo(db, row.task_id, request.id, row.id) && (event(db, row.task_id, 'adoption_failed', { session: asked.session, error: message }), true));
+      // A failed adoption answers its request and ends the hold the request put on the card: the card is held again
+      // only if it was held before the request (an incident's hold, kept for its own release), and is otherwise the
+      // dispatcher's again. A hold that outlived its failed request held cards nobody adopted until a person released them.
+      const answered = !error.superseded && tx(board, db => {
+        if (!adoptionOpenTo(db, row.task_id, request.id, row.id)) return false;
+        event(db, row.task_id, 'adoption_failed', { session: asked.session, error: message });
+        restoreHoldBefore(db, row.task_id, request.id);
+        return true;
+      });
       // A request another round answered or claimed first is that round's, not a failure of this one: it is noted where
       // no round prints it. A failure after this round's own claim (bound, then its agent run not recorded) is one.
       if (!answered && !progress.claimed) { (report.adoption_skipped ??= []).push([row.task_id, message]); continue; }
@@ -2064,6 +2078,19 @@ export async function completeAdoptions(board, fleet, settings, report, lanes =
   }
 }
 
+/**
+ * The card's hold as it stood before adoption request `request` (an event id), restored once that request failed: a
+ * hold the request found (an incident's) is written again as it was, so its own release still finds it; a card that was
+ * not held, or held only for this adoption (`create --adopt`'s hold, an earlier request this one answers), is released.
+ */
+const ADOPTION_HOLDS = new Set(['adoption requested', 'awaiting adoption']);
+export function restoreHoldBefore(db, id, request) {
+  const before = db.prepare("SELECT kind, payload FROM task_events WHERE task_id = ? AND id < ? AND kind IN ('dispatch_held','dispatch_released','session_adopted') ORDER BY id DESC LIMIT 1").get(id, request);
+  const held = before?.kind === 'dispatch_held' ? json(before.payload, {}) ?? {} : null;
+  if (held && !ADOPTION_HOLDS.has(held.reason)) { const { by: _by, ...kept } = held; event(db, id, 'dispatch_held', { ...kept, restored_after: request }); }
+  else event(db, id, 'dispatch_released', { reason: 'adoption failed', request });
+}
+
 /** Whether request `request` is still this round's to answer: the card's latest answer is `open`, or this process's claim of it. */
 function adoptionOpenTo(db, id, request, open) {
   const last = latestAnswer(db, id);
@@ -2078,8 +2105,9 @@ async function nativeListing(who) {
   const m = /^sc:([^:]+):([^:]+):(.+)$/.exec(String(who));
   if (!m || !HARNESSES[m[2]]) return null;
   const [, host, harness, session_id] = m;
+  // a discovery its machine did not answer is unknown, not absent: it is thrown (unread), never taken as no listing
   try { return nativeReading(await readNative(host, harness, session_id), { session_id, harness }).alive === true ? { address: who, machine: normalMachine(host), harness, session_id, pane: null, name: null } : null; }
-  catch { return null; }
+  catch (error) { if (error.launchDeferred) throw error; return null; }
 }
 
 /** The verb an adoption with no current run fires: the workflow's own `adopt` where it declares one, else its dispatch start. */
@@ -2100,7 +2128,8 @@ function adoptedRole(db, board, entry, task, run) {
 
 async function adoptSession(board, id, who, { request = null, open = request, progress = {}, workspace = null, ttl, assignee = null, role = null, fleet = null, lanes = null } = {}) {
   fleet ??= await observeFleet();
-  if (!fleet.ok) throw new Error(`supercode could not read the fleet: ${fleet.error}`);
+  // a fleet that could not be read says nothing of the session: the request stays open for the next reading
+  if (!fleet.ok) throw Object.assign(new Error(`supercode could not read the fleet: ${fleet.error}`), { unread: true });
   const found = fleet.sessions.find((s) => s.address === who || s.address.endsWith(`:${who}`) || s.name === who) ?? await nativeListing(who);
   if (!found) throw Object.assign(new Error(`the fleet lists no live session ${who}`), { notListed: true });
   const [, host, harness, sessionId] = found.address.split(':');

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