@volter/supercode-orchestrator 0.5.106 → 0.5.108

package/activation.mjs

@@ -176,6 +176,9 @@ export const MODEL_ARGUMENTS = Object.freeze({
   'claude-code': (model) => ['--model', model],
   codex: (model) => ['-c', `model=${JSON.stringify(model)}`],
   gemini: (model) => ['-m', model],
+  // The Runhuman harness runs a routine (runhuman-2 ADR 0038 §13): the worker's model names it, `routine:<org>/<name>`;
+  // with none, the routine is the `.runhuman` folder in the worker's cwd. The card role's agent is the run's agent.
+  runhuman: (model) => ['--routine', model],
 });
 
 /**

package/board/doors.mjs

@@ -64,6 +64,11 @@ export async function machineCall(machine, method, params = {}, { timeoutMs = 60
   }
 }
 
+export async function machineRecordStream(params = {}) {
+  const door = await opened(null);
+  return door.channel.open('machine-record-changes', params);
+}
+
 /** Let go of every held channel (the owner stopping). */
 export async function closeDoors() {
   for (const [key, opening] of [...held]) {

package/board/machine-fleet.mjs

@@ -8,7 +8,9 @@
 // sessions under them not read) or was never read is `unknown` (its runs are kept, as an unread machine's always were), unless its record says it was unlinked from the
 // team: then it is offline. This machine's own record not being given is no reading at all.
 import { noteStep } from '@volter/supercode-harness-sdk/slow-log';
-import { machineCall } from './doors.mjs';
+import { machineCall, machineRecordStream } from './doors.mjs';
+import { RecordView } from './record-view.mjs';
+const recordView = new RecordView(machineRecordStream);
 const DEADLINE_MS = 10_000;
 const within = (promise, ms) => Promise.race([promise, new Promise((_, reject) => setTimeout(() => reject(Object.assign(new Error(`no answer within ${ms} ms`), { code: 'timeout' })), ms).unref?.())]);
 // One machine's reading, from its held record: its panes, what a board launch needs of it, and the session under each
@@ -32,7 +34,15 @@ export async function readMachineFleet(machines, local) {
   const names = [...new Set([local, ...machines])];
   const started = performance.now();
   let held = null, heldError = null;
-  try { held = (await within(machineCall(null, 'harness.v1.machine.records', {}), DEADLINE_MS))?.records ?? {}; }
+  try {
+    try { held = await within(recordView.read(DEADLINE_MS), DEADLINE_MS); }
+    catch (error) {
+      if (!String(error.message).includes('unknown stream machine-record-changes')) throw error;
+      // Supported older daemons have only the snapshot door. A refusal or a
+      // failed current stream never falls back to data of uncertain freshness.
+      held = (await within(machineCall(null, 'harness.v1.machine.records', {}), DEADLINE_MS))?.records ?? {};
+    }
+  }
   catch (error) { heldError = String(error?.message ?? error).slice(0, 300); }
   const rows = names.map((name) => heldError ? { machine: name, error: `this machine's daemon did not give the records it holds: ${heldError}`, code: 'unavailable' } : readOne(name, held[name]));
   noteStep(`fleet reading (${names.length} machine${names.length === 1 ? '' : 's'}, held records)`, performance.now() - started);

package/board/record-view.mjs

@@ -0,0 +1,93 @@
+// Resident local consumer of the daemon's committed record rows. Disconnects
+// preserve the last applied cursor, but held data is stale until caught up.
+export class RecordView {
+  constructor(open) {
+    this.open = open; this.records = {}; this.positions = new Map();
+    this.cursor = null; this.stream = null; this.waiters = new Set();
+    this.ready = false; this.heardAt = 0;
+  }
+  async read(timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    if (this.stream && Date.now() - this.heardAt > 45_000) this.stream.close('its record stream went quiet');
+    if (!this.stream && !this.opening) {
+      this.opening = this.open({ after: this.cursor }).then((stream) => {
+        this.stream = stream;
+        this.ready = false;
+        this.heardAt = Date.now();
+        stream.on('data', (frame) => {
+          try { this.apply(frame); }
+          catch (error) { this.fail(error); stream.close(error.message); }
+        });
+        stream.on('close', (reason) => {
+          if (this.stream !== stream) return;
+          this.stream = null; this.ready = false;
+          this.fail(new Error(reason ?? 'the local record stream closed'));
+        });
+      }).finally(() => { this.opening = null; });
+    }
+    if (this.opening) await this.opening;
+    if (this.ready) return this.records;
+    if (!this.stream) throw this.failure ?? new Error('the local record stream ended before its snapshot');
+    return new Promise((resolve, reject) => {
+      const waiter = { resolve, reject };
+      waiter.timer = setTimeout(() => {
+        this.waiters.delete(waiter);
+        reject(new Error('the local record stream did not finish its snapshot or cursor catch-up within its deadline'));
+      }, Math.max(0, deadline - Date.now()));
+      this.waiters.add(waiter);
+    });
+  }
+  fail(error) {
+    this.failure = error;
+    for (const waiter of this.waiters) { clearTimeout(waiter.timer); waiter.reject(error); }
+    this.waiters.clear();
+  }
+  own(key) { return key.role === 'producer' ? key.machine === this.self : key.role === 'holder' && key.machine !== this.self; }
+  apply(frame) {
+    if (frame.type === 'beat') { this.heardAt = Date.now(); return; }
+    if (frame.type === 'snapshot') {
+      this.self = frame.machine; this.records = frame.records; this.positions.clear();
+      for (const [machine, held] of Object.entries(this.records)) this.positions.set(machine, new Map((held.record?.sessions ?? []).map((row, at) => [row.address, at])));
+      this.cursor = frame.cursor; this.ready = true;
+    } else if (frame.type === 'changes') {
+      if (!this.cursor || frame.cursor?.id !== this.cursor.id) throw new Error('record row changes name a different database; a new snapshot is required');
+      const moved = new Set();
+      for (const change of frame.changes ?? []) {
+        if (change.sequence <= this.cursor.sequence || !this.own(change.key)) continue;
+        const { machine, section, key, position } = change.key;
+        if (change.topic === 'record-head') {
+          if (change.operation === 'delete') { delete this.records[machine]; this.positions.delete(machine); continue; }
+          const { record: summary, meta } = change.value;
+          const previous = this.records[machine]?.record;
+          const record = summary == null ? null : { sessions: [], mail: {}, panes: null, capabilities: null, unread: {}, ...previous, ...summary };
+          if (record) { if (!summary.sessions_rows) record.sessions = null; delete record.sessions_rows; }
+          this.records[machine] = { record, stream: machine === this.self ? 'self' : meta?.stream ?? 'closed', since: meta?.since ?? null, why: meta?.why ?? null, received_at: meta?.received_at ?? null };
+        } else if (change.topic === 'record-row') {
+          const held = this.records[machine] ??= { stream: 'closed', record: null };
+          const record = held.record ??= { sessions: [], mail: {}, panes: null, capabilities: null, unread: {} };
+          const deleted = change.operation === 'delete';
+          if (section === 'sessions') {
+            const rows = new Map((record.sessions ?? []).map((row) => [row.address, row]));
+            const positions = this.positions.get(machine) ?? new Map();
+            this.positions.set(machine, positions);
+            if (deleted) { rows.delete(key); positions.delete(key); }
+            else { rows.set(key, change.value); positions.set(key, position); }
+            record.sessions = [...rows.values()]; moved.add(machine);
+          } else if (section === 'mail') {
+            if (deleted) delete record.mail[key]; else record.mail[key] = change.value;
+          } else record[section] = deleted ? null : change.value;
+        }
+      }
+      for (const machine of moved) {
+        const positions = this.positions.get(machine);
+        this.records[machine]?.record?.sessions?.sort((a, b) => (positions.get(a.address) ?? 0) - (positions.get(b.address) ?? 0) || a.address.localeCompare(b.address));
+      }
+      this.cursor = frame.cursor; this.ready = !frame.more;
+    } else throw new Error(`unrecognized record-view frame ${frame.type}`);
+    this.heardAt = Date.now();
+    if (this.ready) {
+      for (const waiter of this.waiters) { clearTimeout(waiter.timer); waiter.resolve(this.records); }
+      this.waiters.clear();
+    }
+  }
+}

package/kanban-worker.mjs

@@ -19,6 +19,9 @@ import { pinnedSkills, taskProtocol } from './board/worker-prompt.mjs';
 import { mountOrchestratorMcp } from './mcp/mount.mjs';
 import { normalizeWorkerEvent, widensSandbox } from './loop.mjs';
 import { askBoardOwner, callerFacts, unansweredText } from '@volter/teams/board-owner';
+// A card's own words are read from its board (a routine has no board tools); what the worker writes goes through the board's owner.
+import { DEFAULT_BOARD, openBoard, view } from './board/store.mjs';
+import { getTask } from './board/engine.mjs';
 import { permissionResponse } from './reducer.mjs';
 import { boardGuardArguments } from '@volter/teams/board-process-guard';
 
@@ -85,6 +88,8 @@ export async function runKanbanWorker(argv, env = process.env) {
 
 async function runTurn({ client, profile, harness, worker, route, root, vault, surfaceKey, runEnv, instructions, task, cwd, args, say }) {
   const descriptor = (await client.supportReport()).harnesses.find((h) => h.id === harness);
+  // A worker's folder that is gone (a home moved or swept) fails its launch as the harness program missing; say which.
+  if (!existsSync(cwd) || !statSync(cwd).isDirectory()) { say(`hermes-worker: the worker's folder ${cwd} does not exist (the profile's worker.cwd)`); return 2; }
   const base = descriptor?.runtime?.default_launch;
   if (!base) { say(`hermes-worker: ${harness} publishes no launch`); return 2; }
   const reasoning = args.reasoning && harness === 'codex' ? ['-c', `model_reasoning_effort=${JSON.stringify(args.reasoning)}`] : [];
@@ -98,11 +103,15 @@ async function runTurn({ client, profile, harness, worker, route, root, vault, s
   const policy = approvalPolicy(profile, harness);
   const runtime = await client.startManagedRuntime({ harness, cwd, launch: mount.launch, ...(mount.mcp_servers ? { mcp_servers: mount.mcp_servers } : {}), ...(policy ? { approval_policy: policy } : {}) });
   try { await recordSession(root, task, harness, runtime.handle.runtime_id); } catch (error) { say(`hermes-worker: recording the session on its run: ${error.message}`); }
-  let text = '';
+  let text = '', last = '';
   // `agent.max_turns` for a worker that takes no cap at launch, held as the daemon holds it (loop.mjs `holdTurnLimit`)
   const counter = turnCounter(profile, harness);
-  const outcome = await new Promise((done) => {
+  const outcome = await new Promise((resolve) => {
+    // Settled once: the runtime's close after the turn's final answer is not the worker ending.
+    let settled = false;
+    const done = (code) => { settled = true; resolve(code); };
     const on = (ev) => {
+      if (settled) return;
       if (counter?.count(ev)) {
         say(`hermes-worker: ${counter.cap + 1} model calls in one turn passes agent.max_turns ${counter.cap}; the turn is interrupted`);
         void Promise.resolve(runtime.interrupt?.()).catch((error) => say(`hermes-worker: interrupt failed: ${error.message}`));
@@ -110,7 +119,7 @@ async function runTurn({ client, profile, harness, worker, route, root, vault, s
       let w = normalizeWorkerEvent(ev);
       if (!w) return;
       if (w.kind === 'final' && counter) w = counter.settle(w);
-      if (w.kind === 'text') text += w.block && text ? `\n\n${w.delta}` : w.delta;
+      if (w.kind === 'text') { text += w.block && text ? `\n\n${w.delta}` : w.delta; last = w.delta; }
       else if (w.kind === 'request') {
         // nobody attends a dispatched worker: an untrusted server's tool is denied; anything else is answered by Hermes's
         // approval rule in single-query mode, as the daemon's path asks it (loop.mjs): a safe command runs, a dangerous
@@ -137,13 +146,42 @@ async function runTurn({ client, profile, harness, worker, route, root, vault, s
     runtime.on('event', on);
     runtime.on('closed', on);
     runtime.on('runtimeError', on);
-    runtime.sendInput(args.query).catch((error) => { say(`hermes-worker: ${error.message}`); done(1); });
+    runtime.sendInput(harness === 'runhuman' ? cardWords(root, task) ?? args.query : args.query).catch((error) => { say(`hermes-worker: ${error.message}`); done(1); });
   });
   if (text) say(text);
   await runtime.close().catch(() => {});
+  // A routine has no board tools: its run's answer (the turn's last line, its returns) completes the card it worked.
+  if (harness === 'runhuman' && outcome === 0 && task.HERMES_KANBAN_TASK) {
+    const answer = last.trim();
+    const done = await askBoardOwner(root, {
+      // As the card's worker, by its own board tool (its card, run and board name it), as a harness's board tools do.
+      tool: { name: 'kanban_complete', args: { summary: answer || 'The run ended with no answer.', ...(answer ? { result: answer } : {}) }, env: task },
+      board: task.HERMES_KANBAN_BOARD || null, caller: null, session: null, cwd: root, stdin: null,
+      facts: { ...callerFacts(), SUPERCODE_CONTEXT: process.env.SUPERCODE_CONTEXT || 'local' },
+    }).catch((error) => ({ code: 1, stderr: error.message }));
+    // The tool's own refusal comes back as its JSON (an `error`), not as a failed request.
+    const refused = (() => { try { return JSON.parse(done.stdout ?? '{}')?.error; } catch { return undefined; } })();
+    if (refused && !done.code) Object.assign(done, { code: 1, stderr: String(refused) });
+    if (done.unanswered === true || done.code) { say(`hermes-worker: completing ${task.HERMES_KANBAN_TASK} with the run's answer: ${done.unanswered === true ? unansweredText(done, 'the card\'s completion').trim() : (done.stderr || 'the board owner did not complete it').trim()}`); return 1; }
+  }
   return outcome;
 }
 
+/**
+ * A Runhuman worker's first input: the card's own words (its title and body), which a routine takes as its variables
+ * (a ```runhuman-vars block, its `ask`, its links). A routine has no board tools to read the card by its id.
+ */
+function cardWords(root, task) {
+  if (!task.HERMES_KANBAN_TASK) return null;
+  const board = openBoard(root, task.HERMES_KANBAN_BOARD || DEFAULT_BOARD);
+  try {
+    const card = view(board, (db) => getTask(db, task.HERMES_KANBAN_TASK));
+    return card ? [card.title, card.body].filter(Boolean).join('\n\n') : null;
+  } finally {
+    board.close();
+  }
+}
+
 /**
  * The worker's session on its run, where supercode keeps it (`metadata.supercode.session_id`, beside the pid the
  * dispatcher recorded): the harness's own transcript, found and resumed by supercode like any session. Written by the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-orchestrator",
-  "version": "0.5.106",
+  "version": "0.5.108",
   "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.44",
+    "@volter/teams": "0.2.45",
     "@volter/ztrack": "^2.4.23",
     "yaml": "^2.9.0"
   },