@volter/supercode-orchestrator 0.5.73 → 0.5.75

package/agents.mjs

@@ -24,8 +24,8 @@ function store(root){
   return db;
 }
 const digest=value=>createHash('sha256').update(value).digest('hex');
-const minted=(key,machine)=>{
-  const reply=runtimeDoor(machine,'harness.v1.agents.mint',{key});
+const minted=async(key,machine)=>{
+  const reply=await runtimeDoor(machine,'harness.v1.agents.mint',{key});
   if(reply.code===0)return JSON.parse(reply.stdout).id;
   // A host without the machine daemon (a container running only the orchestrator) mints the same
   // globally unique shape here; the intent row keyed by this key is what keeps the id stable.
@@ -65,14 +65,18 @@ export function finishAgentAssignment(root,org,assignment,reason){
   }catch(error){try{db.exec('ROLLBACK');}catch{}throw error;}finally{db.close();}
 }
 /** Mint and retain intent before any network call. Offline declarations keep their immutable id for sync. */
-export function declareAgentIntent({root,org,server,profiles,profile,key,machine=null,refresh=true}) {
-  const intended=resolveAgentProfile(profiles,profile),stable=`${server}/${org}/${key}`,db=store(root);
+export async function declareAgentIntent({root,org,server,profiles,profile,key,machine=null,refresh=true}) {
+  const intended=resolveAgentProfile(profiles,profile),stable=`${server}/${org}/${key}`;
+  // the id is minted (a door call, awaited) before the store is opened: no write is held across it
+  const known=(db)=>{const head=db.prepare('SELECT * FROM agent_declaration_heads WHERE org=? AND key=?').get(org,stable);
+    return head?db.prepare('SELECT * FROM agent_intents WHERE org=? AND id=?').get(org,head.agent_id):db.prepare('SELECT * FROM agent_intents WHERE org=? AND key=?').get(org,stable);};
+  let peek=store(root),mint=null;try{if(!known(peek))mint=await minted(stable,machine);}finally{peek.close();}
+  const db=store(root);
   try {
-    const head=db.prepare('SELECT * FROM agent_declaration_heads WHERE org=? AND key=?').get(org,stable);
-    let row=head?db.prepare('SELECT * FROM agent_intents WHERE org=? AND id=?').get(org,head.agent_id):db.prepare('SELECT * FROM agent_intents WHERE org=? AND key=?').get(org,stable);
+    let row=known(db);
     const fresh=!row;
     if(!row){
-      const id=minted(stable,machine);
+      const id=mint??await minted(stable,machine);
       db.prepare('INSERT INTO agent_intents(org,id,key,profile_ref,profile_json,declared,created_at) VALUES (?,?,?,?,?,0,?) ON CONFLICT(org,key) DO NOTHING').run(org,id,stable,profile,JSON.stringify(intended),Date.now());
       row=db.prepare('SELECT * FROM agent_intents WHERE org=? AND key=?').get(org,stable);
     }
@@ -81,7 +85,11 @@ export function declareAgentIntent({root,org,server,profiles,profile,key,machine
     return {id:row.id,key:row.key,baseKey:stable,declared:!!row.declared,intended:refresh?intended:JSON.parse(row.profile_json),fresh,org};
   }finally{db.close();}
 }
-function nextAgentGeneration(root,intent,machine){
+async function nextAgentGeneration(root,intent,machine){
+  // the next generation's id is minted before the write opens (a door call, awaited, never inside the transaction);
+  // a head moved meanwhile answers with its agent, and the mint (keyed) is simply not used
+  let peek=store(root),next;try{const head=peek.prepare('SELECT generation FROM agent_declaration_heads WHERE org=? AND key=?').get(intent.org,intent.baseKey);next=head?{generation:head.generation+1}:null;}finally{peek.close();}
+  if(next){next.key=`${intent.baseKey}/generation/${next.generation}`;next.id=await minted(next.key,machine);}
   const db=store(root);try{
     db.exec('BEGIN IMMEDIATE');
     const head=db.prepare('SELECT * FROM agent_declaration_heads WHERE org=? AND key=?').get(intent.org,intent.baseKey);
@@ -89,7 +97,9 @@ function nextAgentGeneration(root,intent,machine){
       const row=db.prepare('SELECT * FROM agent_intents WHERE org=? AND id=?').get(intent.org,head.agent_id);db.exec('COMMIT');
       return {...intent,id:row.id,key:row.key,declared:!!row.declared};
     }
-    const generation=head.generation+1,key=`${intent.baseKey}/generation/${generation}`,id=minted(key,machine);
+    const generation=head.generation+1,key=`${intent.baseKey}/generation/${generation}`;
+    if(next?.generation!==generation){db.exec('ROLLBACK');return await nextAgentGeneration(root,intent,machine);}
+    const id=next.id;
     db.prepare('INSERT INTO agent_intents(org,id,key,profile_ref,profile_json,created_at) VALUES (?,?,?,?,?,?)').run(intent.org,id,key,intent.intended.profile,JSON.stringify(intent.intended),Date.now());
     db.prepare('UPDATE agent_declaration_heads SET agent_id=?,generation=? WHERE org=? AND key=?').run(id,generation,intent.org,intent.baseKey);
     db.exec('COMMIT');return {...intent,id,key,declared:false};
@@ -106,15 +116,15 @@ function recordDeclaration(root,org,id,declaration){
 /** The identity a run starts as, never asking Teams: the daemon-minted id and retained intent. Its declaration is handed
  * to this machine's daemon (handOffAgents), which declares it to Teams under the same id. Nothing is granted from this
  * local record; `identity.synced` says whether the declaration has been handed on. */
-function localAgent(options,{key,name,declaration,assignment,parent=null,starter}){
+async 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});
+  const rootIntent=await declareAgentIntent({root,org,server,profiles,profile:rootProfile,key:'root',machine,refresh:false});
   recordDeclaration(root,org,rootIntent.id,{kind:'root',profile:rootProfile,name:basename(root),parent:null});
-  let intent=key==='root'?rootIntent:declareAgentIntent({root,org,server,profiles,profile,key,machine});
+  let intent=key==='root'?rootIntent:await declareAgentIntent({root,org,server,profiles,profile,key,machine});
   // An agent ended here is never started again: its end is on its runs here (handOffAgents), 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'&&endedHere(root,org,intent.id))intent=await nextAgentGeneration(root,intent,machine);
   const above=parent??(key==='root'?null:{id:rootIntent.id,path:basename(root)});
   if(key!=='root')recordDeclaration(root,org,intent.id,{...declaration,name,parent:above?.id??null});
   const identity={id:intent.id,kind:'agent',org,name,path:above?`${above.path}/${name}`:name,parent:above?.id??null,
@@ -123,7 +133,7 @@ function localAgent(options,{key,name,declaration,assignment,parent=null,starter
   const assigned=assignAgent(root,org,intent.id,assignment);
   return {identity,intended:intent.intended,assignment:assigned,assignments:[assignment],org,synced:false};
 }
-export function localCardAgent(options){
+export async function localCardAgent(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.
@@ -138,7 +148,7 @@ export function localCardAgent(options){
     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)}`}});
 }
-export function localProfileAgent(options){
+export async function localProfileAgent(options){
   const {root,profiles,profile,agent:declared=null,declarations={}}=options,rootProfile=profiles.default?'default':profile;
   const starter={kind:'automation',id:`orchestrator:${basename(root)}`};
   if(declared&&declared!==profile){
@@ -148,7 +158,7 @@ export function localProfileAgent(options){
   }
   if(profile===rootProfile)return localAgent(options,{key:'root',name:basename(root),assignment:{kind:'profile',target:profile,role:'profile'},declaration:{kind:'root',profile},starter});
   resolveAgentProfile(profiles,profile);
-  const parentProfile=profiles[profile].parent,parent=parentProfile&&parentProfile!==rootProfile?localProfileAgent({...options,profile:parentProfile}).identity:null;
+  const parentProfile=profiles[profile].parent,parent=parentProfile&&parentProfile!==rootProfile?(await localProfileAgent({...options,profile:parentProfile})).identity:null;
   return localAgent(options,{key:`profile/${profile}`,name:profile,parent,assignment:{kind:'profile',target:profile,role:'profile'},declaration:{kind:'profile',profile},starter});
 }
 /** A local identity for a retained run: its id, intent and assignments, without a Teams record. */
@@ -189,13 +199,13 @@ function adoptLocalOrg(root,scope){
 }
 /** An explicit fork's child, declared under its parent and started by the fork's source session; the source must be a
  * session this home ran for the parent. Local: the child's declaration is handed on like any other (handOffAgents). */
-export function localForkAgent(options){
+export async function localForkAgent(options){
   const {root,org,profiles,parent,session,name,key}=options;
   const owner=agentRunForSession(root,[session]);
   if(owner?.agent_id!==parent)throw new Error('fork source is not a session of the declared parent');
   const parentIntent=agentIntent(root,org,parent);
   if(!parentIntent)throw new Error('fork parent has no retained profile intent here');
-  let intent=declareAgentIntent({...options,profile:parentIntent.profile_ref,key:`fork/${parent}/${key}`,refresh:false});
+  let intent=await declareAgentIntent({...options,profile:parentIntent.profile_ref,key:`fork/${parent}/${key}`,refresh:false});
   if(endedHere(root,org,intent.id))throw new Error('this fork identity ended; declare a new fork key');
   // The snapshot copies configuration only. Memory stays the new child's own empty state.
   const intended=structuredClone(intent.fresh?parentIntent.profile:intent.intended);
@@ -227,9 +237,9 @@ function contextForOrg(org){
  * (the context named, for its org alone). Never the process's own environment: the work was recorded for an org, and
  * that org's context is the one that delivers it.
  */
-export function handOffAgents(root,{context=null}={}){
+export async function handOffAgents(root,{context=null}={}){
   const waiting=[];
-  if(context){const scope=agentScope(context);if(!scope.offline)handOffOrg(root,scope,waiting);return waiting;}
+  if(context){const scope=agentScope(context);if(!scope.offline)await handOffOrg(root,scope,waiting);return waiting;}
   let orgs;
   const db=store(root);
   try{orgs=db.prepare("SELECT org FROM agent_intents WHERE declared=0 AND declaration_json IS NOT NULL UNION SELECT org FROM agent_end_outbox").all().map(row=>row.org).filter(org=>org&&org!=='local');}
@@ -240,13 +250,13 @@ export function handOffAgents(root,{context=null}={}){
       const named=contextForOrg(org);
       if(!named){waiting.push({agent:'*',error:`no Teams context on this machine for org ${org} (or several, none selected); its agent work waits`});continue;}
       const scope=agentScope(named);
-      if(!scope.offline&&scope.org===org)handOffOrg(root,scope,waiting);
+      if(!scope.offline&&scope.org===org)await handOffOrg(root,scope,waiting);
     }catch(error){waiting.push({agent:'*',error:`org ${org}: ${error.message}; its agent work waits`});}
   }
   return waiting;
 }
 
-function handOffOrg(root,scope,waiting){
+async function handOffOrg(root,scope,waiting){
   adoptLocalOrg(root,scope);
   let db=store(root),rows,ends;
   try{
@@ -258,7 +268,7 @@ function handOffOrg(root,scope,waiting){
     const body={org:scope.org,id:row.id,name:declaration.name??declaration.profile,parent:declaration.parent??null,profile:declaration.profile,
       ...(declaration.kind==='root'?{root:true}:{}),...(declaration.sponsor?{sponsor:declaration.sponsor}:{}),
       ...(declaration.starterSession?{starter_session:declaration.starterSession}:{}),key:digest(row.key)};
-    const reply=runtimeDoor(null,'harness.v1.agents.declare',body,{timeout:15_000});
+    const reply=await runtimeDoor(null,'harness.v1.agents.declare',body,{timeout:15_000});
     if(reply.code!==0){waiting.push({agent:row.id,error:`not handed to this machine's daemon: ${reply.stderr.trim().split('\n').at(-1)}`});break;}
     db=store(root);try{db.prepare('UPDATE agent_intents SET declared=1 WHERE org=? AND id=?').run(scope.org,row.id);}finally{db.close();}
   }
@@ -266,7 +276,7 @@ function handOffOrg(root,scope,waiting){
     db=store(root);let active;
     try{active=db.prepare("SELECT 1 FROM agent_assignments WHERE org=? AND agent_id=? AND state='active'").get(scope.org,row.agent_id);if(active)db.prepare('DELETE FROM agent_end_outbox WHERE org=? AND agent_id=?').run(scope.org,row.agent_id);}finally{db.close();}
     if(active)continue;
-    const reply=runtimeDoor(null,'harness.v1.agents.end',{org:scope.org,agent:row.agent_id,reason:row.reason,key:digest(`${scope.org}/${row.agent_id}/end/${row.created_at}`)},{timeout:15_000});
+    const reply=await runtimeDoor(null,'harness.v1.agents.end',{org:scope.org,agent:row.agent_id,reason:row.reason,key:digest(`${scope.org}/${row.agent_id}/end/${row.created_at}`)},{timeout:15_000});
     if(reply.code!==0){waiting.push({agent:row.agent_id,error:`end not handed to this machine's daemon: ${reply.stderr.trim().split('\n').at(-1)}`});break;}
     db=store(root);
     try{

package/bin/orchestrator.mjs

@@ -18,6 +18,8 @@ if (process.argv[2] === 'workflow') {
   // a store's own error (SQLite's, with its errcode) is no message written for a person: its stack says which statement
   // met it, as a follower's end in the connector's log (board events) otherwise could not
   catch(error) {process.stderr.write(`supercode workflow: ${error.message??error}\n${error?.errcode!=null&&error.stack?`${error.stack}\n`:''}`);code=1;}
+  // the board documents' git work this command queued (a ztrack board's commit and push) is finished before it exits
+  try{const{settleDocuments}=await import('../board/git-document.mjs');await settleDocuments();}catch{/* nothing queued */}
   await Promise.all([process.stdout,process.stderr].map(stream=>new Promise(done=>stream.write('',done))));
   process.exit(code);
 } else if (process.argv[2] === 'agent-channel') {

package/board/agent-declarations.mjs

@@ -5,7 +5,7 @@ import { agentScope, localCardAgent, finishAgentAssignment, activeAgentAssignmen
 import { event, json, tx, view } from './store.mjs';
 import { workflowFor } from './workflow.mjs';
 
-export function declareCardAgentEffect(board,effect) {
+export async function declareCardAgentEffect(board,effect) {
   const task=view(board,db=>db.prepare('SELECT t.*,c.subtask_of,c.archived,c.sponsor FROM tasks t JOIN supercode_cards c ON c.task_id=t.id WHERE t.id=?').get(effect.id));
   if(!task||task.subtask_of)return true;
   const entry=workflowFor(board.root),profile=task.assignee??effect.profile??entry.params.default_assignee;
@@ -19,10 +19,10 @@ export function declareCardAgentEffect(board,effect) {
     const context=effect.context,scope=agentScope(context);
     const options={root:board.root,org:scope.org,server:scope.server,profiles:entry.profiles,
       profile,card:effect.id,role:effect.role,sponsor:task.sponsor??null,context,starterSession:effect.starter_session};
-    const agent=localCardAgent(options);
+    const agent=await localCardAgent(options);
     if(task.archived||['done','cancelled','archived'].includes(task.status))finishAgentAssignment(board.root,scope.org,agent.assignment,`card ${effect.id} ${task.status}`);
     // A daemon not running keeps the declaration here; every delivery pass hands it on again.
-    const waiting=handOffAgents(board.root,{context});
+    const waiting=await handOffAgents(board.root,{context});
     tx(board,db=>event(db,effect.id,'agent_declared',{agent:agent.identity.id,org:scope.org,role:effect.role,profile,assignment:agent.assignment,handed_to_machine:!waiting.length}));
     return true;
   }catch(error) {
@@ -33,12 +33,12 @@ export function declareCardAgentEffect(board,effect) {
 
 /** The card agents of `ids` whose cards are done, cancelled or archived end their assignments, and an agent left with
  * none has its end handed to this machine's daemon: run by the verb that closed the card, so no dispatcher is needed. */
-export function endFinishedAgents(board,ids){
+export async function endFinishedAgents(board,ids){
   const wanted=new Set(ids.map(String)),assignments=activeAgentAssignments(board.root).filter(item=>item.kind==='card'&&wanted.has(String(item.target)));
   if(!assignments.length)return [];
   for(const assignment of assignments){
     const task=view(board,db=>db.prepare('SELECT t.status,c.archived FROM tasks t JOIN supercode_cards c ON c.task_id=t.id WHERE t.id=?').get(assignment.target));
     if(task&&(task.archived||['done','cancelled','archived'].includes(task.status)))finishAgentAssignment(board.root,assignment.org,assignment.id,`card ${assignment.target} ${task.archived?'archived':task.status}`);
   }
-  return handOffAgents(board.root);
+  return await handOffAgents(board.root);
 }