@volter/supercode-orchestrator 0.4.118 → 0.4.119

package/board/dispatch.mjs

@@ -116,11 +116,13 @@ export function observeFleet() {
   const list = sc(['message', 'list', '--json']);
   const sessions = list.code === 0 ? json(list.stdout.trim(), null) : null;
   if (!Array.isArray(sessions)) return { ok: false, alive: new Set(), online: new Set(), error: `message list: ${(list.stderr || list.stdout).trim().slice(-300)}` };
-  const machines = sc(['teams', 'machines', 'list', '--json']);
-  const rows = machines.code === 0 ? lastJson(machines.stdout)?.items : null;
+  const machines = sc(['teams', 'machines', 'events', '--json']);
+  const presence = machines.code === 0 ? lastJson(machines.stdout) : null;
   const online = new Set([localMachine()]);
-  for (const m of rows ?? []) if (m.enrollment === 'active' && m.connection === 'online') online.add(normalMachine(m.name));
-  return { ok: true, sessions, alive: new Set(sessions.map((s) => s.address).filter(Boolean)), online, error: rows ? null : 'teams machines list gave no answer; only this machine counts as online' };
+  for (const m of presence?.items ?? []) if (m.linked) online.add(normalMachine(m.name));
+  return { ok: true, sessions, alive: new Set(sessions.map((s) => s.address).filter(Boolean)), online,
+    presenceKnown: presence?.connected === true, machineEvents: presence,
+    error: presence?.connected ? null : 'machine event stream unavailable; retaining existing runs until availability is known' };
 }
 
 // how the launcher opens each harness a pane lane can run, and how it names the session: Claude Code is told the id
@@ -247,6 +249,30 @@ function supervise(board, fleet, settings, report, entry, effects) {
         }
       };
       const limits = limitsOf(db, board, entry, task, session);
+      // Availability is the same retained linked/unlinked feed subscribers hear.
+      // A failed stream is unknown, not evidence that every remote machine left.
+      if (session?.session_id && session.surface !== 'headless') {
+        const panes = session.pane ? observed.get(session.machine) : null;
+        const reachable = panes instanceof Set || fleet.online.has(session.machine);
+        if (!reachable && !fleet.presenceKnown) return;
+        if (!reachable) {
+          const next = {...session, offline_since: session.offline_since ?? t};
+          setRunSession(db,runRow.id,next);
+          observe('machine_offline',{machine:session.machine,seconds:t-next.offline_since},null);
+          const age = Number(entry.params.block_age_seconds ?? 3600);
+          if (t-Number(next.offline_notified_at ?? next.offline_since)>=age) {
+            setRunSession(db,runRow.id,{...currentRun(db,id)?.metadata?.supercode,offline_notified_at:t});
+            observe('machine_wait_aged',{machine:session.machine,seconds:t-next.offline_since,reason:`machine ${session.machine} has been unlinked for ${t-next.offline_since}s`},null);
+          }
+          if (getTask(db,id)?.current_run_id===runRow.id) extendClaim(db,id,{ttl:settings.ttl,reason:'machine_offline'});
+          return;
+        }
+        if (session.offline_since != null) {
+          setRunSession(db,runRow.id,{...session,offline_since:null,offline_notified_at:null});
+          observe('machine_online',{machine:session.machine,reason:'machine linked again'},null);
+          session=currentRun(db,id)?.metadata?.supercode ?? session;
+        }
+      }
       // Hermes's orphan reconciliation: a running card whose claim bookkeeping is broken, with nothing live behind it
       const paneReading = session?.pane ? observed.get(session.machine) : undefined;
       const paneLive = paneReading instanceof Set ? paneReading.has(session.pane) : null;
@@ -286,13 +312,6 @@ function supervise(board, fleet, settings, report, entry, effects) {
         const young = t - Number(session.launched_at ?? 0) < Number(limits.grace ?? settings.grace);
         const missing = !alive && machineUp && !young;
         const next = { ...session };
-        // a machine that is off the fleet: how long, for the workflow's machine_offline (the claim is kept meanwhile)
-        if (machineUp) next.offline_since = null; else next.offline_since ??= t;
-        if (!machineUp) {
-          setRunSession(db, runRow.id, next);
-          observe('machine_offline', { machine: session.machine, seconds: t - next.offline_since }, null);
-          if (getTask(db, id)?.current_run_id !== runRow.id) return; // the workflow moved it
-        }
         if (alive) { next.seen_at ??= t; next.missing_since = null; }
         if (missing) next.missing_since ??= t;
         if (missing && t - next.missing_since >= Number(limits.grace ?? settings.grace)) {
@@ -618,7 +637,7 @@ function observeIdle(board, fleet, settings, report, entry, effects) {
       if (!(entry.workflow.statuses[status]?.on?.session_idle || entry.workflow.on?.session_idle || entry.workflow.run?.on?.session_idle)) return;
       const runRow = currentRun(db, id);
       const session = runRow?.metadata?.supercode;
-      if (!session?.session_id || session.surface !== 'pane') return;
+      if (!session?.session_id || session.surface !== 'pane' || session.offline_since != null) return;
       const live = fleet.sessions.find((x) => x.address?.endsWith(`:${session.session_id}`));
       const observedAt = now();
       const lastAt = Math.floor(Number(live?.last_message_at_ms) / 1000);
@@ -727,6 +746,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.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
@@ -1438,6 +1458,7 @@ function readMailbox(board, address, report) {
     try { renameSync(path, join(box, 'cur', name)); } catch { continue; } // another reader took it
     // an answer to a question the board asked is what a card waits on (read by the card's workflow), not a verb
     if (envelope.in_reply_to) continue;
+    if (envelope.from === `sc:${localMachine()}:operator:teams-events` && json(envelope.body, {})?.machine_event) { report.mailed.push([envelope.from, 'machine_event']); continue; }
     const argv = json(envelope.body, {})?.workflow;
     let answer;
     if (!Array.isArray(argv) || !argv.length || NOT_BY_MAIL.has(argv[0])) answer = `not applied: a mailed card update is one \`supercode workflow\` verb other than ${[...NOT_BY_MAIL].join(', ')}`;
@@ -1548,6 +1569,10 @@ export async function tick({ root, lanes, settings, only = null, slugs = null, d
       // where the tick's time goes, phase by phase (ms), printed by `serve --verbose` and in `--json`
       let mark = Date.now();
       const phase = (name) => { const t = Date.now(); report.ms[name] = t - mark; mark = t; };
+      if (!fleet.machineEvents?.subscriptions?.includes(boardAddress(board.label))) {
+        const subscription = sc(['teams','machines','subscribe',boardAddress(board.label),'--json']);
+        if (subscription.code !== 0) report.failed.push(['machine_events',(subscription.stderr || subscription.stdout).trim().slice(-200)]);
+      }
       readMailbox(board, boardAddress(board.label), report); phase('mailbox');
       await refreshRelationAnswers(board); phase('answers');
       const effects = [];

package/package.json

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