@volter/supercode-orchestrator 0.5.26 → 0.5.27

package/bin/agent-door.mjs

@@ -2,7 +2,6 @@
 // The orchestrator's synchronous host reaches Teams through the installed neutral SDK.
 import { fromContext } from '@volter/teams/context';
 import { supercodeHome } from '@volter/teams/home';
-import { createHash } from 'node:crypto';
 import { openMachine, normalMachineName } from '@volter/teams/machine-door';
 import { hostname } from 'node:os';
 import { StreamRpc } from '@volter/teams/client';
@@ -31,10 +30,21 @@ try{
   }
   else if(op==='reader')result=await team.agents.delegateReader(args[0],{},{...options,ifMatch:args[1]});
   else if(op==='bindContext'){
-    const key=createHash('sha256').update(`${scope.origin}/${scope.team_id}/${args[0]}`).digest('hex');
-    const channel=await openMachine({machine:reach(args[2]),context:context??process.env.SUPERCODE_CONTEXT});
-    try{const rpc=new StreamRpc(await channel.open('node'));result=await rpc.call('harness.v1.agents.bindSession',{session:args[1],context:`agent-${key.slice(0,32)}`,assignments:args[3]??[],intended:args[4]??null});}
-    finally{channel.close();}
+    // The binding names the agent's reader context on the session's machine, so it installs that context itself: a
+    // launch installs one before its session starts, but an adopted session never had one, and a context installed a
+    // day before has expired. An ended agent has neither a reader nor a live session: Teams revoked its credentials
+    // and ended its sessions when it ended, so there is nothing to bind.
+    const agent=(await team.agents.get(args[0],options)).data;
+    if(agent.state==='ended')result={bound:false,reason:`agent ${agent.id} ended`};
+    else{
+      const reader=await team.agents.delegateReader(agent.id,{expires_in_ms:86400000},{...options,ifMatch:agent.revision});
+      const channel=await openMachine({machine:reach(args[2]),context:context??process.env.SUPERCODE_CONTEXT});
+      try{
+        const rpc=new StreamRpc(await channel.open('node'));
+        const installed=await rpc.call('harness.v1.agents.context',{origin:scope.origin,team:scope.team_id,agent:agent.id,credential:reader.data});
+        result=await rpc.call('harness.v1.agents.bindSession',{session:args[1],context:installed.context,assignments:args[3]??[],intended:args[4]??null});
+      }finally{channel.close();}
+    }
   }
   else if(op==='readerContext'){
     const identity=await team.agents.get(args[0],options);

package/board/dispatch.mjs

@@ -143,6 +143,16 @@ const pause = (ms) => Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0,
 // headless worker by its pid, a pane by that machine's pane list. Null only when the machine cannot answer.
 const sessionAlive = (fleet, session) => fleet.native?.has(addressOf(session)) ? fleet.native.get(addressOf(session)).alive : unpublishedAlive(session);
 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.
+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; }
+}
 function unpublishedAlive(session) {
   if (!session) return null;
   if (session.surface === 'headless' && session.pid) return pidAlive(session.pid);
@@ -302,7 +312,10 @@ function supervise(board, fleet, settings, report, entry, effects) {
         }
       };
       const limits = limitsOf(db, board, entry, task, session);
-      if (runRow && (session?.launch_pending || session?.launch_deferred || (!session?.session_id && !session?.pid))) {
+      // A verified adoption binds the run to its session; a launch key still pending beside it is the reconciler's to
+      // retire at its machine, and no longer what the run waits on.
+      const adopted = session?.mode === 'adopt' && Boolean(session.address);
+      if (runRow && ((session?.launch_pending && !adopted) || session?.launch_deferred || (!session?.session_id && !session?.pid))) {
         const age = t - Number(session?.launched_at ?? runRow.started_at);
         if (age >= settings.launchWindow) {
           const reason = session?.launch_deferred_error ?? session?.launch_error ?? 'no session or process was bound to the dispatched run';
@@ -795,13 +808,16 @@ export function closeRequested(board, report, { taskId = null, caller = null } =
         receipt = launchReceipt(board, session);
         if (!receipt) receipt = cancelUnissuedLaunch(board, session);
       } catch (error) { receiptError = error.message; }
-      if (unissuedLaunch(receipt, session) && retireUnissuedLaunch(board, row, session, receipt)) {
+      const retired = unissuedLaunch(receipt, session) && retireUnissuedLaunch(board, row, session, receipt);
+      if (retired === true) {
         (report.closed ??= []).push({ task_id: row.task_id, ...session, receipt });
         continue;
       }
+      // the key was never issued, and the session adopted onto the run is closed (or released) as its own below
+      if (retired === 'released') session = json(board.db.prepare('SELECT metadata FROM task_runs WHERE id = ?').get(row.id)?.metadata, {})?.supercode;
       // A receipt that names its pane and reads it not live is terminal enough to settle, with or without a status (a
       // daemon that predates launch statuses answers none): the board's own pane reading below confirms the close
-      if (receipt?.pane && receipt.status !== 'issued' && (receipt.status || typeof receipt.live === 'boolean' || receipt.exit)) { bindLaunch(board, row, session, receipt.pane, session.session_id); session = { ...session, pane: receipt.pane }; }
+      else if (receipt?.pane && receipt.status !== 'issued' && (receipt.status || typeof receipt.live === 'boolean' || receipt.exit)) { bindLaunch(board, row, session, receipt.pane, session.session_id); session = { ...session, pane: receipt.pane }; }
       else {
         const error = `close deferred: ${receiptError ?? `awaiting terminal launch receipt ${session.launch_key} (${receipt?.status ?? 'unknown'})`}`;
         tx(board, (db) => {
@@ -1187,12 +1203,24 @@ function unissuedLaunch(receipt, session) {
     receipt?.outcome === 'not_issued' && receipt?.live === false && receipt?.pane === null;
 }
 
+/**
+ * Retire a launch key its machine confirmed it never issued. Returns true when the run's launch is settled and closed,
+ * 'released' when the key is retired but the run keeps a session adopted onto it, false when the run is not this key's.
+ */
 function retireUnissuedLaunch(board, row, session, receipt, { entry = null, effects = [] } = {}) {
   if (!unissuedLaunch(receipt, session)) return false;
   const result = tx(board, db => {
     const current = db.prepare('SELECT ended_at, metadata FROM task_runs WHERE id=?').get(row.id);
     const saved = json(current?.metadata, {})?.supercode;
-    if (!saved || saved.launch_key !== session.launch_key || saved.pane || saved.address || saved.pid) return { retired: false, effects: [] };
+    if (!saved || saved.launch_key !== session.launch_key) return { retired: false, effects: [] };
+    // A session adopted onto a run whose launch was still pending did not come from that launch (the machine never
+    // issued the key): the key is retired and the adopted session stays the run's, supervised and closed as its own.
+    if (saved.mode === 'adopt' && saved.address && saved.launch_pending) {
+      setRunSession(db, row.id, { launch_pending: false, launch_cancellation: receipt, launch_error: null, launch_key: null });
+      event(db, row.task_id, 'session_launch_cancelled', { key: session.launch_key, machine: session.machine, receipt, kept: saved.address }, row.id);
+      return { retired: 'released', effects: [] };
+    }
+    if (saved.pane || saved.address || saved.pid) return { retired: false, effects: [] };
     if (!current.ended_at && (!entry || getTask(db, row.task_id)?.current_run_id !== row.id)) return { retired: false, effects: [] };
     if (saved.close_confirmed_at) return { retired: true, effects: [] };
     const collected = [];
@@ -1313,7 +1341,7 @@ function reconcileLaunches(board, fleet, report, entry, effects, settings, lanes
   for(const [org,context] of orgs)for(const row of pendingAgentRuns(board.root,org)){
     const launch=agentRuns.find(run=>String(run.id)===String(row.run_id));
     try{synchronizeAgentRun(board.root,org,row,{context,intended:json(launch?.metadata,{})?.supercode?.agent_profile_intent});}
-    catch(error){if(error.code==='rate_limited'){report.queued.push([row.run_id,`agent session sync pending: ${error.message}`]);break;}const gone=error.claimRefused&&error.status===404&&fleet.ok&&sessionAlive(fleet,{address:`sc:${row.machine||localMachine()}:${row.session_ref}`,machine:row.machine||localMachine()})===false;if(gone)abandonAgentRun(board.root,org,row.session_ref);report.failed.push([row.run_id,`agent session sync failed: ${error.message}${gone?`; ${row.session_ref} is stopped and Teams refuses it, so it leaves the sync`:''}`]);}
+    catch(error){if(error.code==='rate_limited'){report.queued.push([row.run_id,`agent session sync pending: ${error.message}`]);break;}const gone=error.claimRefused&&error.status===404&&fleet.ok&&syncRowAlive(fleet,row)===false;if(gone)abandonAgentRun(board.root,org,row.session_ref);report.failed.push([row.run_id,`agent session sync failed: ${error.message}${gone?`; ${row.session_ref} is stopped and Teams refuses it, so it leaves the sync`:''}`]);}
   }
   const deferred=view(board,db=>db.prepare("SELECT t.id,r.id run_id,COALESCE(json_extract(r.metadata,'$.supercode.launched_at'),r.started_at) launched_at FROM tasks t JOIN task_runs r ON r.id=t.current_run_id WHERE r.ended_at IS NULL AND json_extract(r.metadata,'$.supercode.launch_deferred')=1").all());
   // A deferred launch was never issued (a reading or door was not yet available): it is the start its manager, creator
@@ -1761,7 +1789,8 @@ function adoptSession(board, id, who, { workspace = null, ttl, assignee = null,
     const session = { surface: found.pane ? 'pane' : 'native', session_id: sessionId, harness, machine: host, pane: found.pane ?? null, address: found.address, mode: 'adopt', launched_at: now(), seen_at: now(),
       ...(agent ? { agent_id: agent.identity.id, agent_org: team.org, agent_context: context ?? null,
         agent_profile_intent: { ...structuredClone(agent.intended.resolved), worker: { ...agent.intended.resolved?.worker, harness: lane.harness, model: lane.model ?? null, cwd: dir ?? task.workspace_path ?? null } } } : {}) };
-    setRunSession(db, runId, { ...(currentRun(db, id)?.metadata?.supercode ?? {}), ...session, slot: currentRun(db, id)?.metadata?.supercode?.slot ?? beforeSession?.slot ?? expected?.session ?? 'worker', close_requested: null, closed_at: null, close_confirmed_at: null, close_error: null, missing_since: null });
+    // a deferred launch was never issued: the adopted session is the run's, and no later round launches another
+    setRunSession(db, runId, { ...(currentRun(db, id)?.metadata?.supercode ?? {}), ...session, launch_deferred: false, slot: currentRun(db, id)?.metadata?.supercode?.slot ?? beforeSession?.slot ?? expected?.session ?? 'worker', close_requested: null, closed_at: null, close_confirmed_at: null, close_error: null, missing_since: null });
     event(db, id, 'session_adopted', { session_id: sessionId, machine: host, pane: session.pane, address: found.address, mode: 'adopt', role: currentRun(db, id)?.metadata?.supercode?.role }, runId);
     subscribeIn(db, id, found.address, 'worker');
     for (const p of db.prepare('SELECT parent_id FROM task_links WHERE child_id = ?').all(id)) subscribeIn(db, p.parent_id, found.address, 'dependency');

package/package.json

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