@volter/supercode-orchestrator 0.5.37 → 0.5.38

package/bin/machine-fleet.mjs

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+// One fleet reading for a synchronous board process: each named machine's panes and the harness session under each live
+// pane, every machine read at once through its own door, each bounded by its own deadline. Prints one row per machine:
+// { machine, panes, activities } when its door answered, { machine, error, code } when it did not.
+import { openMachine } from '@volter/teams/machine-door';
+import { StreamRpc, harnessTransport } from '@volter/teams/client';
+import { SupercodeHarnessClient } from '@volter/supercode-harness-sdk';
+let input = ''; for await (const chunk of process.stdin) input += chunk;
+const { machines, deadlineMs } = JSON.parse(input);
+const within = (promise, ms) => Promise.race([promise, new Promise((_, reject) => setTimeout(() => reject(Object.assign(new Error(`no answer within ${ms} ms`), { code: 'timeout' })), ms))]);
+async function read({ name, at }) {
+  let channel;
+  try {
+    channel = await openMachine({ machine: at });
+    const panes = await new StreamRpc(await channel.open('node')).call('harness.v1.panes.list', {});
+    const live = (Array.isArray(panes) ? panes : []).filter((pane) => !pane.dead && pane.pid);
+    let activities = [];
+    if (live.length) {
+      const client = new SupercodeHarnessClient({ transport: harnessTransport(channel) });
+      try { await client.start?.(); activities = (await client.request('harness.v1.sessions.activity_under', { pids: live.map((pane) => pane.pid) }))?.activities ?? []; }
+      finally { await client.close?.(); }
+    }
+    return { machine: name, panes, activities };
+  } finally { channel?.close(); }
+}
+const rows = await Promise.all(machines.map((machine) => within(read(machine), deadlineMs)
+  .catch((error) => ({ machine: machine.name, error: String(error?.message ?? error).slice(0, 300), code: error?.code ?? 'unavailable' }))));
+process.stdout.write(`${JSON.stringify(rows)}\n`);
+process.exit(0);

package/board/cli.mjs

@@ -1440,7 +1440,7 @@ async function serve(root, args = {}) {
   const running = installed();
   log(`dispatching the boards of ${root} from ${localMachine()} (orchestrator ${running ?? 'unknown'})`);
   events = watchBoard({ root, binary: supercodeBin(), env: commandEnv(), log });
-  log('dispatch wakes on board writes, document edits, board mail and session catalogue events; interval is a safety sweep');
+  log('dispatch wakes on board writes, document edits and board mail; the interval sweep reads each machine\'s own door');
   const stuck = {};
   const warned = {};
   let pausedSaid = false;

package/board/dispatch.mjs

@@ -16,11 +16,11 @@
 // subscriber's cursor moves only after its notice was delivered, so two dispatchers over one board never both
 // launch and a crash between the two steps is answered by the next tick.
 import { monitorsRuns, failedObservation, surfaceIncident, auditEndedRuns, originOf } from './incidents.mjs';
-import { readEventFleet } from './event-fleet.mjs';
-let eventFleetRoot = null;
+import { readMachineFleet } from './machine-fleet.mjs';
+let fleetRoot = null;
 import { inspectCompletionEvidence, noCodeChange, openReviewPullRequests, reviewDue, withCompletionEvidence, reviewCandidate, workflowRevision, retainWorkflowTick } from './ci.mjs';
 import { runtimeDoor } from './runtime-door.mjs';
-import { agentScope, localCardAgent, localReaderContext, localAgentSessions, synchronizeLocalAgents, runBudgetRefusal, runsAwaitingUsage, recordRunUsage, agentPreamble, agentEnvironment, recordAgentRun, pendingAgentRuns, synchronizeAgentRun, abandonAgentRun,agentProfileMismatch,activeAgentAssignments,finishAgentAssignment,synchronizeAgentEnds, agentRunForSession } from '../agents.mjs';
+import { agentScope, localCardAgent, localReaderContext, localAgentSessions, synchronizeLocalAgents, runBudgetRefusal, runsAwaitingUsage, recordRunUsage, agentPreamble, agentEnvironment, recordAgentRun, pendingAgentRuns, synchronizeAgentRun, abandonAgentRun,activeAgentAssignments,finishAgentAssignment,synchronizeAgentEnds, agentRunForSession } from '../agents.mjs';
 import { materializeAgentHome } from '../agent-home.mjs';
 import { memorySnapshotSync } from '../hermes-cli.mjs';
 import { createRequire } from 'node:module';
@@ -115,9 +115,22 @@ export function callerSession() {
   return claude;
 }
 
-export function observeFleet(root = eventFleetRoot) {
-  const fleet = readEventFleet(root);
-  presenceReading = { known: fleet.presenceKnown === true, online: new Set([localMachine(), ...fleet.online]) };
+/** The fleet as the home's machines answer for themselves (machine-fleet.mjs): this machine, and every machine an open
+ * card of the home names or one of its notice subscribers is on. */
+export function observeFleet(root = fleetRoot) {
+  const machines = new Set();
+  for (const slug of root ? listBoards(root) : []) {
+    try {
+      const b = openBoard(root, slug);
+      try {
+        const live = "t.status NOT IN ('done', 'cancelled', 'archived') AND NOT COALESCE(c.archived, 0)";
+        for (const { machine } of b.db.prepare(`SELECT DISTINCT c.machine FROM supercode_cards c JOIN tasks t ON t.id = c.task_id WHERE c.machine IS NOT NULL AND c.machine != '' AND ${live}`).all()) machines.add(normalMachine(machine));
+        for (const { chat_id: address } of b.db.prepare(`SELECT DISTINCT s.chat_id FROM kanban_notify_subs s JOIN tasks t ON t.id = s.task_id JOIN supercode_cards c ON c.task_id = t.id WHERE s.platform = 'supercode' AND s.chat_id LIKE 'sc:%' AND ${live}`).all()) machines.add(normalMachine(address.split(':')[1]));
+      } finally { b.close(); }
+    } catch { /* its own tick reports it */ }
+  }
+  const fleet = readMachineFleet(machines, localMachine());
+  presenceReading = { known: fleet.presenceKnown === true, online: new Set([localMachine(), ...fleet.online]), unknown: fleet.unknown ?? new Set() };
   notePresence(presenceReading);
   return fleet;
 }
@@ -139,24 +152,27 @@ const adoptedOnly = (s) => s?.mode === 'adopt' && !s.launch_key && s.surface !==
 const addressOf = (s) => s?.address ?? (s?.session_id && s.machine ? `sc:${s.machine}:${s.harness ?? 'claude-code'}:${s.session_id}` : null);
 const pause = (ms) => Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
 
-// A run Teams never published (one outside a synced root, a scratch workspace's) is read on its own machine: a
-// headless worker by its pid, a pane by that machine's pane list. Null only when the machine cannot answer.
+// A session in a live pane of its machine is the fleet's reading; any other run is read on its own machine: a headless
+// worker by its pid, a pane by that machine's pane list, a session in no pane (an adopted native one) by that machine's
+// harness discovery. Null only when the machine cannot answer.
 const sessionAlive = (fleet, session) => fleet.native?.has(addressOf(session)) ? fleet.native.get(addressOf(session)).alive : unpublishedAlive(session);
+/** A subscriber's address as the session it names, for sessionAlive (its machine, harness and native id). */
+const sessionAt = (address) => { const m = /^sc:([^:]+):([^:]+):(.+)$/.exec(String(address)); return m && HARNESSES[m[2]] ? { address, machine: normalMachine(m[1]), harness: m[2], session_id: m[3] } : null; };
+const subscriberAlive = (fleet, address) => fleet.alive.has(address) || (sessionAt(address) ? sessionAlive(fleet, sessionAt(address)) === true : false);
 const paneLists = new Map();
-// A run the agent sync holds names only its machine and native session (`harness:id`), never a pane or pid. Teams'
-// fleet answers for a session it published; one it never published (a gateway worker in its profile's directory,
-// outside every synced root) is read through its machine's native discovery, as a native close reads it.
+// A run the agent sync holds names only its machine and native session (`harness:id`), never a pane or pid.
 function syncRowAlive(fleet, row) {
   const machine = row.machine || localMachine(), at = row.session_ref.indexOf(':');
-  const session = { machine, harness: row.session_ref.slice(0, at), session_id: row.session_ref.slice(at + 1), address: `sc:${machine}:${row.session_ref}` };
-  const alive = sessionAlive(fleet, session);
-  if (alive !== null) return alive;
-  try { return nativeReading(nativeSessions(machine, session.harness), session).alive; } catch { return null; }
+  return sessionAlive(fleet, { machine, harness: row.session_ref.slice(0, at), session_id: row.session_ref.slice(at + 1), address: `sc:${machine}:${row.session_ref}` });
 }
 function unpublishedAlive(session) {
   if (!session) return null;
   if (session.surface === 'headless' && session.pid) return pidAlive(session.pid);
-  if (!session.pane || !session.machine) return null;
+  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; }
+  }
   let entry = paneLists.get(session.machine);
   if (!entry || Date.now() - entry.at > 5000) {
     const r = doorOn(session.machine, 'harness.v1.panes.list', {}, { timeout: 60_000 });
@@ -177,12 +193,14 @@ function nativeSessions(machine, harness) {
   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) {
   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: 120_000 })
-    : sc(['discover', '--on', machine, '--harness', harness, '--limit', '2000'], { timeout: 120_000 });
+    ? 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 });
   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;
@@ -256,8 +274,9 @@ export function lanesOf(profiles = {}) {
   return out;
 }
 
-// The latest presence reading (observeFleet). A machine it reads as offline is not asked: each remote call would
-// wait out its timeout, and one offline machine held every close and launch on this one.
+// The latest presence reading (observeFleet). A machine that did not answer it (offline, or unread this round) is not
+// asked again until the next reading: each remote call would wait out its timeout, and one silent machine held every
+// close and launch on this one. Its door answers `machine_offline`, which every caller tries again next round.
 let presenceReading = null;
 const offlineMachine = (machine) => {
   const m = normalMachine(machine ?? localMachine());
@@ -265,7 +284,7 @@ const offlineMachine = (machine) => {
 };
 /** A machine's public door (`harness.v1.*`), answered at once when the machine reads as offline. */
 const doorOn = (machine, method, params, options) => offlineMachine(machine)
-  ? { code: 1, stdout: '', stderr: `machine ${normalMachine(machine)} is offline` }
+  ? { code: 1, stdout: '', stderr: JSON.stringify({ code: 'machine_offline', message: `machine ${normalMachine(machine)} did not answer the fleet reading` }) }
   : runtimeDoor(normalMachine(machine ?? localMachine()) === localMachine() ? null : machine, method, params, options);
 const unavailable = message => Object.assign(new Error(message), { launchDeferred: true });
 
@@ -329,11 +348,11 @@ function supervise(board, fleet, settings, report, entry, effects) {
         } else extendClaim(db, id, { ttl: settings.ttl, reason: 'launch_receipt_pending' });
         return;
       }
-      // Availability is the same retained linked/unlinked feed subscribers hear.
-      // A failed stream is unknown, not evidence that every remote machine left.
+      // Availability is the machine's own door (observeFleet). A machine whose door did not answer is unknown, not
+      // evidence that it left: its run is kept. Only a relay's positive answer that it is not linked reads as offline.
       if (session?.session_id && session.surface !== 'headless') {
         const reachable = fleet.online.has(session.machine);
-        if (!reachable && !fleet.presenceKnown) return;
+        if (!reachable && (!fleet.presenceKnown || fleet.unknown?.has(session.machine))) return;
         if (!reachable) {
           const next = {...session, offline_since: session.offline_since ?? t};
           setRunSession(db,runRow.id,next);
@@ -736,7 +755,7 @@ export function launchRun(board, entry, id, lane, fleet, settings) {
 export async function startCard(board, id, { roles = ['manager'], lanes, settings } = {}) {
   // the board's own published fleet projection, as a tick reads it: a manager's or creator's start that continues the
   // slot's session checks that session through it
-  eventFleetRoot = board.root;
+  fleetRoot = board.root;
   const entry = await loadWorkflow(board.root);
   const fleet = observeFleet();
   const before = getTaskNow(board, id), checked = checkWorkspace(board, before);
@@ -933,8 +952,11 @@ function observeIdle(board, fleet, settings, report, entry, effects) {
       const runRow = currentRun(db, id);
       const session = runRow?.metadata?.supercode;
       if (!session?.session_id || !['pane', 'native'].includes(session.surface) || session.offline_since != null) return;
-      if (session.surface === 'native' && fleet.native?.get(addressOf(session))?.alive !== true) return;
-      const live = fleet.sessions.find((x) => x.address === addressOf(session));
+      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 */ }
+      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);
       const lastAt = Math.floor(Number(lastAtMs) / 1000);
@@ -989,7 +1011,7 @@ function observeIdle(board, fleet, settings, report, entry, effects) {
         const observation = retain('dispatched', { turns_after: Number(stored?.goal_turns ?? 0), nudge_queued: r.effects.some(e => e.kind === 'send_to_actor'), run_ended: after?.id !== runRow.id });
         event(db, id, 'session_idle_observed', observation, runRow.id);
         if (after?.id === runRow.id) setRunSession(db, runRow.id, { goal_nudged_at: observedAt });
-        report.notified.push([id, 'session_idle', live.address]);
+        report.notified.push([id, 'session_idle', addressOf(session)]);
       } catch (error) {
         retain('dispatch_failed', { error: String(error.message).slice(-200) });
         report.failed.push([id, `session_idle: ${String(error.message).slice(-200)}`]);
@@ -1121,7 +1143,7 @@ function launcherCheck(db, task, lane, fleet) {
   if (!task.machine) return 'the card names no machine; a pane session runs on the machine its card names';
   const machine = normalMachine(task.machine);
   if (!fleet.ok) return `supercode could not read the fleet: ${fleet.error}`;
-  if (machine !== localMachine() && !fleet.presenceKnown) return 'machine event stream unavailable; launch waits for a current availability reading';
+  if (fleet.unknown?.has(machine)) return `machine ${machine}'s door did not answer; the card starts when it does`;
   if (!fleet.online.has(machine)) return `machine ${machine} is offline; the card starts when it is back`;
   // a card on this machine gets its workspace made here (scratch, dir or worktree, as Hermes makes it); another
   // machine's card names its directory there
@@ -1266,7 +1288,7 @@ function bindLaunch(board, row, session, pane, sid) {
 
 /** A fast worker can reach its first board door before open's reply. Bind only the daemon's keyed pane. */
 export function reconcileCallerLaunch(board, sid) {
-  eventFleetRoot = board.root;
+  fleetRoot = board.root;
   if (view(board, (db) => db.prepare(`SELECT 1 FROM task_runs r JOIN tasks t ON t.current_run_id=r.id
     WHERE json_extract(r.metadata, '$.supercode.session_id')=? AND COALESCE(json_extract(r.metadata, '$.supercode.launch_pending'),0)=0`).get(sid))) return;
   const rows = view(board, (db) => db.prepare(`SELECT r.id, r.task_id, r.metadata FROM task_runs r
@@ -1299,15 +1321,6 @@ function reconcileLaunches(board, fleet, report, entry, effects, settings, lanes
   for(const row of agentRuns){
     const session=json(row.metadata,{})?.supercode;
     if(!session?.session_id||!session.agent_org)continue;
-    const observation=fleet.sessions?.find(item=>item.address===addressOf(session))?.identity;
-    if(observation?.agent?.id===session.agent_id&&session.agent_profile_revision!==observation.revision){
-      const mismatch=agentProfileMismatch(session.agent_profile_intent,observation.resolved);
-      tx(board,db=>{
-        // Rule 4: a run whose recorded profile differs from its agent's intent is shown and not counted.
-        setRunSession(db,row.id,{agent_profile_recorded:observation.resolved,agent_profile_revision:observation.revision,agent_profile_mismatch:mismatch,counted:!mismatch.differences.length});
-        event(db,row.task_id,mismatch.differences.length?'agent_profile_drift':'agent_profile_recorded',{agent:session.agent_id,session:session.session_id,comparison:mismatch},row.id);
-      });
-    }
     const ref=`${session.harness}:${session.session_id}`;
     // An ended run whose session the agent store already holds, published, for another agent lost that claim when it
     // ran: no round can change an ended run or a published owner, so the disagreement is history. It is said once on
@@ -1327,7 +1340,8 @@ function reconcileLaunches(board, fleet, report, entry, effects, settings, lanes
     orgs.set(session.agent_org,session.agent_context);
   }
   // Identities minted while Teams was absent are declared under their ids before their sessions are joined.
-  const context=process.env.SUPERCODE_CONTEXT,scope=agentScope(context);
+  const context=process.env.SUPERCODE_CONTEXT;
+  let scope;try{scope=agentScope(context);}catch(error){scope={offline:true};report.failed.push(['agents',`agent declarations wait: ${error.message}`]);}
   if(!scope.offline){
     orgs.set(scope.org,orgs.get(scope.org)??context);
     for(const pending of synchronizeLocalAgents({root:board.root,profiles:entry.profiles,context}))report.queued.push([pending.agent,`agent declaration pending: ${pending.error}`]);
@@ -1436,7 +1450,8 @@ function launchPane(board, task, runId, lane, fleet, { input = null, slot = 'wor
   if (lane.harness === 'codex' && lane.reasoning_effort) tail.push('-c', `model_reasoning_effort=${JSON.stringify(lane.reasoning_effort)}`);
   const harness = HARNESSES[lane.harness] ? lane.harness : 'claude-code';
   const how = HARNESSES[harness];
-  const base = ['open', '--new', how.program, '--detach', `--window=${window}`, '--on', task.machine, '--cwd', task.workspace_path, '--env', 'SUPERCODE_BOARD_PROCESS_GUARD=1',
+  // A card on this machine opens through this machine's own daemon; only another machine is reached with `--on`.
+  const base = ['open', '--new', how.program, '--detach', `--window=${window}`, ...(machine === localMachine() ? [] : ['--on', task.machine]), '--cwd', task.workspace_path, '--env', 'SUPERCODE_BOARD_PROCESS_GUARD=1',
     ...Object.entries(meta.agent_env??{}).flatMap(([key,value])=>['--env',`${key}=${value}`])];
   // the slot's last session: kept when live, resumed when lost, never another slot's (a reviewer's is its own)
   // a close its session's own command asked for is carried out first, so its pane is gone before the slot's next
@@ -1497,10 +1512,14 @@ function launchPane(board, task, runId, lane, fleet, { input = null, slot = 'wor
   };
   let session = null;
   let replaced = null;
-  if (prev?.surface === 'native' && !prev.pane && !prev.close_confirmed_at) {
+  // A session in no pane is read on its machine before anything replaces it. One the board released (an adopted
+  // 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);
     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`);
     if (reading.alive && (prev.closed_at || prev.close_requested || prev.forgotten)) throw unavailable(`native session ${addressOf(prev)} is still live; its close must finish before replacement`);
   }
   if (prev?.forgotten) {
@@ -1750,25 +1769,13 @@ function adoptionOpenTo(db, id, request, open) {
   return Boolean(claim) && claim.request === request && claim.lock === claimer();
 }
 
-/**
- * A session on this machine that Teams never published (one outside every synced root: a profile's own directory) is
- * found through this machine's own doors: its panes, and the native session each pane's process runs. Only a full
- * address is looked up here; liveness is still verified below as for any other session.
- */
-function localListing(who) {
+/** A session in no pane (a native process its machine's harness discovery holds as running), by its full address. */
+function nativeListing(who) {
   const m = /^sc:([^:]+):([^:]+):(.+)$/.exec(String(who));
-  if (!m || normalMachine(m[1]) !== localMachine()) return null;
-  const [, , harness, sessionId] = m;
-  const listed = runtimeDoor(null, 'harness.v1.panes.list', {}, { timeout: 60_000 });
-  const panes = (listed.code === 0 ? json(listed.stdout.trim(), []) : []) ?? [];
-  const live = panes.filter((p) => !p.dead && p.pid);
-  if (!live.length) return null;
-  const r = runtimeDoor(null, 'harness.v1.sessions.activity_under', { pids: live.map((p) => p.pid) }, { timeout: 30_000 });
-  const row = (r.code === 0 ? json(r.stdout.trim(), {})?.activities ?? [] : []).find((a) => a.activity?.session_id === sessionId && (a.activity?.harness ?? harness) === harness);
-  // Not found in a pane of this machine: not listed, so a session opened moments ago is looked for again next tick.
-  const pane = row ? live.find((p) => p.pid === row.pid)?.pane ?? null : null;
-  if (!pane) return null;
-  return { address: `sc:${localMachine()}:${harness}:${sessionId}`, machine: localMachine(), harness, session_id: sessionId, pane, name: null };
+  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; }
+  catch { return null; }
 }
 
 /** The verb an adoption with no current run fires: the workflow's own `adopt` where it declares one, else its dispatch start. */
@@ -1790,7 +1797,7 @@ function adoptedRole(db, board, entry, task, run) {
 function adoptSession(board, id, who, { request = null, open = request, progress = {}, workspace = null, ttl, assignee = null, role = null, fleet = null, lanes = null } = {}) {
   fleet ??= observeFleet();
   if (!fleet.ok) throw new Error(`supercode could not read the fleet: ${fleet.error}`);
-  const found = fleet.sessions.find((s) => s.address === who || s.address.endsWith(`:${who}`) || s.name === who) ?? localListing(who);
+  const found = fleet.sessions.find((s) => s.address === who || s.address.endsWith(`:${who}`) || s.name === who) ?? nativeListing(who);
   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`);
@@ -2105,7 +2112,7 @@ function endWorkerSubscriptions(board, fleet, report, natively = new Map()) {
     const ended = new Map();
     for (const row of db.prepare("SELECT task_id, chat_id, thread_id FROM kanban_notify_subs WHERE platform = 'supercode' AND json_extract(delivery_metadata, '$.role') = 'worker'").all()) {
       const address = row.chat_id, record = latest.get(address);
-      if (!record || record.session.released || held.has(address) || (fleet.ok && fleet.alive.has(address))) continue;
+      if (!record || record.session.released || held.has(address) || (fleet.ok && subscriberAlive(fleet, address))) continue;
       const evidence = record.session.close_confirmed_at ? { by: 'board_close', run: record.run, closed_at: record.session.close_confirmed_at } : natively.get(address);
       if (!evidence || !remove.run(row.task_id, address, row.thread_id).changes) continue;
       if (!ended.has(address)) ended.set(address, { record, evidence, cards: [] });
@@ -2132,7 +2139,7 @@ async function notify(board, fleet, report, entry) {
     // a session the fleet does not list this tick is told next tick: one reading is not a loss (a loaded box drops
     // sessions from a read, and a dropped subscription never came back), and a session that is replaced on its card
     // has its subscription moved when the new one starts
-    if (role !== 'creator' && fleet.ok && !fleet.alive.has(sub.chat_id)) return;
+    if (role !== 'creator' && fleet.ok && !subscriberAlive(fleet, sub.chat_id)) return;
     const kinds = heardBy(entry, role);
     if (!kinds.length) return;
     const events = board.db.prepare(`SELECT id, kind, payload, created_at, run_id FROM task_events WHERE task_id = ? AND id > ? AND kind IN (${kinds.map(() => '?').join(', ')}) ORDER BY id`)
@@ -2459,7 +2466,7 @@ const CORRUPT = /malformed|not a database|corrupt|disk image/i;
 
 /** What a tick would start on each board of the home, planned through the workflow's `dispatch`, writing nothing. */
 export async function plan({ root, lanes, settings, slugs = null, params = {} }) {
-  eventFleetRoot = root;
+  fleetRoot = root;
   const loaded = await loadWorkflow(root, { fresh: true });
   const entry = { ...loaded, params: { ...loaded.params, ...params } };
   const fleet = Object.values(lanes).some((l) => l.surface === 'pane') ? observeFleet() : { ok: false, alive: new Set(), online: new Set(), sessions: [], error: 'no pane lanes' };
@@ -2569,10 +2576,10 @@ function capMax(cap, group, entry, lanes) {
  * effects in `runEffects` (send_to_actor, session_notice, merge_reviewed, declare_card_agent), board mail,
  * subscription notices (a doubled notice_delivered has been seen live), deferred-launch retries (two panes),
  * launch-receipt work (cancelUnissuedLaunch, bindLaunch), the Teams agent-run sync in reconcileLaunches, and
- * board-only writes that do not re-check (a doubled agent_profile_recorded). Answers one report per board.
+ * board-only writes that do not re-check. Answers one report per board.
  */
 export async function tick({ root, lanes, settings, only = null, slugs = null, dispatch = true, params = {}, deploymentReceipt = false }) {
-  eventFleetRoot = root;
+  fleetRoot = root;
   // 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/engine.mjs

@@ -901,7 +901,7 @@ export function diagnose(db, task, { failureLimit = DEFAULT_FAILURE_LIMIT, stran
   }
   if (task.status === 'running' && fleet?.ok) {
     const session = lastSession(db, task.id);
-    if (session?.machine && !fleet.online.has(session.machine)) out.push({ kind: 'machine_offline', severity: 'warning', title: `its machine ${session.machine} is offline`, data: { machine: session.machine }, actions: [] });
+    if (session?.machine && !fleet.online.has(session.machine) && !fleet.unknown?.has(session.machine)) out.push({ kind: 'machine_offline', severity: 'warning', title: `its machine ${session.machine} is offline`, data: { machine: session.machine }, actions: [] });
   }
   const order = ['critical', 'error', 'warning'];
   return out.sort((a, b) => order.indexOf(a.severity) - order.indexOf(b.severity));

package/board/machine-fleet.mjs

@@ -0,0 +1,49 @@
+// The fleet as each machine the board works on answers for itself: its panes (`harness.v1.panes.list`) and the harness
+// session beneath each live pane's process (`harness.v1.sessions.activity_under`). This is the reading the machine's
+// connector publishes to Teams, taken at its source. Teams' session feed is for viewers; dispatch never waits on it
+// (D137, D138).
+//
+// Every machine is read at once, each within DEADLINE_MS (bin/machine-fleet.mjs), so one hung machine or relay costs a
+// reading that long, not the sum of them. A machine that answered is `online`. A remote machine that did not is
+// `unknown` (its runs are kept, as an unread machine's always were), unless the relay positively answered that it is
+// 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';
+
+const entry = fileURLToPath(new URL('../bin/machine-fleet.mjs', import.meta.url));
+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 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 });
+  let rows = null;
+  try { rows = JSON.parse(String(reply.stdout).trim().split('\n').pop()); } catch { /* no reading */ }
+  const online = new Set(), unknown = new Set(), alive = new Set(), native = new Map(), sessions = [];
+  if (!Array.isArray(rows)) {
+    const error = String(reply.stderr || reply.error?.message || 'no answer').trim().slice(-300);
+    return { ok: false, presenceKnown: false, online, unknown: new Set(names), alive, native, sessions, error: `the fleet reading did not answer: ${error}` };
+  }
+  let localError = null;
+  for (const row of rows) {
+    if (row.error) {
+      if (row.machine === local) localError = row.error;
+      else if (row.code !== 'machine_offline') unknown.add(row.machine);
+      continue;
+    }
+    online.add(row.machine);
+    const live = (row.panes ?? []).filter((pane) => !pane.dead && pane.pid);
+    for (const { pid, activity } of row.activities ?? []) {
+      const pane = live.find((item) => item.pid === pid);
+      if (!pane || !activity?.session_id || !activity.harness) continue;
+      const address = `sc:${row.machine}:${activity.harness}:${activity.session_id}`, running = activity.presence === 'running';
+      native.set(address, { alive: running ? true : null, states: [running ? true : null] });
+      if (running) alive.add(address);
+      sessions.push({ address, machine: row.machine, harness: activity.harness, session_id: activity.session_id, pane: pane.pane, name: pane.title ?? pane.label ?? null,
+        state: running ? 'running' : 'unknown', turn: activity.turn ?? null, native_state: activity.evidence?.native_state ?? null });
+    }
+  }
+  const ok = online.has(local);
+  return { ok, presenceKnown: ok, online, unknown, alive, native, sessions, error: ok ? null : `machine ${local}'s door did not answer: ${localError ?? 'no row'}` };
+}

package/board/wake.mjs

@@ -3,7 +3,6 @@
 import { watch, existsSync, readFileSync, readdirSync, writeFileSync, renameSync, unlinkSync, realpathSync } from 'node:fs';
 import { basename, dirname, join, resolve } from 'node:path';
 import { randomUUID } from 'node:crypto';
-import { followFleet } from './event-fleet.mjs';
 import { boardEventRelay } from './event-relay.mjs';
 import { fileURLToPath } from 'node:url';
 
@@ -27,7 +26,7 @@ export function watchBoard({ root, binary, env, log = () => {} }) {
     if (!pending) pending = { at, sources: new Set() };
     pending.at = Math.min(pending.at, at);
     pending.sources.add(source);
-    if (!source.startsWith('session-events')) void relay?.wake();
+    void relay?.wake();
     waiter?.();
   };
   const directory = (path, key, accept) => {
@@ -94,7 +93,6 @@ export function watchBoard({ root, binary, env, log = () => {} }) {
   refresh();
   const supercodeHome = env.SUPERCODE_HOME || (env.XDG_CONFIG_HOME ? join(env.XDG_CONFIG_HOME,'supercode') : join(env.HOME ?? '', '.config','supercode'));
   relay = boardEventRelay({root,supercodeHome,log});
-  const fleet = followFleet({root,supercodeHome,wake,log});
   void relay.wake();
   return {
     refresh,
@@ -111,7 +109,7 @@ export function watchBoard({ root, binary, env, log = () => {} }) {
       return result ? { at: result.at, sources: [...result.sources] } : null;
     },
     close() {
-      closed = true; waiter?.(); fleet.close(); relay.close();
+      closed = true; waiter?.(); relay.close();
       for (const handle of watchers.values()) handle.close();
       watchers.clear();
     },

package/package.json

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

package/board/event-fleet.mjs

@@ -1,66 +0,0 @@
-// A projection of retained Teams events. Dispatch reads this projection, never a periodically fetched catalogue.
-import { readFileSync, writeFileSync, renameSync } from 'node:fs';
-import { join } from 'node:path';
-import { randomUUID } from 'node:crypto';
-import { eventClient, retryAfterMs } from '@volter/teams/event-client';
-const pathOf=root=>join(root,'.session-events.json');
-const normalize=value=>String(value??'').toLowerCase().replace(/[^a-z0-9-]/g,'-').replace(/-+/g,'-').replace(/^-|-$/g,'');
-const wait=(signal,ms)=>new Promise(resolve=>{const timer=setTimeout(resolve,ms);signal.addEventListener('abort',()=>{clearTimeout(timer);resolve();},{once:true});});
-
-export function followFleet({root,context,supercodeHome,wake,log}){
-  const abort=new AbortController();let resources={},cursor=null,connected=false,snapshot=null;
-  const persist=()=>{
-    const path=pathOf(root),temporary=`${path}.${randomUUID()}.tmp`;
-    writeFileSync(temporary,JSON.stringify({pid:process.pid,connected,cursor,resources}),{mode:0o600});renameSync(temporary,path);
-  };
-  const apply=(target,frame)=>{
-    const event=frame.data;if(!event||!['session','machine'].includes(event.resource?.kind))return false;
-    const key=`${event.resource.kind}:${event.resource.id}`,old=target[key];
-    if(old&&old.sequence>=frame.sequence)return false;
-    target[key]={sequence:frame.sequence,data:event.data};return true;
-  };
-  void(async()=>{
-    // Refused for load, the follower waits out the server's retry_after, doubling while it is refused (to 5 min), and
-    // keeps its cursor: asking every 5 s spent the slot it waited for on the next refusal.
-    let refused=0;
-    while(!abort.signal.aborted){
-      let pause=5000;
-      try{
-        const {team}=eventClient({context,supercodeHome});
-        // Every connection begins with a complete, ACL-filtered snapshot. A process restart cannot trust an old cache.
-        for await(const frame of team.events.follow({kinds:['session.started','session.ended','session.changed','resource.changed']}, {signal:abort.signal,after:cursor,caller:'dispatch session-events'})){
-          if(frame.type==='snapshot_begin'){snapshot={};connected=false;persist();}
-          else if(frame.type==='snapshot_item')apply(snapshot??resources,frame);
-          else if(frame.type==='snapshot_end'){resources=snapshot??resources;snapshot=null;cursor=frame.cursor;connected=true;refused=0;persist();wake('session-events-snapshot');}
-          else if(frame.type==='event'){const changed=apply(resources,frame);cursor=frame.cursor;connected=true;persist();if(changed)wake('session-events');}
-          else if(frame.type==='checkpoint'){const recovered=!connected;cursor=frame.cursor;connected=true;refused=0;persist();if(recovered)wake('session-events-reconnected');}
-          else if(frame.terminal){cursor=null;connected=false;persist();wake('session-events-unavailable');break;}
-        }
-      }catch(error){
-        const asked=retryAfterMs(error);if(asked){pause=Math.min(300000,asked*2**refused);refused++;}
-        if(!abort.signal.aborted)log(`dispatch session events unavailable: ${error.code??error.message}${asked?` (retrying in ${Math.round(pause/1000)} s)`:''}`);if(error.status===409)cursor=null;
-      }
-      connected=false;persist();wake('session-events-unavailable');if(!abort.signal.aborted)await wait(abort.signal,pause);
-    }
-  })();
-  return {close(){abort.abort();connected=false;persist();}};
-}
-
-export function readEventFleet(root){
-  let cache;try{cache=JSON.parse(readFileSync(pathOf(root),'utf8'));process.kill(cache.pid,0);}catch{return {ok:false,alive:new Set(),online:new Set(),sessions:[],native:new Map(),error:'published session events unavailable',presenceKnown:false};}
-  const machines=new Map(),online=new Set();
-  for(const [key,value] of Object.entries(cache.resources??{}))if(key.startsWith('machine:')){machines.set(value.data.id,normalize(value.data.name));if(cache.connected&&value.data.linked)online.add(normalize(value.data.name));}
-  const sessions=[],native=new Map(),alive=new Set();
-  for(const [key,value] of Object.entries(cache.resources??{}))if(key.startsWith('session:')){
-    for(const binding of value.data.bindings??[]){
-      const machine=machines.get(binding.machine_id);if(!machine||!binding.harness||!binding.native_session_id)continue;
-      const address=`sc:${machine}:${binding.harness}:${binding.native_session_id}`;
-      const known=cache.connected&&online.has(machine),state=known?(binding.state==='running'?true:binding.state==='stopped'?false:null):null;
-      const previous=native.get(address),states=[...(previous?.states??[]),state];
-      const combined=states.includes(true)?true:states.includes(null)?null:states.every(value=>value===false)?false:null;
-      native.set(address,{alive:combined,states});if(combined===true)alive.add(address);
-      sessions.push({address,machine,harness:binding.harness,session_id:binding.native_session_id,pane:binding.pane??null,name:binding.name??null,state:binding.state,turn:binding.turn??null,native_state:binding.evidence?.native_state??null,identity:value.data.agent_identity??null});
-    }
-  }
-  return {ok:!!cache.connected,presenceKnown:!!cache.connected,online,alive,native,sessions,error:cache.connected?null:'published session events disconnected'};
-}