@volter/supercode-orchestrator 0.5.12 → 0.5.14

package/agents.mjs

@@ -9,8 +9,10 @@ import { runtimeDoor } from './board/runtime-door.mjs';
 import { resolveAgentProfile } from './agent-profiles.mjs';
 import { compareAgentProfile } from '@volter/teams/agent-profile';
 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);
 export function agentDoor(op,args=[],{context,timeout=25000}={}){
-  const reply=spawnSync(process.execPath,[entry],{input:JSON.stringify({op,args,context}),encoding:'utf8',timeout,maxBuffer:4*1024*1024});
+  const reply=spawnSync(process.execPath,[entry],{input:JSON.stringify({op,args,context}),encoding:'utf8',timeout,maxBuffer:4*1024*1024,env:{...process.env,SUPERCODE_CALLER_NAME:`${HOST_CALLER} agent-door ${op}`}});
   if(reply.status!==0){let detail;try{detail=JSON.parse(reply.stderr);}catch{detail={message:reply.error?.message??String(reply.stderr).slice(-1000)};}throw Object.assign(new Error(detail.message??'Teams agent door unavailable'),detail);}
   return JSON.parse(reply.stdout);
 }
@@ -365,8 +367,23 @@ export function recordNativeAgentSession(root,runtimeRef,session) {
   return agentRunForSession(root,[runtimeRef]);
 }
 /** Join an observed native session through the public catalogue; unknown catalogue state remains pending. */
+// A run whose session ownership Teams refused (a 4xx answer to the claim: not found, forbidden, conflict, signed out)
+// is asked again after a growing wait (two minutes, doubling to an hour), not every round: each ask spends the shared
+// credential's allowance. Anything else (the rate limit, a timeout, a 5xx, the local daemon's bind of a session just
+// spawned) is not the run's own and is asked again next round.
+const runRetry=new Map();
+const retryKey=(org,row)=>`${org}/${row.agent_id}/${row.session_ref}`;
+const refused=error=>error?.status>=400&&error.status<500&&error.status!==408&&error.status!==429;
 export function synchronizeAgentRun(root,org,row,{context,intended}={}) {
-  const response=agentDoor('ownSession',[row.agent_id,{session:row.session_ref,main:row.main!==0&&row.main!==false,...(row.starter_session?{starter_session:row.starter_session}:{})},digest(`${org}/${row.agent_id}/${row.session_ref}`)],{context});
+  try{const answer=joinAgentRun(root,org,row,{context,intended});runRetry.delete(retryKey(org,row));return answer;}
+  catch(error){
+    if(error?.claimRefused){const wait=Math.min((runRetry.get(retryKey(org,row))?.wait??60000)*2,3600000);runRetry.set(retryKey(org,row),{at:Date.now()+wait,wait});}
+    throw error;
+  }
+}
+function joinAgentRun(root,org,row,{context,intended}) {
+  const claim=(...args)=>{try{return agentDoor(...args);}catch(error){throw Object.assign(error,{claimRefused:refused(error)});}};
+  const response=claim('ownSession',[row.agent_id,{session:row.session_ref,main:row.main!==0&&row.main!==false,...(row.starter_session?{starter_session:row.starter_session}:{})},digest(`${org}/${row.agent_id}/${row.session_ref}`)],{context});
   const intent=agentIntent(root,org,row.agent_id);
   const runtime=agentDoor('bindContext',[row.agent_id,row.session_ref,row.machine,intent?.assignments??[],intended??intent?.profile.resolved],{context});
   publishAgentRun(root,org,row.session_ref);
@@ -381,7 +398,7 @@ export function recordAgentRun(root,org,id,{session,machine=null,run,profile=nul
     db.exec('COMMIT');
   }catch(error){try{db.exec('ROLLBACK');}catch{}throw error;}finally{db.close();}
 }
-export function pendingAgentRuns(root,org){const db=store(root);try{return db.prepare('SELECT * FROM agent_runs WHERE org=? AND published=0 ORDER BY rowid LIMIT 100').all(org);}finally{db.close();}}
+export function pendingAgentRuns(root,org){const db=store(root);try{return db.prepare('SELECT * FROM agent_runs WHERE org=? AND published=0 ORDER BY rowid LIMIT 100').all(org).filter(row=>!(runRetry.get(retryKey(org,row))?.at>Date.now()));}finally{db.close();}}
 /** Session references come from the bound runtime, never from a model's requested agent id. */
 export function agentRunForSession(root, references) {
   const db = store(root);

package/bin/agent-door.mjs

@@ -3,8 +3,12 @@
 import { fromContext } from '@volter/teams/context';
 import { supercodeHome } from '@volter/teams/home';
 import { createHash } from 'node:crypto';
-import { openMachine } from '@volter/teams/machine-door';
+import { openMachine, normalMachineName } from '@volter/teams/machine-door';
+import { hostname } from 'node:os';
 import { StreamRpc } from '@volter/teams/client';
+// This machine is reached through its own daemon's socket, never through the Teams server: the server route lists the
+// org's machines and opens a channel on the shared credential's allowance for a request that never leaves the box.
+const reach=machine=>machine&&normalMachineName(machine)!==normalMachineName(hostname())?machine:null;
 let input='';for await(const chunk of process.stdin)input+=chunk;
 try{
   const {op,args=[],context}=JSON.parse(input);
@@ -28,14 +32,14 @@ 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:args[2]??null,context:context??process.env.SUPERCODE_CONTEXT});
+    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();}
   }
   else if(op==='readerContext'){
     const identity=await team.agents.get(args[0],options);
     const reader=await team.agents.delegateReader(args[0],{expires_in_ms:86400000},{...options,ifMatch:identity.data.revision});
-    const channel=await openMachine({machine:args[1]??null,context:context??process.env.SUPERCODE_CONTEXT});
+    const channel=await openMachine({machine:reach(args[1]),context:context??process.env.SUPERCODE_CONTEXT});
     try{const rpc=new StreamRpc(await channel.open('node'));result=await rpc.call('harness.v1.agents.context',{origin:scope.origin,team:scope.team_id,agent:args[0],credential:reader.data});}
     finally{channel.close();}
   }

package/board/dispatch.mjs

@@ -1189,7 +1189,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){report.queued.push([row.run_id,`agent session sync pending: ${error.message}`]);}
+    catch(error){report.queued.push([row.run_id,`agent session sync pending: ${error.message}`]);if(error.code==='rate_limited')break;}
   }
   const deferred=view(board,db=>db.prepare("SELECT t.id,r.started_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

package/board/event-relay.mjs

@@ -6,7 +6,7 @@ import { boardSourceName, publishableCard, recordCardPublications } from './publ
 import { listBoards, openBoard } from './store.mjs';
 
 export function boardEventRelay({root,context,supercodeHome,log=()=>{}}) {
-  let work=null,dirty=false,closed=false,retry=null,reconcile=true;const sources=new Map();
+  let work=null,dirty=false,closed=false,retry=null,reconcile=true,heldUntil=0;const sources=new Map();
   const run=async()=>{
     if(reconcile){
       // Establish every native source head before any network operation. A
@@ -37,10 +37,14 @@ export function boardEventRelay({root,context,supercodeHome,log=()=>{}}) {
   };
   const wake=(refresh=true)=>{
     reconcile ||= refresh;dirty=true;if(work||closed)return work;
+    // Refused for the rate limit, delivery waits out the server's retry-after: a board write meanwhile would only ask
+    // again and spend the allowance the credential shares with every other caller.
+    if(Date.now()<heldUntil)return null;
     work=(async()=>{while(dirty&&!closed){dirty=false;await run();}})().catch(error=>{
       log(`board event delivery pending: ${error.code?`${error.code}: `:''}${error.message}`);
       // Retry durable delivery, not a read of the board's current state.
-      retry=setTimeout(()=>wake(false),5000);retry.unref?.();
+      const wait=error.code==='rate_limited'?Math.max(5000,Number(error.details?.retry_after_seconds??30)*1000):5000;heldUntil=Date.now()+wait;
+      clearTimeout(retry);retry=setTimeout(()=>{heldUntil=0;wake(false);},wait);retry.unref?.();
     }).finally(()=>{work=null;});return work;
   };
   return {wake,close(){closed=true;clearTimeout(retry);}};

package/board/event-stream.mjs

@@ -15,14 +15,18 @@ const RESETTLE_MS = 30_000;
 export async function* followBoardPublications({root,after,signal}) {
   const home=identity(root), positions={}, watchers=new Map();
   let dirty=true, wake=null, failure=null, inventory=null;
-  // The stores' files as this follower last left them. Its own pass writes (the publication transaction) and closes
-  // the board, which rewrites the WAL and raises a watch event of its own; an event that finds every store file as the
-  // pass left it is that echo, not a change, and does not start another pass. Without this the follower woke itself
-  // every half second and burned a core with nothing to publish (t_0328d520).
-  let stores=[], settled=null;
-  const stamp=()=>stores.map(path=>{try{const s=statSync(path);return `${s.size}:${s.mtimeMs}`;}catch{return '-';}}).join('|');
+  // Each store file as this follower's own pass left it, stamped right after that board's close. Its pass writes (the
+  // publication transaction) and closes the board, which rewrites the WAL and raises a watch event of its own; an event
+  // for a store file that is still as its pass left it is that echo, not a change, and does not start another pass.
+  // Without this the follower woke itself every quarter second and burned a core with nothing to publish
+  // (t_0328d520). Stamped per board, a write to one board while later boards' passes run is never taken for an echo.
+  let stores=[];
+  const settled=new Map();
+  const statOf=path=>{try{const s=statSync(path);return `${s.size}:${s.mtimeMs}`;}catch{return '-';}};
   const notify=(name=null)=>{
-    if(name!==null&&settled!==null&&stores.some(path=>basename(path)===name)&&stamp()===settled)return;
+    const named=name===null?[]:stores.filter(path=>basename(path)===name);
+    // A store file no pass stamps (the root's kanban.db where only named boards exist) reads '-' until one does.
+    if(named.length&&named.every(path=>statOf(path)===(settled.get(path)??'-')))return;
     dirty=true;wake?.();
   };
   const directory=(path,accept)=>{
@@ -90,12 +94,11 @@ export async function* followBoardPublications({root,after,signal}) {
               for(const row of rows){positions[slug].sequence=row.sequence;yield {type:'event',id:row.id,kind:row.kind,cursor:cursorOf(home,positions),data:{board:slug,card:JSON.parse(row.snapshot)}};}
             }
           }
-        }finally{board.close();}
+        }finally{board.close();const paths=backingPaths(root,slug);for(const path of [paths.sqlite,`${paths.sqlite}-wal`])settled.set(path,statOf(path));}
       }
       if(initial){initial=false;yield {type:'snapshot_end',cursor:cursorOf(home,positions)};dirty=true;}
       else if(checkpointPending){checkpointPending=false;yield {type:'checkpoint',cursor:cursorOf(home,positions)};}
-      settled=stamp();
-      // A write that lands between the pass and the stamp above has its event taken for this pass's echo: a pass
+      // A write that lands between a board's close and its stamp has its event taken for that pass's echo: a pass
       // every RESETTLE_MS anyway bounds how long that write can wait.
       let timer=null;
       if(!dirty&&!signal?.aborted)await new Promise(done=>{wake=done;timer=setTimeout(()=>{dirty=true;done();},RESETTLE_MS);timer.unref?.();if(dirty||signal?.aborted)done();});

package/loop.mjs

@@ -200,7 +200,7 @@ export class Orchestrator {
       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)){
         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}`);}
+        catch(error){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}`);}
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-orchestrator",
-  "version": "0.5.12",
+  "version": "0.5.14",
   "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": {
@@ -25,7 +25,7 @@
   },
   "dependencies": {
     "@volter/supercode-harness-sdk": "^0.3.41",
-    "@volter/teams": "0.2.7",
+    "@volter/teams": "0.2.8",
     "@volter/ztrack": "^2.4.23",
     "yaml": "^2.9.0"
   },