@volter/supercode-orchestrator 0.5.115 → 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/dispatch.mjs

@@ -172,6 +172,8 @@ const HARNESSES = {
 // machine_offline; a stream that timed out, 504), says nothing about what it was asked: it is tried again next round.
 const doorTransient = (r) => r.code === null || ['unavailable', 'machine_offline', 'rate_limited', 504, '504', 'ETIMEDOUT', 'ECONNRESET', 'EAI_AGAIN'].includes(json(String(r.stderr ?? '').trim().split('\n').pop(), null)?.code);
 const adoptedOnly = (s) => s?.mode === 'adopt' && !s.launch_key && s.surface !== 'headless';
+/** A close the machine refused for good (not deferred): the board will not try it again, and the session runs on. */
+const closeRefused = (s) => Boolean(s?.close_failed_at && s.close_error && !/^close deferred/.test(s.close_error) && !s.close_confirmed_at);
 const addressOf = (s) => s?.address ?? (s?.session_id && s.machine ? `sc:${s.machine}:${s.harness ?? 'claude-code'}:${s.session_id}` : null);
 
 // A session in a live pane of its machine is the fleet's reading; any other run is read on its own machine: a headless
@@ -1059,7 +1061,7 @@ export async function closeRequested(board, report, { taskId = null, caller = nu
     }
     // A final refusal stops further close attempts. Only an authorized observation of this exact pane may establish
     // absence: panes.list can be filtered or carry missing context keys. Unknown/invisible keeps the original failure.
-    const finalFailure = Boolean(session.close_failed_at && session.close_error && !/^close deferred/.test(session.close_error));
+    const finalFailure = closeRefused(session);
     if (finalFailure) {
       if (!session.pane) continue;
       const r = await doorOn(session.machine ?? localMachine(), 'harness.v1.panes.presence', { pane: session.pane }, { timeout: 10_000, as: boardAddress(board.label) });
@@ -1724,9 +1726,13 @@ async function launchPane(board, task, runId, lane, fleet, { input = null, slot
   // session starts (never two processes on one session)
   // Every old pane in the slot must be settled, including a failed launch with no session id.
   await closeRequested(board, { undelivered: [] }, { taskId: task.id });
+  // The slot's own last session whose close was refused for good is not waited on: it runs on, and is continued below
+  // (continuationOf), never started beside.
+  const last = view(board, (db) => lastSession(db, task.id, slot));
   const pending = view(board, (db) => db.prepare('SELECT id, ended_at, metadata FROM task_runs WHERE task_id = ? AND id != ?').all(task.id, runId))
     .map((r) => ({ ...r, session: json(r.metadata, {})?.supercode }))
-    .find((r) => (r.session?.pane || r.session?.launch_key || r.session?.surface === 'native') && !r.session.close_transferred_to && (r.session.slot ?? 'worker') === slot && (r.ended_at || r.session.close_requested) && !r.session.close_confirmed_at);
+    .find((r) => (r.session?.pane || r.session?.launch_key || r.session?.surface === 'native') && !r.session.close_transferred_to && (r.session.slot ?? 'worker') === slot && (r.ended_at || r.session.close_requested) && !r.session.close_confirmed_at
+      && !(closeRefused(r.session) && last?.session_id && r.session.session_id === last.session_id));
   if (pending) throw unavailable(`slot ${slot} still owns pane ${pending.session.pane} from run ${pending.id}; closure must be confirmed before another session starts: ${pending.session.close_error ?? 'close pending'}`);
   let prev = view(board, (db) => lastSession(db, task.id, slot));
   if (prev?.session_id && !prev.forgotten && (prev.harness ?? 'claude-code') === harness && prev.machine === machine) {
@@ -1740,7 +1746,7 @@ async function launchPane(board, task, runId, lane, fleet, { input = null, slot
     if (pane && pane !== prev.pane) prev = { ...prev, pane, close_requested: null, closed_at: null, close_confirmed_at: null, close_error: null };
     fleet = fresh;
   }
-  if (prev?.close_requested && !prev.closed_at) {
+  if (prev?.close_requested && !prev.closed_at && !closeRefused(prev)) {
     const report = { undelivered: [] };
     await closeRequested(board, report, { taskId: task.id });
     prev = view(board, (db) => lastSession(db, task.id, slot));
@@ -1810,13 +1816,18 @@ async function launchPane(board, task, runId, lane, fleet, { input = null, slot
     if (next === 'refuse') throw new Error(`session ${prev.session_id} still has live pane ${prev.pane}; cannot resume or replace it`);
     if (next === 'keep') {
       // the session is kept; the heartbeat's count belongs to the run that ended, so the new run starts it again
-      const { missing_since: _m, goal_turns: _t, goal_nudged_at: _n, idle_since: _is, unknown_since: _us, unknown_notice: _un, work_progress: _wp, idle_observation: _io, idle_below_threshold: _ib, idle_eligible: _ie, close_requested: _q, closed_at: _c, close_confirmed_at: _cc, close_error: _ce, close_attempts: _ca, close_attempted_at: _ct, monitor_held: _mh, released: _rl, ...kept } = prev;
+      const { missing_since: _m, goal_turns: _t, goal_nudged_at: _n, idle_since: _is, unknown_since: _us, unknown_notice: _un, work_progress: _wp, idle_observation: _io, idle_below_threshold: _ib, idle_eligible: _ie, close_requested: _q, closed_at: _c, close_confirmed_at: _cc, close_error: _ce, close_attempts: _ca, close_attempted_at: _ct, close_failed_at: _cf, close_claim: _cl, monitor_held: _mh, released: _rl, ...kept } = prev;
       session = { ...kept, mode: 'adopt', launched_at: now(), seen_at: now() };
       // a kept session is told what this run is for (its card came back to it, with what happened since), only while
       // this run is still the card's current one (its pane and native reads were awaited)
       tx(board, (db) => {
         if (!runCurrent(db, task.id, runId)) throw Object.assign(new Error(`run ${runId} of ${task.id} ended or was replaced while its session was read; nothing was told to it`), { launchSuperseded: true });
         setRunSession(db, runId, { ...session, ...meta });
+        // an earlier run's close of this pane is this run's now: the pane is the kept session's, not a close to retry
+        if (prev.pane) for (const r of db.prepare('SELECT id, metadata FROM task_runs WHERE task_id = ? AND id != ?').all(task.id, runId)) {
+          const s = json(r.metadata, {})?.supercode;
+          if (s?.pane === prev.pane && s.machine === prev.machine && !s.close_confirmed_at && !s.close_transferred_to) setRunSession(db, r.id, { ...s, close_transferred_to: runId, close_requested: null });
+        }
       });
       // filed in its mailbox, which delivers it
       if (input) { assertRunCurrent(board, task.id, runId); await fileMail(board, addressOf(prev), input, `board-run-${task.id}-r${runId}`); }
@@ -1888,10 +1899,10 @@ async function launchPane(board, task, runId, lane, fleet, { input = null, slot
  * What a slot's last session on the card's machine is to the card's next run, given whether it is live (its pane, else
  * its native process): an open session that is live is kept, and the run is delivered into it; a live pane holding a
  * session the board closed refuses the launch; anything else is resumed. A released session is open: its release only
- * freed the slot, and the session was left running.
+ * freed the slot, and the session was left running. So is one whose close the machine refused for good.
  */
 export function continuationOf(prev, live) {
-  const open = Boolean(prev.released) || (!prev.closed_at && !prev.close_requested);
+  const open = Boolean(prev.released) || closeRefused(prev) || (!prev.closed_at && !prev.close_requested);
   if (open) return live ? 'keep' : 'resume';
   return live && prev.pane ? 'refuse' : 'resume';
 }

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