@volter/supercode-orchestrator 0.5.13 → 0.5.15

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
@@ -2192,6 +2192,9 @@ export async function tick({ root, lanes, settings, only = null, slugs = null, d
     try {
       board = openBoard(root, slug);
       board.label = boardLabel(root, slug);
+      // A board document committed by a write whose push the remote refused (or never answered) is published by the
+      // round, not left for the next write: a quiet board still reaches its remote.
+      try { board.publishPending?.(); } catch (error) { report.queued.push(['board document', `push pending: ${error.message}`]); }
       // what the dispatcher records on its own is the board's act
       setActor(boardAddress(board.label));
       // where the tick's time goes, phase by phase (ms), printed by `serve --verbose` and in `--json`

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/git-document.mjs

@@ -6,8 +6,8 @@
 // the two texts of a board document merged by ztrack's own document merge, in which a hand edit wins its cards. Nothing
 // either side wrote is dropped; a merge that cannot be made stops the push and says why, leaving both texts in the
 // checkout's history.
-import { execFileSync } from 'node:child_process';
-import { readFileSync, writeFileSync } from 'node:fs';
+import { execFileSync, spawn } from 'node:child_process';
+import { readFileSync, statSync, writeFileSync } from 'node:fs';
 import { basename, dirname, relative } from 'node:path';
 
 const git = (cwd, args, input) => execFileSync('git', args, { cwd, encoding: 'utf8', stdio: [input === undefined ? 'ignore' : 'pipe', 'pipe', 'pipe'], ...(input === undefined ? {} : { input }), timeout: 120_000 });
@@ -23,6 +23,10 @@ const indexed = (cwd, args) => {
   }
 };
 
+const FETCH_EVERY_MS = 15_000;
+/** When this checkout last asked its remote (git writes FETCH_HEAD on every fetch, whichever process ran it). */
+const fetchedAt = (root) => { try { return statSync(git(root, ['rev-parse', '--git-path', 'FETCH_HEAD']).trim().replace(/^(?!\/)/, `${root}/`)).mtimeMs; } catch { return 0; } };
+
 export class GitDocument {
   constructor(paths, merge) {
     this.paths = paths;
@@ -46,11 +50,16 @@ export class GitDocument {
     this.warnedDetached = true;
   }
 
-  // Before a write: take what was pushed, so a merged pull request's edit is the document the write starts from.
+  // Before a write: take what was pushed, so a merged pull request's edit is the document the write starts from. The
+  // remote is asked at most every FETCH_EVERY_MS (git's own FETCH_HEAD is the stamp, so every board process shares it):
+  // a fetch on every write put a network round trip on each one. A checkout holding commits its background push did
+  // not land (refused: something was pushed meanwhile) takes what was pushed now and pushes before writing again.
   pull() {
     if (!this.usable) return;
     const branch = this.branch();
     if (!branch) return this.detached();
+    if (this.unpushed(branch)) return this.pushing ? undefined : this.publish(branch, 'board');
+    if (Date.now() - fetchedAt(this.root) < FETCH_EVERY_MS) return;
     if (quiet(this.root, ['fetch', '--quiet', 'origin', branch]) === null) return; // offline: the next write tries again
     const behind = Number(git(this.root, ['rev-list', '--count', `HEAD..origin/${branch}`]).trim());
     if (behind === 0) return;
@@ -72,6 +81,33 @@ export class GitDocument {
     indexed(this.root, ['-c', `user.name=${who}`, '-c', 'user.email=board@supercode.invalid', 'commit', '--quiet', '--author', `${who} <board@supercode.invalid>`, '-m', message, '--', ...files]);
     const branch = this.branch();
     if (!branch) return this.detached();
+    // The push leaves the write's path: the commit is the write, and a push the remote refuses is taken up by the next
+    // write's pull (unpushed commits), which merges what was pushed and pushes before it writes.
+    // While it runs, this process's next write does not push the same commits beside it.
+    const pushing = spawn('git', ['push', '--quiet', 'origin', `HEAD:${branch}`], { cwd: this.root, stdio: 'ignore', detached: true });
+    this.pushing = pushing;
+    const done = () => { if (this.pushing === pushing) this.pushing = null; };
+    pushing.on('error', done); pushing.on('exit', done);
+    pushing.unref();
+  }
+
+  /** The board's round: publish what an earlier write committed and the remote has not taken (a refused or failed
+   *  background push), with the same merge and three attempts a write's pull uses. */
+  publishPending() {
+    if (!this.usable || this.pushing) return;
+    const branch = this.branch();
+    if (!branch || !this.unpushed(branch)) return;
+    if (quiet(this.root, ['fetch', '--quiet', 'origin', branch]) === null) return; // offline: the next round tries again
+    if (this.unpushed(branch)) this.publish(branch, 'board');
+  }
+
+  /** Whether this checkout holds board commits the remote does not have. */
+  unpushed(branch) {
+    return Number(quiet(this.root, ['rev-list', '--count', `origin/${branch}..HEAD`])?.trim() || 0) > 0;
+  }
+
+  /** Push what this checkout holds, taking anything pushed meanwhile. */
+  publish(branch, who) {
     for (let attempt = 0; attempt < 3; attempt++) {
       if (quiet(this.root, ['push', '--quiet', 'origin', `HEAD:${branch}`]) !== null) return;
       if (quiet(this.root, ['fetch', '--quiet', 'origin', branch]) === null) throw new Error('the board documents were committed here but could not be pushed: the remote did not answer');

package/board/ztrack.mjs

@@ -69,7 +69,7 @@ export function openZtrackBoard(marker, { create = false, document = null, seed
   const backing = new ZtrackBoard({ ...config, seed, marker, init, root, slug, compatPath });
   // A board made here is in Hermes's kanban.db at once, not after its first write.
   if (create) backing.exportFollowing();
-  return { db: backing.db, tx: (fn) => backing.tx(fn), close: () => backing.close(), document: backing.path };
+  return { db: backing.db, tx: (fn) => backing.tx(fn), publishPending: () => backing.git?.publishPending(), close: () => backing.close(), document: backing.path };
 }
 
 class ZtrackBoard {

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.13",
+  "version": "0.5.15",
   "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"
   },