@volter/supercode-orchestrator 0.5.62 → 0.5.64

package/board/ci.mjs

@@ -5,6 +5,7 @@ import { readFileSync, realpathSync, writeFileSync, renameSync, statSync } from
 import { dirname, join, relative } from 'node:path';
 import { createHash } from 'node:crypto';
 import { branchCheckouts, checkoutOf, isLocalWorkspace, resolveWorkspace } from './workspace.mjs';
+import { noteStep } from '@volter/supercode-harness-sdk/slow-log';
 
 // GitHub is read through its REST API with Node's own fetch, not the gh binary: Node takes a World's trust bundle and
 // injector (NODE_EXTRA_CA_CERTS, NODE_OPTIONS), so a review World's GitHub twin answers it, where gh (Go) trusts only
@@ -35,7 +36,9 @@ function github(path, all = false) {
     const env = token ? { ...process.env, GH_TOKEN: token } : process.env;
     return spawnSync(process.execPath, ['--input-type=module', '-e', GITHUB_READ, path, all ? '1' : '0'], { env, encoding: 'utf8', timeout: 30_000, maxBuffer: 16 * 1024 * 1024 });
   };
+  const started = performance.now();
   let result = read();
+  noteStep('github read', performance.now() - started);
   if (result.status !== 0 && !fixed && loginToken && /^GitHub 401 /.test(result.stderr ?? '')) { loginToken = null; result = read(); }
   if (result.status !== 0) throw new Error(`GitHub: ${(result.stderr || result.error?.message || 'read failed').trim().slice(-500)}`);
   return JSON.parse(result.stdout);

package/board/dispatch.mjs

@@ -16,6 +16,7 @@
 // `workflow dispatch`) is harmless: every act of a round is a compare-and-set claim, a transaction that re-reads what it
 // acts on and does nothing when another round already acted (see `tick`). Every side effect follows a committed claim, so
 // a crash between the two steps is answered by the next round.
+import { noteStep } from '@volter/supercode-harness-sdk/slow-log';
 import { monitorsRuns, failedObservation, surfaceIncident, auditEndedRuns, originOf } from './incidents.mjs';
 import { readMachineFleet } from './machine-fleet.mjs';
 import { boardLabel, boardName } from '@volter/teams/board-name';
@@ -77,7 +78,9 @@ function sc(args, { input = null, timeout = 120_000, as = null } = {}) {
   // `as`: the board this
   // command acts for, so a card's pane is started and closed by its board, whichever session ran the board's verb
   const env = commandEnv(as);
+  const started = performance.now();
   const r = spawnSync(supercodeBin(), args, { cwd: tmpdir(), input: input ?? undefined, encoding: 'utf8', timeout, env, maxBuffer: 512 * 1024 * 1024 });
+  noteStep(`supercode ${args[0]}`, performance.now() - started);
   return { code: r.status, stdout: r.stdout ?? '', stderr: (r.stderr ?? '') + (r.error ? r.error.message : '') };
 }
 
@@ -2393,7 +2396,7 @@ export async function plan({ root, lanes, settings, slugs = null, params = {} })
     const board = openBoard(root, slug);
     try {
       board.label = boardLabel(root, slug);
-      await activatePullRequestReviews(board, entry, report, [], { dry: true });
+      await activatePullRequestReviews(board, entry, report, [], { dry: true, fleet });
       startCards(board, fleet, lanes, settings, report, entry, [], { dry: true, held });
     } finally { board.close(); }
     out.push(report);
@@ -2414,7 +2417,19 @@ function noCodeReviewDue(board, id) {
 
 /** 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.
-async function activatePullRequestReviews(board, entry, report, effects, { only = null, dry = false } = {}) {
+/** 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. */
+function turnInFlight(board, id, fleet) {
+  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(nativeSessions(session.machine, session.harness ?? 'claude-code', session.session_id), session).row?.activity?.turn ?? null; } catch { /* unread: waits on nothing */ }
+  return turn === 'working' ? `its session ${addressOf(session)} is in a turn; the review is requested once the turn ends` : null;
+}
+
+async function activatePullRequestReviews(board, entry, report, effects, { only = null, dry = false, fleet = null } = {}) {
   const candidates = view(board, db => db.prepare(`SELECT t.id FROM tasks t JOIN supercode_cards c ON c.task_id=t.id
     WHERE c.subtask_of IS NULL AND c.every IS NULL
     AND t.workspace_kind!='scratch' ${only ? 'AND t.id=?' : ''}`).all(...(only ? [only] : [])));
@@ -2432,6 +2447,8 @@ 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 = turnInFlight(board, id, fleet);
+    if (inTurn) { report.queued.push([id, `review waits: ${inTurn}`]); continue; }
     let payload = null;
     try {
       payload = openReviewPullRequests(board, id);
@@ -2601,7 +2618,7 @@ export async function tick({ root, lanes, settings, only = null, slugs = null, d
       report.unsettled = [];
       report.promoted = recomputeReady(board, effects, report.unsettled);
       tx(board,db=>auditEndedRuns(db,board,entry));
-      if (dispatch) await activatePullRequestReviews(board, entry, report, effects, { only });
+      if (dispatch) await activatePullRequestReviews(board, entry, report, effects, { only, fleet });
       if (dispatch && !stopping) startCards(board, fleet, lanes, settings, report, entry, effects, { only, held });
       phase('start');
       if (dispatch && !only && !report.paused) observeIdle(board, fleet, settings, report, entry, effects);

package/board/machine-fleet.mjs

@@ -10,6 +10,7 @@
 // not linked (`machine_offline`): then it is offline. This machine's door not answering is no reading at all.
 import { spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
+import { noteStep } from '@volter/supercode-harness-sdk/slow-log';
 
 const entry = fileURLToPath(new URL('../bin/machine-fleet.mjs', import.meta.url));
 const DEADLINE_MS = 10_000;
@@ -17,8 +18,10 @@ const DEADLINE_MS = 10_000;
 /** One reading of `machines` (normalized names) and this machine, `local`. */
 export function readMachineFleet(machines, local) {
   const names = [...new Set([local, ...machines])];
+  const started = performance.now();
   const reply = spawnSync(process.execPath, [entry], { input: JSON.stringify({ machines: names.map((name) => ({ name, at: name === local ? null : name })), deadlineMs: DEADLINE_MS }),
     encoding: 'utf8', timeout: DEADLINE_MS + 5_000, maxBuffer: 64 * 1024 * 1024 });
+  noteStep(`fleet reading (${names.length} machine${names.length === 1 ? '' : 's'})`, performance.now() - started);
   let rows = null;
   try { rows = JSON.parse(String(reply.stdout).trim().split('\n').pop()); } catch { /* no reading */ }
   // `panes`: each answering machine's live pane ids, whether or not a session was read in them

package/board/runtime-door.mjs

@@ -1,12 +1,16 @@
 import { spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
+import { noteStep } from '@volter/supercode-harness-sdk/slow-log';
 const entry = fileURLToPath(new URL('../bin/runtime-door.mjs',import.meta.url));
 
 /** Public machine RPC only; no Teams binary or implementation/state-file access. */
 export function runtimeDoor(machine,method,params={}, {env=process.env,timeout=60_000,as=null}={}) {
+  // a step of the running command (a dispatch round's slow-log line names its doors, and their time, by method)
+  const started = performance.now();
   const result = spawnSync(process.execPath,[entry],{
     input:JSON.stringify({machine,method,params}),encoding:'utf8',timeout,
     env:{...env,...(as?{SUPERCODE_CALLER:as}:{})},maxBuffer:512*1024*1024,
   });
+  noteStep(`door ${method}${machine ? ' (another machine)' : ''}`, performance.now() - started);
   return {code:result.status,stdout:result.stdout??'',stderr:(result.stderr??'')+(result.error?.message??'')};
 }

package/package.json

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