@volter/supercode-orchestrator 0.5.115 → 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));
@@ -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/package.json

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