@volter/supercode-orchestrator 0.4.24 → 0.4.26

package/board/cli.mjs

@@ -20,10 +20,10 @@ Hermes Kanban's verbs, with their flags:
   init · boards list|create|rm|switch|show|rename|set-default-workdir|export|import
   create <title> [--body] [--assignee] [--parent]... [--workspace scratch|worktree[:<path>]|dir:<path>] [--branch] [--project]
          [--tenant] [--priority] [--triage] [--idempotency-key] [--max-runtime 30m] [--created-by] [--skill]... [--max-retries]
-         [--model] [--provider] [--goal] [--goal-max-turns] [--initial-status blocked|running]
+         [--model] [--provider] [--goal|--no-goal] [--goal-max-turns] [--initial-status blocked|running]
   swarm <goal> --worker PROFILE:TITLE[:SKILL,SKILL]... --verifier P --synthesizer P
   list [--mine] [--assignee] [--status] [--tenant] [--session] [--archived] [--sort]   show <id>   context <id>   runs <id>
-  assign <id> <profile|none>   reassign <id> <profile> [--reclaim] [--reason]   set-model <id> [model] [--provider]
+  assign <id> <profile|none>   reassign <id> <profile> [--reclaim] [--reason]   set-model <id> [model] [--provider]   set-goal <id>... [--goal-max-turns N] [--off]
   claim <id> [--ttl]   reclaim <id> [--reason]   heartbeat <id> [--note]   link|unlink <parent> <child>
   comment <id> <text> [--author] [--max-len]   attach <id> <path> [--name] [--content-type]   attachments <id>   attach-rm <n>
   complete <id>... [--result] [--summary] [--metadata JSON]   edit <id> --result [--summary] [--metadata]
@@ -51,7 +51,7 @@ supercode's own:
 
 const MULTI = new Set(['parent', 'skill', 'worker', 'child', 'ids', 'rm']);
 const FLAGS = new Set(['json', 'triage', 'no-notify', 'no-start', 'all', 'force', 'help', 'mine', 'archived', 'reclaim', 'dry-run',
-  'goal', 'switch', 'delete', 'no-attachments', 'include-logs', 'verbose']);
+  'goal', 'no-goal', 'off', 'switch', 'delete', 'no-attachments', 'include-logs', 'verbose']);
 // flags that take every following word up to the next flag (Hermes's nargs='+')
 const GREEDY = new Set(['ids', 'rm']);
 
@@ -235,13 +235,15 @@ export async function runWorkflow(argv) {
       const meta = boardMeta(root, slug);
       let workspace = args.workspace;
       if ((workspace === 'dir' || workspace === 'worktree') && meta.default_workdir) workspace = `${workspace}:${meta.default_workdir}`;
+      // a home whose `kanban.goal_mode_default` is true makes every new card a goal card (a subtask is never started alone)
+      const goalDefault = !args.goal && !args['no-goal'] && !args['subtask-of'] && (await laneState(root)).kanban.goal_mode_default === true;
       const created = withBoard((b) => engine.createCard(b, {
         title: rest.join(' '), body: args.body, assignee: args.assignee === 'none' ? null : args.assignee, machine: args.machine,
         workspace, branch: args.branch, parents: args.parent, priority: args.priority, tenant: args.tenant,
         triage: args.triage, idempotencyKey: args['idempotency-key'], maxRuntime: duration(args['max-runtime']),
         maxRetries, skills: args.skill, model: args.model, provider: args.provider, createdBy: args['created-by'] ?? callerName(),
         sessionId: process.env.CLAUDE_CODE_SESSION_ID ?? null, subtaskOf: args['subtask-of'] ?? null, initialStatus: args['initial-status'] ?? null,
-        project: args.project ?? meta.project_id ?? null, goal: args.goal ? { maxTurns: args['goal-max-turns'] ? Number(args['goal-max-turns']) : null } : null,
+        project: args.project ?? meta.project_id ?? null, goal: args.goal || goalDefault ? { maxTurns: args['goal-max-turns'] ? Number(args['goal-max-turns']) : null } : null,
       }), true);
       let answer = { id: created.id, existing: created.existing };
       if (!args['no-start'] && !created.existing && !args['subtask-of']) {
@@ -377,6 +379,14 @@ export async function runWorkflow(argv) {
       say(args, `Reassigned ${id} to ${rest[1]}`, { ok: true }); return 0;
     }
     case 'set-model': need(1, 'a card id'); withBoard((b) => engine.setModel(b, id, rest[1] ?? null, args.provider ?? null)); say(args, rest[1] ? `${id} runs on model ${rest[1]}${args.provider ? ` (${args.provider})` : ''} from its next start` : `${id} uses its profile's model`, { ok: true }); return 0;
+    case 'set-goal': {
+      // a card into goal mode (or out of it with --off) from its next idle turn: the heartbeat keeps its session going
+      need(1, 'a card id');
+      const maxTurns = args['goal-max-turns'] ? Number(args['goal-max-turns']) : null;
+      if (maxTurns !== null && !(Number.isInteger(maxTurns) && maxTurns >= 1)) throw new Error('--goal-max-turns is a whole number of turns, at least 1');
+      for (const t of ids()) withBoard((b) => engine.setGoal(b, t, { on: !args.off, maxTurns }));
+      say(args, ids().map((t) => args.off ? `${t} is no longer a goal card` : `${t} is a goal card${maxTurns ? ` (${maxTurns} turns)` : ''}`).join('\n'), { ok: true }); return 0;
+    }
     case 'move': need(2, 'a card id and a machine (or none)'); withBoard((b) => engine.setMachine(b, id, rest[1] === 'none' ? null : rest[1])); say(args, `${id} runs on ${rest[1]}`, { ok: true }); return 0;
 
     case 'claim': {
@@ -942,7 +952,7 @@ function authorize(db, verb, rest, args, own) {
   }
   if (verb === 'boards') { if (!['list', 'ls', 'show', 'current', undefined].includes(rest[0])) refuse('does not change the home\'s boards'); return; }
   // verbs that act on the board rather than on a card are the manager's and the board's, never a card's session's
-  if (['pause', 'resume', 'swarm', 'dispatch', 'daemon', 'serve', 'gc', 'repair', 'adopt', 'close', 'move', 'reassign', 'assign', 'set-model', 'claim', 'reclaim', 'archive', 'promote', 'schedule', 'link', 'unlink', 'edit', 'reopen-review', 'reopen', 'attach-rm'].includes(verb)) refuse(`does not ${verb}; the fleet's manager does`);
+  if (['pause', 'resume', 'swarm', 'dispatch', 'daemon', 'serve', 'gc', 'repair', 'adopt', 'close', 'move', 'reassign', 'assign', 'set-model', 'set-goal', 'claim', 'reclaim', 'archive', 'promote', 'schedule', 'link', 'unlink', 'edit', 'reopen-review', 'reopen', 'attach-rm'].includes(verb)) refuse(`does not ${verb}; the fleet's manager does`);
   if (args.all) refuse(`does not ${verb} every card; only its own`);
   const card = engine.getTask(db, rest[0]);
   if (!card) return; // the verb itself answers "no card"

package/board/dispatch.mjs

@@ -474,8 +474,9 @@ function launchPane(board, task, runId, lane, fleet, { input = null } = {}) {
   let replaced = null;
   if (prev && prev.machine === machine) {
     if (sessionAlive(fleet, prev)) {
-      session = { ...prev, mode: 'adopt', launched_at: now(), seen_at: now() };
-      delete session.missing_since;
+      // the session is kept; the heartbeat's count belongs to the run that ended, so the new run starts it again
+      const { missing_since: _m, goal_turns: _t, goal_nudged_at: _n, idle_since: _i, worked_since_ask: _w, ...kept } = prev;
+      session = { ...kept, mode: 'adopt', launched_at: now(), seen_at: now() };
     } else if (prev.resumable !== false) {
       const r = sc([...base, '--key', `board-${task.id}-r${runId}-resume`, '--input',
         `The board resumed this session after it was lost; you are still on card ${task.id}: ${task.title}. Carry on.`, '--', '--resume', prev.session_id, ...tail], { timeout: 180_000 });
@@ -911,13 +912,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 +930,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

@@ -768,6 +768,15 @@ export function setModel(board, id, model = null, provider = null) {
   });
 }
 
+/** Goal mode on a card (Hermes's goal loop, which Hermes sets only at creation): on or off, with its turn budget. */
+export function setGoal(board, id, { on = true, maxTurns = null } = {}) {
+  return tx(board, (db) => {
+    must(db, id);
+    run(db, 'UPDATE tasks SET goal_mode = ?, goal_max_turns = ? WHERE id = ?', on ? 1 : 0, on ? maxTurns : null, id);
+    event(db, id, 'goal_set', { goal_mode: Boolean(on), goal_max_turns: on ? maxTurns : null });
+  });
+}
+
 export function addAttachment(board, id, { file, name, contentType = null, author = 'user', dir }) {
   return tx(board, (db) => {
     must(db, id);

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