@volter/supercode-orchestrator 0.5.176 → 0.5.178

package/agents.mjs

@@ -1,6 +1,6 @@
 // Teams identity, orchestrator intent and assignments: one boundary, joined by the immutable agent id.
 import { DatabaseSync } from 'node:sqlite';
-import { mkdirSync } from 'node:fs';
+import { mkdirSync, existsSync } from 'node:fs';
 import { join, basename } from 'node:path';
 import { createHash, randomBytes } from 'node:crypto';
 import { runtimeDoor } from './board/runtime-door.mjs';
@@ -18,10 +18,15 @@ function store(root){
   CREATE TABLE IF NOT EXISTS agent_declaration_heads(org TEXT NOT NULL,key TEXT NOT NULL,agent_id TEXT NOT NULL,generation INTEGER NOT NULL DEFAULT 0,PRIMARY KEY(org,key));
   CREATE TABLE IF NOT EXISTS agent_assignments(org TEXT NOT NULL,id TEXT NOT NULL,agent_id TEXT NOT NULL,kind TEXT NOT NULL,target TEXT NOT NULL,role TEXT NOT NULL,state TEXT NOT NULL,started_at INTEGER NOT NULL,ended_at INTEGER,PRIMARY KEY(org,id));
   CREATE INDEX IF NOT EXISTS agent_active_assignments ON agent_assignments(org,agent_id,state);
+  CREATE INDEX IF NOT EXISTS agent_card_assignments ON agent_assignments(kind,target);
+  CREATE TABLE IF NOT EXISTS agent_card_assignment_changes(sequence INTEGER PRIMARY KEY AUTOINCREMENT,target TEXT NOT NULL,payload TEXT NOT NULL,recorded INTEGER NOT NULL DEFAULT 0);
+  CREATE INDEX IF NOT EXISTS agent_card_assignment_changes_pending ON agent_card_assignment_changes(recorded,target,sequence);
+  CREATE TABLE IF NOT EXISTS agent_card_scope_transitions(target TEXT PRIMARY KEY,from_org TEXT NOT NULL,to_org TEXT NOT NULL,changed_at INTEGER NOT NULL);
   CREATE TABLE IF NOT EXISTS agent_end_outbox(org TEXT NOT NULL,agent_id TEXT NOT NULL,reason TEXT NOT NULL,created_at INTEGER NOT NULL,PRIMARY KEY(org,agent_id));
   CREATE TABLE IF NOT EXISTS agent_runtime_sessions(org TEXT NOT NULL,runtime_ref TEXT NOT NULL,session_ref TEXT NOT NULL,PRIMARY KEY(org,runtime_ref));
   CREATE TABLE IF NOT EXISTS agent_runs(org TEXT NOT NULL,agent_id TEXT NOT NULL,session_ref TEXT NOT NULL,machine TEXT,run_id TEXT,profile_json TEXT,ended_at INTEGER,end_reason TEXT,main INTEGER NOT NULL DEFAULT 1,starter_session TEXT,usage_json TEXT,PRIMARY KEY(org,session_ref));
   CREATE TABLE IF NOT EXISTS agent_usage_unread(org TEXT NOT NULL,session_ref TEXT NOT NULL,stamp TEXT NOT NULL,PRIMARY KEY(org,session_ref));`);
+  db.prepare('DELETE FROM agent_card_assignment_changes WHERE recorded=1').run();
   return db;
 }
 const digest=value=>createHash('sha256').update(value).digest('hex');
@@ -34,10 +39,50 @@ const minted=async(key,machine)=>{
   throw new Error(`agent id mint unavailable: ${reply.stderr.slice(-500)}`);
 };
 export function agentIntent(root,org,id){const db=store(root);try{const row=db.prepare('SELECT * FROM agent_intents WHERE org=? AND id=?').get(org,id);return row?{...row,profile:JSON.parse(row.profile_json),assignments:db.prepare("SELECT * FROM agent_assignments WHERE org=? AND agent_id=? AND state='active'").all(org,id)}:null;}finally{db.close();}}
+/** Ownership moves and their board obligation commit together in the assignment owner's store. */
+function retainCardAgentChange(db,old,to,profile){
+  if(old?.kind!=='card'||old.agent_id===to)return;
+  const fromProfile=db.prepare('SELECT profile_ref FROM agent_intents WHERE org=? AND id=?').get(old.org,old.agent_id)?.profile_ref??null;
+  db.prepare('INSERT INTO agent_card_assignment_changes(target,payload) VALUES (?,?)').run(old.target,JSON.stringify({org:old.org,assignment:old.id,role:old.role,from:old.agent_id,to,profile:profile??null,from_profile:fromProfile,changed_at:Date.now()}));
+}
 export function assignAgent(root,org,id,{kind,target,role}){
-  const db=store(root),key=digest(JSON.stringify([kind,target,role]));try{db.prepare("INSERT INTO agent_assignments(org,id,agent_id,kind,target,role,state,started_at) VALUES (?,?,?,?,?,?,'active',?) ON CONFLICT(org,id) DO UPDATE SET agent_id=excluded.agent_id,state='active',ended_at=NULL").run(org,key,id,kind,target,role,Date.now());return key;}finally{db.close();}
+  const db=store(root),key=digest(JSON.stringify([kind,target,role]));try{
+    db.exec('BEGIN IMMEDIATE');
+    if(kind==='card'&&org==='local'&&db.prepare('SELECT 1 FROM agent_card_scope_transitions WHERE target=?').get(target)){
+      console.warn(`card agent rejected: ${target} has left local scope`);
+      throw Object.assign(new Error('card agent scope was adopted; local declarations are refused'),{code:'card_scope_adopted'});
+    }
+    const old=db.prepare('SELECT * FROM agent_assignments WHERE org=? AND id=?').get(org,key);
+    db.prepare("INSERT INTO agent_assignments(org,id,agent_id,kind,target,role,state,started_at) VALUES (?,?,?,?,?,?,'active',?) ON CONFLICT(org,id) DO UPDATE SET agent_id=excluded.agent_id,state='active',ended_at=NULL").run(org,key,id,kind,target,role,Date.now());
+    const profile=db.prepare('SELECT profile_ref FROM agent_intents WHERE org=? AND id=?').get(org,id)?.profile_ref;
+    retainCardAgentChange(db,old,id,profile);
+    db.exec('COMMIT');return key;
+  }catch(error){try{db.exec('ROLLBACK');}catch{}throw error;}finally{db.close();}
 }
 export function activeAgentAssignments(root){const db=store(root);try{return db.prepare("SELECT * FROM agent_assignments WHERE state='active'").all();}finally{db.close();}}
+/** Retained card assignments, including ends a board still owes to its publication log. */
+export function cardAgentAssignments(root,target=null){const db=store(root);try{return db.prepare(`SELECT a.*,i.profile_ref AS profile FROM agent_assignments a LEFT JOIN agent_intents i ON i.org=a.org AND i.id=a.agent_id WHERE a.kind='card'${target===null?'':' AND a.target=?'} ORDER BY a.target,a.role,a.org,a.id`).all(...(target===null?[]:[target]));}finally{db.close();}}
+/** Adoption remains authoritative after its delivery receipt is acknowledged. One read pins scope and native state. */
+export function cardAgentScopeTransition(root,target){
+  const path=join(root,'agent-state.sqlite');if(!existsSync(path))return null;
+  const db=new DatabaseSync(path,{readOnly:true});
+  try{
+    db.exec('PRAGMA busy_timeout=5000; BEGIN');
+    if(!db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='agent_card_scope_transitions'").get())return null;
+    const transition=db.prepare('SELECT from_org,to_org AS org,changed_at FROM agent_card_scope_transitions WHERE target=?').get(target);
+    if(!transition)return null;
+    const assignments=db.prepare("SELECT a.*,i.profile_ref AS profile FROM agent_assignments a LEFT JOIN agent_intents i ON i.org=a.org AND i.id=a.agent_id WHERE a.kind='card' AND a.target=? AND a.org=? ORDER BY a.role,a.id").all(target,transition.org);
+    return {...transition,assignments};
+  }finally{db.close();}
+}
+/** A board consumes these in receipt order before mirroring the assignment's present owner or end. */
+export function pendingCardAgentChanges(root,target){const db=store(root);try{return db.prepare('SELECT sequence,payload FROM agent_card_assignment_changes WHERE recorded=0 AND target=? ORDER BY sequence').all(target).map(row=>({receipt:Number(row.sequence),...JSON.parse(row.payload)}));}finally{db.close();}}
+/** The board committed facts and dedupe watermark before acknowledging; only pending receipts remain here. */
+export function acknowledgeCardAgentChanges(root,receipts){const db=store(root);try{
+  db.exec('BEGIN IMMEDIATE');
+  for(const receipt of receipts)db.prepare('DELETE FROM agent_card_assignment_changes WHERE sequence=?').run(receipt);
+  db.exec('COMMIT');
+}catch(error){try{db.exec('ROLLBACK');}catch{}throw error;}finally{db.close();}}
 export async function reassignAgent(root,org,assignment,to,{context}={}) {
   const target=(await agentDoor('management',[to],{context})).data;
   const db=store(root);
@@ -48,6 +93,7 @@ export async function reassignAgent(root,org,assignment,to,{context}={}) {
     db.exec('BEGIN IMMEDIATE');
     const moved=db.prepare("UPDATE agent_assignments SET agent_id=? WHERE org=? AND id=? AND agent_id=? AND state='active'").run(to,org,assignment,old.agent_id);
     if(moved.changes!==1)throw new Error('assignment changed while reassigning it');
+    retainCardAgentChange(db,old,to,target.profile);
     db.prepare('DELETE FROM agent_end_outbox WHERE org=? AND agent_id=?').run(org,to);
     if(old.agent_id!==to&&!db.prepare("SELECT 1 FROM agent_assignments WHERE org=? AND agent_id=? AND state='active'").get(org,old.agent_id))
       db.prepare('INSERT OR IGNORE INTO agent_end_outbox(org,agent_id,reason,created_at) VALUES (?,?,?,?)').run(org,old.agent_id,`last assignment reassigned to ${to}`,Date.now());
@@ -58,11 +104,12 @@ export async function reassignAgent(root,org,assignment,to,{context}={}) {
 export function finishAgentAssignment(root,org,assignment,reason){
   const db=store(root);try{
     db.exec('BEGIN IMMEDIATE');
-    const row=db.prepare("SELECT * FROM agent_assignments WHERE org=? AND id=? AND state='active'").get(org,assignment);
-    if(!row){db.exec('COMMIT');return;}
+    const row=db.prepare('SELECT * FROM agent_assignments WHERE org=? AND id=?').get(org,assignment);
+    if(!row||row.state!=='active'){db.exec('COMMIT');return row??null;}
     const at=Date.now();db.prepare("UPDATE agent_assignments SET state='ended',ended_at=? WHERE org=? AND id=?").run(at,org,assignment);
     if(!db.prepare("SELECT 1 FROM agent_assignments WHERE org=? AND agent_id=? AND state='active'").get(org,row.agent_id))db.prepare('INSERT OR IGNORE INTO agent_end_outbox(org,agent_id,reason,created_at) VALUES (?,?,?,?)').run(org,row.agent_id,reason,at);
     db.exec('COMMIT');
+    return {...row,state:'ended',ended_at:at};
   }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. */
@@ -136,6 +183,10 @@ async function localAgent(options,{key,name,declaration,assignment,parent=null,s
 }
 export async function localCardAgent(options){
   const {root,org,server,profiles,card,role,profile}=options;
+  if(org==='local'&&cardAgentScopeTransition(root,card)){
+    console.warn(`card agent rejected: ${card} has left local scope`);
+    throw Object.assign(new Error('card agent scope was adopted; local declarations are refused'),{code:'card_scope_adopted'});
+  }
   // 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);
@@ -216,8 +267,18 @@ function adoptLocalOrg(root,scope){
     }
     for(const head of db.prepare("SELECT * FROM agent_declaration_heads WHERE org='local'").all())
       db.prepare('INSERT OR IGNORE INTO agent_declaration_heads(org,key,agent_id,generation) VALUES (?,?,?,?)').run(scope.org,rekey(head.key),ids.get(head.agent_id)??head.agent_id,head.generation);
-    for(const [old,id] of ids)for(const table of ['agent_assignments','agent_runs','agent_end_outbox'])
-      db.prepare(`UPDATE OR IGNORE ${table} SET org=?,agent_id=? WHERE org='local' AND agent_id=?`).run(scope.org,id,old);
+    // An earlier transition is permanent: even an old writer's stray local row cannot migrate it again.
+    db.prepare("DELETE FROM agent_assignments WHERE org='local' AND kind='card' AND target IN (SELECT target FROM agent_card_scope_transitions)").run();
+    const cards=db.prepare("SELECT DISTINCT target FROM agent_assignments WHERE org='local' AND kind='card'").all();
+    // Local transfers cannot describe the destination's native ownership. Drop them in the adoption transaction.
+    db.prepare("DELETE FROM agent_card_assignment_changes WHERE json_extract(payload,'$.org')='local'").run();
+    for(const table of ['agent_assignments','agent_runs','agent_end_outbox'])for(const {agent_id:old} of db.prepare(`SELECT DISTINCT agent_id FROM ${table} WHERE org='local'`).all())
+      db.prepare(`UPDATE OR IGNORE ${table} SET org=?,agent_id=? WHERE org='local' AND agent_id=?`).run(scope.org,ids.get(old)??old,old);
+    for(const card of cards){
+      const transition={kind:'agent_assignment_adopted',org:scope.org,from_org:'local',changed_at:Date.now()};
+      db.prepare('INSERT INTO agent_card_scope_transitions(target,from_org,to_org,changed_at) VALUES (?,?,?,?)').run(card.target,transition.from_org,transition.org,transition.changed_at);
+      db.prepare('INSERT INTO agent_card_assignment_changes(target,payload) VALUES (?,?)').run(card.target,JSON.stringify(transition));
+    }
     for(const table of ['agent_runtime_sessions','agent_usage_unread'])db.prepare(`UPDATE OR IGNORE ${table} SET org=? WHERE org='local'`).run(scope.org);
     for(const table of ['agent_intents','agent_declaration_heads','agent_assignments','agent_runs','agent_end_outbox','agent_runtime_sessions','agent_usage_unread'])db.prepare(`DELETE FROM ${table} WHERE org='local'`).run();
     db.exec('COMMIT');

package/board/agent-declarations.mjs

@@ -1,9 +1,16 @@
 // Consume the card-creation intent after the board transaction; retries reuse the daemon-minted id. The card's agent is
 // minted and recorded here, and its declaration handed to this machine's daemon, which declares it in Teams: whoever ran
 // the effect (the creating command, or a delivery pass retrying it) makes no Teams call (D137).
-import { agentScope, localCardAgent, finishAgentAssignment, activeAgentAssignments, handOffAgents } from '../agents.mjs';
+import { agentScope, localCardAgent, finishAgentAssignment, cardAgentAssignments, cardAgentScopeTransition, pendingCardAgentChanges, acknowledgeCardAgentChanges, handOffAgents } from '../agents.mjs';
 import { event, json, tx, view } from './store.mjs';
 import { workflowFor } from './workflow.mjs';
+import { cardAgentFacts, cardAgentReceiptRecorded, syncCardAgentScope } from './published.mjs';
+
+function admitsScope(board,target,org){
+  if(org!=='local'||!cardAgentScopeTransition(board.root,target))return true;
+  console.warn(`card agent mirror rejected: ${target} has left local scope`);
+  return false;
+}
 
 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));
@@ -11,34 +18,84 @@ export async function declareCardAgentEffect(board,effect) {
   const entry=workflowFor(board.root),profile=task.assignee??effect.profile??entry.params.default_assignee;
   // The reasons already told since the card's last declaration: each is recorded once, so a retry that alternates
   // between two refusals writes nothing (a write wakes the dispatcher, which would retry at once).
-  const told=view(board,db=>new Set(db.prepare("SELECT payload FROM task_events WHERE task_id=? AND kind='agent_declaration_pending' AND id>COALESCE((SELECT max(id) FROM task_events WHERE task_id=? AND kind='agent_declared'),0)").all(effect.id,effect.id).map(row=>json(row.payload,{})?.reason)));
+  const told=view(board,db=>new Set(db.prepare("SELECT payload FROM task_events WHERE task_id=? AND kind='agent_declaration_pending' AND id>MAX(COALESCE((SELECT max(id) FROM task_events WHERE task_id=? AND kind='agent_declared'),0),COALESCE((SELECT declared_event_id FROM supercode_card_agent_facts WHERE task_id=?),0))").all(effect.id,effect.id,effect.id).map(row=>json(row.payload,{})?.reason)));
+  let org;
   try {
     if(!entry.profiles[profile])throw new Error('card agent declaration needs a named profile');
     // the context the card's creator named, kept with the declaration: never the context of whoever retries it
     if(!effect.context)throw new Error('the card agent declaration recorded no Teams context; it is declared again by a call that names one');
     const context=effect.context,scope=agentScope(context);
+    org=scope.org;
+    if(!admitsScope(board,effect.id,org))return true;
     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=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=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}));
+    // Hand-off yielded: an assignment may have ended or moved while it ran. The retained owner row supplies state.
+    const assignment=cardAgentAssignments(board.root,effect.id).find(row=>row.org===scope.org&&row.id===agent.assignment);
+    if(!assignment)throw new Error('card agent declaration has no retained assignment receipt');
+    recordCardAgentChanges(board,effect.id);
+    const state=assignment.agent_id===agent.identity.id?assignment.state:'ended';
+    tx(board,db=>{if(admitsScope(board,effect.id,org))event(db,effect.id,'agent_declared',{agent:agent.identity.id,org:scope.org,role:effect.role,profile:agent.identity.profile??profile,assignment:agent.assignment,state,handed_to_machine:!waiting.length});});
     return true;
   }catch(error) {
+    if(org==='local'&&!admitsScope(board,effect.id,org))return true;
     if(!told.has(error.message))tx(board,db=>event(db,effect.id,'agent_declaration_pending',{role:effect.role,profile,reason:error.message}));
     return false;
   }
 }
 
+/** A failed board write leaves the owner's receipt pending. A failed acknowledgement repeats no board event. */
+export function recordCardAgentChanges(board,target){
+  const changes=pendingCardAgentChanges(board.root,target);
+  const transition=cardAgentScopeTransition(board.root,target);
+  const missingScope=transition&&!view(board,db=>db.prepare('SELECT 1 FROM supercode_card_agent_scopes WHERE task_id=?').get(target));
+  if(!changes.length&&!missingScope)return;
+  const recorded=(db,change)=>cardAgentReceiptRecorded(db,target,change.receipt);
+  if(missingScope||view(board,db=>changes.some(change=>!recorded(db,change))))tx(board,db=>{
+    if(transition)syncCardAgentScope(db,target,transition);
+    for(const change of changes)if(!recorded(db,change)&&admitsScope(board,target,change.org))event(db,target,change.kind??'agent_assignment_reassigned',change);
+  });
+  acknowledgeCardAgentChanges(board.root,changes.map(change=>change.receipt));
+}
+
+/** Mirror a retained assignment (including reviewer roles created on the launch/adoption path) once per state. */
+export function recordCardAgentAssignment(board,assignment){
+  if(!assignment)return;
+  recordCardAgentChanges(board,assignment.target);
+  if(!admitsScope(board,assignment.target,assignment.org))return;
+  const payload=db=>{
+    const previous=cardAgentFacts(db,assignment.target).find(agent=>agent.org===assignment.org&&agent.id===assignment.agent_id&&agent.assignment===assignment.id);
+    const value={agent:assignment.agent_id,org:assignment.org,role:assignment.role,profile:assignment.profile??previous?.profile??null,assignment:assignment.id,state:assignment.state};
+    return previous&&previous.role===value.role&&previous.profile===value.profile&&previous.state===value.state?null:value;
+  };
+  if(!view(board,payload))return;
+  tx(board,db=>{const value=payload(db);if(value&&admitsScope(board,assignment.target,assignment.org))event(db,assignment.target,'agent_declared',value);});
+}
+
+/** End in the assignment owner, then retain that receipt in the card's own transaction. Already ended rows repair
+ * a missed board write on retry; a matching recorded end writes nothing and wakes no dispatcher. */
+export function finishCardAgentAssignment(board,assignment,reason){
+  recordCardAgentChanges(board,assignment.target);
+  if(!admitsScope(board,assignment.target,assignment.org))return;
+  const ended=assignment.state==='ended'?assignment:finishAgentAssignment(board.root,assignment.org,assignment.id,reason);
+  if(ended?.state!=='ended')return;
+  const recorded=db=>cardAgentFacts(db,assignment.target).some(agent=>agent.org===ended.org&&agent.id===ended.agent_id&&agent.assignment===ended.id&&agent.state==='ended');
+  if(view(board,recorded))return;
+  tx(board,db=>{if(!recorded(db)&&admitsScope(board,assignment.target,assignment.org))event(db,assignment.target,'agent_assignment_ended',{
+    agent:ended.agent_id,org:ended.org,role:ended.role,profile:ended.agent_id===assignment.agent_id?assignment.profile??null:null,assignment:ended.id,state:'ended',ended_at:ended.ended_at});});
+}
+
 /** 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 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)));
+  const wanted=new Set(ids.map(String)),assignments=cardAgentAssignments(board.root).filter(item=>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}`);
+    if(task&&(assignment.state==='ended'||task.archived||['done','cancelled','archived'].includes(task.status)))finishCardAgentAssignment(board,assignment,`card ${assignment.target} ${task.archived?'archived':task.status}`);
   }
   return await handOffAgents(board.root);
 }

package/board/cli.mjs

@@ -32,6 +32,7 @@ import { actorOf, CALLER_RUN_ADDRESS, SESSION_CURRENT_RUNS, SESSION_RUNS, sessio
 import { isLocalWorkspace } from './workspace.mjs';
 import { openZtrackBoard } from './ztrack.mjs';
 import * as engine from './engine.mjs';
+import { recordCardAgentChanges } from './agent-declarations.mjs';
 
 // A mailbox read through the mailbox's own command, awaited (never a wait that holds the event loop). Gap A31: a
 // helper process until the daemon owns mail (order 3 PR 4).
@@ -665,7 +666,7 @@ export async function runVerb(argv) {
       const assignment=activeAgentAssignments(root).find(item=>item.org===scope.org&&item.kind==='card'&&item.target===id&&item.role===role);
       if(!assignment)throw new Error('declare the card role before reassigning its assignment');
       const changed=await reassignAgent(root,scope.org,assignment.id,args.agent,{context});
-      withBoard(b=>tx(b,db=>event(db,id,'agent_assignment_reassigned',{assignment:assignment.id,role,from:assignment.agent_id,to:changed.agent_id})));
+      withBoard(b=>recordCardAgentChanges(b,id));
       say(args,`Reassigned ${id}/${role} to agent ${changed.agent_id}; sessions keep their identity`,{ok:true,assignment:changed});return 0;
     } need(2, 'a card id and a profile (or none)'); await withBoardAsync((b) => engine.set(b, id, 'assignee', rest[1] === 'none' ? null : rest[1])); say(args, `Assigned ${id} to ${rest[1] === 'none' ? '(nobody)' : rest[1]}`, { ok: true }); return 0;
     case 'set-goal': {

package/board/dispatch.mjs

@@ -30,7 +30,8 @@ import { boardLabel, boardName } from '@volter/teams/board-name';
 let fleetRoot = null;
 import { inspectCompletionEvidence, noCodeChange, openReviewPullRequests, reviewDue, withCompletionEvidence, reviewCandidate, workflowRevision, retainWorkflowTick } from './ci.mjs';
 import { runtimeDoor } from './runtime-door.mjs';
-import { agentScope, localCardAgent, localReaderContext, localAgentSessions, runBudgetRefusal, runsAwaitingUsage, recordRunUsage, recordUsageUnread, agentPreamble, agentEnvironment, recordAgentRun, activeAgentAssignments,finishAgentAssignment,handOffAgents, agentRunForSession } from '../agents.mjs';
+import { agentScope, localCardAgent, localReaderContext, localAgentSessions, runBudgetRefusal, runsAwaitingUsage, recordRunUsage, recordUsageUnread, agentPreamble, agentEnvironment, recordAgentRun, cardAgentAssignments,handOffAgents, agentRunForSession } from '../agents.mjs';
+import { finishCardAgentAssignment, recordCardAgentAssignment } from './agent-declarations.mjs';
 import { materializeAgentHome } from '../agent-home.mjs';
 import { memorySnapshot } from '../hermes-cli.mjs';
 import { createRequire } from 'node:module';
@@ -1014,6 +1015,7 @@ async function launchAttempt(board, entry, id, lane, fleet, settings, runId) {
     const agent=await 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});
     assertRunCurrent(board,id,runId);
+    recordCardAgentAssignment(board,cardAgentAssignments(board.root,id).find(assignment=>assignment.org===team.org&&assignment.id===agent.assignment));
     // 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;
@@ -1904,10 +1906,10 @@ async function synchronizeAgents(board, report) {
       await readRunUsage(board.root,org,row,run.ended_at);read++;
     }
   }
-  for(const assignment of activeAgentAssignments(board.root)){
-    if(assignment.kind!=='card')continue;
+  for(const assignment of cardAgentAssignments(board.root)){
     const task=getTaskNow(board,assignment.target);
-    if(task&&(task.archived||['done','cancelled'].includes(task.status)))finishAgentAssignment(board.root,assignment.org,assignment.id,`card ${assignment.target} ${task.archived?'archived':task.status}`);
+    if(task&&(assignment.state==='ended'||task.archived||['done','cancelled'].includes(task.status)))finishCardAgentAssignment(board,assignment,`card ${assignment.target} ${task.archived?'archived':task.status}`);
+    else if(task)recordCardAgentAssignment(board,assignment);
   }
   // What a creating or closing verb could not hand on (no daemon running then) is handed on here.
   try{for(const pending of await handOffAgents(board.root))report.queued.push([pending.agent,pending.error]);}
@@ -2464,6 +2466,7 @@ async function adoptSession(board, id, who, { request = null, open = request, pr
   progress.claimed = request !== null;
   // 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 ? await 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;
+  if(agent)recordCardAgentAssignment(board,cardAgentAssignments(board.root,id).find(assignment=>assignment.org===team.org&&assignment.id===agent.assignment));
   // 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/board/engine.mjs

@@ -18,6 +18,7 @@ import { view, actorOf, principalOf, claimer, contention, event, json, newTaskId
 import { completionPhase, inspectCompletionEvidence, observeCompletionEvidence, withCompletionEvidence } from './ci.mjs';
 import { addDependency, retireSupersededRuns, refreshCardInputs, requestSessionClose, eventTo, fire, loadWorkflow, setStatus, settle, startNew, statusOf, runEvent, workflowFor } from './workflow.mjs';
 import { refuseCredentialDump, withheldIfDump } from './credential-guard.mjs';
+import { AGENT_KIND_LIST, compactCardAgentEvents } from './published.mjs';
 
 export const STATUSES = ['triage', 'todo', 'scheduled', 'ready', 'running', 'blocked', 'review', 'done', 'archived'];
 export const WORKSPACE_KINDS = ['scratch', 'dir', 'worktree'];
@@ -947,9 +948,14 @@ export function runs(db, id, { stateType = null, stateName = null } = {}) {
   return all(db, `SELECT * FROM task_runs WHERE task_id = ?${where} ORDER BY id`, ...(where ? [id, stateName] : [id])).map((r) => ({ ...r, metadata: json(r.metadata, null) }));
 }
 
-/** Delete the thread events of done and archived cards older than `seconds` (Hermes's `gc` of events). */
+/** Retain assignment facts in checkpoints, then delete old thread events of done and archived cards. */
 export function gcEvents(board, seconds) {
-  return tx(board, (db) => Number(run(db, "DELETE FROM task_events WHERE kind != 'created' AND created_at < ? AND task_id IN (SELECT id FROM tasks WHERE status IN ('done', 'archived'))", now() - seconds).changes));
+  return tx(board, db=>{
+    const cut=now()-seconds;
+    const cards=all(db,`SELECT DISTINCT task_id FROM task_events WHERE kind IN (${AGENT_KIND_LIST.map(()=>'?').join(',')}) AND created_at<? AND task_id IN (SELECT id FROM tasks WHERE status IN ('done','archived'))`,...AGENT_KIND_LIST,cut);
+    let compacted=0;for(const card of cards)compacted+=compactCardAgentEvents(db,card.task_id);
+    return compacted+Number(run(db,"DELETE FROM task_events WHERE kind!='created' AND created_at<? AND task_id IN (SELECT id FROM tasks WHERE status IN ('done','archived'))",cut).changes);
+  });
 }
 
 // ------------------------------------------------------------------ diagnostics

package/board/published.mjs

@@ -6,6 +6,7 @@
 // publishes the marked cards and clears their marks; one that marked nothing reads one row and publishes nothing.
 import { createHash, randomUUID } from 'node:crypto';
 import { executionOf } from './session-work.mjs';
+import { cardAgentScopeTransition } from '../agents.mjs';
 export const PUBLICATION_SCHEMA = `
 CREATE TABLE IF NOT EXISTS supercode_publications (
   sequence INTEGER PRIMARY KEY AUTOINCREMENT, id TEXT NOT NULL UNIQUE, resource_id TEXT NOT NULL,
@@ -17,6 +18,13 @@ CREATE TABLE IF NOT EXISTS supercode_publication_heads (
 CREATE TABLE IF NOT EXISTS supercode_publication_log (
   id TEXT PRIMARY KEY, pruned_through INTEGER NOT NULL DEFAULT 0
 );
+CREATE TABLE IF NOT EXISTS supercode_card_agent_facts (
+  task_id TEXT PRIMARY KEY, facts_json TEXT NOT NULL, receipt_sequence INTEGER NOT NULL DEFAULT 0,
+  declared_event_id INTEGER NOT NULL DEFAULT 0
+);
+CREATE TABLE IF NOT EXISTS supercode_card_agent_scopes (
+  task_id TEXT PRIMARY KEY, from_org TEXT NOT NULL, org TEXT NOT NULL, changed_at INTEGER NOT NULL
+);
 -- keyless: a writing statement's own conflict clause (an upsert, OR REPLACE, OR ABORT) governs its triggers' inserts
 -- too, so a key here would fail the writer's statement; readers take the distinct ids
 CREATE TABLE IF NOT EXISTS supercode_publication_dirty (task_id TEXT NOT NULL);
@@ -24,8 +32,9 @@ CREATE INDEX IF NOT EXISTS supercode_publication_dirty_task ON supercode_publica
 CREATE INDEX IF NOT EXISTS supercode_publication_heads_sequence ON supercode_publication_heads(sequence);`;
 
 const REVIEW_KIND_LIST = ['review_requested', 'approved', 'review_approved', 'changes_requested', 'escalated'];
+export const AGENT_KIND_LIST = ['agent_declared', 'agent_assignment_ended', 'agent_assignment_reassigned', 'agent_assignment_adopted'];
 // The tables a card's snapshot reads (cardSnapshot), each with the column naming its card; a link names two.
-const MARKED = [['tasks', ['id']], ['supercode_cards', ['task_id']], ['task_comments', ['task_id']], ['task_runs', ['task_id']], ['task_links', ['parent_id', 'child_id']], ['task_events', ['task_id']]];
+const MARKED = [['tasks', ['id']], ['supercode_cards', ['task_id']], ['task_comments', ['task_id']], ['task_runs', ['task_id']], ['task_links', ['parent_id', 'child_id']], ['task_events', ['task_id']], ['supercode_card_agent_facts',['task_id']], ['supercode_card_agent_scopes',['task_id']]];
 /**
  * The triggers that mark a changed card, on a store that has these tables (CREATE … IF NOT EXISTS: laid out on every
  * open). A card already marked is not marked again, so a writer's many writes while the owner is away leave one mark.
@@ -35,20 +44,24 @@ const MARKED = [['tasks', ['id']], ['supercode_cards', ['task_id']], ['task_comm
 export function publicationTriggers(db) {
   const tables = new Set(db.prepare("SELECT name FROM sqlite_master WHERE type = 'table'").all().map((row) => row.name));
   const first = !db.prepare("SELECT 1 FROM sqlite_master WHERE type = 'trigger' AND name = 'supercode_publish_tasks_insert'").get();
-  const reviews = `(${REVIEW_KIND_LIST.map((kind) => `'${kind}'`).join(',')})`;
+  const snapshotEvents = `(${[...REVIEW_KIND_LIST,...AGENT_KIND_LIST].map((kind) => `'${kind}'`).join(',')})`;
+  const agentMigration = tables.has('task_events') && !db.prepare("SELECT sql FROM sqlite_master WHERE type='trigger' AND name='supercode_publish_task_events_insert'").get()?.sql.includes("'agent_assignment_adopted'");
+  const scopeMigration = !db.prepare("SELECT 1 FROM sqlite_master WHERE type='trigger' AND name='supercode_publish_supercode_card_agent_scopes_insert'").get();
   db.exec('SAVEPOINT supercode_publication_marking');
   try {
+    // Existing event triggers only watched reviews. Replace that filter once, preserving the savepoint rollback.
+    if(agentMigration)for(const verb of ['insert','update','delete'])db.exec(`DROP TRIGGER IF EXISTS supercode_publish_task_events_${verb}`);
     for (const [table, columns] of MARKED) {
       if (!tables.has(table)) continue;
-      // a task event changes a snapshot only when it is a review (the snapshot's `reviews`): an update marks when the
+      // Reviews and agent assignment events change a snapshot: an update marks when the
       // row was one before or is one after
-      const when = (rows) => table === 'task_events' ? ` WHEN ${rows.map((row) => `${row}.kind IN ${reviews}`).join(' OR ')}` : '';
+      const when = (rows) => table === 'task_events' ? ` WHEN ${rows.map((row) => `${row}.kind IN ${snapshotEvents}`).join(' OR ')}` : '';
       const mark = (row) => columns.map((column) => `INSERT INTO supercode_publication_dirty (task_id) SELECT ${row}.${column} WHERE ${row}.${column} IS NOT NULL AND NOT EXISTS (SELECT 1 FROM supercode_publication_dirty WHERE task_id = ${row}.${column});`).join(' ');
       db.exec(`CREATE TRIGGER IF NOT EXISTS supercode_publish_${table}_insert AFTER INSERT ON ${table}${when(['NEW'])} BEGIN ${mark('NEW')} END;
         CREATE TRIGGER IF NOT EXISTS supercode_publish_${table}_update AFTER UPDATE ON ${table}${when(['OLD', 'NEW'])} BEGIN ${mark('NEW')} ${mark('OLD')} END;
         CREATE TRIGGER IF NOT EXISTS supercode_publish_${table}_delete AFTER DELETE ON ${table}${when(['OLD'])} BEGIN ${mark('OLD')} END;`);
     }
-    if (first && tables.has('tasks')) db.exec(`INSERT INTO supercode_publication_dirty (task_id)
+    if ((first || agentMigration || scopeMigration) && tables.has('tasks')) db.exec(`INSERT INTO supercode_publication_dirty (task_id)
       SELECT id FROM tasks UNION SELECT resource_id FROM supercode_publication_heads WHERE digest != 'removed'
       EXCEPT SELECT task_id FROM supercode_publication_dirty`);
     db.exec('RELEASE supercode_publication_marking');
@@ -82,11 +95,76 @@ export function taskStatusOf(lane, completedAt) {
 }
 
 const REVIEW_KINDS=`(${REVIEW_KIND_LIST.map((kind) => `'${kind}'`).join(',')})`;
+const AGENT_KINDS=`(${AGENT_KIND_LIST.map((kind) => `'${kind}'`).join(',')})`;
+function agentFacts(db,taskId){
+  const checkpoint=db.prepare('SELECT facts_json,receipt_sequence,declared_event_id FROM supercode_card_agent_facts WHERE task_id=?').get(taskId);
+  const agents=new Map(parse(checkpoint?.facts_json,[]).map(agent=>[JSON.stringify([agent.org,agent.assignment,agent.id]),agent]));
+  let scope=db.prepare('SELECT from_org,org,changed_at FROM supercode_card_agent_scopes WHERE task_id=?').get(taskId)??null;
+  let receipt=checkpoint?.receipt_sequence??0,declared=checkpoint?.declared_event_id??0;
+  for(const event of db.prepare(`SELECT id,kind,payload FROM task_events WHERE task_id=? AND kind IN ${AGENT_KINDS} ORDER BY id`).all(taskId)){
+    if(event.kind==='agent_declared')declared=Math.max(declared,event.id);
+    const value=parse(event.payload,{});
+    if(Number.isSafeInteger(value.receipt))receipt=Math.max(receipt,value.receipt);
+    if(event.kind==='agent_assignment_adopted'){
+      if(!scope&&value.from_org==='local'&&typeof value.org==='string'&&value.org!=='local')scope={from_org:'local',org:value.org,changed_at:value.changed_at};
+      continue;
+    }
+    if(scope&&value.org==='local'){console.warn(`card agent mirror rejected: ${taskId} has left local scope (event ${event.id})`);continue;}
+    const id=event.kind==='agent_assignment_reassigned'?value.to:value.agent;
+    if(typeof id!=='string'||typeof value.assignment!=='string'||typeof value.role!=='string')continue;
+    const org=value.org??null,key=JSON.stringify([org,value.assignment,id]),previous=agents.get(key);
+    if(event.kind==='agent_assignment_reassigned'&&typeof value.from==='string'&&value.from!==id){
+      const fromKey=JSON.stringify([org,value.assignment,value.from]),from=agents.get(fromKey);
+      agents.set(fromKey,{org,id:value.from,role:value.role,profile:value.from_profile??from?.profile??null,assignment:value.assignment,state:'ended'});
+    }
+    const state=event.kind==='agent_assignment_ended'||value.state==='ended'?'ended':'active';
+    if(state==='active')for(const agent of agents.values())if(agent.org===org&&agent.assignment===value.assignment&&agent.id!==id)agent.state='ended';
+    agents.set(key,{org,id,role:value.role,profile:value.profile??previous?.profile??null,assignment:value.assignment,state});
+  }
+  if(scope)for(const agent of agents.values())if(agent.org!==scope.org)agent.state='ended';
+  return {receipt,declared,scope,agents:[...agents.values()].sort((a,b)=>a.role.localeCompare(b.role)||a.assignment.localeCompare(b.assignment)||a.id.localeCompare(b.id))};
+}
+/** Facts plus only the events not yet checkpointed, independent of whether a run has started. */
+export function cardAgentFacts(db,id){const facts=agentFacts(db,id);return facts.scope?facts.agents.filter(agent=>agent.org===facts.scope.org):facts.agents;}
+export function cardAgentReceiptRecorded(db,id,receipt){
+  return Number(db.prepare('SELECT receipt_sequence FROM supercode_card_agent_facts WHERE task_id=?').get(id)?.receipt_sequence??0)>=receipt
+    ||Boolean(db.prepare(`SELECT 1 FROM task_events WHERE task_id=? AND kind IN ${AGENT_KINDS} AND json_extract(payload,'$.receipt')=?`).get(id,receipt));
+}
+/** Facts and the receipt watermark replace consumed event history together in the board transaction. */
+function saveAgentFacts(db,id,facts){
+  if(facts.scope)db.prepare('INSERT INTO supercode_card_agent_scopes(task_id,from_org,org,changed_at) VALUES (?,?,?,?) ON CONFLICT(task_id) DO NOTHING').run(id,facts.scope.from_org,facts.scope.org,facts.scope.changed_at);
+  db.prepare('INSERT INTO supercode_card_agent_facts(task_id,facts_json,receipt_sequence,declared_event_id) VALUES (?,?,?,?) ON CONFLICT(task_id) DO UPDATE SET facts_json=excluded.facts_json,receipt_sequence=excluded.receipt_sequence,declared_event_id=excluded.declared_event_id').run(id,JSON.stringify(facts.agents),facts.receipt,facts.declared);
+  return Number(db.prepare(`DELETE FROM task_events WHERE task_id=? AND kind IN ${AGENT_KINDS}`).run(id).changes);
+}
+export function compactCardAgentEvents(db,id){
+  if(!db.prepare(`SELECT 1 FROM task_events WHERE task_id=? AND kind IN ${AGENT_KINDS} LIMIT 1`).get(id))return 0;
+  return saveAgentFacts(db,id,agentFacts(db,id));
+}
+/** A permanent native transition closes local scope. Only destination-native assignments can be active afterward. */
+export function syncCardAgentScope(db,id,transition){
+  if(!transition)return;
+  db.prepare('INSERT INTO supercode_card_agent_scopes(task_id,from_org,org,changed_at) VALUES (?,?,?,?) ON CONFLICT(task_id) DO NOTHING').run(id,transition.from_org,transition.org,transition.changed_at);
+  const facts=agentFacts(db,id);
+  if(facts.scope.org!==transition.org)throw new Error(`card ${id} has conflicting retained agent scopes`);
+  const agents=new Map(facts.agents.map(agent=>[JSON.stringify([agent.org,agent.assignment,agent.id]),{...agent,state:'ended'}]));
+  for(const row of transition.assignments){
+    const key=JSON.stringify([row.org,row.id,row.agent_id]),previous=agents.get(key);
+    agents.set(key,{org:row.org,id:row.agent_id,role:row.role,profile:row.profile??previous?.profile??null,assignment:row.id,state:row.state});
+  }
+  facts.agents=[...agents.values()].sort((a,b)=>a.role.localeCompare(b.role)||a.assignment.localeCompare(b.assignment)||a.id.localeCompare(b.id));
+  const previous=db.prepare('SELECT facts_json,receipt_sequence,declared_event_id FROM supercode_card_agent_facts WHERE task_id=?').get(id);
+  if(previous?.facts_json===JSON.stringify(facts.agents)&&previous.receipt_sequence===facts.receipt&&previous.declared_event_id===facts.declared
+    &&!db.prepare(`SELECT 1 FROM task_events WHERE task_id=? AND kind IN ${AGENT_KINDS} LIMIT 1`).get(id))return;
+  saveAgentFacts(db,id,facts);
+}
+/** Organization scope stays internal; the publication contract has exactly these five fields. */
+export function cardAgents(db,id){return cardAgentFacts(db,id).map(({org,...agent})=>agent);}
 /** A card's rows read one card at a time. */
 const perCard=db=>({
   own:id=>db.prepare('SELECT * FROM supercode_cards WHERE task_id=?').get(id),
   comments:id=>db.prepare('SELECT id,author,body,created_at FROM task_comments WHERE task_id=? ORDER BY id').all(id),
   reviews:id=>db.prepare(`SELECT id,kind,payload,created_at FROM task_events WHERE task_id=? AND kind IN ${REVIEW_KINDS} ORDER BY id`).all(id),
+  agents:id=>cardAgents(db,id),
   attempts:id=>db.prepare('SELECT id,profile,step_key,status,started_at,ended_at,outcome,summary,metadata,error FROM task_runs WHERE task_id=? ORDER BY id').all(id),
   parents:id=>db.prepare('SELECT parent_id FROM task_links WHERE child_id=? ORDER BY parent_id').all(id).map(link=>link.parent_id),
   children:id=>db.prepare('SELECT child_id FROM task_links WHERE parent_id=? ORDER BY child_id').all(id).map(link=>link.child_id),
@@ -111,7 +189,7 @@ export function cardSnapshot(db,row,rows=perCard(db)) {
     blocked_by:parse(own.blocked_by,[]),paused:parse(own.paused),every:own.every??null,
     workspace:{kind:row.workspace_kind,path:row.workspace_path,branch:row.branch_name,root:own.workspace_root,anchor:own.workspace_anchor},
     parents:rows.parents(row.id),
-    reviews,children:rows.children(row.id),comments,attempts};
+    agents:rows.agents(row.id),reviews,children:rows.children(row.id),comments,attempts};
 }
 
 /**
@@ -119,7 +197,7 @@ export function cardSnapshot(db,row,rows=perCard(db)) {
  * transaction: each marked card's snapshot when it differs from its published head, a removal when the card is gone.
  * The marks are cleared with it. Retention is the owner's (prunePublications), never a transaction's.
  */
-export function recordCardPublications(db,actor) {
+export function recordCardPublications(db,actor,root) {
   const marked=db.prepare('SELECT DISTINCT task_id FROM supercode_publication_dirty').all().map(row=>row.task_id);
   if(!marked.length)return 0;
   db.prepare('INSERT INTO supercode_publication_log(id,pruned_through) SELECT ?,0 WHERE NOT EXISTS (SELECT 1 FROM supercode_publication_log)').run(`log_${randomUUID()}`);
@@ -131,6 +209,8 @@ export function recordCardPublications(db,actor) {
   for(const id of marked){
     const row=task.get(id),previous=head.get(id);
     if(row){
+      const transition=cardAgentScopeTransition(root,id);
+      if(transition)syncCardAgentScope(db,id,transition);else compactCardAgentEvents(db,id);
       const snapshot=JSON.stringify(cardSnapshot(db,row,rows)),digest=hash(snapshot);
       if(previous?.digest===digest)continue;
       const last=lastEvent.get(id);

package/board/store.mjs

@@ -425,7 +425,7 @@ export const tx = (board, fn) => {
   const caller = /at (?:async )?([\w.$<>]+) /.exec(String(new Error().stack).split('\n')[2] ?? '')?.[1] ?? 'unknown';
   const started = performance.now();
   try {
-    const result = board.tx(db => {const result=fn(db);const began=performance.now();try{recordCardPublications(db,actorOf());}finally{noteStep('board tx publications',performance.now()-began);}return result;});
+    const result = board.tx(db => {const result=fn(db);const began=performance.now();try{recordCardPublications(db,actorOf(),board.root);}finally{noteStep('board tx publications',performance.now()-began);}return result;});
     signalBoardWrite(board.root, actorOf());
     return result;
   } finally { noteStep(`board tx from ${caller}`, performance.now() - started); }
@@ -445,7 +445,7 @@ export function publishMarked(root) {
       // a mark in the store, or a backing edit not yet imported into its tables (a ztrack document): the transaction
       // imports the edit, which marks its cards, and publishes them
       const marked = step('marks', () => board.db.prepare('SELECT 1 FROM supercode_publication_dirty LIMIT 1').get()) || step('unimported', () => board.unimported?.());
-      if (marked) published += step('publish', () => board.tx((db) => recordCardPublications(db, actorOf())));
+      if (marked) published += step('publish', () => board.tx((db) => recordCardPublications(db, actorOf(),board.root)));
       if (step('prune due', () => pruneDue(board.db))) step('prune', () => board.tx((db) => prunePublications(db)));
     } finally { board?.close(); }
   }

package/index.d.ts

@@ -115,7 +115,13 @@ export function agentIntent(root: Path, org: string, id: string): Record<string,
 export function assignAgent(root: Path, org: string, id: string, assignment: {kind: string; target: string; role: string}): string;
 export function reassignAgent(root: Path, org: string, assignment: string, to: string, options?: {context?: string}): Promise<Record<string, unknown>>;
 export function activeAgentAssignments(root: Path): Array<Record<string, unknown>>;
-export function finishAgentAssignment(root: Path, org: string, assignment: string, reason: string): void;
+/** Retained card assignments, including ended rows awaiting a board mirror. */
+export function cardAgentAssignments(root: Path, target?: string | null): Array<Record<string, unknown>>;
+/** Permanent offline adoption scope and its current destination-native assignments, read together. */
+export function cardAgentScopeTransition(root: Path, target: string): {from_org: string; org: string; changed_at: number; assignments: Array<Record<string, unknown>>} | null;
+export function pendingCardAgentChanges(root: Path, target: string): Array<{receipt: number; [key: string]: unknown}>;
+export function acknowledgeCardAgentChanges(root: Path, receipts: number[]): void;
+export function finishAgentAssignment(root: Path, org: string, assignment: string, reason: string): Record<string, unknown> | null;
 export function recordAgentRun(root: Path, org: string, id: string, run: {session: string; machine?: string | null; run: string | number; profile?: unknown; main?: boolean; starterSession?: string | null}): void;
 export function agentRunForSession(root: Path, references: Array<string | null | undefined>): Record<string, unknown> | null;
 export function agentPreamble(agent: LocalAgent, options?: {main?: boolean; previous?: Array<{session: string; machine?: string | null; ended_at?: number | null; end_reason?: string | null}>}): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-orchestrator",
-  "version": "0.5.176",
+  "version": "0.5.178",
   "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.100",
-    "@volter/teams": "0.2.77",
+    "@volter/teams": "0.2.78",
     "@volter/ztrack": "^2.4.23",
     "yaml": "^2.9.0"
   },