@volter/supercode-orchestrator 0.4.24 → 0.4.25

package/board/dispatch.mjs

@@ -911,13 +911,17 @@ function readMailbox(board, address, report) {
 // ------------------------------------------------------------------ goals and triage
 
 /**
- * Hermes's goal loop for a pane session: a goal card whose session sits idle while the card is still running is told
- * to keep going, up to the card's turn budget; when the budget is spent the card is blocked for review. Whether the
- * work is done is the session's call through its card (`request-review`), not an auxiliary judge's.
+ * The board's heartbeat for a pane session: a running card's session never sits idle without deciding. Each tick, a
+ * session that is idle while its card is still running is asked to decide: `request-review` when the work is done,
+ * `block` with its kind when it cannot go on (waiting on a person, a capability, another card), or keep working. A
+ * goal card (Hermes's goal loop) is told to keep going. A session is asked once it has been idle a whole tick; one
+ * seen working since the last ask answered it, and its count starts again. After the turn budget (`goal_max_turns`, else
+ * `kanban.goal_max_turns`) of asks in a row with no work and no decision (a goal card: of turns), the card is blocked `needs_input` and its creator is told.
+ * Whether the work is done is the session's call through its card, not an auxiliary judge's.
  */
 function pursueGoals(board, fleet, settings, report) {
   if (!fleet.ok) return;
-  const cards = board.db.prepare("SELECT id FROM tasks WHERE status = 'running' AND goal_mode = 1").all();
+  const cards = board.db.prepare("SELECT id FROM tasks WHERE status = 'running'").all();
   for (const { id } of cards) {
     const nudge = tx(board, (db) => {
       const task = getTask(db, id);
@@ -925,22 +929,37 @@ function pursueGoals(board, fleet, settings, report) {
       const session = runRow?.metadata?.supercode;
       if (!session?.session_id || session.surface !== 'pane') return null;
       const live = fleet.sessions.find((x) => x.address?.endsWith(`:${session.session_id}`));
-      if (live?.status !== 'idle') return null;
+      if (!live) return null;
+      // a session seen working since the last ask answered it by working: its count starts again (a goal card keeps
+      // Hermes's budget of turns); one idle for less than a whole tick is between turns, not idle
+      if (live.status !== 'idle') {
+        if (session.idle_since || (session.goal_nudged_at && !session.worked_since_ask)) setRunSession(db, runRow.id, { ...session, idle_since: null, worked_since_ask: true });
+        return null;
+      }
+      if (!session.idle_since) { setRunSession(db, runRow.id, { ...session, idle_since: now() }); return null; }
+      if (now() - session.idle_since < settings.interval) return null;
       if (session.goal_nudged_at && now() - session.goal_nudged_at < settings.interval * 2) return null;
-      const turns = Number(session.goal_turns ?? 0);
+      const turns = session.worked_since_ask && !task.goal_mode ? 0 : Number(session.goal_turns ?? 0);
       const budget = task.goal_max_turns ?? settings.goalMaxTurns;
       if (turns >= budget) {
         db.prepare("UPDATE tasks SET status = 'blocked', claim_lock = NULL, claim_expires = NULL WHERE id = ?").run(id);
-        const ended = endRun(db, id, { outcome: 'blocked', summary: `goal turn budget (${budget}) spent` });
-        event(db, id, 'blocked', { reason: `goal turn budget (${budget}) spent; review it`, kind: 'needs_input', source_status: 'ready' }, ended);
+        const ended = endRun(db, id, { outcome: 'blocked', summary: `idle ${budget} times without deciding done or blocked` });
+        event(db, id, 'blocked', { reason: `its session went idle ${budget} times without deciding done or blocked; review it`, kind: 'needs_input', source_status: 'running' }, ended);
         return null;
       }
-      setRunSession(db, runRow.id, { ...session, goal_turns: turns + 1, goal_nudged_at: now() });
-      event(db, id, 'goal_continued', { turn: turns + 1, budget }, runRow.id);
-      return { address: live.address, text: `Card ${id} (${task.title}) is not done yet: keep working toward it (goal turn ${turns + 1} of ${budget}). When it is done, \`request-review\` it; if you are stuck, \`block\` it with its kind.` };
+      setRunSession(db, runRow.id, { ...session, goal_turns: turns + 1, goal_nudged_at: now(), worked_since_ask: false });
+      event(db, id, task.goal_mode ? 'goal_continued' : 'decision_asked', { turn: turns + 1, budget }, runRow.id);
+      const local = normalMachine(task.machine) === localMachine();
+      const where = local ? `--root ${board.root}${board.slug !== 'default' ? ` --board ${board.slug}` : ''}` : `--at ${boardAddress(board.label)}`;
+      const decide = `When it is done, \`supercode workflow request-review ${id} --summary "<what>" ${where}\`; if you cannot go on, \`supercode workflow block ${id} "<why>" --kind <needs_input|capability|transient|dependency> ${where}\`.`;
+      const text = task.goal_mode
+        ? `Card ${id} (${task.title}) is not done yet: keep working toward it (goal turn ${turns + 1} of ${budget}). ${decide}`
+        : `Card ${id} (${task.title}) is still running and you are idle: decide (${turns + 1} of ${budget}). If there is more to do, keep working. ${decide} `
+          + `A session that stays idle without deciding has its card blocked for its creator after ${budget}.`;
+      return { address: live.address, text, kind: task.goal_mode ? 'goal_continued' : 'decision_asked' };
     });
     if (nudge) {
-      try { send(boardAddress(board.label), board.label, nudge.address, nudge.text, `board-goal-${id}-${now()}`); report.notified.push([id, 'goal_continued', nudge.address]); }
+      try { send(boardAddress(board.label), board.label, nudge.address, nudge.text, `board-goal-${id}-${now()}`); report.notified.push([id, nudge.kind, nudge.address]); }
       catch (error) { report.undelivered.push([id, nudge.address, String(error.message).slice(-200)]); }
     }
   }

package/kanban-worker.mjs

@@ -2,9 +2,11 @@
 // starts a headless profile's worker as Hermes's dispatcher starts its own: `-p <assignee> --cli --accept-hooks
 // [--skills <s>]… [-m <model> [--provider <p>]] [--reasoning <e>] chat -q "work kanban task <id>"`, detached, in the
 // task's workspace, its output to the task's log, the task in its environment (`KANBAN_ENV`), and watches the pid.
-// This is that process: it runs the assignee profile's own worker for the one query, with Hermes's task protocol,
-// the task's skills and the home's memory in its system prompt and the board's tools on its door, prints the answer
-// to the log and exits, as `hermes chat -q` does. A profile whose worker is Hermes runs Hermes itself.
+// This is that process: it runs the assignee profile's own worker for the one query, with the task protocol and the
+// task's skills in its system prompt and the board's tools on its door, prints the answer to the log and exits, as
+// `hermes chat -q` does. It runs no Hermes code: the worker is a session supercode starts and records (its id on the
+// run), its memory is its harness's own, its requests are answered by supercode's unattended rule. A profile whose
+// worker is Hermes runs Hermes itself, as its harness.
 import { spawn } from 'node:child_process';
 import { existsSync, statSync } from 'node:fs';
 import { basename, dirname, join, resolve } from 'node:path';
@@ -12,10 +14,12 @@ import { SupercodeHarnessClient } from '@volter/supercode-harness-sdk';
 import { load } from './orchestration.mjs';
 import { INSTRUCTION_ARGUMENTS, activationCwd, activationEnv, sandboxArguments, approvalPolicy, limitArguments, materializePersona, materializeSkills, modelArguments, turnCounter, userHomeArguments, userHomePersona } from './activation.mjs';
 import { workerRoute } from './worker-route.mjs';
-import { KANBAN_ENV, untrustedServerVerdict, hermesApproval, hermesInstall, hermesToolEnv, memorySnapshot, mirrorSession } from './hermes-cli.mjs';
+import { KANBAN_ENV, untrustedServerVerdict, hermesInstall } from './hermes-cli.mjs';
 import { pinnedSkills, taskProtocol } from './board/worker-prompt.mjs';
 import { mountOrchestratorMcp } from './mcp/mount.mjs';
-import { normalizeWorkerEvent, WORKER_STORE } from './loop.mjs';
+import { normalizeWorkerEvent } from './loop.mjs';
+import { DEFAULT_BOARD, json, openBoard, tx } from './board/store.mjs';
+import { setRunSession } from './board/engine.mjs';
 import { permissionResponse } from './reducer.mjs';
 
 /** Hermes's worker argv, as `_default_spawn` builds it. */
@@ -63,11 +67,9 @@ export async function runKanbanWorker(argv, env = process.env) {
   materializeSkills(profile);
   const route = workerRoute(profile, worker, vault);
   const surfaceKey = `kanban|task|${taskId}`;
-  const runEnv = { ...hermesToolEnv(profile.dir), ...activationEnv({ root, profile, surfaceKey, vault }), ...route.env, ...task };
-  // Hermes's system prompt for a dispatched worker: the home's memory, the task protocol, the task's skills
-  const memory = await memorySnapshot(profile.dir).catch(() => '');
-  // the task protocol and the pinned skills, supercode's own (board/worker-prompt.mjs)
-  const instructions = [userHomePersona(profile), memory, taskProtocol(taskId), pinnedSkills(profile.dir, args.skills)].filter(Boolean).join('\n\n');
+  const runEnv = { HERMES_HOME: profile.dir, ...activationEnv({ root, profile, surfaceKey, vault }), ...route.env, ...task };
+  // the persona, the task protocol and the pinned skills, supercode's own (board/worker-prompt.mjs)
+  const instructions = [userHomePersona(profile), taskProtocol(taskId), pinnedSkills(profile.dir, args.skills)].filter(Boolean).join('\n\n');
 
   const client = new SupercodeHarnessClient(env.SUPERCODE_BIN ? { command: env.SUPERCODE_BIN } : {});
   try {
@@ -90,6 +92,7 @@ async function runTurn({ client, profile, harness, worker, route, root, vault, s
   const mount = mountOrchestratorMcp({ root, profile, harness, surfaceKey, launch, vault, task });
   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 { recordSession(root, task, harness, runtime.handle.runtime_id); } catch (error) { say(`hermes-worker: recording the session on its run: ${error.message}`); }
   let text = '';
   // `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);
@@ -104,13 +107,12 @@ async function runTurn({ client, profile, harness, worker, route, root, vault, s
       if (w.kind === 'final' && counter) w = counter.settle(w);
       if (w.kind === 'text') text += w.block && text ? `\n\n${w.delta}` : w.delta;
       else if (w.kind === 'request') {
-        // Hermes's approval rule for a single-query worker (`approvals.single_query_mode` for a dangerous command)
+        // nobody attends a dispatched worker: an untrusted server's tool is denied, anything else is answered by the
+        // profile's `worker.permission.unattended` (deny unless it says approve)
         const gated = untrustedServerVerdict(profile, w.tool, 'single_query', { mcp: w.mcp && !String(w.tool ?? '').startsWith('mcp__orchestrator__') });
-        void (gated ? Promise.resolve(gated) : hermesApproval(profile.dir, { command: w.command ?? null, context: 'single_query' })).catch(() => null).then((hermes) => {
-          const approve = hermes ? hermes.verdict === 'allow' : profile.worker?.permission?.unattended === 'approve';
-          if (!hermes || hermes.verdict !== 'allow') say(`hermes-worker: ${approve ? 'approved' : 'denied'} a permission request with nobody attending (${hermes ? `Hermes: ${hermes.why}` : 'worker.permission.unattended'}): ${w.subject}`);
-          runtime.respond(JSON.parse(w.id), permissionResponse(w.options, approve, hermes?.message ?? null)).catch(() => {});
-        });
+        const approve = gated ? gated.verdict === 'allow' : profile.worker?.permission?.unattended === 'approve';
+        say(`hermes-worker: ${approve ? 'approved' : 'denied'} a permission request with nobody attending (${gated ? gated.why : 'worker.permission.unattended'}): ${w.subject}`);
+        runtime.respond(JSON.parse(w.id), permissionResponse(w.options, approve, gated?.message ?? (approve ? null : 'Denied: nobody is attending this run to approve it (worker.permission.unattended). Find an alternative approach that avoids this action.'))).catch(() => {});
       } else if (w.kind === 'final') {
         if (w.outcome === 'error') say(`hermes-worker: the turn failed: ${w.message ?? 'no reason given'}`);
         done(w.outcome === 'error' ? 1 : 0);
@@ -125,20 +127,27 @@ async function runTurn({ client, profile, harness, worker, route, root, vault, s
     runtime.sendInput(args.query).catch((error) => { say(`hermes-worker: ${error.message}`); done(1); });
   });
   if (text) say(text);
-  // the run's transcript in the home's session store, as a Hermes worker's is: tagged `kanban`
-  await mirrorRun(client, profile, harness, runtime.handle.runtime_id).catch((error) => say(`hermes-worker: mirror: ${error.message}`));
   await runtime.close().catch(() => {});
   return outcome;
 }
 
-async function mirrorRun(client, profile, harness, sessionId) {
-  const store = WORKER_STORE[harness];
-  if (!store) return;
-  const { sessions } = await client.discover({ harnesses: [harness], homes: store(join(profile.dir, harness)), include_child_sessions: true, root_session_id: sessionId, limit: 8 });
-  const locator = sessions.find((d) => d.locator.session_id === sessionId)?.locator;
-  if (!locator) return;
-  const loaded = await client.loadWindow(locator, { message_limit: 1_000_000 });
-  await mirrorSession(profile.dir, { id: sessionId, sessionKey: null, binding: { key: { platform: 'kanban' }, worker: { harness } }, session: loaded.session, locator: locator.storage?.path ?? null });
+/**
+ * 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.
+ */
+function recordSession(root, task, harness, sessionId) {
+  if (!task.HERMES_KANBAN_RUN_ID || !sessionId) return;
+  const board = openBoard(root, task.HERMES_KANBAN_BOARD || DEFAULT_BOARD);
+  try {
+    tx(board, (db) => {
+      const row = db.prepare('SELECT metadata FROM task_runs WHERE id = ?').get(Number(task.HERMES_KANBAN_RUN_ID));
+      if (!row) return;
+      const meta = json(row.metadata, {}) ?? {};
+      setRunSession(db, Number(task.HERMES_KANBAN_RUN_ID), { ...(meta.supercode ?? {}), session_id: sessionId, harness });
+    });
+  } finally {
+    board.close();
+  }
 }
 
 /** A profile whose worker is Hermes: the dispatcher's own command, run as Hermes would have run it. */

package/mcp/server.mjs

@@ -48,8 +48,12 @@ export function bindingFromEnv(env = process.env) {
 /** The profile's folder: the root is the `default` profile, `profiles/<name>` the rest (a Hermes home's layout). */
 const profileDir = (binding) => (binding.profile === 'default' ? binding.root : join(binding.root, 'profiles', binding.profile));
 
-/** The tools this door publishes: the orchestrator's, and the board's where a dispatch gave it a task. */
-const published = (binding) => (binding.kanban ? [...TOOLS, ...KANBAN_TOOLS] : TOOLS);
+// the tools Hermes's own handlers answer (mcp/verbs.mjs): a worker the board dispatched is supercode's session, and a
+// profile that wants Hermes's session search, memory and skills tools makes Hermes its worker's harness
+const HERMES_ANSWERED = new Set(['session_search', 'memory', 'skills_list', 'skill_view']);
+
+/** The tools this door publishes: the orchestrator's, and for a worker the board dispatched, the board's without Hermes's. */
+const published = (binding) => (binding.kanban ? [...TOOLS.filter((t) => !HERMES_ANSWERED.has(t.name)), ...KANBAN_TOOLS] : TOOLS);
 
 /**
  * A board tool, answered by supercode's own board (board/tools.mjs) on the home's board file: the task, its run and

package/mcp/verbs.mjs

@@ -217,7 +217,8 @@ export async function runVerb(orch, { verb, args = {}, profile: profileName, sur
         const prompt = typeof args.prompt === 'string' && args.prompt.trim();
         const skilled = Array.isArray(args.skills) && args.skills.some((x) => String(x).trim());
         if (!gate.no_agent && !prompt && !skilled) throw new Error('an agent job needs a prompt or skills (a script alone needs no_agent)');
-        const schedule = parseSchedule(args.schedule, now, profile.dir);
+        // a board-dispatched worker's schedules are parsed by supercode alone (its session runs no Hermes code)
+        const schedule = parseSchedule(args.schedule, now, String(surface ?? '').startsWith('kanban|') ? null : profile.dir);
         // Hermes's tool contract (cron/jobs.py `_normalize_workdir`, measured in
         // ORC-8's week): the workdir is trimmed, `~`-expanded, refused when
         // relative (jobs run detached from any shell cwd), symlink-RESOLVED, and

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-orchestrator",
-  "version": "0.4.24",
+  "version": "0.4.25",
   "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": {