@volter/supercode-orchestrator 0.5.36 → 0.5.37

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/board/dispatch.mjs

@@ -20,7 +20,7 @@ import { readEventFleet } from './event-fleet.mjs';
 let eventFleetRoot = 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,agentProfileMismatch,activeAgentAssignments,finishAgentAssignment,synchronizeAgentEnds, agentRunForSession } from '../agents.mjs';
 import { materializeAgentHome } from '../agent-home.mjs';
 import { memorySnapshotSync } from '../hermes-cli.mjs';
 import { createRequire } from 'node:module';
@@ -684,28 +684,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 +710,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
@@ -1831,7 +1816,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 +1830,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;

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.37",
   "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": {