@volter/supercode-orchestrator 0.5.117 → 0.5.118

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/package.json

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