@volter/supercode-orchestrator 0.5.179 → 0.5.181

package/bin/agent-channel.mjs

@@ -142,7 +142,9 @@ log('info', `${values.agent}: the account Room ${roomId} is carried to its mailb
 
 const supercode = process.env.SUPERCODE_BIN || 'supercode';
 const sc = (args) => JSON.parse(execFileSync(supercode, args, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }));
-let boundTo = null;
+let boundTo = null, failedAs = null;
+const lastLine = (error) => String(error.stderr || error.message).trim().split('\n').at(-1);
+const warnOnce = (as, line) => { if (failedAs !== as) { failedAs = as; log('warn', line); } };
 /** The agent's own seat takes its session at RH2's own-seat door (PUT …/members/:principalId/session, a Room
  * reader's): the session alone changes, never the seat's roles or who may read and post to it, which stay a
  * members.manage holder's. A refusal throws with its status. */
@@ -151,15 +153,21 @@ async function seatSession(session) {
   const res = await adapter.fetch(`${adapter.apiUrl()}/api/v3${path}`, { method: 'PUT', headers: adapter.headers(), body: JSON.stringify({ session }) });
   if (!res.ok) throw new Error(`PUT ${path} -> HTTP ${res.status}: ${(await res.text()).slice(0, 200)}`);
 }
-/** The participant's seat bound to the agent's current main session; a new main session rebinds it. */
+/** The participant's seat bound to the agent's current main session; a new main session rebinds it. The agent's record
+ *  is read again on every tick, so a re-declared main is bound at the next one. A bind that fails is said once per main
+ *  and reason (a main that is not in the team's catalog, or one no session ever ran as), never only at debug level,
+ *  which this process does not print. */
 async function bindDm() {
   let main;
-  try { main = [sc(['agent', 'show', values.agent, '--json'])].flat().find((a) => a.name === values.agent)?.main_session; } catch { return; }
+  try { main = [sc(['agent', 'show', values.agent, '--json'])].flat().find((a) => a.name === values.agent)?.main_session; }
+  catch (error) { warnOnce(`agent show: ${lastLine(error)}`, `${values.agent}: its agent record was not read (${lastLine(error)}); its DM stays bound to ${boundTo ?? 'nothing'}`); return; }
   const session = typeof main === 'string' ? main.split(':').pop() : null;
-  if (!session || session === boundTo) return;
+  if (!session) { warnOnce('no main', `${values.agent}: its agent record names no main session; its DM stays bound to ${boundTo ?? 'nothing'}`); return; }
+  if (session === boundTo) return;
   let bound;
   try { bound = sc(['sessions', 'bind', session, '--room', roomId, '--agent', adapter.principalId(), '--rh2', adapter.apiUrl(), '--json']).data; }
-  catch (error) { log('debug', `${values.agent}: its DM is not bound yet (${String(error.stderr ?? error.message).trim().split('\n').at(-1)})`); return; }
+  catch (error) { warnOnce(`${session}: ${lastLine(error)}`, `${values.agent}: its DM is not bound to its main session ${main} (exit ${error.status ?? '?'}: ${lastLine(error)}); retried every 15 s with the record read again`); return; }
+  failedAs = null;
   await seatSession({ harness: bound.harness, sessionId: bound.sessionId, team: bound.team, teamsUrl: bound.teamsUrl });
   boundTo = session;
   log('info', `${values.agent}: its DM in the account Room is its main session ${session}`);

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/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.179",
+  "version": "0.5.181",
   "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"