@volter/supercode-orchestrator 0.5.59 → 0.5.61

package/board/dispatch.mjs

@@ -192,7 +192,7 @@ function unpublishedAlive(session) {
   if (!session.machine) return null;
   if (!session.pane) {
     if (!session.session_id) return null;
-    try { return nativeReading(nativeSessions(session.machine, session.harness ?? 'claude-code'), session).alive; } catch { return null; }
+    try { return nativeReading(nativeSessions(session.machine, session.harness ?? 'claude-code', session.session_id), session).alive; } catch { return null; }
   }
   let entry = paneLists.get(session.machine);
   if (!entry || Date.now() - entry.at > READING_MS) {
@@ -205,8 +205,9 @@ function unpublishedAlive(session) {
   return entry.panes ? entry.panes.some((p) => p.pane === session.pane && !p.dead) : null;
 }
 
-/** Native activity comes from the machine's harness discovery, not catalogue age. One discovery (up to 2000
- * sessions, seconds each) serves a round's every native session on that machine, as paneLists serves its panes. */
+/** Native activity comes from the machine's harness discovery, not catalogue age: each session the round reads is
+ * discovered by its id (about 0.2 s), once per round (tick clears them). Listing the machine's every session to find
+ * them (up to 2000, 1-6 s each) cost more than the sessions a board runs. */
 const discoveries = new Map();
 // A machine's pane list and harness discovery are read before a board write opens, never inside one: a door that
 // takes seconds would hold the board's write lock past a worker's own command's busy wait. A write that needs a
@@ -217,25 +218,26 @@ const txRead = (board, fn) => { readingsOnly += 1; try { return tx(board, fn); }
 /** Take the readings a board write about `session` will need, before the write. */
 function readBefore(fleet, session) {
   if (!session?.session_id || !session.machine || session.surface === 'headless') return;
-  try { nativeSessions(session.machine, session.harness ?? 'claude-code'); } catch { /* unread: unknown inside the write */ }
+  try { nativeSessions(session.machine, session.harness ?? 'claude-code', session.session_id); } catch { /* unread: unknown inside the write */ }
   sessionAlive(fleet, session);
 }
-function nativeSessions(machine, harness) {
-  const key = `${normalMachine(machine)}\u0000${harness}`, seen = discoveries.get(key);
-  if (seen && Date.now() - seen.at <= READING_MS) return seen.sessions;
+function nativeSessions(machine, harness, sessionId) {
+  const key = nativeKey(machine, harness, sessionId), seen = discoveries.get(key);
+  if (seen) return seen.sessions;
   if (readingsOnly) throw unavailable('native liveness is read before a board write, not inside it');
-  const sessions = discoverNative(machine, harness);
+  const sessions = discoverNative(machine, harness, sessionId);
   discoveries.set(key, { at: Date.now(), sessions });
   return sessions;
 }
 // A native discovery is bounded as the fleet reading is: one that does not answer in time is unknown, read next round.
 const NATIVE_DISCOVERY_MS = 15_000;
-function discoverNative(machine, harness) {
+const nativeKey = (machine, harness, sessionId) => `${normalMachine(machine)}\u0000${harness}\u0000${sessionId}`;
+function discoverNative(machine, harness, sessionId) {
   if (offlineMachine(machine)) throw unavailable(`native liveness unavailable: machine ${normalMachine(machine)} is offline`);
   // This machine's discovery is its harness door, as every other harness read here is; another machine's is supercode's fleet arm
   const result = normalMachine(machine) === localMachine()
-    ? doorOn(machine, 'harness.v1.sessions.discover', { harnesses: [harness], limit: 2000 }, { timeout: NATIVE_DISCOVERY_MS })
-    : sc(['discover', '--on', machine, '--harness', harness, '--limit', '2000'], { timeout: NATIVE_DISCOVERY_MS });
+    ? doorOn(machine, 'harness.v1.sessions.discover', { harnesses: [harness], query: sessionId, limit: 2000 }, { timeout: NATIVE_DISCOVERY_MS })
+    : sc(['discover', '--on', machine, '--harness', harness, '--query', sessionId, '--limit', '2000'], { timeout: NATIVE_DISCOVERY_MS });
   const page = result.code === 0 ? lastJson(result.stdout) : null;
   if (!Array.isArray(page?.sessions)) throw unavailable(`native liveness unavailable on ${machine}: ${(result.stderr || result.stdout).trim().slice(-300)}`);
   return page.sessions;
@@ -525,8 +527,8 @@ function stopSession(board, session) {
     const r = sc(['close', addressOf(session)], { timeout: 120_000, as: boardAddress(board.label) });
     if (r.code !== 0) throw new Error(`${doorTransient(r) ? 'close deferred: ' : ''}closing native session ${addressOf(session)}: ${(r.stderr || r.stdout).trim().slice(-500)}`);
     // the close's receipt is a discovery taken after it, never the round's cached one from before
-    discoveries.delete(`${normalMachine(session.machine)}\u0000${session.harness}`);
-    const reading = nativeReading(nativeSessions(session.machine, session.harness), session);
+    discoveries.delete(nativeKey(session.machine, session.harness, session.session_id));
+    const reading = nativeReading(nativeSessions(session.machine, session.harness, session.session_id), session);
     if (reading.alive !== false) throw new Error(`native close has no confirmed stopped receipt for ${addressOf(session)}`);
     return;
   }
@@ -931,7 +933,7 @@ export function closeRequested(board, report, { taskId = null, caller = null, tt
     try {
       const machine = session.machine ?? localMachine();
       if (session.surface === 'native' && !session.pane) {
-        const reading = nativeReading(nativeSessions(machine, session.harness), session);
+        const reading = nativeReading(nativeSessions(machine, session.harness, session.session_id), session);
         if (reading.alive == null) throw new Error(`close deferred: native liveness unknown for ${addressOf(session)}`);
         if (reading.alive) {
           const protectedNow = active.some(r => addressOf(json(r.metadata, {})?.supercode) === addressOf(session));
@@ -997,13 +999,12 @@ export function closeRequested(board, report, { taskId = null, caller = null, tt
 function observeIdle(board, fleet, settings, report, entry, effects) {
   if (!fleet.ok) return;
   // The published fleet says whether a session runs and its turn, not when it last wrote: that is the session's own
-  // record, read from its machine's discovery (one read per machine and harness a round, only when a card needs it).
+  // record, read from its machine's discovery (once a round, only when a card needs it).
   // Without it every reading was 'no_timestamp' and no session was ever found idle.
-  const discovered = new Map();
   const updatedAt = (session) => {
-    const key = `${session.machine}|${session.harness ?? 'claude-code'}`;
-    if (!discovered.has(key)) { try { discovered.set(key, nativeSessions(session.machine ?? localMachine(), session.harness ?? 'claude-code')); } catch { discovered.set(key, null); } }
-    return Number(discovered.get(key)?.find((row) => row.locator?.session_id === session.session_id)?.updated_at_ms) || null;
+    let rows = null;
+    try { rows = nativeSessions(session.machine ?? localMachine(), session.harness ?? 'claude-code', session.session_id); } catch { /* unread: no timestamp */ }
+    return Number(rows?.find((row) => row.locator?.session_id === session.session_id)?.updated_at_ms) || null;
   };
   const managers = [].concat(entry.params.managers ?? []).filter(Boolean);
   const running = board.db.prepare(entry.workflow.run ? "SELECT id FROM tasks WHERE current_run_id IS NOT NULL" : "SELECT id FROM tasks WHERE status = 'running'").all();
@@ -1021,7 +1022,7 @@ function observeIdle(board, fleet, settings, report, entry, effects) {
       if (session.surface === 'native' && sessionAlive(fleet, session) !== true) return;
       // a session in no pane has its turn on its machine's discovery row, which sessionAlive just read
       let nativeRow = null;
-      if (session.surface === 'native') try { nativeRow = nativeReading(nativeSessions(session.machine, session.harness ?? 'claude-code'), session).row; } catch { /* unread: no turn */ }
+      if (session.surface === 'native') try { nativeRow = nativeReading(nativeSessions(session.machine, session.harness ?? 'claude-code', session.session_id), session).row; } catch { /* unread: no turn */ }
       const live = fleet.sessions.find((x) => x.address === addressOf(session)) ?? (nativeRow ? { address: addressOf(session), turn: nativeRow.activity?.turn ?? null } : undefined);
       const observedAt = now();
       const lastAtMs = Number(live?.last_message_at_ms) || updatedAt(session);
@@ -1537,7 +1538,7 @@ function launchPane(board, task, runId, lane, fleet, { input = null, slot = 'wor
   // 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.
   if (prev?.surface === 'native' && !prev.pane && (!prev.close_confirmed_at || prev.released)) {
-    const reading = nativeReading(nativeSessions(prev.machine, prev.harness), prev);
+    const reading = nativeReading(nativeSessions(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`);
@@ -1789,7 +1790,7 @@ function nativeListing(who) {
   const m = /^sc:([^:]+):([^:]+):(.+)$/.exec(String(who));
   if (!m || !HARNESSES[m[2]]) return null;
   const [, host, harness, session_id] = m;
-  try { return nativeReading(nativeSessions(host, harness), { session_id, harness }).alive === true ? { address: who, machine: normalMachine(host), harness, session_id, pane: null, name: null } : null; }
+  try { return nativeReading(nativeSessions(host, harness, session_id), { session_id, harness }).alive === true ? { address: who, machine: normalMachine(host), harness, session_id, pane: null, name: null } : null; }
   catch { return null; }
 }
 
@@ -1816,7 +1817,7 @@ function adoptSession(board, id, who, { request = null, open = request, progress
   if (!found) throw Object.assign(new Error(`the fleet lists no live session ${who}`), { notListed: true });
   const [, host, harness, sessionId] = found.address.split(':');
   if (!HARNESSES[harness]) throw new Error(`${found.address} is ${harness}; the board keeps and resumes ${Object.keys(HARNESSES).join(' and ')} sessions`);
-  const native = found.pane ? null : nativeReading(nativeSessions(host, harness), { session_id: sessionId, harness });
+  const native = found.pane ? null : nativeReading(nativeSessions(host, harness, sessionId), { session_id: sessionId, harness });
   if (found.pane ? !panePresent(host, found.pane) : native.alive !== true) throw new Error(`${found.address} has no verified live native process or pane`);
   const beforeRun = view(board, (db) => currentRun(db, id));
   const beforeSession = beforeRun?.metadata?.supercode;
@@ -1826,7 +1827,7 @@ function adoptSession(board, id, who, { request = null, open = request, progress
   // the session's own working directory, as discovery records it (where `--resume` finds it), else its pane's
   let dir = workspace ?? native?.row?.cwd;
   if (!dir) {
-    dir = nativeSessions(host, harness).find((x) => x.locator?.session_id === sessionId)?.cwd ?? null;
+    dir = nativeSessions(host, harness, sessionId).find((x) => x.locator?.session_id === sessionId)?.cwd ?? null;
   }
   if (!dir && found.pane) {
     const r = runtimeDoor(normalMachine(host)===localMachine()?null:host,'harness.v1.panes.list',{}, { timeout: 60_000 });
@@ -2559,6 +2560,7 @@ export async function deliver({ root, slugs = null }) {
  */
 export async function tick({ root, lanes, settings, only = null, slugs = null, dispatch = true, params = {}, deploymentReceipt = false }) {
   fleetRoot = root;
+  discoveries.clear();
   // a verb's flags (dispatch --max, --failure-limit) are params of this tick, read by the workflow as its own
   const deployment = deploymentReceipt ? workflowRevision(root) : null;
   const loaded = await loadWorkflow(root, { fresh: true });

package/board/workflow.mjs

@@ -167,9 +167,12 @@ const execFileAsync = promisify(execFile);
 export async function refreshRelationAnswers(board) {
   const ids = new Set();
   const entry = workflowFor(board.root);
-  for (const row of board.db.prepare("SELECT t.*,c.blocked_by FROM tasks t JOIN supercode_cards c ON c.task_id=t.id WHERE c.blocked_by IS NOT NULL AND c.blocked_by!='[]'").all()) {
-    if (!relationActive(board.db, board, entry, row)) continue;
-    for (const block of json(row.blocked_by, []) ?? []) if (block.kind === 'message') ids.add(block.id);
+  for (const row of board.db.prepare("SELECT t.*,c.blocked_by FROM tasks t JOIN supercode_cards c ON c.task_id=t.id WHERE c.blocked_by IS NOT NULL AND c.blocked_by!='[]' AND t.status NOT IN ('done','cancelled','archived') AND NOT COALESCE(c.archived,0)").all()) {
+    // only an open card's message has an answer to read: a closed card, or one blocked by cards alone, needs no scope
+    // built for its guard (75 walked on 2026-10-04, one of them a live message blocker)
+    const messages = (json(row.blocked_by, []) ?? []).filter((block) => block.kind === 'message');
+    if (!messages.length || !relationActive(board.db, board, entry, row)) continue;
+    for (const block of messages) ids.add(block.id);
   }
   for (const row of board.db.prepare("SELECT e.payload FROM task_events e JOIN (SELECT task_id, MAX(id) id FROM task_events WHERE kind IN ('blocked','unblocked') GROUP BY task_id) last ON e.id=last.id JOIN tasks t ON t.id=e.task_id WHERE e.kind='blocked' AND t.status='blocked'").all()) {
     const id = json(row.payload, {})?.waiting_on; if (id) ids.add(id);

package/package.json

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