@volter/supercode-orchestrator 0.5.27 → 0.5.29

package/board/dispatch.mjs

@@ -1304,8 +1304,21 @@ function reconcileLaunches(board, fleet, report, entry, effects, settings, lanes
         event(db,row.task_id,mismatch.differences.length?'agent_profile_drift':'agent_profile_recorded',{agent:session.agent_id,session:session.session_id,comparison:mismatch},row.id);
       });
     }
+    const ref=`${session.harness}:${session.session_id}`;
+    // An ended run whose session the agent store already holds, published, for another agent lost that claim when it
+    // ran: no round can change an ended run or a published owner, so the disagreement is history. It is said once on
+    // its card (agent_ownership_conflict) and the run is not recorded again. A live run is never history: it is
+    // recorded below every round, and a conflict there is refused and said each round as before.
+    if(row.ended_at){
+      let owner=null;try{owner=agentRunForSession(board.root,[ref]);}catch{/* conflicting owners: recorded below, refused there */}
+      if(owner?.published===1&&owner.org===session.agent_org&&owner.agent_id!==session.agent_id){
+        const said=db=>db.prepare("SELECT 1 FROM task_events WHERE task_id=? AND run_id=? AND kind='agent_ownership_conflict' LIMIT 1").get(row.task_id,row.id);
+        if(!view(board,said))tx(board,db=>{if(!said(db))event(db,row.task_id,'agent_ownership_conflict',{session:ref,run_agent:session.agent_id,owner:owner.agent_id,owner_run:owner.run_id},row.id);});
+        continue;
+      }
+    }
     // One run whose session another agent already owns is that card's problem, said on it; the round goes on for the rest.
-    try{recordAgentRun(board.root,session.agent_org,session.agent_id,{session:`${session.harness}:${session.session_id}`,machine:session.machine,run:row.id});}
+    try{recordAgentRun(board.root,session.agent_org,session.agent_id,{session:ref,machine:session.machine,run:row.id});}
     catch(error){report.queued.push([row.task_id,`run ${row.id}: ${error.message}`]);continue;}
     orgs.set(session.agent_org,session.agent_context);
   }
@@ -1719,6 +1732,22 @@ function localListing(who) {
   return { address: `sc:${localMachine()}:${harness}:${sessionId}`, machine: localMachine(), harness, session_id: sessionId, pane, name: null };
 }
 
+/** The verb an adoption with no current run fires: the workflow's own `adopt` where it declares one, else its dispatch start. */
+const adoptionVerb = (entry) => (entry.workflow.verbs?.adopt || !entry.workflow.run ? 'adopt' : entry.workflow.dispatch.start);
+
+/**
+ * The role an adopted session works on its card: a rebound run's own, else the role of the status the adoption's verb
+ * moves the card to, as its claim names it. A card in review adopts its reviewer, never its implementer.
+ */
+function adoptedRole(db, board, entry, task, run) {
+  const kept = run?.metadata?.supercode?.role;
+  if (kept) return kept;
+  const verb = adoptionVerb(entry), by = verb === 'adopt' ? 'manager' : 'platform';
+  const status = statusOf(db, task), scope = scopeOf(db, board, task, { params: entry.params });
+  const t = transitionsFor(entry.workflow, status, verb).find((x) => !x.by?.length || x.by.includes(by));
+  return runSpec(entry, t?.target ? String(templateValue(t.target, scope)) : status, task)?.role ?? null;
+}
+
 function adoptSession(board, id, who, { workspace = null, ttl, assignee = null, role = null, fleet = null, lanes = null } = {}) {
   fleet ??= observeFleet();
   if (!fleet.ok) throw new Error(`supercode could not read the fleet: ${fleet.error}`);
@@ -1745,12 +1774,12 @@ function adoptSession(board, id, who, { workspace = null, ttl, assignee = null,
   // Rule 2: a session working a card role is that role's agent, however it started; adopted, it joins the agent as a
   // launch does, and its recorded profile is compared with the role's intent (rule 4).
   const entry0 = workflowFor(board.root), card0 = view(board, (db) => getTask(db, id));
-  const spec0 = view(board, (db) => runSpec(entry0, entry0.workflow.verbs?.adopt?.[0]?.target ?? 'running', card0));
-  const laneName = view(board, (db) => evaluate(entry0.workflow.roles?.[spec0?.role] ?? 'card.assignee', scopeOf(db, board, card0, { params: entry0.params }))) ?? assignee ?? card0?.assignee;
+  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);
   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: spec0?.role ?? 'implementer', sponsor: card0?.sponsor ?? null, machine: normalMachine(host) === localMachine() ? null : host, context }); }
+    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; }
   }
   // A session another agent already owns is refused before anything is recorded: the run would name one agent and the
@@ -1782,10 +1811,13 @@ function adoptSession(board, id, who, { workspace = null, ttl, assignee = null,
     event(db, id, 'dispatch_released', { reason: 'verified adoption', session: found.address });
     // the manager's adoption is the workflow's own `adopt` verb where it declares one, sent as the manager; else its
     // dispatch start, which the platform sends for a verified adoption
-    if (!beforeRun) { const verb = entry.workflow.verbs?.adopt || !entry.workflow.run ? 'adopt' : entry.workflow.dispatch.start;
+    if (!beforeRun) { const verb = adoptionVerb(entry);
       fire(db, board, entry, id, verb, { roles: [verb === 'adopt' ? 'manager' : 'platform'], payload: { lock: claimer() } }); }
     const runId = getTask(db, id).current_run_id;
     if (!runId) throw new Error(`${id} waits on parents that are not done`);
+    // the agent joined above is the one of the run's own role; a run of another role would name the wrong agent
+    const runRole = currentRun(db, id)?.metadata?.supercode?.role;
+    if (agent && runRole && runRole !== agentRole) throw new Error(`${id}'s run is its ${runRole}'s, and ${found.address} was joined as its ${agentRole}; adopt again`);
     const session = { surface: found.pane ? 'pane' : 'native', session_id: sessionId, harness, machine: host, pane: found.pane ?? null, address: found.address, mode: 'adopt', launched_at: now(), seen_at: now(),
       ...(agent ? { agent_id: agent.identity.id, agent_org: team.org, agent_context: context ?? null,
         agent_profile_intent: { ...structuredClone(agent.intended.resolved), worker: { ...agent.intended.resolved?.worker, harness: lane.harness, model: lane.model ?? null, cwd: dir ?? task.workspace_path ?? null } } } : {}) };
@@ -2207,7 +2239,13 @@ function readMailbox(board, address, report) {
     try { renameSync(path, join(box, 'cur', name)); } catch { continue; } // another reader took it
     // an answer to a question the board asked is what a card waits on (read by the card's workflow), not a verb
     if (envelope.in_reply_to) continue;
-    if (envelope.from === `sc:${localMachine()}:operator:teams-events` && envelope.kind === 'notice') { report.mailed.push([envelope.from, 'machine_event']); continue; }
+    // A notice is news for the board, never a card update: a machine's event, or Claude Code's delivery notice about a
+    // message the board sent (filed by the relay from `sc:<machine>:claude-code:notice`, which is no session). Its sender
+    // asked for no reply (reply_via none), so it is filed as read and never answered.
+    if (envelope.kind === 'notice' || envelope.reply_via?.mode === 'none') {
+      report.mailed.push([envelope.from, envelope.from === `sc:${localMachine()}:operator:teams-events` ? 'machine_event' : 'notice']);
+      continue;
+    }
     const argv = json(envelope.body, {})?.workflow;
     let answer;
     if (!Array.isArray(argv) || !argv.length || NOT_BY_MAIL.has(argv[0])) answer = `not applied: a mailed card update is one \`supercode workflow\` verb other than ${[...NOT_BY_MAIL].join(', ')}`;

package/board/ztrack.mjs

@@ -339,12 +339,19 @@ class ZtrackBoard {
   }
 
   // A document whose hash is neither the published one nor the one a pending publication replaces
-  // was edited by hand.
+  // was edited by hand. A write also reads again a document its index does not measure: spans whose lengths do not
+  // add up to the text cannot place an edit in it (a span's stored text changed outside the board, its length not).
   staleDocuments({ pending }) {
     const published = this.get('published', {});
     const inFlight = pending ? this.get('pending_hashes', null) : null;
+    // the repair is said, so a span length written wrong stays visible
+    const measured = (doc) => {
+      const gap = lf(doc.raw).length - this.entries(doc.role).reduce((sum, e) => sum + e.len, 0);
+      if (gap) process.stderr.write(`board: warning: ${doc.path}: its index spans measure ${Math.abs(gap)} character${Math.abs(gap) === 1 ? '' : 's'} ${gap > 0 ? 'short of' : 'past'} its text; this write reads it again\n`);
+      return !gap;
+    };
     return this.docs.map((doc) => ({ ...doc, ...this.fileHash(doc.path) }))
-      .filter((doc) => doc.hash !== published[doc.role] && !(inFlight?.[doc.role] && doc.hash === inFlight[doc.role].before))
+      .filter((doc) => (doc.hash !== published[doc.role] && !(inFlight?.[doc.role] && doc.hash === inFlight[doc.role].before)) || (!pending && !measured(doc)))
       .map((doc) => ({ ...doc, text: lf(doc.raw) }));
   }
 
@@ -493,9 +500,13 @@ class ZtrackBoard {
       const edit = stale.find((s) => s.role === doc.role);
       if (!edit) { plan.layout.set(doc.role, entries); continue; }
       let base = this.get('published', {})[doc.role] !== undefined && entries.length ? entries : [];
+      // Spans are compared by their stored text and spliced by their recorded length: an index whose lengths are not
+      // its texts' (a stored span rewritten outside the board) is no base to re-read a region against.
+      let texts = this.texts(base);
+      if (texts.some((t, i) => t.text.length !== base[i].len)) { base = []; texts = []; }
       let result;
       // A region that cannot be re-read on its own is read with the whole document.
-      try { result = this.codec.rechunkBoardDocument(this.texts(base), edit.text, doc.path); }
+      try { result = this.codec.rechunkBoardDocument(texts, edit.text, doc.path); }
       catch { base = []; result = this.codec.rechunkBoardDocument([], edit.text, doc.path); }
       const added = result.chunks.slice(result.from, result.to).map((c) => ({ cid: null, id: c.id, level: c.level, len: c.text.length, rec: null, text: c.text }));
       plan.layout.set(doc.role, [...base.slice(0, result.from), ...added, ...base.slice(result.oldTo)]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-orchestrator",
-  "version": "0.5.27",
+  "version": "0.5.29",
   "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": {