@volter/supercode-orchestrator 0.5.41 → 0.5.42

package/board/cli.mjs

@@ -5,7 +5,7 @@
 // which lands here. The home is `--root`, else `SUPERCODE_ORCHESTRATOR_HOME`, else `HERMES_HOME`; the board is
 // `--board <slug>`, else `HERMES_KANBAN_BOARD`, else the home's current board (`kanban/current`), else `default`.
 import { taskStatusOf } from './published.mjs';
-import { appendFileSync, copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
+import { appendFileSync, copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
 import { spawnSync } from 'node:child_process';
 import { recordSlow, takeSteps } from '@volter/supercode-harness-sdk/slow-log';
 import { basename, join, resolve } from 'node:path';
@@ -15,6 +15,19 @@ import { actorOf, view, backingPaths, layOut, backingOf, boardExists, boardPath,
 import { isLocalWorkspace } from './workspace.mjs';
 import { openZtrackBoard } from './ztrack.mjs';
 import * as engine from './engine.mjs';
+import { runtimeDoor } from './runtime-door.mjs';
+
+/**
+ * What this machine's connector reports of publishing this board home (`harness.v1.boards.list`): whether the team
+ * refused its credential, the publication it is retrying and the ones it abandoned. Null when no daemon answers or the
+ * home is not registered: diagnostics then say nothing of publishing.
+ */
+function boardPublishing(root) {
+  const read = runtimeDoor(null, 'harness.v1.boards.list', {}, { timeout: 15_000 });
+  if (read.code !== 0) return null;
+  let here; try { here = realpathSync(root); } catch { here = resolve(root); }
+  try { const listed = JSON.parse(read.stdout); const board = listed.boards?.find((b) => b.root === here); return board ? { ...board, refused: listed.refused ?? null } : null; } catch { return null; }
+}
 import { requestAdoption, alertManagers, boardAddress, boardLabel, boardSettings, callerSession, commandEnv, reconcileCallerLaunch, closeRequested, lanesOf, localMachine, observeFleet, paused, plan, startCard, stopDispatching, supercodeBin, tick, deliver, startDelivery } from './dispatch.mjs';
 import { watchBoard } from './wake.mjs';
 import { streamBoardPublications } from './event-stream.mjs';
@@ -819,10 +832,12 @@ export async function runWorkflow(argv) {
     case 'diagnostics': case 'diag': {
       const { settings } = await laneState(root).catch(() => ({ settings: boardSettings({}) }));
       const fleet = observeFleet(root);
+      const publishing = boardPublishing(root);
       const order = ['warning', 'error', 'critical'];
       const found = withBoard((b) => {
         const cards = args.task ? [engine.getTask(b.db, args.task)].filter(Boolean) : engine.listCards(b.db, {});
-        return cards.flatMap((t) => engine.diagnose(b.db, t, { failureLimit: settings.failureLimit, fleet, launchWindowSeconds: settings.launchWindow }).map((d) => ({ task: t.id, title_of_task: t.title, ...d })))
+        return [...(args.task ? [] : engine.diagnosePublishing(publishing).map((d) => ({ task: '(board)', title_of_task: null, ...d }))),
+          ...cards.flatMap((t) => engine.diagnose(b.db, t, { failureLimit: settings.failureLimit, fleet, launchWindowSeconds: settings.launchWindow, publishing }).map((d) => ({ task: t.id, title_of_task: t.title, ...d })))]
           .filter((d) => !args.severity || order.indexOf(d.severity) >= order.indexOf(args.severity));
       });
       if (args.json) { say(args, '', found); return 0; }
@@ -1448,6 +1463,13 @@ async function serve(root, args = {}) {
   const running = installed();
   log(`dispatching the boards of ${root} from ${localMachine()} (orchestrator ${running ?? 'unknown'})`);
   events = watchBoard({ root, binary: supercodeBin(), env: commandEnv(), log });
+  // The board's events are published by this machine's connector, not by the dispatcher (D137, D138 step 4): the home is
+  // named to the daemon once, and the connector follows its `workflow events` from then on, with or without this serve.
+  { const named = runtimeDoor(null, 'harness.v1.boards.register', { root }, { timeout: 30_000 });
+    const refused = named.code === 0 ? JSON.parse(named.stdout || '{}').refused ?? null : null;
+    log(named.code !== 0 ? `board events: not published; the machine daemon did not take this home: ${(named.stderr || named.stdout).trim().split('\n').at(-1)}`
+      : refused ? `board events: registered, but the team refused this machine's credential (${refused.status}); nothing is published until it is re-enrolled`
+      : `board events: this home is published by the machine's connector`); }
   log('dispatch wakes on board writes, document edits and board mail; the interval sweep reads each machine\'s own door');
   const stuck = {};
   const warned = {};

package/board/engine.mjs

@@ -912,12 +912,20 @@ export function gcEvents(board, seconds) {
 
 const hours = (s) => s / 3600;
 
+/** The board home's publishing, as its machine's connector reports it (`harness.v1.boards.list`): what holds it all. */
+export function diagnosePublishing(publishing) {
+  if (!publishing) return [];
+  if (publishing.refused) return [{ kind: 'publishing_refused', severity: 'error', title: `the team refused this machine's credential (${publishing.refused.status}); no card of this home is published until the machine is re-enrolled`, data: publishing.refused, actions: ['supercode teams enroll'] }];
+  if (publishing.error) return [{ kind: 'publishing_waits', severity: 'warning', title: `publishing to the team waits and is retried: ${publishing.error}`, data: { failing: publishing.failing ?? null }, actions: [] }];
+  return [];
+}
+
 /**
  * Distress signals on a card, computed on demand and never stored (Hermes's diagnostics, the same kinds where the
  * same thing can go wrong, and supercode's own where only its sessions can): each `{ kind, severity, title, data,
  * actions }`, worst first.
  */
-export function diagnose(db, task, { failureLimit = DEFAULT_FAILURE_LIMIT, strandedSeconds = 30 * 60, blockedHours = 24, fleet = null, launchWindowSeconds = 300 } = {}) {
+export function diagnose(db, task, { failureLimit = DEFAULT_FAILURE_LIMIT, strandedSeconds = 30 * 60, blockedHours = 24, fleet = null, launchWindowSeconds = 300, publishing = null } = {}) {
   const out = [];
   const t = now();
   const events = all(db, 'SELECT kind, payload, created_at FROM task_events WHERE task_id = ? ORDER BY id', task.id);
@@ -979,6 +987,10 @@ export function diagnose(db, task, { failureLimit = DEFAULT_FAILURE_LIMIT, stran
     const p = json(row.payload, {}) ?? {};
     out.push({ kind: 'notice_abandoned', severity: 'warning', title: `the notice of event ${p.source_event} to ${p.address} was abandoned after ${p.attempts} attempts: ${p.error ?? 'no reason recorded'}`, data: { event: p.source_event, address: p.address, attempts: p.attempts }, actions: [] });
   }
+  // publications of the card the machine's connector abandoned: the team refused each one past its attempts
+  for (const a of (publishing?.abandoned ?? []).filter((a) => a.card === task.id).slice(0, 20)) {
+    out.push({ kind: 'publication_abandoned', severity: 'warning', title: `its ${a.kind} (sequence ${a.sequence}) was not published to the team: refused ${a.attempts} times (${a.status} ${a.code ?? ''}): ${a.error}`, data: { publication: a.publication, sequence: a.sequence, status: a.status, code: a.code }, actions: [] });
+  }
   const order = ['critical', 'error', 'warning'];
   return out.sort((a, b) => order.indexOf(a.severity) - order.indexOf(b.severity));
 }

package/board/event-stream.mjs

@@ -81,9 +81,11 @@ export async function* followBoardPublications({root,after,signal}) {
             // The transaction's watermark fences concurrent mutations. Replay
             // after it repairs any head updated while this inventory is read.
             for(const sequence of boundary.heads){
-              const row=board.db.prepare('SELECT snapshot FROM supercode_publications WHERE sequence=?').get(sequence);
+              const row=board.db.prepare('SELECT id,kind,sequence,snapshot FROM supercode_publications WHERE sequence=?').get(sequence);
               if(!row)throw resync('Workflow snapshot unavailable');
-              yield {type:'snapshot_item',data:{board:slug,card:JSON.parse(row.snapshot)}};
+              // each item names the publication it is (its id, kind and sequence), as an event does, so a follower that
+              // republishes it keys and orders it the same way however it first read it
+              yield {type:'snapshot_item',id:row.id,kind:row.kind,sequence:row.sequence,data:{board:slug,card:JSON.parse(row.snapshot)}};
             }
             positions[slug]={log:boundary.log,sequence:boundary.high};
           }else{
@@ -91,7 +93,7 @@ export async function* followBoardPublications({root,after,signal}) {
             if(!position||position.log!==boundary.log||!Number.isSafeInteger(position.sequence)||position.sequence<boundary.floor||position.sequence>boundary.high)throw resync(`Workflow publication log changed: ${slug}`);
             for(;;){
               const rows=board.db.prepare('SELECT * FROM supercode_publications WHERE sequence>? ORDER BY sequence LIMIT 32').all(positions[slug].sequence);if(!rows.length)break;
-              for(const row of rows){positions[slug].sequence=row.sequence;yield {type:'event',id:row.id,kind:row.kind,cursor:cursorOf(home,positions),data:{board:slug,card:JSON.parse(row.snapshot)}};}
+              for(const row of rows){positions[slug].sequence=row.sequence;yield {type:'event',id:row.id,kind:row.kind,sequence:row.sequence,cursor:cursorOf(home,positions),data:{board:slug,card:JSON.parse(row.snapshot)}};}
             }
           }
         }finally{board.close();const paths=backingPaths(root,slug);for(const path of [paths.sqlite,`${paths.sqlite}-wal`])settled.set(path,statOf(path));}

package/board/published.mjs

@@ -1,10 +1,6 @@
 // The card writer commits the full snapshot and a retained delivery obligation together.
 import { createHash, randomUUID } from 'node:crypto';
-import { realpathSync } from 'node:fs';
 export const PUBLICATION_SCHEMA = `
-CREATE TABLE IF NOT EXISTS supercode_publication_receipts (
-  event_id TEXT NOT NULL, destination TEXT NOT NULL, PRIMARY KEY(event_id,destination)
-);
 CREATE TABLE IF NOT EXISTS supercode_publications (
   sequence INTEGER PRIMARY KEY AUTOINCREMENT, id TEXT NOT NULL UNIQUE, resource_id TEXT NOT NULL,
   kind TEXT NOT NULL, snapshot TEXT NOT NULL, actor TEXT, created_at INTEGER NOT NULL
@@ -103,39 +99,8 @@ export function recordCardPublications(db,actor) {
   if(history>2*RETAINED_CHANGES){
     const cut=Number(db.prepare('SELECT sequence FROM supercode_publications WHERE sequence NOT IN (SELECT sequence FROM supercode_publication_heads) ORDER BY sequence DESC LIMIT 1 OFFSET ?').get(RETAINED_CHANGES).sequence);
     const old='SELECT id FROM supercode_publications WHERE sequence<=? AND sequence NOT IN (SELECT sequence FROM supercode_publication_heads)';
-    db.prepare(`DELETE FROM supercode_publication_receipts WHERE event_id IN (${old})`).run(cut);
     db.prepare(`DELETE FROM supercode_publications WHERE id IN (${old})`).run(cut);
     db.prepare('UPDATE supercode_publication_log SET pruned_through=MAX(pruned_through,?)').run(cut);
   }
   return changed;
 }
-export const boardSourceName = (root,slug) => `board:${hash(realpathSync(root)).slice(0,24)}:${slug}`;
-
-/**
- * The card as one published event may carry it (`limit`: the bytes its `data`, `{ board, card }`, may serialize to).
- * The board keeps every card whole; a card too large to send keeps its newest history: the oldest comments, attempts
- * and reviews go first, then the body's tail, and `omitted` counts what the event leaves out.
- */
-export function publishableCard(card,board,limit) {
-  const bytes=value=>Buffer.byteLength(JSON.stringify(value));
-  const size=value=>bytes({board,card:value});
-  if(size(card)<=limit)return card;
-  const omitted={comments:0,attempts:0,reviews:0,body_chars:0};
-  const fitted={...card,omitted};
-  // Counted once per item (its bytes and a separator), then checked whole: a card of megabytes fits in one pass.
-  let over=size(fitted)-limit;
-  for(const field of ['comments','attempts','reviews']){
-    const items=card[field]??[];let drop=0;
-    while(drop<items.length&&over>0){over-=bytes(items[drop])+1;drop+=1;}
-    fitted[field]=items.slice(drop);omitted[field]=drop;
-  }
-  for(const field of ['comments','attempts','reviews']){
-    while(fitted[field].length&&size(fitted)>limit){fitted[field]=fitted[field].slice(1);omitted[field]+=1;}
-  }
-  const body=String(card.body??'');
-  for(let keep=body.length;size(fitted)>limit&&keep>0;){
-    keep=Math.max(0,Math.min(keep-1,keep-(size(fitted)-limit)-64));
-    fitted.body=body.slice(0,keep);omitted.body_chars=body.length-keep;
-  }
-  return fitted;
-}

package/board/wake.mjs

@@ -3,7 +3,6 @@
 import { watch, existsSync, readFileSync, readdirSync, writeFileSync, renameSync, unlinkSync, realpathSync } from 'node:fs';
 import { basename, dirname, join, resolve } from 'node:path';
 import { randomUUID } from 'node:crypto';
-import { boardEventRelay } from './event-relay.mjs';
 import { fileURLToPath } from 'node:url';
 
 export function signalBoardWrite(root, actor) {
@@ -20,13 +19,11 @@ export function signalBoardWrite(root, actor) {
 export function watchBoard({ root, binary, env, log = () => {} }) {
   const watchers = new Map();
   let pending = null, waiter = null, closed = false;
-  let relay = null;
   const wake = (source, at = Date.now()) => {
     if (closed) return;
     if (!pending) pending = { at, sources: new Set() };
     pending.at = Math.min(pending.at, at);
     pending.sources.add(source);
-    void relay?.wake();
     waiter?.();
   };
   const directory = (path, key, accept) => {
@@ -91,9 +88,6 @@ export function watchBoard({ root, binary, env, log = () => {} }) {
     }
   };
   refresh();
-  const supercodeHome = env.SUPERCODE_HOME || (env.XDG_CONFIG_HOME ? join(env.XDG_CONFIG_HOME,'supercode') : join(env.HOME ?? '', '.config','supercode'));
-  relay = boardEventRelay({root,supercodeHome,log});
-  void relay.wake();
   return {
     refresh,
     wake,
@@ -109,7 +103,7 @@ export function watchBoard({ root, binary, env, log = () => {} }) {
       return result ? { at: result.at, sources: [...result.sources] } : null;
     },
     close() {
-      closed = true; waiter?.(); relay.close();
+      closed = true; waiter?.();
       for (const handle of watchers.values()) handle.close();
       watchers.clear();
     },

package/board.mjs

@@ -15,6 +15,7 @@ import { fileURLToPath } from 'node:url';
 import { summary } from './board/cli.mjs';
 import { commandEnv, notifyChats, startDelivery, supercodeBin } from './board/dispatch.mjs';
 import { watchBoard } from './board/wake.mjs';
+import { runtimeDoor } from './board/runtime-door.mjs';
 import { workflowEntry } from './board/workflow.mjs';
 import { evaluate, holds } from './board/expr.mjs';
 
@@ -101,6 +102,9 @@ export async function startBoard({ root, orchestration = null, log = () => {}, a
     }
   };
   const events = watchBoard({ root, binary: supercodeBin(), env: commandEnv(), log: message => log('warn', message) });
+  // The board's events are published by this machine's connector (D137, D138 step 4): the home is named to it once.
+  { const named = runtimeDoor(null, 'harness.v1.boards.register', { root }, { timeout: 30_000 });
+    log(named.code === 0 ? 'info' : 'warn', named.code === 0 ? 'board: its events are published by the machine\'s connector' : `board: events not published; the machine daemon did not take this home: ${(named.stderr || named.stdout).trim().split('\n').at(-1)}`); }
   void (async () => {
     let wakeReason = null;
     while (!stopped) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-orchestrator",
-  "version": "0.5.41",
+  "version": "0.5.42",
   "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.60",
-    "@volter/teams": "0.2.13",
+    "@volter/teams": "0.2.14",
     "@volter/ztrack": "^2.4.23",
     "yaml": "^2.9.0"
   },

package/board/event-relay.mjs

@@ -1,51 +0,0 @@
-// App-owned source names/maps live here; the Teams core knows only a scoped event publisher.
-import { createHash } from 'node:crypto';
-import { eventClient, spentClause } from '@volter/teams/event-client';
-import { EVENT_DATA_LIMIT } from '@volter/teams/event-limits';
-import { boardSourceName, publishableCard, recordCardPublications } from './published.mjs';
-import { listBoards, openBoard } from './store.mjs';
-
-export function boardEventRelay({root,context,supercodeHome,log=()=>{}}) {
-  let work=null,dirty=false,closed=false,retry=null,reconcile=true,heldUntil=0;const sources=new Map();
-  const run=async()=>{
-    if(reconcile){
-      // Establish every native source head before any network operation. A
-      // delivery retry cannot leave later boards without their initial inventory.
-      for(const slug of listBoards(root)){const board=openBoard(root,slug);try{board.tx(db=>recordCardPublications(db,null));}finally{board.close();}}
-      reconcile=false;
-    }
-    const {team,context:audience}=eventClient({context,supercodeHome});
-    for(const slug of listBoards(root)){
-      const board=openBoard(root,slug);
-      try{
-        const key=JSON.stringify({server:audience.server,org:audience.org,principal:audience.principal,board:slug});
-        let source=sources.get(key);
-        if(!source){source=(await team.events.createSource({name:boardSourceName(root,slug)},{caller:'board-relay source'})).data.id;sources.set(key,source);}
-        const destination=createHash('sha256').update(`${key}:${source}`).digest('hex');
-        for(;;){
-          const rows=board.db.prepare('SELECT * FROM supercode_publications p WHERE NOT EXISTS (SELECT 1 FROM supercode_publication_receipts r WHERE r.event_id=p.id AND r.destination=?) ORDER BY sequence LIMIT 32').all(destination);if(!rows.length)break;
-          for(const row of rows){
-            if(closed)return;
-            const id=`event_${createHash('sha256').update(`${row.id}:${destination}`).digest('hex')}`;
-            await team.events.publish(source,{id,kind:row.kind,resource:{kind:'task',id:`${source}:${row.resource_id}`},revision:row.sequence,data:{board:slug,card:publishableCard(JSON.parse(row.snapshot),slug,EVENT_DATA_LIMIT)},actor:{session:row.actor?`session:${row.actor}`:null}},{idempotencyKey:id,caller:'board-relay publish'})
-              .catch(error=>{throw Object.assign(error,{message:`${row.resource_id} ${row.kind} (sequence ${row.sequence}): ${error.message}`});});
-            board.tx(db=>db.prepare('INSERT OR IGNORE INTO supercode_publication_receipts VALUES (?,?)').run(row.id,destination));
-          }
-        }
-      }finally{board.close();}
-    }
-  };
-  const wake=(refresh=true)=>{
-    reconcile ||= refresh;dirty=true;if(work||closed)return work;
-    // Refused for the rate limit, delivery waits out the server's retry-after: a board write meanwhile would only ask
-    // again and spend the allowance the credential shares with every other caller.
-    if(Date.now()<heldUntil)return null;
-    work=(async()=>{while(dirty&&!closed){dirty=false;await run();}})().catch(error=>{
-      log(`board event delivery pending: ${error.code?`${error.code}: `:''}${error.message}${spentClause(error)}`);
-      // Retry durable delivery, not a read of the board's current state.
-      const wait=error.code==='rate_limited'?Math.max(5000,Number(error.details?.retry_after_seconds??30)*1000):5000;heldUntil=Date.now()+wait;
-      clearTimeout(retry);retry=setTimeout(()=>{heldUntil=0;wake(false);},wait);retry.unref?.();
-    }).finally(()=>{work=null;});return work;
-  };
-  return {wake,close(){closed=true;clearTimeout(retry);}};
-}