@volter/supercode-orchestrator 0.5.107 → 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/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.107",
+  "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"
   },