@volter/supercode-orchestrator 0.5.36 → 0.5.38

package/agents.mjs

@@ -8,6 +8,8 @@ import { createHash, randomBytes } from 'node:crypto';
 import { runtimeDoor } from './board/runtime-door.mjs';
 import { resolveAgentProfile } from './agent-profiles.mjs';
 import { compareAgentProfile } from '@volter/teams/agent-profile';
+import { WorkspaceContexts } from '@volter/teams/context';
+import { supercodeHome } from '@volter/teams/home';
 const entry=fileURLToPath(new URL('./bin/agent-door.mjs',import.meta.url));
 // The caller each door names to Teams (X-Supercode-Caller): this host's own command words, then the door's operation.
 const HOST_CALLER=(process.env.SUPERCODE_CALLER_NAME??`orchestrator ${process.argv.slice(2).filter(arg=>!arg.startsWith('-')).slice(0,2).filter(arg=>/^[a-z][a-z0-9-]{0,30}$/.test(arg)).join(' ')}`).slice(0,80);
@@ -22,11 +24,9 @@ export function teamsUnavailable(error){
   if(error?.status!=null)return error.status>=500||error.status===401;
   return !['forbidden','conflict','not_found','invalid_request','revision_mismatch','idempotency_conflict'].includes(error?.code);
 }
-/** The Org agent identity belongs to: the selected Teams context, or this home's local store when there is none. */
-export function agentScope(context){
-  try{return agentDoor('scope',[],{context});}
-  catch(error){if(teamsUnavailable(error))return {server:'local',org:'local',principal:null,offline:true,reason:error.message};throw error;}
-}
+/** The Org agent identity belongs to: the selected Teams context as this home records it (read locally, no request),
+ * or this home's local store when none is selected. A context named but unreadable here is this home's error, and throws. */
+export function agentScope(context){return agentDoor('scope',[],{context});}
 function store(root){
   mkdirSync(root,{recursive:true,mode:0o700});const db=new DatabaseSync(join(root,'agent-state.sqlite'));
   db.exec(`PRAGMA busy_timeout=5000; PRAGMA journal_mode=WAL;
@@ -260,27 +260,42 @@ export function ensureForkAgent(options) {
 export function agentRunForKey(root,org,agent,key) {
   const db=store(root);try{return db.prepare('SELECT * FROM agent_runs WHERE org=? AND agent_id=? AND run_id=? ORDER BY rowid DESC LIMIT 1').get(org,agent,key)??null;}finally{db.close();}
 }
+const declarationHead=(root,org,key)=>{const db=store(root);try{return db.prepare('SELECT agent_id FROM agent_declaration_heads WHERE org=? AND key=?').get(org,key)?.agent_id??null;}finally{db.close();}};
+const endedHere=(root,org,id)=>{const db=store(root);try{return !!db.prepare('SELECT 1 FROM agent_runs WHERE org=? AND agent_id=? AND end_reason IS NOT NULL LIMIT 1').get(org,id);}finally{db.close();}};
 function recordDeclaration(root,org,id,declaration){
   const db=store(root);try{db.prepare('UPDATE agent_intents SET declaration_json=? WHERE org=? AND id=? AND declared=0').run(JSON.stringify(declaration),org,id);}finally{db.close();}
 }
-/** Situation 16: no reachable Teams. The daemon-minted id and retained intent stand in for the declaration,
- * which synchronizeLocalAgents later makes under the same id. Nothing is granted from this local record. */
+/** The identity a run starts as without asking Teams: the daemon-minted id and retained intent. An identity not yet
+ * declared is declared later under the same id (synchronizeLocalAgents). Nothing is granted from this local record;
+ * `identity.synced` says whether Teams has the declaration, and the record's own `synced: false` that Teams was not read. */
 function localAgent(options,{key,name,declaration,assignment,parent=null,starter}){
   const {root,org,server,profiles,profile,machine=null}=options;
   const rootProfile=profiles.default?'default':profile;
   const rootIntent=declareAgentIntent({root,org,server,profiles,profile:rootProfile,key:'root',machine,refresh:false});
   recordDeclaration(root,org,rootIntent.id,{kind:'root',profile:rootProfile});
-  const intent=key==='root'?rootIntent:declareAgentIntent({root,org,server,profiles,profile,key,machine});
+  let intent=key==='root'?rootIntent:declareAgentIntent({root,org,server,profiles,profile,key,machine});
+  // An agent Teams ended is never started again: its end, once synchronized, is on its runs here (synchronizeAgentEnds),
+  // and the key's next generation is minted in its place, with fresh memory.
+  if(key!=='root'&&endedHere(root,org,intent.id))intent=nextAgentGeneration(root,intent,machine);
   if(key!=='root')recordDeclaration(root,org,intent.id,declaration);
   const above=parent??(key==='root'?null:{id:rootIntent.id,path:basename(root)});
   const identity={id:intent.id,kind:'agent',org,name,path:above?`${above.path}/${name}`:name,parent:above?.id??null,
     lineage:{starter},sponsor:options.sponsor??null,explicit_sponsor:options.sponsor??null,profile,state:'active',
-    synced:false,main_session:null,revision:0};
+    synced:!!intent.declared,main_session:null,revision:0};
   const assigned=assignAgent(root,org,intent.id,assignment);
   return {identity,intended:intent.intended,assignment:assigned,assignments:[assignment],org,synced:false};
 }
 export function localCardAgent(options){
-  const {card,role,profile}=options;
+  const {root,org,server,profiles,card,role,profile}=options;
+  // A card role's assignment the manager moved to another agent (`workflow reassign --agent`) runs as that agent: the
+  // active assignment names it, not the key's own head, and an agent whose end was synchronized here is not used.
+  const held=activeAgentAssignments(root).find(item=>item.org===org&&item.kind==='card'&&item.target===card&&item.role===role);
+  if(held&&held.agent_id!==declarationHead(root,org,`${server}/${org}/card/${card}/${role}`)&&!endedHere(root,org,held.agent_id)){
+    const record=localAgentRecord(root,org,held.agent_id);
+    const identity=record?{...record.identity,synced:true}:{id:held.agent_id,kind:'agent',org,name:held.agent_id,path:held.agent_id,parent:null,
+      lineage:{starter:null},sponsor:options.sponsor??null,explicit_sponsor:options.sponsor??null,profile,state:'active',synced:true,main_session:null,revision:0};
+    return {identity,intended:record?.intended??resolveAgentProfile(profiles,profile),assignment:held.id,assignments:[{kind:'card',target:card,role}],org,synced:false};
+  }
   return localAgent(options,{key:`card/${card}/${role}`,name:`${card}-${role}`,assignment:{kind:'card',target:card,role},
     declaration:{kind:'card',card,role,profile,sponsor:options.sponsor??null,starterSession:options.starterSession??null},
     starter:options.starterSession?{kind:'session',id:options.starterSession}:{kind:'automation',id:`board:${basename(options.root)}`}});
@@ -459,6 +474,13 @@ export function agentPreamble(agent,{main=true,previous=[]}={}){
   const {identity:a,intended,assignments=[]}=agent;
   return `You are agent ${a.path} (${a.id}), ${main?'its main session':'a concurrent session'}.${a.synced===false?' This identity was minted on this machine and is not yet declared on a Teams server; it keeps this id when it is.':''}\nSponsor: ${a.sponsor??'none yet'}; parent: ${a.parent??'none'}; lineage: ${JSON.stringify(a.lineage)}.\nAssignments: ${assignments.map(value=>`${value.kind} ${value.target}, role ${value.role}`).join("; ")}; profile: ${a.profile}; permission layers: ${JSON.stringify(intended.resolved.permissions.layers)}.\nAsk again with supercode agent whoami. List your sessions with supercode agent sessions; read a transcript only when needed.${previous.length?'\nEarlier sessions:\n'+previous.map(s=>`${s.session} · ${s.machine??'unknown machine'} · ended ${s.ended_at??'live'} · ${s.end_reason??''}`).join('\n'):''}`;
 }
+/** The agent's reader context this home already holds (a session of it was bound here before), read from the contexts
+ * file without a request, or null. A launch on this machine hands it to the session, so its Teams verbs run delegated
+ * from the first turn; a context that has since expired fails there, as an absent one does. */
+export function localReaderContext(org,id){
+  const contexts=new WorkspaceContexts(supercodeHome()).read().contexts??{};
+  return Object.entries(contexts).find(([,value])=>value?.principal_id===id&&value?.team_id===org)?.[0]??null;
+}
 export function agentProfileMismatch(intent,resolved){return compareAgentProfile(intent?.resolved??intent,resolved);}
 
 export function agentEnvironment(agent,{root,context,session=null,main=true}={}) {

package/bin/agent-door.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 // The orchestrator's synchronous host reaches Teams through the installed neutral SDK.
-import { fromContext } from '@volter/teams/context';
+import { fromContext, WorkspaceContexts } from '@volter/teams/context';
 import { supercodeHome } from '@volter/teams/home';
 import { openMachine, normalMachineName } from '@volter/teams/machine-door';
 import { hostname } from 'node:os';
@@ -11,6 +11,9 @@ const reach=machine=>machine&&normalMachineName(machine)!==normalMachineName(hos
 let input='';for await(const chunk of process.stdin)input+=chunk;
 try{
   const {op,args=[],context}=JSON.parse(input);
+  // No context selected: identity is this home's own (Org `local`). A context that is named but unreadable is an error.
+  const named=context??process.env.SUPERCODE_CONTEXT??new WorkspaceContexts(supercodeHome()).read().current;
+  if(op==='scope'&&(!named||named==='local')){process.stdout.write(JSON.stringify({server:'local',org:'local',principal:null,offline:true,reason:'no Teams context is selected'})+'\n');process.exit(0);}
   const {client,context:scope}=fromContext({supercodeHome:supercodeHome(),name:context??process.env.SUPERCODE_CONTEXT});
   const team=client.team(scope.team_id),options={signal:AbortSignal.timeout(20000)};
   let result;

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 { agentDoor, agentScope, teamsUnavailable, ensureCardAgent, localCardAgent, 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);
@@ -684,28 +703,20 @@ export function launchRun(board, entry, id, lane, fleet, settings) {
   // the model it runs is recorded with the session, for caps that count by model
   const meta = { status, role: spec.role, slot, model: task.model_override ?? lane.model ?? null, ...(spec.role === 'reviewer' ? { review_candidate: reviewCandidate(board, id) } : {}) };
   try {
-    const context=process.env.SUPERCODE_CONTEXT,team=agentScope(context),machine=normalMachine(task.machine)===localMachine()?null:task.machine;
-    const cardOptions={root:board.root,org:team.org,server:team.server,profiles:entry.profiles,
-      profile:lane.name,card:id,role:spec.role??slot,sponsor:task.sponsor??null,machine,context};
-    // Situation 16: with no reachable Teams the card's agent is its locally minted identity, declared later under the same id.
-    let agent=null,previous=null,reader=null;
-    if(!team.offline){
-      try{
-        agent=ensureCardAgent(cardOptions);
-        previous=agentDoor('sessions',[agent.identity.id,{limit:200}],{context}).items??[];
-        reader=agentDoor('readerContext',[agent.identity.id,machine],{context,timeout:60000});
-      }catch(error){if(!teamsUnavailable(error))throw error;tx(board,db=>event(db,id,'agent_identity_local',{reason:error.message},runId));}
-    }
-    agent??=localCardAgent(cardOptions);
+    // Teams is never on a launch's path: the card's agent is its identity minted on this host under its retained intent,
+    // and its sessions are joined to it off this path, after the launch. No Teams answer starts, stops or holds a card.
+    const context=process.env.SUPERCODE_CONTEXT,team=agentScope(context);
+    const agent=localCardAgent({root:board.root,org:team.org,server:team.server,profiles:entry.profiles,
+      profile:lane.name,card:id,role:spec.role??slot,sponsor:task.sponsor??null});
     // G3: a run of an agent over its budget does not start; the reason waits on the card until the window passes
     const budgets=[...(entry.profiles?.default?.budgets??[]),...(lane.name!=='default'?entry.profiles?.[lane.name]?.budgets??[]:[])];
     const refused=budgets.length?runBudgetRefusal(board.root,agent.identity.id,budgets,new Date().toISOString()):null;
     if(refused)throw Object.assign(new Error(`not started, over budget: ${refused}`),{launchDeferred:true});
-    previous??=localAgentSessions(board.root,team.org,agent.identity.id);
+    const previous=localAgentSessions(board.root,team.org,agent.identity.id);
     prompt=`${agentPreamble(agent,{previous:previous.map(item=>({session:item.session,machine:item.machine,ended_at:item.ended_at,end_reason:item.end_reason}))})}\n\n${prompt}`;
     Object.assign(meta,{agent_id:agent.identity.id,agent_org:team.org,agent_context:context??null,
       agent_profile_intent:structuredClone(agent.intended.resolved),
-      agent_env:agentEnvironment(agent,{root:board.root,context:reader?.context})});
+      agent_env:agentEnvironment(agent,{root:board.root,context:normalMachine(task.machine??localMachine())===localMachine()?localReaderContext(team.org,agent.identity.id)??undefined:undefined})});
     // The agent's own memory reaches every session of it: headless runs open its home; a pane, which may sit on
     // another machine, gets the home's snapshot in its first prompt. A shared profile's memory is never used.
     const agentHome=materializeAgentHome(board.root,team.org,agent.identity.id,lane);
@@ -718,14 +729,7 @@ export function launchRun(board, entry, id, lane, fleet, settings) {
       setRunSession(db,runId,{launch_deferred:false,launch_deferred_error:null,restart_authorized:false});
       event(db,id,'restart_authorization_consumed',{},runId);
     });
-    if(result?.session_id){
-      const ref=`${result.harness}:${result.session_id}`;
-      recordAgentRun(board.root,team.org,agent.identity.id,{session:ref,machine:result.machine,run:runId});
-      if(agent.synced!==false){
-        try{synchronizeAgentRun(board.root,team.org,{agent_id:agent.identity.id,session_ref:ref,machine:result.machine},{context,intended:meta.agent_profile_intent});}
-        catch(error){tx(board,db=>event(db,id,'agent_session_sync_pending',{session:ref,agent:agent.identity.id,error:error.message},runId));}
-      }
-    }
+    if(result?.session_id)recordAgentRun(board.root,team.org,agent.identity.id,{session:`${result.harness}:${result.session_id}`,machine:result.machine,run:runId});
     return result;
   } catch(error) {
     // An issued asynchronous launch may bind later. Its original permission
@@ -751,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);
@@ -948,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);
@@ -1004,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)}`]);
@@ -1136,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
@@ -1281,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
@@ -1314,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
@@ -1342,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}`]);
@@ -1451,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
@@ -1512,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) {
@@ -1765,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. */
@@ -1805,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`);
@@ -1831,7 +1823,7 @@ function adoptSession(board, id, who, { request = null, open = request, progress
   const agentRole = view(board, (db) => adoptedRole(db, board, entry0, card0, beforeRun)) ?? 'implementer';
   const laneName = view(board, (db) => evaluate(entry0.workflow.roles?.[agentRole] ?? 'card.assignee', scopeOf(db, board, card0, { params: entry0.params }))) ?? assignee ?? card0?.assignee;
   const lane = laneName ? lanes?.[laneName] : null, context = process.env.SUPERCODE_CONTEXT, team = agentScope(context);
-  // The request is claimed before this adoption's first write outside the board (the agent's Teams record, below), in
+  // The request is claimed before this adoption's first write outside the board (the agent store, below), in
   // a transaction that finds it still open and the card's run the one read: a request answered or claimed meanwhile, or
   // a run that changed, ends it here with nothing written anywhere, and no other round acts on a request claimed here.
   const stale = (db) => {
@@ -1845,11 +1837,8 @@ function adoptSession(board, id, who, { request = null, open = request, progress
     event(db, id, 'adoption_claimed', { request, session: who, ...newClaim(ttl) });
   });
   progress.claimed = request !== null;
-  let agent = null;
-  if (lane && !team.offline) {
-    try { agent = ensureCardAgent({ root: board.root, org: team.org, server: team.server, profiles: entry0.profiles, profile: lane.name, card: id, role: agentRole, sponsor: card0?.sponsor ?? null, machine: normalMachine(host) === localMachine() ? null : host, context }); }
-    catch (error) { if (!teamsUnavailable(error)) throw error; }
-  }
+  // The adopted session joins the role's agent as a launch does: its identity minted on this host, never asked of Teams.
+  const agent = lane ? localCardAgent({ root: board.root, org: team.org, server: team.server, profiles: entry0.profiles, profile: lane.name, card: id, role: agentRole, sponsor: card0?.sponsor ?? null }) : null;
   // A session another agent already owns is refused before anything is recorded: the run would name one agent and the
   // agent store another, and every round after would trip on it.
   const owner = agent ? agentRunForSession(board.root, [`${harness}:${sessionId}`]) : null;
@@ -2123,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: [] });
@@ -2150,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`)
@@ -2477,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' };
@@ -2587,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/index.d.ts

@@ -128,10 +128,10 @@ export function synchronizeAgentRun(root: Path, org: string, row: {agent_id: str
 export function agentRunForSession(root: Path, references: Array<string | null | undefined>): Record<string, unknown> | null;
 export function agentPreamble(agent: ReturnType<typeof ensureCardAgent>, options?: {main?: boolean; previous?: Array<{session: string; machine?: string | null; ended_at?: number | null; end_reason?: string | null}>}): string;
 export function agentEnvironment(agent: ReturnType<typeof ensureCardAgent>, options: {root: Path; context?: string; session?: string | null; main?: boolean}): Record<string, string>;
-/** The Org for agent identity; `offline` when no Teams context is selected or reachable (situation 16). */
+/** The Org for agent identity, read from this home's selected context without a request; `offline` when none is selected. Throws when a named context cannot be read. */
 export function agentScope(context?: string): {server: string; org: string; principal: string | null; offline?: true; reason?: string};
 export function teamsUnavailable(error: unknown): boolean;
-/** Locally minted identities (`identity.synced === false`), declared later under the same id. */
+/** The identity a run starts as without asking Teams; `identity.synced` is false until Teams has its declaration, made later under the same id. */
 export function localCardAgent(options: Parameters<typeof ensureCardAgent>[0]): ReturnType<typeof ensureCardAgent> & {synced: false};
 export function localProfileAgent(options: Parameters<typeof ensureProfileAgent>[0]): ReturnType<typeof ensureCardAgent> & {synced: false};
 export function localAgentRecord(root: Path, org: string, id: string): ReturnType<typeof ensureCardAgent> | null;

package/package.json

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