@volter/supercode-orchestrator 0.5.113 → 0.5.115

package/board/dispatch.mjs

@@ -1786,14 +1786,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,11 +1806,11 @@ 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, 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)
@@ -1885,6 +1884,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.
+ */
+export function continuationOf(prev, live) {
+  const open = Boolean(prev.released) || (!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 +2147,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 }); }
@@ -2674,17 +2687,30 @@ export async function plan({ root, lanes, settings, slugs = null, params = {} })
   return out;
 }
 
-/** Whether an arc with no open PR may be one that changed no code and is due its review: it filed and closed tasks
- *  (a fresh arc with none has not started), and no review of it is pending or passed (after changes are requested,
- *  closing the tasks that own the findings makes it due again). */
+/** Whether an arc with no open PR may be one that changed no code and is due its review: it has done work, by filing
+ *  tasks or by a run that ended with an Acceptance outcome ticked (a fresh arc with neither has not started), and no
+ *  review of it is pending or passed (after changes are requested, closing the tasks that own the findings makes it
+ *  due again). */
 function noCodeReviewDue(board, id) {
   return view(board, (db) => {
-    if (!db.prepare('SELECT 1 FROM supercode_cards WHERE subtask_of = ? LIMIT 1').get(id)) return false;
+    const filed = db.prepare('SELECT 1 FROM supercode_cards WHERE subtask_of = ? LIMIT 1').get(id);
+    if (!filed && !(db.prepare('SELECT 1 FROM task_runs WHERE task_id = ? AND ended_at IS NOT NULL LIMIT 1').get(id) &&
+      outcomeTicked(db.prepare('SELECT body FROM tasks WHERE id = ?').get(id)?.body))) return false;
     const last = db.prepare("SELECT kind FROM task_events WHERE task_id = ? AND kind IN ('review_requested', 'changes_requested', 'review_pass','review_voided') ORDER BY id DESC LIMIT 1").get(id);
     return !last || ['changes_requested','review_voided'].includes(last.kind);
   });
 }
 
+/** Whether a card body ticks some outcome under its Acceptance heading. */
+function outcomeTicked(body) {
+  let acceptance = false;
+  return String(body ?? '').split('\n').some((line) => {
+    const heading = /^#{1,6}\s+(.+?)\s*$/.exec(line);
+    if (heading) acceptance = heading[1].toLowerCase() === 'acceptance';
+    return acceptance && /^\s*[-*] \[[xX]\] \S/.test(line);
+  });
+}
+
 /** An opened PR asks for the declared review transition once the arc's tasks are closed. */
 // A task written in the card's own Tasks section that did not become a subtask holds its review too.
 /** The arc's session still in a turn: its review, and the close of that session the request brings (end_run), wait for

package/package.json

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