@volter/supercode-orchestrator 0.5.117 → 0.5.119

package/board/dispatch.mjs

@@ -966,7 +966,10 @@ export async function startCard(board, id, { roles = ['manager'], lanes, setting
 // The programs a harness pane runs in its foreground: Claude Code's, Codex's, and node (the daemon's Codex pane host,
 // a harness installed through npm). A pane running one of these runs a harness session, read or not.
 const HARNESS_COMMANDS = new Set(['claude', 'claude.exe', 'codex', 'codex.exe', 'node']);
-async function turnAtClose(session, pane = null) {
+/** A board launch never bound to a session (no session id read for it) whose launch window has passed. */
+export const unboundLaunch = (session, launchWindow, at = now()) => Boolean(session?.launch_key && !session.session_id && launchWindow
+  && Number(session.launched_at) > 0 && at - Number(session.launched_at) >= launchWindow);
+async function turnAtClose(session, pane = null, { launchWindow = null } = {}) {
   const machine = session.machine ?? localMachine();
   let activity;
   if (pane?.pid) {
@@ -977,6 +980,10 @@ async function turnAtClose(session, pane = null) {
     // No session read under the pane is no absence (a registry it could not read, another config home, a failed process
     // read): the pane's own foreground program says whether a harness runs there. Only a pane running none is closed.
     if (!activity) {
+      // A pane the board launched whose session no reading ever found (the fleet's never bound it, and none runs under
+      // its process now) past the launch window holds a harness that never started a session: nothing is cut by its
+      // close. Waiting on it kept t_7ec85b6b's Codex pane on aarons-mac-mini, stuck before its first turn, open for 15 h.
+      if (unboundLaunch(session, launchWindow)) return null;
       const command = String(pane.command ?? '').split(/[\\/]/).pop().toLowerCase();
       return command && !HARNESS_COMMANDS.has(command) ? null : `pane ${session.pane} runs ${command || 'a program it does not name'}, whose session could not be read`;
     }
@@ -1108,7 +1115,7 @@ export async function closeRequested(board, report, { taskId = null, caller = nu
         if (protectedNow) throw new Error(`close deferred: pane ${session.pane} is owned by an unended run`);
         // An ended run's session is closed only between its turns, read last, after the claim and the pane list (a pane
         // already gone is settled above with no reading; t_f34710bc's coder was cut mid-proof at 15:01:13Z, 2026-10-04).
-        if (row.ended_at) { const inTurn = await turnAtClose(session, observed.live.get(session.pane)); if (inTurn) throw new Error(`close deferred: ${inTurn}`); }
+        if (row.ended_at) { const inTurn = await turnAtClose(session, observed.live.get(session.pane), { launchWindow: boardSettings(workflowFor(board.root).params).launchWindow }); if (inTurn) throw new Error(`close deferred: ${inTurn}`); }
         await stopSession(board, session); observed.live.delete(session.pane);
       }
       }
@@ -2053,9 +2060,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 +2085,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 +2112,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 +2135,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/package.json

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