@volter/supercode-orchestrator 0.4.23 → 0.4.25

package/board/cli.mjs

@@ -466,7 +466,7 @@ export async function runWorkflow(argv) {
       if (args.reason) for (const [t] of results) withBoard((b) => engine.comment(b, t, callerName(), `UNBLOCK: ${args.reason}`));
       say(args, results.map(([t, s]) => `Unblocked ${t} → ${s}`).join('\n'), { ok: true, results }); return 0;
     }
-    case 'request-review': need(1, 'a card id'); withBoard((b) => engine.requestReview(b, id, { summary: args.summary ?? null, reviewer: args.reviewer ?? null, metadata: metadataOf(args.metadata) ?? null, force: Boolean(args.force) })); say(args, `${id} → review`, { ok: true }); return 0;
+    case 'request-review': need(1, 'a card id'); withBoard((b) => engine.requestReview(b, id, { summary: args.summary ?? null, reviewer: args.reviewer ?? null, metadata: metadataOf(args.metadata) ?? null, force: Boolean(args.force), expectedRunId: workerRun(b.db, id, sid) })); say(args, `${id} → review`, { ok: true }); return 0;
     case 'request-changes': need(2, 'a card id and the reason'); withBoard((b) => engine.requestChanges(b, id, { reason: rest.slice(1).join(' '), reviewer: args.reviewer ?? callerName() })); say(args, `${id} sent back for changes`, { ok: true }); return 0;
     case 'reopen': {
       // a done card back to work; the cards that built on it are invalidated with it (Hermes's reopen)
@@ -909,6 +909,17 @@ function importBoard(root, archive, as) {
 // ------------------------------------------------------------------ a card's own session
 
 /** The card whose latest session is `sessionId` (the caller works it), or null. */
+/**
+ * The run the caller works on card `id`, as Hermes's `_worker_run_id_for` names it: a one-shot worker's
+ * `HERMES_KANBAN_TASK`/`HERMES_KANBAN_RUN_ID`, or the run the board recorded for the caller's session. Null for anyone else.
+ */
+function workerRun(db, id, sessionId) {
+  if (process.env.HERMES_KANBAN_TASK === id && Number.isInteger(Number(process.env.HERMES_KANBAN_RUN_ID)) && process.env.HERMES_KANBAN_RUN_ID) return Number(process.env.HERMES_KANBAN_RUN_ID);
+  if (!sessionId) return null;
+  const hit = db.prepare('SELECT id FROM task_runs WHERE task_id = ? AND metadata LIKE ? ORDER BY id DESC LIMIT 1').get(id, `%"session_id":"${sessionId}"%`);
+  return hit ? Number(hit.id) : null;
+}
+
 function ownCard(db, sessionId) {
   const hit = db.prepare('SELECT task_id FROM task_runs WHERE metadata LIKE ? ORDER BY id DESC LIMIT 1').get(`%"session_id":"${sessionId}"%`);
   if (!hit) return null;

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/board/engine.mjs

@@ -7,7 +7,7 @@
 //
 // Each function takes an open board (`store.mjs`) and runs in one write transaction. Nothing here launches,
 // observes or sends: the dispatcher (`dispatch.mjs`) does, and records what it did through these.
-import { spawnSync } from 'node:child_process';
+import { spawn, spawnSync } from 'node:child_process';
 import { existsSync, rmSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { DatabaseSync } from 'node:sqlite';
@@ -60,6 +60,15 @@ export function parseWorkspace(word = 'scratch') {
 
 // ------------------------------------------------------------------ runs
 
+/**
+ * Hermes's `_terminate_reclaimed_worker`: SIGTERM to the worker's process group, SIGKILL if it is still alive five
+ * seconds later. The wait runs in a detached shell, so the board's write lock is never held through it.
+ */
+function terminate(pid) {
+  try { process.kill(-pid, 'SIGTERM'); } catch { try { process.kill(pid, 'SIGTERM'); } catch { return; } }
+  spawn('/bin/sh', ['-c', 'for i in 1 2 3 4 5 6 7 8 9 10; do kill -0 "$0" 2>/dev/null || exit 0; sleep 0.5; done; kill -KILL -"$0" 2>/dev/null || kill -KILL "$0" 2>/dev/null', String(pid)], { detached: true, stdio: 'ignore' }).unref();
+}
+
 /** Close the card's open run; answers its id, or null when none was open. */
 export function endRun(db, taskId, { outcome, status = null, summary = null, error = null, metadata = undefined }) {
   const row = one(db, 'SELECT current_run_id FROM tasks WHERE id = ?', taskId);
@@ -70,9 +79,8 @@ export function endRun(db, taskId, { outcome, status = null, summary = null, err
   // a run taken back (reclaim, archive, a reopened ancestor) stops its one-shot worker on this machine, as Hermes
   // terminates a reclaimed worker (a board's one-shot workers run where the board is); a pane session is a person-visible session and is never killed from the board
   const worker = outcome === 'reclaimed' ? json(was, {})?.supercode : null;
-  if (worker?.surface === 'headless' && worker.pid) {
-    try { process.kill(-worker.pid, 'SIGTERM'); } catch { try { process.kill(worker.pid, 'SIGTERM'); } catch { /* gone */ } }
-  }
+  const lock = one(db, 'SELECT claim_lock FROM task_runs WHERE id = ?', runId)?.claim_lock ?? one(db, 'SELECT claim_lock FROM tasks WHERE id = ?', taskId)?.claim_lock;
+  if (worker?.surface === 'headless' && worker.pid && String(lock ?? '').startsWith(`${claimer().split(':')[0]}:`)) terminate(Number(worker.pid));
   run(db, `UPDATE task_runs SET status = ?, outcome = ?, summary = ?, error = ?, metadata = ?, ended_at = ?, claim_lock = NULL, claim_expires = NULL, worker_pid = NULL
            WHERE id = ? AND ended_at IS NULL`, status ?? outcome, outcome, summary, error, keep, now(), runId);
   run(db, 'UPDATE tasks SET current_run_id = NULL WHERE id = ?', taskId);
@@ -424,13 +432,15 @@ export function unblock(board, id) {
 }
 
 /** Implementation done, awaiting review (not a block): the review lane, optionally under a reviewer profile. */
-export function requestReview(board, id, { summary = null, metadata = null, reviewer = null, force = false } = {}) {
+export function requestReview(board, id, { summary = null, metadata = null, reviewer = null, force = false, expectedRunId = null } = {}) {
   return tx(board, (db) => {
     const task = must(db, id);
     if (!parentsDone(db, id)) throw new Error(`${id} waits on parents that are not done`);
     if (!['running', 'ready'].includes(task.status)) throw new Error(`${id} is ${task.status}; only a running or ready card goes to review`);
     // a live claim is its worker's to hand off; anyone else says so on purpose (Hermes's guard)
-    if (task.status === 'running' && task.claim_lock && !force) throw new Error(`${id} is running under a live claim; its worker requests review, or pass --force to override on purpose`);
+    // (Hermes's expected_run_id: the worker names the run it holds; a superseded run changes nothing)
+    if (expectedRunId !== null && Number(task.current_run_id) !== Number(expectedRunId)) throw new Error(`run ${expectedRunId} of ${id} is no longer its current run; nothing was changed`);
+    if (task.status === 'running' && task.claim_lock && !force && expectedRunId === null) throw new Error(`${id} is running under a live claim; its worker requests review, or pass --force to override on purpose`);
     // a re-review goes back to the reviewer who asked for the changes
     if (!reviewer) {
       const changed = one(db, "SELECT id FROM task_runs WHERE task_id = ? AND outcome = 'changes_requested' ORDER BY id DESC LIMIT 1", id);

package/board/tools.mjs

@@ -97,7 +97,7 @@ export async function boardTool(root, name, args = {}, env = {}) {
       }
       case 'kanban_request_review': {
         const stale = ownRun(); if (stale) return error(stale);
-        engine.requestReview(board, tid, { summary: args.summary ? redact(String(args.summary)) : null, metadata: args.metadata ? redact(args.metadata) : null, reviewer: args.reviewer ?? null, force: own === tid });
+        engine.requestReview(board, tid, { summary: args.summary ? redact(String(args.summary)) : null, metadata: args.metadata ? redact(args.metadata) : null, reviewer: args.reviewer ?? null, expectedRunId: own === tid && runId ? runId : null });
         return ok({ task_id: tid, status: 'review' });
       }
       case 'kanban_request_changes': {

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.23",
+  "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": {