@volter/supercode-orchestrator 0.5.131 → 0.5.133

package/board/ci.mjs

@@ -333,22 +333,27 @@ async function knownRepositories() {
 
 /** Whether the arc's open PRs (`[{ url, head }]`) call for its review: some head no verdict judged that is new work.
  *  Before any verdict every unjudged head is. After a verdict, a PR it judged with a new head is, and so is a head
- *  committed after that verdict (a new PR carrying the fixes, or any PR after a verdict that named none). A PR that
- *  joins with a head committed before the verdict is not: after changes are requested the next run is the
- *  implementer's until it pushes. */
+ *  committed after that verdict (a new PR carrying the fixes, or any PR after a verdict that named none). After changes
+ *  are requested, a PR that joins with a head committed before the verdict is not: the next run is the implementer's
+ *  until it pushes. After a pass nothing is owed by the implementer, so a PR that verdict's request did not name is due
+ *  at whatever head it has: one that was a draft or stacked on another PR's branch when the request was made, and
+ *  became the arc's once that PR merged (t_bbbd2086's #1355, committed 2 h before the pass that named only #1353). */
 export async function reviewDue(board, id, prs) {
   const unjudged = prs.filter((p) => !judgedHead(board, id, p.head));
   if (!unjudged.length) return false;
   const voided = board.db.prepare("SELECT r.payload FROM task_events v JOIN task_events r ON r.id=json_extract(v.payload,'$.review_request') AND r.task_id=v.task_id WHERE v.task_id=? AND v.kind='review_voided' ORDER BY v.id DESC LIMIT 1").get(id);
   if (candidatePullRequests(voided && JSON.parse(voided.payload)?.ci).some(j => unjudged.some(p => p.url === j.pr.url && p.head === j.commit))) return true;
   const last = board.db.prepare(`SELECT r.payload, (SELECT MIN(v.created_at) FROM task_events v WHERE v.task_id = r.task_id
-      AND v.kind IN ('changes_requested', 'review_pass') AND v.id > r.id) AS verdict_at
+      AND v.kind IN ('changes_requested', 'review_pass') AND v.id > r.id) AS verdict_at,
+      (SELECT v.kind FROM task_events v WHERE v.task_id = r.task_id
+      AND v.kind IN ('changes_requested', 'review_pass') AND v.id > r.id ORDER BY v.id LIMIT 1) AS verdict
     FROM task_events r WHERE r.task_id = ? AND r.kind = 'review_requested'
     AND EXISTS (SELECT 1 FROM task_events v WHERE v.task_id = r.task_id AND v.kind IN ('changes_requested', 'review_pass') AND v.id > r.id)
     ORDER BY r.id DESC LIMIT 1`).get(id);
   if (!last) return true;
   const judged = candidatePullRequests(JSON.parse(last.payload)?.ci);
   if (judged.some((j) => prs.some((p) => p.url === j.pr.url && p.head !== j.commit))) return true;
+  if (last.verdict === 'review_pass' && unjudged.some((p) => !judged.some((j) => j.pr.url === p.url))) return true;
   for (const p of unjudged) if (((await commitTime(p)) ?? 0) > Number(last.verdict_at)) return true;
   return false;
 }

package/board/dispatch.mjs

@@ -642,7 +642,7 @@ async function stopSession(board, session) {
     return;
   }
   if (session.pane) {
-    const r = await runtimeDoor(normalMachine(session.machine??localMachine())===localMachine()?null:session.machine,'harness.v1.panes.close',{pane:session.pane},{env:commandEnv(),timeout:60_000,as:boardAddress(board.label)});
+    const r = await runtimeDoor(normalMachine(session.machine??localMachine())===localMachine()?null:session.machine,'harness.v1.panes.close',{pane:session.pane,...(session.launch_key?{launch:session.launch_key}:{})},{env:commandEnv(),timeout:60_000,as:boardAddress(board.label)});
     // a door that timed out or could not be reached says nothing about the pane: the close waits for the next round
     const transient = doorTransient(r);
     if (r.code !== 0 || json(r.stdout.trim(), null)?.closed !== session.pane) throw new Error(`${transient ? 'close deferred: ' : ''}closing pane ${session.pane}: ${(r.stderr || r.stdout || `exit ${r.code}`).trim().slice(-500)}`);
@@ -1141,12 +1141,20 @@ 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 = closeRefused(session);
+    // A refusal's reason can end (the machine's daemon was replaced by one that reads the launch's starter): the same
+    // reading says whether this board's close of the pane would be admitted now (`yours`), and a close it would admit
+    // is tried again, unless an unended run works in the pane. A machine that does not say stays refused.
+    let 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) });
+      const r = await doorOn(session.machine ?? localMachine(), 'harness.v1.panes.presence', { pane: session.pane, ...(session.launch_key ? { launch: session.launch_key } : {}) }, { timeout: 10_000, as: boardAddress(board.label) });
       const observed = r.code === 0 ? json(r.stdout.trim(), null) : null;
-      if (observed?.pane !== session.pane || observed.present !== false) continue;
+      if (observed?.pane !== session.pane) continue;
+      if (observed.present === true && observed.yours === true) {
+        if (view(board, (db) => db.prepare(`SELECT metadata FROM task_runs r WHERE r.ended_at IS NULL OR EXISTS (SELECT 1 FROM tasks t WHERE t.current_run_id = r.id)`).all())
+          .some((r) => { const s = json(r.metadata, {})?.supercode; return s?.pane === session.pane && normalMachine(s.machine) === normalMachine(session.machine); })) continue;
+        finalFailure = false;
+      } else if (observed.present !== false) continue;
     }
     const active = view(board, (db) => db.prepare(`SELECT r.id, r.metadata FROM task_runs r WHERE r.ended_at IS NULL OR EXISTS (SELECT 1 FROM tasks t WHERE t.current_run_id = r.id)`).all());
     // Persist retries even for historical ends that did not have a close_session action. The close is claimed in the
@@ -1226,7 +1234,7 @@ export async function closeRequested(board, report, { taskId = null, caller = nu
         setRunSession(db, row.id, { ...current, close_attempted_at: at, close_attempts: Number(current.close_attempts ?? 0) + 1, close_error: error, ...(final ? { close_failed_at: at } : {}) });
         // Retain every attempt's latest fact, but avoid an unbounded thread of identical failures.
         if (current.close_error !== error) event(db, row.task_id, 'session_close_failed', { session_id: session.session_id, pane: session.pane, error, retry: !final }, row.id);
-        if (final) event(db, row.task_id, 'run_incident', { observation: 'close_failed', run: row.id, reason: `the board could not close ${addressOf(session)} and will not try again: ${error}`, session: session.session_id, machine: session.machine, pane: session.pane ?? null, evidence: { error } }, row.id);
+        if (final && current.close_error !== error) event(db, row.task_id, 'run_incident', { observation: 'close_failed', run: row.id, reason: `the board could not close ${addressOf(session)} and will not try again: ${error}`, session: session.session_id, machine: session.machine, pane: session.pane ?? null, evidence: { error } }, row.id);
       } else if (!current.close_confirmed_at) {
         // a close another closer already confirmed (a claim that expired under it) is said once, by that closer
         const { close_error: _error, ...rest } = current;

package/package.json

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