@volter/supercode-orchestrator 0.5.37 → 0.5.39

package/board/engine.mjs

@@ -463,41 +463,105 @@ export async function goto(board, id, status, { roles = null, payload = {} } = {
   return { ...(await act(board, id, name, { roles, payload })), event: name };
 }
 
-/** The I/O a committed move asked for. */
-export async function runEffects(board, effects = [], { retryNotices = false } = {}) {
+// A delivery (a notice, an actor message, an agent declaration) is tried at most EFFECT_ATTEMPTS times, waiting twice as
+// long after each failed attempt (from 30 s, at most 30 min). Its last failed attempt is its terminal state: the row
+// keeps `failed_at` and the error, the card records `effect_failed` once, diagnose shows it, and nothing tries it again.
+// A board-state effect the dispatcher owns (OWNED: merging the reviewed PRs, cleaning a workspace) is never abandoned:
+// it keeps trying at the capped wait, and at EFFECT_ATTEMPTS failed attempts its card records `effect_stalled` and the
+// managers are mailed once, so a passed card whose merge keeps failing is seen, and still heals when the cause clears.
+export const EFFECT_ATTEMPTS = 6;
+const OWNED = new Set(['merge_reviewed', 'cleanup_workspace']);
+const effectWait = (attempts) => Math.min(1800, 30 * 2 ** Math.max(0, attempts - 1));
+// A delivery pass claims a row by compare-and-set on its next_at (set ahead only while the row is due) before trying it,
+// so two passes (serve's, the hosted loop's, a person's `workflow deliver`, a verb's own) never try one effect at once.
+// The claim outlasts any one attempt: each effect's I/O is bounded by its own timeouts (a send's 180 s, a merge's
+// MERGE_BUDGET plus one in-flight GitHub call), all well inside EFFECT_CLAIM.
+const EFFECT_CLAIM = 900;
+
+/**
+ * The effects a committed move asked for. Board writes the round owns (invalidating descendants, asking a session's
+ * close, stopping a local worker) are made here, in the round; everything that reaches outside the board is recorded
+ * to run after it, in the delivery pass, never inside a dispatch round.
+ */
+export function queueEffects(board, effects = []) {
+  // a board message is its own effect row (dispatch.mjs queueBoardMail), so the move's mail hint is not recorded
+  const fresh = effects.filter((e) => !e.durableId && e.kind !== 'run' && !(e.kind === 'board_message' && !e.event));
+  const now_ = fresh.filter((e) => ['invalidate_descendants', 'close_session', 'run_ended', 'stop_run'].includes(e.kind));
+  const later = fresh.filter((e) => !now_.includes(e));
+  for (const e of now_) {
+    if (e.kind === 'invalidate_descendants') tx(board, (db) => invalidateDescendants(db, board, e.id));
+    else if (e.kind === 'close_session') tx(board, (db) => requestSessionClose(db, e.id, { slot: e.slot, through: e.runId }));
+    else if (e.kind === 'run_ended') { if (e.outcome === 'reclaimed') stopWorker(board, e.runId); tx(board, (db) => requestSessionClose(db, e.id, { runId: e.runId })); }
+    else if (e.kind === 'stop_run') stopWorker(board, e.runId);
+  }
+  if (later.length) tx(board, (db) => { for (const e of later) db.prepare('INSERT INTO supercode_effects (effect) VALUES (?)').run(JSON.stringify(e)); });
+}
+
+/** The I/O a committed move asked for: the move's own `effects`, and with `pending` every recorded effect that is due. */
+export async function runEffects(board, effects = [], { pending: due = false } = {}) {
   const requested = new Set(effects.map((e) => e.durableId).filter(Boolean));
-  const pending = board.db.prepare('SELECT id, effect FROM supercode_effects ORDER BY id').all()
-    .filter((p) => retryNotices || requested.has(p.id));
-  const durable = new Set(pending.map((p) => p.id));
-  const combined = [...pending.map((p) => ({ ...json(p.effect, {}), durableId: p.id })), ...effects.filter((e) => !e.durableId || !durable.has(e.durableId))];
+  const t = now();
+  const rows = board.db.prepare('SELECT id, effect, attempts, next_at FROM supercode_effects WHERE failed_at IS NULL ORDER BY id').all()
+    .filter((p) => (requested.has(p.id) || due) && Number(p.next_at ?? 0) <= t);
+  const durable = new Set(rows.map((p) => p.id));
+  const attempts = new Map(rows.map((p) => [p.id, Number(p.attempts ?? 0)]));
+  const combined = [...rows.map((p) => ({ ...json(p.effect, {}), durableId: p.id })), ...effects.filter((e) => !e.durableId || (!durable.has(e.durableId) && !requested.has(e.durableId)))];
   combined.sort((a,b) => Number(b.kind === 'session_notice') - Number(a.kind === 'session_notice'));
+  // what this call did, for its caller's report: effect ids done, tried and kept, and skipped as another's claim
+  const did = { done: [], kept: [], claimed_elsewhere: [] };
   for (const e of combined) {
-    if (e.kind === 'session_notice') {
-      const { sessionNotice } = await import('./dispatch.mjs');
-      if (!await sessionNotice(board, e)) continue;
-    }
-    else if (e.kind === 'cleanup_workspace') cleanupWorkspace(board, e.id);
-    else if (e.kind === 'declare_card_agent') {
-      const {declareCardAgentEffect}=await import('./agent-declarations.mjs');
-      if(!declareCardAgentEffect(board,e))continue;
-    }
-    else if (e.kind === 'board_message') {
-      const { sendBoardMessages } = await import('./dispatch.mjs');
-      await sendBoardMessages(board, { undelivered: [] }, e.id);
-    }
-    else if (e.kind === 'merge_reviewed') {
-      const { mergeReviewed } = await import('./dispatch.mjs');
-      if (await mergeReviewed(board, e) === false) continue;
-    }
-    else if (e.kind === 'invalidate_descendants') tx(board, (db) => invalidateDescendants(db, board, e.id));
-    else if (e.kind === 'stop_run') stopWorker(board, e.runId);
-    else if (e.kind === 'close_session' || e.kind === 'send_to_actor' || e.kind === 'run_ended') {
-      if (e.kind === 'run_ended' && e.outcome === 'reclaimed') stopWorker(board, e.runId);
-      const { sessionEffect } = await import('./dispatch.mjs');
-      if (await sessionEffect(board, e) === false) continue;
-    }
-    if (e.durableId) tx(board, (db) => db.prepare('DELETE FROM supercode_effects WHERE id = ?').run(e.durableId));
+    // the claim: taken only while the row is due and not failed; another pass holding it answers no change
+    if (e.durableId && !tx(board, (db) => db.prepare('UPDATE supercode_effects SET next_at = ? WHERE id = ? AND failed_at IS NULL AND next_at <= ?').run(now() + EFFECT_CLAIM, e.durableId, now()).changes)) { did.claimed_elsewhere.push(e.durableId); continue; }
+    let done, error = null;
+    try { done = await runEffect(board, e); } catch (thrown) { done = false; error = String(thrown?.message ?? thrown).slice(0, 500); }
+    if (!e.durableId) continue;
+    // a mail inside its batch window is not an attempt: it is looked at again in a few seconds
+    if (done === 'wait') { tx(board, (db) => db.prepare('UPDATE supercode_effects SET next_at = ? WHERE id = ?').run(now() + 5, e.durableId)); did.kept.push(e.durableId); continue; }
+    if (done) { tx(board, (db) => db.prepare('DELETE FROM supercode_effects WHERE id = ?').run(e.durableId)); did.done.push(`${e.durableId}:${e.kind}`); continue; }
+    did.kept.push(e.durableId);
+    const made = (attempts.get(e.durableId) ?? 0) + 1;
+    tx(board, (db) => {
+      const row = db.prepare('SELECT failed_at, last_error FROM supercode_effects WHERE id = ?').get(e.durableId);
+      if (!row || row.failed_at) return;
+      const reason = error ?? row.last_error ?? `${e.kind} was not accepted`;
+      const card = e.id && db.prepare('SELECT 1 FROM tasks WHERE id = ?').get(e.id) ? e.id : null;
+      if (OWNED.has(e.kind)) {
+        db.prepare('UPDATE supercode_effects SET attempts = ?, next_at = ?, last_error = ? WHERE id = ?').run(made, now() + effectWait(made), reason, e.durableId);
+        if (made === EFFECT_ATTEMPTS && card) {
+          event(db, card, 'effect_stalled', { effect: e.durableId, kind: e.kind, attempts: made, error: reason, retry_every_seconds: effectWait(made) }, e.runId ?? null);
+          const to = [].concat(workflowFor(board.root).params?.managers ?? []).find(Boolean);
+          if (to) event(db, card, 'board_message', { to, text: `${card}: the board's ${e.kind.replace('_', ' ')} has failed ${made} times and keeps trying every ${effectWait(made) / 60} min: ${reason}` }, null);
+        }
+      } else if (made >= EFFECT_ATTEMPTS) {
+        db.prepare('UPDATE supercode_effects SET attempts = ?, failed_at = ?, last_error = ? WHERE id = ?').run(made, now(), reason, e.durableId);
+        if (card) event(db, card, 'effect_failed', { effect: e.durableId, kind: e.kind, attempts: made, error: reason, address: e.address ?? null }, e.runId ?? null);
+        if (card && e.kind === 'board_message' && e.event) event(db, card, 'board_message_abandoned', { event: e.event, attempts: made, reason });
+      } else db.prepare('UPDATE supercode_effects SET attempts = ?, next_at = ?, last_error = ? WHERE id = ?').run(made, now() + effectWait(made), reason, e.durableId);
+    });
   }
+  return did;
+}
+
+/** One effect's I/O: true when it is done, false when it is not done yet (the caller counts the attempt). */
+async function runEffect(board, e) {
+  if (e.kind === 'session_notice') { const { sessionNotice } = await import('./dispatch.mjs'); return await sessionNotice(board, e) !== false; }
+  if (e.kind === 'cleanup_workspace') { cleanupWorkspace(board, e.id); return true; }
+  if (e.kind === 'declare_card_agent') { const { declareCardAgentEffect } = await import('./agent-declarations.mjs'); return declareCardAgentEffect(board, e) !== false; }
+  if (e.kind === 'board_message') {
+    const { sendBoardMessage, sendBoardMessages } = await import('./dispatch.mjs');
+    // a verb's own ask sends its card's mail at once; the mail's own effect row then finds it sent
+    if (!e.event) { await sendBoardMessages(board, { undelivered: [] }, e.id); return true; }
+    return await sendBoardMessage(board, e);
+  }
+  if (e.kind === 'merge_reviewed') { const { mergeReviewed } = await import('./dispatch.mjs'); return await mergeReviewed(board, e) !== false; }
+  if (e.kind === 'invalidate_descendants') { tx(board, (db) => invalidateDescendants(db, board, e.id)); return true; }
+  if (e.kind === 'stop_run') { stopWorker(board, e.runId); return true; }
+  if (e.kind === 'close_session' || e.kind === 'send_to_actor' || e.kind === 'run_ended') {
+    if (e.kind === 'run_ended' && e.outcome === 'reclaimed') stopWorker(board, e.runId);
+    const { sessionEffect } = await import('./dispatch.mjs');
+    return await sessionEffect(board, e) !== false;
+  }
+  return true;
 }
 
 // a run taken back stops its one-shot worker on this host (Hermes's _terminate_reclaimed_worker); a pane session is
@@ -901,7 +965,14 @@ 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: [] });
+  }
+  // what the board could not carry out for the card: a delivery failed for good, or a board effect that keeps failing
+  for (const row of all(db, "SELECT id, effect, attempts, failed_at, last_error FROM supercode_effects WHERE json_extract(effect, '$.id') = ? AND (failed_at IS NOT NULL OR attempts >= ?)", task.id, EFFECT_ATTEMPTS)) {
+    const kind = json(row.effect, {})?.kind ?? 'effect';
+    out.push(row.failed_at
+      ? { kind: 'effect_failed', severity: 'warning', title: `its ${kind} failed for good after ${row.attempts} attempts: ${row.last_error ?? 'no reason recorded'}`, data: { effect: row.id, kind, attempts: row.attempts }, actions: [] }
+      : { kind: 'effect_stalled', severity: 'error', title: `its ${kind} has failed ${row.attempts} times and is still tried: ${row.last_error ?? 'no reason recorded'}`, data: { effect: row.id, kind, attempts: row.attempts }, 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/request-mail.mjs

@@ -3,7 +3,9 @@ import { event, json, now } from './store.mjs';
 export function pendingRequestMail(db, taskId = null) {
   const pending = db.prepare(`SELECT id, task_id, payload, created_at FROM task_events original
     WHERE kind='board_message' AND NOT EXISTS (SELECT 1 FROM task_events sent WHERE sent.kind='board_message_sent'
-      AND sent.task_id=original.task_id AND json_extract(sent.payload,'$.event')=original.id) ORDER BY id`).all()
+      AND sent.task_id=original.task_id AND json_extract(sent.payload,'$.event')=original.id)
+    AND NOT EXISTS (SELECT 1 FROM task_events gone WHERE gone.kind='board_message_abandoned'
+      AND gone.task_id=original.task_id AND json_extract(gone.payload,'$.event')=original.id) ORDER BY id`).all()
     .map(row => ({ ...row, mail: json(row.payload, {}) ?? {} }));
   if (!pending.length) return { ready: [], nextAt: Infinity };
   const batches = db.prepare("SELECT payload FROM task_events WHERE kind='board_message_batch' AND id>=? ORDER BY id").all(pending[0].id)

package/board/store.mjs

@@ -76,6 +76,9 @@ CREATE TABLE IF NOT EXISTS supercode_effects (id INTEGER PRIMARY KEY AUTOINCREME
 // `stage`: the card's workflow status where kanban.db stores another (a `reviewing` card is `running` to Hermes)
 // `since`: when the card entered its workflow status; `after_fired`: which of the status's `after` moves have run since
 // `tags`: the card's ordered tags (Hermes's `tenant` holds the first); `sponsor`, `sponsor_evidence`, `requested_by_unverified`: C4
+// An effect's attempts: how many were made, when the next may be, and, once its attempts are spent, when it failed and
+// why (engine.mjs runEffects). A failed effect is kept as the record of its terminal state and never tried again.
+const EFFECT_COLUMNS = { attempts: 'INTEGER NOT NULL DEFAULT 0', next_at: 'INTEGER NOT NULL DEFAULT 0', failed_at: 'INTEGER', last_error: 'TEXT' };
 const OURS_COLUMNS = { workspace_anchor: 'TEXT', workspace_root: 'TEXT', subtask_of: 'TEXT', stage: 'TEXT', since: 'INTEGER', after_fired: 'TEXT', blocked_by: 'TEXT', paused: 'TEXT', archived: 'INTEGER DEFAULT 0', every: 'TEXT', next_run_at: 'INTEGER', tags: 'TEXT', sponsor: 'TEXT', sponsor_evidence: 'TEXT', requested_by_unverified: 'TEXT' };
 
 // ------------------------------------------------------------------ backings
@@ -140,6 +143,8 @@ export function layOut(db, { fresh }) {
   db.exec(PUBLICATION_SCHEMA);
   const have = new Set(db.prepare('PRAGMA table_info(supercode_cards)').all().map((c) => c.name));
   for (const [column, type] of Object.entries(OURS_COLUMNS)) if (!have.has(column)) db.exec(`ALTER TABLE supercode_cards ADD COLUMN ${column} ${type}`);
+  const effectColumns = new Set(db.prepare('PRAGMA table_info(supercode_effects)').all().map((c) => c.name));
+  for (const [column, type] of Object.entries(EFFECT_COLUMNS)) if (!effectColumns.has(column)) db.exec(`ALTER TABLE supercode_effects ADD COLUMN ${column} ${type}`);
 }
 
 /**

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/board.mjs

@@ -13,7 +13,7 @@
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { summary } from './board/cli.mjs';
-import { commandEnv, notifyChats, supercodeBin } from './board/dispatch.mjs';
+import { commandEnv, notifyChats, startDelivery, supercodeBin } from './board/dispatch.mjs';
 import { watchBoard } from './board/wake.mjs';
 import { workflowEntry } from './board/workflow.mjs';
 import { evaluate, holds } from './board/expr.mjs';
@@ -79,6 +79,8 @@ export async function startBoard({ root, orchestration = null, log = () => {}, a
     try {
       const { reports, error } = await dispatchOnce(root);
       if (error) { log('warn', `board: tick failed: ${error}`); return; }
+      // what the round recorded is delivered by a pass of its own, which this loop never waits for
+      startDelivery(root, { log: (level, line) => log(level, `board: ${line}`) });
       // chat-platform subscriptions are delivered here, through the daemon's own channel adapters
       try { await notifyChats(root, adapters, log, wake); } catch (error) { log('warn', `board: chat notices failed: ${error.message}`); }
       for (const r of reports) {

package/loop.mjs

@@ -24,7 +24,7 @@ import { harnessHomes } from './mcp/verbs.mjs';
 import { checkMonitor, runJobScript } from './gates.mjs';
 import { startBoard } from './board.mjs';
 import { SenderIdentityRecord } from '@volter/teams/sender-identity';
-import { agentDoor,agentScope,teamsUnavailable,ensureProfileAgent,localProfileAgent,localAgentRecord,localAgentSessions,synchronizeLocalAgents,ensureForkAgent,agentRunForKey,agentIntent,agentPreamble,agentEnvironment,recordAgentRun,recordNativeAgentSession,pendingAgentRuns,synchronizeAgentRun,agentRunForSession } from './agents.mjs';
+import { agentDoor,agentScope,teamsUnavailable,ensureProfileAgent,localProfileAgent,localAgentRecord,localAgentSessions,synchronizeLocalAgents,ensureForkAgent,agentRunForKey,agentIntent,agentPreamble,agentEnvironment,recordAgentRun,recordNativeAgentSession,pendingAgentRuns,claimAgentRun,releaseAgentRun,synchronizeAgentRun,agentRunForSession } from './agents.mjs';
 import { materializeAgentHome } from './agent-home.mjs';
 import { localMachine } from './board/dispatch.mjs';
 import { execFile } from 'node:child_process';
@@ -201,8 +201,9 @@ export class Orchestrator {
       if(scope.offline)return;
       for(const pending of synchronizeLocalAgents({root:this.state.root,profiles:this.state.profiles,context,declarations:this.state.agents??{}}))this.log('warn',`agent ${pending.agent} declaration pending: ${pending.error}`);
       for(const row of pendingAgentRuns(this.state.root,scope.org)){
+        if(!claimAgentRun(this.state.root,scope.org,row))continue;
         try{synchronizeAgentRun(this.state.root,scope.org,row,{context,intended:row.profile_json?JSON.parse(row.profile_json):undefined});}
-        catch(error){this.log('warn',`agent session ${row.session_ref}: ${error.message}`);if(error.code==='rate_limited')break;}
+        catch(error){releaseAgentRun(this.state.root,scope.org,row);this.log('warn',`agent session ${row.session_ref}: ${error.message}`);if(error.code==='rate_limited')break;}
       }
     }catch(error){this.log('warn',`agent session synchronization: ${error.message}`);}
   }
@@ -521,8 +522,8 @@ export class Orchestrator {
     if(!INSTRUCTION_ARGUMENTS[worker.harness])(this.runtimeAgentPreambles??=new Map()).set(lid,agentPrompt);
     const session=`${worker.harness}:${runtime.handle.runtime_id}`;
     recordAgentRun(this.state.root,scope.org,agent.identity.id,{session,machine:null,run:run_key??lid,profile:agent.intended.resolved,main,starterSession:starter_session});
-    if(agent.synced!==false)try{synchronizeAgentRun(this.state.root,scope.org,{agent_id:agent.identity.id,session_ref:session,machine:null,main},{context,intended:agent.intended.resolved});}
-    catch(error){this.log('warn',`agent session ${session} retained for synchronization: ${error.message}`);}
+    if(agent.synced!==false&&claimAgentRun(this.state.root,scope.org,{session_ref:session,published:0}))try{synchronizeAgentRun(this.state.root,scope.org,{agent_id:agent.identity.id,session_ref:session,machine:null,main},{context,intended:agent.intended.resolved});}
+    catch(error){releaseAgentRun(this.state.root,scope.org,{session_ref:session});this.log('warn',`agent session ${session} retained for synchronization: ${error.message}`);}
     this.enqueue(events.worker({
       profile: profileName, keyString, runtime_id: runtime.handle.runtime_id,
       ev: { kind: 'started', runtime_id: runtime.handle.runtime_id, session_id: runtime.handle.runtime_id, connection: runtime.connection, harness: worker.harness, steer },

package/package.json

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