@volter/supercode-orchestrator 0.5.114 → 0.5.116

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));
@@ -1786,14 +1792,13 @@ async function launchPane(board, task, runId, lane, fleet, { input = null, slot
   let session = null;
   let replaced = null;
   // A session in no pane is read on its machine before anything replaces it. One the board released (an adopted
-  // session it did not launch, left running at its run's end) is its owner's while it runs: it is never resumed beside
-  // itself, and the launch waits for the owner to end it.
+  // session it did not launch, left running at its run's end) is never resumed beside itself: while it runs it is kept,
+  // and the card's next run is delivered into it, as into any kept session.
   if (prev?.surface === 'native' && !prev.pane && (!prev.close_confirmed_at || prev.released)) {
     const reading = nativeReading(await readNative(prev.machine, prev.harness, prev.session_id), prev);
     if (reading.alive == null) throw unavailable(`cannot establish native continuation liveness for ${addressOf(prev)}`);
     fleet.native ??= new Map(); fleet.native.set(addressOf(prev), reading);
-    if (reading.alive && prev.released) throw unavailable(`released session ${addressOf(prev)} still runs; the launch waits for its owner to end it`);
-    if (reading.alive && (prev.closed_at || prev.close_requested || prev.forgotten)) throw unavailable(`native session ${addressOf(prev)} is still live; its close must finish before replacement`);
+    if (reading.alive && !prev.released && (prev.closed_at || prev.close_requested || prev.forgotten)) throw unavailable(`native session ${addressOf(prev)} is still live; its close must finish before replacement`);
   }
   if (prev?.forgotten) {
     if (!prev.close_confirmed_at && prev.pane && await panePresent(prev.machine, prev.pane)) throw new Error(`forgotten session ${prev.session_id} still has live pane ${prev.pane}; close it before replacement`);
@@ -1807,17 +1812,22 @@ async function launchPane(board, task, runId, lane, fleet, { input = null, slot
   } else if (prev && prev.machine === machine) {
     // a session the board closed, or one whose close its own command asked for (the next tick's sweep closes that
     // run's pane), is not kept, whatever a fleet reading taken before the close still lists
-    const paneLive = prev.pane ? await panePresent(prev.machine, prev.pane) : false;
-    if (paneLive && (prev.closed_at || prev.close_requested || prev.forgotten)) throw new Error(`session ${prev.session_id} still has live pane ${prev.pane}; cannot resume or replace it`);
-    if (!prev.closed_at && !prev.close_requested && (prev.pane ? paneLive : sessionAlive(fleet, prev))) {
+    const next = continuationOf(prev, prev.pane ? await panePresent(prev.machine, prev.pane) : sessionAlive(fleet, prev));
+    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, ...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}`); }
@@ -1885,6 +1895,18 @@ async function launchPane(board, task, runId, lane, fleet, { input = null, slot
   return session;
 }
 
+/**
+ * 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. So is one whose close the machine refused for good.
+ */
+export function continuationOf(prev, live) {
+  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';
+}
+
 /** A machine reading, not a missing catalog entry, establishes whether a pane is alive. */
 async function panePresent(machine, pane) {
   const r = await doorOn(machine, 'harness.v1.panes.list',{}, { timeout: 60_000 });
@@ -2136,7 +2158,9 @@ async function adoptSession(board, id, who, { request = null, open = request, pr
     if (beforeRun && assignee && assignee !== task.assignee) throw new Error('rebinding a session does not reassign its active run');
     if (task.machine && normalMachine(task.machine) !== host) throw new Error(`${id} runs on ${task.machine}, and ${found.address} is on ${host}; move the card first`);
     const was = lastSession(db, id);
-    if (was && was.session_id !== sessionId && sessionAlive(fleet, was)) throw new Error(`${id} already has a live session, ${was.address}`);
+    // a session whose close the board confirmed is not live, whatever a fleet reading still lists (a released one was
+    // left running, and is read)
+    if (was && was.session_id !== sessionId && !(was.close_confirmed_at && !was.released) && sessionAlive(fleet, was)) throw new Error(`${id} already has a live session, ${was.address}`);
     if (!task.machine) db.prepare('INSERT INTO supercode_cards (task_id, machine) VALUES (?, ?) ON CONFLICT(task_id) DO UPDATE SET machine = excluded.machine').run(id, host);
     // the lane that resumes it if it is lost, set in the same transaction (assigning first would let a tick start another)
     if (assignee && assignee !== task.assignee) { db.prepare('UPDATE tasks SET assignee = ? WHERE id = ?').run(assignee, id); event(db, id, 'assigned', { assignee }); }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-orchestrator",
-  "version": "0.5.114",
+  "version": "0.5.116",
   "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": {
@@ -25,7 +25,7 @@
   },
   "dependencies": {
     "@volter/supercode-harness-sdk": "^0.3.60",
-    "@volter/teams": "0.2.46",
+    "@volter/teams": "0.2.47",
     "@volter/ztrack": "^2.4.23",
     "yaml": "^2.9.0"
   },