@volter/supercode-orchestrator 0.5.73 → 0.5.74

package/board/ztrack.mjs

@@ -132,7 +132,9 @@ class ZtrackBoard {
       exec(sql) { return self.active ? self.noting(() => self.conn.exec(sql)) : self.tx(() => self.conn.exec(sql)); },
       close() { self.close(); },
     };
-    if (seed) this.tx(() => {});
+    // A board's first open in this process recovers what its store accepted and derives what git owes for it (tx), so
+    // a board that is only read, or whose owner runs no round, still finishes an earlier process's commit.
+    if (seed || this.git?.underived) this.tx(() => {});
   }
   // The board's documents: the open one, the current archive, and each rotated archive (recorded in the board's own
   // state, so a rotation committed but not yet written is still a document of the board).
@@ -400,7 +402,7 @@ class ZtrackBoard {
         this.conn.exec('DELETE FROM temp.board_dirty; DELETE FROM temp.board_touched');
         this.refused = new Set();
         timedStep('board tx errors', () => this.loadErrors());
-        timedStep('board tx recover', () => this.recover());
+        const recovered = timedStep('board tx recover', () => this.recover());
         if (this.seed) this.indexForSeed();
         else {
           const stale = timedStep('board tx stale check', () => this.staleDocuments({ pending: false }));
@@ -422,7 +424,7 @@ class ZtrackBoard {
         const held = performance.now() - txStarted;
         noteStep('board transaction', held);
         recordSlow({ kind: 'call', name: 'board transaction', ms: held, slowest: null, extra: { board: this.path } });
-        outcome = { result, files, intent };
+        outcome = { result, files, intent, recovered };
       } catch (error) {
         try { this.conn.exec('ROLLBACK'); } catch { /* not begun */ }
         this.active = false; this.seen = null; this.loadErrors();
@@ -430,6 +432,13 @@ class ZtrackBoard {
         throw error;
       } finally { this.active = false; }
       this.seed = null;
+      // What an earlier process left owed in git is derived once this board's recovery has written what its store
+      // accepted, with every document the board has; a recovery in any later write is committed the same way.
+      if (this.git && (this.git.underived || outcome.recovered)) {
+        this.git.paths = this.docs.map((doc) => doc.path);
+        try { timedStep('board git derive', () => outcome.recovered && !this.git.underived ? this.git.commitDirty('board: documents another write accepted') : this.git.derive()); }
+        catch (error) { current().err(`board: ${error.message}\n`); }
+      }
       if (outcome.intent) {
         this.publish(outcome);
         // Committed as the session (or person) whose act this write was, and pushed.
@@ -471,7 +480,7 @@ class ZtrackBoard {
   // document it replaced; merge it into a document edited since (the hand edit wins its cards).
   recover() {
     const pending = this.get('pending');
-    if (!pending) return;
+    if (!pending) return false;
     for (const file of pending.files) {
       const current = this.fileHash(file.path);
       if (current.hash === file.after) continue;
@@ -483,6 +492,7 @@ class ZtrackBoard {
       if (merged) atomic(file.path, merged.text);
     }
     this.drop('pending'); this.drop('pending_hashes');
+    return true;
   }
 
   // ------------------------------------------------------------------ the document index

package/hermes-cli.mjs

@@ -4,8 +4,8 @@
 // pinned `hermes` on its `PATH`; and what Hermes's scheduler records about a failed run (its incidents,
 // in `cron/executions.db`) the orchestrator records through Hermes's own function.
 import { spawn, spawnSync } from 'node:child_process';
-import { existsSync, readFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
+import { accessSync, constants, existsSync, readFileSync, statSync } from 'node:fs';
+import { delimiter, dirname, join } from 'node:path';
 import { parseDotenv } from './orchestration.mjs';
 import { locateHermes } from './apply/doors.mjs';
 
@@ -28,7 +28,8 @@ let located;
 export function hermesInstall() {
   if (located !== undefined) return located;
   try {
-    const which = spawnSync('sh', ['-c', 'command -v hermes'], { encoding: 'utf8' }).stdout.trim();
+    // `hermes` on PATH, found by the file system (no shell started for it)
+    const which = String(process.env.PATH ?? '').split(delimiter).filter(Boolean).map((dir) => join(dir, 'hermes')).find((path) => { try { accessSync(path, constants.X_OK); return statSync(path).isFile(); } catch { return false; } }) ?? '';
     located = which ? { bin: dirname(which), ...locateHermes() } : null;
   } catch {
     located = null;
@@ -350,15 +351,6 @@ export async function memorySnapshot(profileDir) {
   return runHermes(profileDir, { op: 'snapshot' });
 }
 
-/** memorySnapshot for a synchronous caller (the board's launch). An unreadable store contributes nothing. */
-export function memorySnapshotSync(profileDir) {
-  const install = hermesInstall();
-  if (!install?.python) return '';
-  const run = spawnSync(install.python, ['-c', HERMES_TOOL], { input: JSON.stringify({ op: 'snapshot' }), encoding: 'utf8', timeout: 30_000, cwd: install.source, env: hermesEnv(install, profileDir) });
-  try { const out = hermesAnswer('snapshot', { stdout: run.stdout ?? '', stderr: run.stderr || run.error?.message || '' }); return typeof out === 'string' ? out : ''; }
-  catch { return ''; }
-}
-
 /**
  * A schedule string as Hermes parses it (`{ kind: once|interval|cron, … }`), or null when no Hermes is
  * installed; throws Hermes's own refusal. Synchronous: schedules are parsed where a job is built.

package/loop.mjs

@@ -180,16 +180,16 @@ export class Orchestrator {
   tick(at = this.clock()) {
     this.queue = this.queue.then(() => this.adoptOutsideJobs()).catch((error) => this.log('warn', `cron/jobs.json not read back: ${error.message}`));
     return this.dispatch(events.tick(at, cronInactivitySeconds(), cronMaxParallel())).then(
-      (result) => { this.tickerHeartbeat(true); this.declareLocalAgents();return result; },
+      (result) => { this.tickerHeartbeat(true); void this.declareLocalAgents().catch((error) => this.log('warn', `agent hand-off: ${error.message}`));return result; },
       (error) => { this.tickerHeartbeat(false); throw error; },
     );
   }
 
   /** The home's agent declarations and ends a launch could not hand to this machine's daemon (none was running) are
    * handed on. The daemon declares and ends them in Teams and binds their sessions; the gateway makes no Teams call. */
-  declareLocalAgents(){
+  async declareLocalAgents(){
     if(!existsSync(join(this.state.root,'agent-state.sqlite')))return;
-    try{for(const pending of handOffAgents(this.state.root))this.log('warn',`agent ${pending.agent}: ${pending.error}`);}
+    try{for(const pending of await handOffAgents(this.state.root))this.log('warn',`agent ${pending.agent}: ${pending.error}`);}
     catch(error){this.log('warn',`agent hand-off: ${error.message}`);}
   }
 
@@ -416,8 +416,8 @@ export class Orchestrator {
         if(!record)throw new Error('launch as an agent requires its retained profile intent');
         agent=record;
       }
-      agent??=localProfileAgent({root:this.state.root,org:scope.org,server:scope.server,profiles:this.state.profiles,profile:profileName,agent:agentName,declarations:this.state.agents});
-      if(!scope.offline)for(const pending of handOffAgents(this.state.root,{context}))this.log('warn',`agent ${pending.agent}: ${pending.error}`);
+      agent??=await localProfileAgent({root:this.state.root,org:scope.org,server:scope.server,profiles:this.state.profiles,profile:profileName,agent:agentName,declarations:this.state.agents});
+      if(!scope.offline)for(const pending of await handOffAgents(this.state.root,{context}))this.log('warn',`agent ${pending.agent}: ${pending.error}`);
       agent.intended.resolved.worker={...agent.intended.resolved.worker,...worker,cwd};
       main=new_fork||!agent.identity.main_session;
       if(resume_runtime_id&&!new_fork){
@@ -507,8 +507,8 @@ export class Orchestrator {
     if(this.runtimes.has(leaseId(profileName,keyString)))throw new Error('fork requires an unoccupied target conversation');
     if(!(await this.descriptorFor(locator.harness))?.runtime?.capabilities?.resume_session)throw new Error('this harness cannot resume a materialized fork');
     const context=process.env.SUPERCODE_CONTEXT,scope=agentScope(context),session=`${locator.harness}:${locator.session_id}`;
-    const child=localForkAgent({root:this.state.root,org:scope.org,server:scope.server,profiles:this.state.profiles,parent,session,name,key});
-    if(!scope.offline)for(const pending of handOffAgents(this.state.root,{context}))this.log('warn',`agent ${pending.agent}: ${pending.error}`);
+    const child=await localForkAgent({root:this.state.root,org:scope.org,server:scope.server,profiles:this.state.profiles,parent,session,name,key});
+    if(!scope.offline)for(const pending of await handOffAgents(this.state.root,{context}))this.log('warn',`agent ${pending.agent}: ${pending.error}`);
     const runKey=`fork:${key}`,prior=agentRunForKey(this.state.root,scope.org,child.identity.id,runKey);
     let target;
     if(prior) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-orchestrator",
-  "version": "0.5.73",
+  "version": "0.5.74",
   "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.24",
+    "@volter/teams": "0.2.25",
     "@volter/ztrack": "^2.4.23",
     "yaml": "^2.9.0"
   },

package/bin/machine-fleet.mjs

@@ -1,38 +0,0 @@
-#!/usr/bin/env node
-// One fleet reading for a synchronous board process: each named machine's panes and the harness session under each live
-// pane, every machine read at once through its own door, each bounded by its own deadline. Prints one row per machine:
-// { machine, panes, activities } when its door answered, { machine, error, code } when it did not.
-import { openMachine } from '@volter/teams/machine-door';
-import { StreamRpc, harnessTransport } from '@volter/teams/client';
-import { SupercodeHarnessClient } from '@volter/supercode-harness-sdk';
-let input = ''; for await (const chunk of process.stdin) input += chunk;
-const { machines, deadlineMs } = JSON.parse(input);
-const within = (promise, ms) => Promise.race([promise, new Promise((_, reject) => setTimeout(() => reject(Object.assign(new Error(`no answer within ${ms} ms`), { code: 'timeout' })), ms))]);
-async function read({ name, at }) {
-  let channel;
-  try {
-    channel = await openMachine({ machine: at });
-    const node = new StreamRpc(await channel.open('node'));
-    const panes = await node.call('harness.v1.panes.list', {});
-    // What a board launch needs of this machine: its board process guard (describe), and its keyed launch door, asked
-    // for a key no launch has (an answer of null is the door; an unknown method is its absence)
-    const description = await node.call('harness.v1.machine.describe', {}).catch(() => null);
-    const keyed = await node.call('harness.v1.launches.get', { key: 'board-capability-reading' }).then(() => null, (error) => String(error?.message ?? error).slice(0, 200));
-    const capabilities = { guard: description?.boardProcessPolicy?.version === 1 ? description.boardProcessPolicy.harnesses ?? [] : [], launches: keyed === null, launchesRefused: keyed };
-    const live = (Array.isArray(panes) ? panes : []).filter((pane) => !pane.dead && pane.pid);
-    // the session under each live pane: the harness stream, an operator's; a caller the machine admits only to its panes
-    // (a box another custodian enrolled, granting view and control) reads its panes and no sessions
-    let activities = [], sessionsUnread = null;
-    if (live.length) {
-      const client = new SupercodeHarnessClient({ transport: harnessTransport(channel) });
-      try { await client.start?.(); activities = (await client.request('harness.v1.sessions.activity_under', { pids: live.map((pane) => pane.pid) }))?.activities ?? []; }
-      catch (error) { sessionsUnread = String(error?.message ?? error).slice(0, 200); }
-      finally { await client.close?.().catch(() => {}); }
-    }
-    return { machine: name, panes, activities, capabilities, sessionsUnread };
-  } finally { channel?.close(); }
-}
-const rows = await Promise.all(machines.map((machine) => within(read(machine), deadlineMs)
-  .catch((error) => ({ machine: machine.name, error: String(error?.message ?? error).slice(0, 300), code: error?.code ?? 'unavailable' }))));
-process.stdout.write(`${JSON.stringify(rows)}\n`);
-process.exit(0);

package/bin/runtime-door.mjs

@@ -1,23 +0,0 @@
-#!/usr/bin/env node
-// A synchronous board process delegates one request to the public daemon door.
-// This helper owns neither credentials nor machine state; the SDK opens the admitted channel.
-import { openMachine } from '@volter/teams/machine-door';
-import { StreamRpc, harnessTransport } from '@volter/teams/client';
-import { SupercodeHarnessClient } from '@volter/supercode-harness-sdk';
-let input = ''; for await (const chunk of process.stdin) input += chunk;
-let channel;
-try {
-  const { machine, method, params = {} } = JSON.parse(input);
-  if (!method.startsWith('harness.v1.')) throw new Error('the runtime door accepts harness.v1 methods');
-  channel = await openMachine({machine});
-  let result;
-  if (method.startsWith('harness.v1.sessions.')) {
-    // A session's records are the harness's own service, spoken by its SDK over the machine's harness stream.
-    const client = new SupercodeHarnessClient({ transport: harnessTransport(channel) });
-    try { await client.start?.(); result = await client.request(method, params); } finally { await client.close?.(); }
-  } else result = await new StreamRpc(await channel.open('node')).call(method,params);
-  process.stdout.write(JSON.stringify(result)+'\n');
-} catch (error) {
-  process.stderr.write(JSON.stringify({code:error.code??'unavailable',message:error.message})+'\n');
-  process.exitCode = 1;
-} finally { channel?.close(); }