@volter/supercode-orchestrator 0.5.107 → 0.5.109

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/dispatch.mjs

@@ -1010,9 +1010,15 @@ export async function closeRequested(board, report, { taskId = null, caller = nu
       (report.closed ??= []).push({ task_id: row.task_id, ...session, released: true });
       continue;
     }
-    // A close that failed for a reason another attempt cannot change is tried once and raised as an incident, not tried
-    // every round (each attempt is a process). A deferred close (an offline machine, a run that still owns the pane) waits.
-    if (session.close_failed_at && session.close_error && !/^close deferred/.test(session.close_error)) continue;
+    // A final refusal stops further close attempts. Only an authorized observation of this exact pane may establish
+    // absence: panes.list can be filtered or carry missing context keys. Unknown/invisible keeps the original failure.
+    const finalFailure = Boolean(session.close_failed_at && session.close_error && !/^close deferred/.test(session.close_error));
+    if (finalFailure) {
+      if (!session.pane) continue;
+      const r = await doorOn(session.machine ?? localMachine(), 'harness.v1.panes.presence', { pane: session.pane }, { timeout: 10_000, as: boardAddress(board.label) });
+      const observed = r.code === 0 ? json(r.stdout.trim(), null) : null;
+      if (observed?.pane !== session.pane || observed.present !== false) continue;
+    }
     const active = view(board, (db) => db.prepare(`SELECT r.id, r.metadata FROM task_runs r WHERE r.ended_at IS NULL OR EXISTS (SELECT 1 FROM tasks t WHERE t.current_run_id = r.id)`).all());
     // Persist retries even for historical ends that did not have a close_session action. The close is claimed in the
     // same transaction, before the pane or process is touched: of two rounds (or a round and a verb) that read one close,
@@ -1039,7 +1045,7 @@ export async function closeRequested(board, report, { taskId = null, caller = nu
           if (row.ended_at) { const inTurn = await turnAtClose(session); if (inTurn) throw new Error(`close deferred: ${inTurn}`); }
           await stopSession(board, session);
         }
-      } else {
+      } else if (!finalFailure) {
       if (!panes.has(machine)) {
         const r = await doorOn(machine, 'harness.v1.panes.list',{}, { timeout: 60_000, as: boardAddress(board.label) });
         const list = r.code === 0 ? json(r.stdout.trim(), null) : null;
@@ -1088,7 +1094,8 @@ export async function closeRequested(board, report, { taskId = null, caller = nu
         const subscribed = db.prepare('SELECT r.id, r.metadata FROM task_runs r WHERE r.ended_at IS NULL OR EXISTS (SELECT 1 FROM tasks t WHERE t.current_run_id = r.id)').all()
           .some((r) => addressOf(json(r.metadata, {})?.supercode) === address && r.id !== row.id);
         const unsubscribed = subscribed ? 0 : db.prepare("DELETE FROM kanban_notify_subs WHERE platform = 'supercode' AND chat_id = ? AND (task_id = ? OR json_extract(delivery_metadata, '$.role') = 'worker')").run(address, row.task_id).changes;
-        event(db, row.task_id, 'session_closed', { session_id: session.session_id, pane: session.pane, machine: session.machine, unsubscribed }, row.id);
+        event(db, row.task_id, 'session_closed', { session_id: session.session_id, pane: session.pane, machine: session.machine, unsubscribed,
+          ...(finalFailure ? { reason: 'authorized pane presence observed absence after an earlier close refusal' } : {}) }, row.id);
       }
     });
     if (error) report.undelivered.push([row.task_id, addressOf(session), error, 'close']);

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.109",
   "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"
   },