@volter/supercode-orchestrator 0.5.180 → 0.5.182

package/board/dispatch.mjs

@@ -2107,7 +2107,7 @@ 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, close_failed_at: _cf, close_unread: _cu, close_claim: _cl, 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_unread: _cu, close_claim: _cl, monitor_held: _mh, released: _rl, review_held: _rh, ...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)
@@ -3070,16 +3070,42 @@ function outcomeTicked(body) {
 /** 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
- *  the turn to end, so work in flight is never cut (t_f34710bc's coder had a proof take running when its review was
- *  requested at 15:01:13Z on 2026-10-04, and the close ended it). A session the reading cannot place waits on nothing. */
-async function turnInFlight(board, id, fleet) {
+ *  the turn to end, so work in flight is never cut and the reviewer never starts in the coder's checkout beside a turn
+ *  still running there (t_f34710bc's coder had a proof take running when its review was requested at 15:01:13Z on
+ *  2026-10-04, and the close ended it). A session the reading cannot place waits on nothing.
+ *
+ *  A Codex session with an active thread goal is never read between turns: the goal starts the next turn the moment one
+ *  ends (t_374d7f70, codex 01a108b7, 2026-10-14). For it the turn boundary is the one its harness records: the open turn
+ *  was started by the goal (Codex's own `turn_trigger`, published as the activity's `turn_trigger`), not by a person or
+ *  by mail, and it started after `heldSince`, the first round that found the review due with nothing but this turn
+ *  holding it. So the turn that was running when the review fell due, the one that closed the tasks and pushed the
+ *  heads, has ended with the coder's own completion; a goal turn that began before that round, which may be the one
+ *  running a proof, still holds the review. */
+async function turnInFlight(board, id, fleet, heldSince = null) {
   if (!fleet?.ok) return null;
   const session = currentRun(board.db, id)?.metadata?.supercode;
   if (!session?.session_id || session.surface === 'headless' || session.close_requested) return null;
-  let turn = fleet.sessions?.find((x) => x.address === addressOf(session))?.turn ?? null;
-  if (turn == null && session.surface === 'native') try { turn = nativeReading(await readNative(session.machine, session.harness ?? 'claude-code', session.session_id), session).row?.activity?.turn ?? null; } catch { /* unread: waits on nothing */ }
+  let live = fleet.sessions?.find((x) => x.address === addressOf(session)) ?? null;
+  if (live?.turn == null && session.surface === 'native') try {
+    const activity = nativeReading(await readNative(session.machine, session.harness ?? 'claude-code', session.session_id), session).row?.activity;
+    live = activity ? { turn: activity.turn ?? null, turn_trigger: activity.evidence?.turn_trigger ?? null, turn_since_ms: activity.evidence?.native_state_since_ms ?? null } : live;
+  } catch { /* unread: waits on nothing */ }
+  const turn = live?.turn ?? null;
   // a turn stopped on a permission or a question (needs_input) is a turn not finished, as one still working is
-  return ['working', 'needs_input'].includes(turn) ? `its session ${addressOf(session)} is in a turn (${turn}); the review is requested once the turn ends` : null;
+  if (!['working', 'needs_input'].includes(turn)) return null;
+  const started = Number(live.turn_since_ms) / 1000;
+  if (turn === 'working' && live.turn_trigger === 'goal' && heldSince != null && started > heldSince) return null;
+  return { why: `its session ${addressOf(session)} is in a turn (${turn}${live.turn_trigger ? `, started by ${live.turn_trigger}` : ''}); the review is requested once the turn ends${live.turn_trigger === 'goal' ? ', or once a goal turn starts after this round' : ''}` };
+}
+
+/** What a review held on its session's turn was due on: the arc's PR heads (or its no-code act) and its last task close.
+ *  A hold is kept only while this stays the same; anything else due is a new hold from its own round. */
+function reviewDueKey(board, id, payload) {
+  const closed = board.db.prepare(`SELECT MAX(id) AS id FROM task_events WHERE kind IN ('completed', 'cancelled')
+    AND task_id IN (SELECT task_id FROM supercode_cards WHERE subtask_of = ?)`).get(id)?.id ?? null;
+  const source = payload.no_code ? `no_code:${payload.no_code.kind ?? ''}:${payload.no_code.repository ?? ''}:${payload.no_code.base ?? ''}`
+    : payload.pr.map((url, index) => `${url}@${payload.pr_head[index]}`).join(',');
+  return `${source}|${closed ?? ''}`;
 }
 
 async function activatePullRequestReviews(board, entry, report, effects, { only = null, dry = false, fleet = null } = {}) {
@@ -3101,8 +3127,6 @@ async function activatePullRequestReviews(board, entry, report, effects, { only
     const ready = view(board, eligible);
     if (!ready) continue;
     if (ready !== true) { report.queued.push([id, `review waits: ${ready.length} open task(s) in the card's Tasks: ${ready[0].id} ${ready[0].title}`]); continue; }
-    const inTurn = await turnInFlight(board, id, fleet);
-    if (inTurn) { report.queued.push([id, `review waits: ${inTurn}`]); continue; }
     let payload = null;
     try {
       payload = await openReviewPullRequests(board, id);
@@ -3121,6 +3145,16 @@ async function activatePullRequestReviews(board, entry, report, effects, { only
       }
       const evidence = payload.no_code ? { required: false, ready: true, reason: null, phase: 'source', no_code: payload.no_code } : await inspectCompletionEvidence(board, id, entry, payload, 'request_review');
       if (!evidence.ready) throw new Error(evidence.reason);
+      // Due in every other respect: only the session's turn may still hold it. The first round that finds it so is
+      // recorded on the run (`review_held`), with what it was due on, so a goal turn can be told to have started after.
+      const heldRun = currentRun(board.db, id), dueKey = reviewDueKey(board, id, payload);
+      const held = heldRun?.metadata?.supercode?.review_held?.key === dueKey ? heldRun.metadata.supercode.review_held : null;
+      const inTurn = await turnInFlight(board, id, fleet, held ? Number(held.since) : null);
+      if (inTurn) {
+        if (!held && !dry && heldRun) tx(board, (db) => { if (currentRun(db, id)?.id === heldRun.id) setRunSession(db, heldRun.id, { review_held: { key: dueKey, since: now() } }); });
+        report.queued.push([id, `review waits: ${inTurn.why}`]);
+        continue;
+      }
       // a dry run names the review a tick would request and writes nothing
       if (dry) { (report.would_review ??= []).push({ id, prs: payload.pr, heads: payload.pr_head, no_code: payload.no_code ?? null }); continue; }
       await refreshCardInputs(board, id, { commits: true });

package/board/doors.mjs

@@ -26,8 +26,11 @@ async function opened(machine) {
   }
   const opening = (async () => {
     const channel = await openMachine({ machine: machine || null });
-    const door = { channel, node: null, harness: null };
+    const door = { channel, node: null, harness: null, heardAt: performance.now() };
+    // when the channel last carried anything (an answer, a stream's data, the keep-alive's pong): see retireSilent
+    channel.socket?.on?.('data', () => { door.heardAt = performance.now(); });
     channel.on('close', () => { if (held.get(key) === opening) held.delete(key); });
+    door.opening = opening;
     return door;
   })();
   held.set(key, opening);
@@ -43,13 +46,14 @@ async function opened(machine) {
 export async function machineCall(machine, method, params = {}, { timeoutMs = 60_000 } = {}) {
   if (!method.startsWith('harness.v1.')) throw new Error('a machine door is a harness.v1 method');
   const started = performance.now();
+  let door = null;
   try {
-    const door = await opened(machine);
+    door = await opened(machine);
     if (method.startsWith('harness.v1.sessions.')) {
       // The harness client starts its transport again itself once it ends (a daemon restart there); one that never
       // started is let go, so the next call starts another.
       if (!door.harness) {
-        const starting = (async () => { const client = new SupercodeHarnessClient({ transport: harnessTransport(door.channel) }); await client.start?.(); return client; })();
+        const starting = (async () => { const client = new SupercodeHarnessClient({ transport: channelHarness(door.channel, machine) }); await client.start?.(); return client; })();
         starting.catch(() => { if (door.harness === starting) door.harness = null; });
         door.harness = starting;
       }
@@ -66,11 +70,46 @@ export async function machineCall(machine, method, params = {}, { timeoutMs = 60
       door.node = opening;
     }
     return await (await door.node).call(method, params, { timeoutMs });
+  } catch (error) {
+    if (machine && door && (error?.code === 'REQUEST_TIMEOUT' || error?.code === 504)) retireSilent(machine, door, started);
+    throw error;
   } finally {
     noteStep(`door ${method}${machine ? ' (another machine)' : ''}`, performance.now() - started);
   }
 }
 
+/**
+ * Another machine's channel that carried nothing at all for the whole of a request's bound is closed, so the next call
+ * opens a fresh one. Such a channel's socket to the Teams server can stay open after the server has lost the far side:
+ * every request on it waits out its bound, and nothing ends the channel until the server closes the socket. On
+ * 2026-10-14 the board owner's discoveries on other machines timed out five times running (00:05:16 to 00:06:31), the
+ * server closed their channel at 00:06:37 (two calls failed "connection closed"), and the next channel answered in
+ * 1.4 s. The keep-alive's ping is answered by the far machine's own channel, so a channel that carried anything
+ * meanwhile (another answer, a pong) reaches that machine and is kept: the request was slow there.
+ */
+function retireSilent(machine, door, started) {
+  if (door.heardAt >= started || door.channel.closed) return;
+  if (held.get(machine) === door.opening) held.delete(machine);
+  door.channel.close();
+}
+
+/**
+ * The harness transport over a machine channel, saying what ended when it ends: the channel's stream is no harness
+ * process, and its close (`connection closed`) read as "Volter Harness service exited" sent F81 looking for a child
+ * that never exited.
+ */
+function channelHarness(channel, machine) {
+  const inner = harnessTransport(channel);
+  const where = machine ? `the Teams server channel to ${machine}` : "the socket to this machine's daemon";
+  return {
+    get running() { return inner.running; },
+    start: (handlers) => inner.start({ ...handlers,
+      onExit: (code, reason) => handlers.onExit(code, `${reason ?? 'closed'}: ${where} ended, no harness process exited`) }),
+    write: (line) => inner.write(line),
+    close: () => inner.close(),
+  };
+}
+
 export async function machineRecordStream(params = {}) {
   const door = await opened(null);
   return door.channel.open('machine-record-changes', params);

package/board/machine-fleet.mjs

@@ -100,8 +100,10 @@ export async function readMachineFleet(machines, local) {
       sessions.push({ address, machine: row.machine, harness: activity.harness, session_id: activity.session_id, pane: pane.pane, name: pane.title ?? pane.label ?? null,
         starter_session: pane.starter_session ?? null,
         state: running ? 'running' : 'unknown', turn: activity.turn ?? null, native_state: activity.evidence?.native_state ?? null,
-        // what a session that needs input says it waits for and since when, where its harness publishes them
-        waiting_for: activity.evidence?.waiting_for ?? null, turn_source: activity.evidence?.source ?? null, turn_since_ms: activity.evidence?.native_state_since_ms ?? null });
+        // what a session that needs input says it waits for, what started its open turn (Codex: `goal` for a thread
+        // goal's continuation) and since when, where its harness publishes them
+        waiting_for: activity.evidence?.waiting_for ?? null, turn_source: activity.evidence?.source ?? null, turn_since_ms: activity.evidence?.native_state_since_ms ?? null,
+        turn_trigger: activity.evidence?.turn_trigger ?? null });
     }
   }
   const ok = online.has(local);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-orchestrator",
-  "version": "0.5.180",
+  "version": "0.5.182",
   "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": {
@@ -24,7 +24,7 @@
     "check-types": "node scripts/generate-types.mjs --check"
   },
   "dependencies": {
-    "@volter/supercode-harness-sdk": "^0.3.100",
+    "@volter/supercode-harness-sdk": "^0.3.101",
     "@volter/teams": "0.2.79",
     "@volter/ztrack": "^2.4.23",
     "yaml": "^2.9.0"