@volter/supercode-orchestrator 0.4.124 → 0.4.126

package/board/cli.mjs

@@ -13,8 +13,9 @@ import { view, backingPaths, layOut, backingOf, boardExists, boardPath, DEFAULT_
 import { isLocalWorkspace } from './workspace.mjs';
 import { openZtrackBoard } from './ztrack.mjs';
 import * as engine from './engine.mjs';
-import { adoptSession, boardAddress, boardLabel, boardSettings, callerSession, reconcileCallerLaunch, closeRequested, lanesOf, localMachine, observeFleet, paused, plan, startCard, tick } from './dispatch.mjs';
-import { loadWorkflow, requestSessionClose, scopeOf, statusOf, useWorkflow, workflowEntry, workflowFor } from './workflow.mjs';
+import { adoptSession, boardAddress, boardLabel, boardSettings, callerSession, commandEnv, reconcileCallerLaunch, closeRequested, lanesOf, localMachine, observeFleet, paused, plan, startCard, supercodeBin, tick } from './dispatch.mjs';
+import { watchBoard } from './wake.mjs';
+import { creatorOf, loadWorkflow, requestSessionClose, scopeOf, statusOf, useWorkflow, workflowEntry, workflowFor } from './workflow.mjs';
 import { evaluate } from './expr.mjs';
 
 const HELP = `supercode workflow <verb> [--root <home>] [--board <slug>] [--json]
@@ -34,6 +35,7 @@ Hermes Kanban's verbs, with their flags:
   complete <id>... [--result] [--summary] [--metadata JSON]   edit <id> --result [--summary] [--metadata]
   block <id> [reason] (--on <card> | --waiting-on <message id>) [--ids ...]   schedule <id> [reason] [--ids ...]
   pause <id> --reason <why>   resume <id>   cancel <id>   set-every <id> <interval|none>
+  request-state <id> --state block|pause|done|cancelled --reason <why> [--on <card>|--waiting-on <message>] [--evidence <pointers>]
   unblock <id>... [--reason]   request-review <id> [--summary] [--reviewer] [--force]   request-changes <id> <reason>   reopen-review <id>...   reopen <id>... [--reason]
   promote <id> [reason] [--ids ...] [--force] [--dry-run]   archive <id>... [--rm <id>...]
   specify <id> [--title --body] [--all]   decompose <id> [--child "<title>[@<profile>]"]... [--all]
@@ -55,8 +57,8 @@ supercode's own:
   goto <id> <status> [reason] [--<field> value]: the event the workflow says takes the card to that status, sent.
 
   specify/decompose with no spec start a session on the triage card to write it. A card's own session may comment on,
-  block (with --kind), heartbeat and request review of its card, specify or decompose it in triage, and file, complete,
-  block and comment on its subtasks; its arc is marked done by its reviewers, never by itself.
+  heartbeat and request review of its card, specify or decompose it in triage, and work its subtasks. The home's
+  workflow declares who may block, pause or finish a card; request-state mails its manager without changing state.
 `;
 
 const MULTI = new Set(['parent', 'skill', 'worker', 'child', 'ids', 'rm']);
@@ -238,6 +240,7 @@ export async function runWorkflow(argv) {
 
   // a caller that is a card's own session (its harness names it; the board recorded which session it launched)
   const listing = ['list','ls'].includes(verb);
+  await loadWorkflow(root).catch((error) => { if (verb !== 'init' && verb !== 'boards') throw error; });
   const sid = listing && !args.mine ? null : callerSession();
   // what this command records is the calling session's act (its address, as its subscriptions name it)
   if (sid) setActor(`sc:${localMachine()}:${sid === process.env.CODEX_THREAD_ID ? 'codex' : 'claude-code'}:${sid}`);
@@ -246,7 +249,6 @@ export async function runWorkflow(argv) {
   }
   // the board's workflow (the IR's): what each verb does, and who may send it, is its
   // every verb reads the board through its workflow (a list settles cards too), so every verb loads it
-  if (verb !== 'help' && !listing) await loadWorkflow(root).catch((error) => { if (verb !== 'init' && verb !== 'boards') throw error; });
   engine.setCaller((db, cardId) => rolesFor(db, cardId, sid, workflowFor(root).params));
   // a verb with no session behind it (a person at the CLI, the board file's sync) is the manager's, as its roles are
   if (!sid && verb !== 'help') { try { setActor([].concat(workflowFor(root).params?.managers ?? [])[0] ?? null); } catch { /* no workflow */ } }
@@ -840,10 +842,10 @@ export async function runWorkflow(argv) {
       if (!declared) throw new Error(`no workflow verb ${verb}; \`supercode workflow help\` lists them`);
       need(1, 'a card id');
       const { _: _words, root: _r, board: _b, json: _j, at: _a, ids: _i, ...fields } = args;
-      const payload = { ...fields, reason: args.reason ?? (rest.slice(1).join(' ') || null) };
+      const payload = { ...fields, waiting_on: args['waiting-on'] ?? fields.waiting_on, reason: args.reason ?? (rest.slice(1).join(' ') || null) };
       const results = [];
       for (const t of [id, ...(args.ids ?? [])]) results.push([t, (await withBoardAsync((b) => engine.act(b, t, name, { payload }))).to]);
-      say(args, results.map(([t, s]) => `${t} → ${s}`).join('\n'), { ok: true, results }); return 0;
+      say(args, results.map(([t, s]) => name === 'request_state' ? `${t}: ${payload.state} requested; state remains ${s}. Mail delivery is recorded on the card.` : `${t} → ${s}`).join('\n'), { ok: true, results }); return 0;
     }
   }
 }
@@ -1060,16 +1062,10 @@ function ownCard(db, sessionId) {
 
 const READS = new Set(['list', 'ls', 'show', 'context', 'runs', 'log', 'tail', 'watch', 'stats', 'assignees', 'diagnostics', 'diag', 'attachments', 'notify-list', 'help', 'init']);
 
-/**
- * What a card's own session may write (the owner's rule): on its card, comment, block with a typed reason, heartbeat,
- * request review, attach a file, specify or decompose it in triage; on its subtasks, file, complete, block, unblock,
- * comment and attach. Never its arc's completion, and never another arc's card: anything across arcs goes through the
- * fleet's manager.
- */
 /**
  * Who a caller is on card `cardId`, in the workflow's roles: a person or the fleet's manager at the CLI (no session)
  * is `manager`; the session of the card's current run has that run's role; the card's working session between runs
- * is its `implementer`; the session working a subtask's arc is `arc`; any other session is nobody on it.
+ * is its `implementer`; the session working a subtask's arc is `arc`; its recorded creator also has the creator role; any other session is nobody on it.
  */
 function rolesFor(db, cardId, sessionId, params = {}) {
   if (!sessionId) return ['manager', 'owner'];
@@ -1079,6 +1075,7 @@ function rolesFor(db, cardId, sessionId, params = {}) {
   const task = engine.getTask(db, cardId);
   if (!task) return [];
   const roles = [];
+  if (creatorOf(db, cardId)?.endsWith(`:${sessionId}`)) roles.push('creator');
   const current = task.current_run_id ? json(db.prepare('SELECT metadata FROM task_runs WHERE id = ?').get(task.current_run_id)?.metadata, {})?.supercode : null;
   if (current?.session_id === sessionId) roles.push(current.role ?? 'implementer');
   else if (engine.lastSession(db, cardId)?.session_id === sessionId) roles.push('implementer');
@@ -1099,6 +1096,7 @@ function authorize(db, verb, rest, args, own) {
   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"
+  if (creatorOf(db, card.id)?.endsWith(`:${callerSession()}`)) return; // its declared creator doors still govern the act
   // a card's session writes its own card and its subtasks; what it may do with them is the workflow's (`by`)
   if (card.id !== own.id && card.subtask_of !== own.id) refuse(`writes only its own card and its subtasks, not ${card.id}`);
   for (const other of args.ids ?? []) if (other !== own.id && engine.getTask(db, other)?.subtask_of !== own.id) refuse(`writes only its own card and its subtasks, not ${other}`);
@@ -1139,7 +1137,8 @@ async function serve(root, args = {}) {
   const params = { ...(Number(args.max) > 0 ? { max_spawn: Number(args.max) } : {}), ...(Number(args['failure-limit']) > 0 ? { failure_limit: Number(args['failure-limit']) } : {}) };
   if (args.pidfile) writeFileSync(args.pidfile, `${process.pid}\n`);
   let stopped = false;
-  const stop = () => { stopped = true; };
+  let events;
+  const stop = () => { stopped = true; events?.close(); };
   process.on('SIGTERM', stop);
   process.on('SIGINT', stop);
   // what the serve says is kept in the home too (logs/workflow-serve.log), so why it stopped outlives its pane
@@ -1154,9 +1153,12 @@ async function serve(root, args = {}) {
   const installed = () => { try { return JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version ?? null; } catch { return null; } };
   const running = installed();
   log(`dispatching the boards of ${root} from ${localMachine()} (orchestrator ${running ?? 'unknown'})`);
+  events = watchBoard({ root, binary: supercodeBin(), env: commandEnv(), log });
+  log('dispatch wakes on board writes, document edits, board mail and session catalogue events; interval is a safety sweep');
   const stuck = {};
   const warned = {};
   let pausedSaid = false;
+  let wakeReason = null;
   try {
     while (!stopped) {
       // An installer owns this operational window, not a card pause. Finish the
@@ -1177,6 +1179,8 @@ async function serve(root, args = {}) {
       pausedSaid = Boolean(paused(root)) && pausedSaid;
       let interval = 60;
       const began = Date.now();
+      if (wakeReason) log(`dispatch wake ${wakeReason.sources.join(', ')}; event age ${began - wakeReason.at}ms`);
+      wakeReason = null;
       try {
         const state = await laneState(root);
         const settings = { ...state.settings, ...override };
@@ -1186,9 +1190,9 @@ async function serve(root, args = {}) {
           if (!said.endsWith('nothing to do') || args.verbose) log(said);
           if (args.verbose && r.ms) log(`  took ${Object.entries(r.ms).map(([k, v]) => `${k} ${(v / 1000).toFixed(1)}s`).join(', ')}`);
           if (r.paused && !pausedSaid) { log(`new starts paused by ${r.paused} (\`supercode workflow resume\` lifts it)`); pausedSaid = true; }
-          // Hermes's stuck warning: ready work for six ticks running and nothing started
-          stuck[r.board] = r.ready_waiting && !r.started.length && !r.paused ? (stuck[r.board] ?? 0) + 1 : 0;
-          if (stuck[r.board] >= 6 && Date.now() - (warned[r.board] ?? 0) >= 300_000) { log(`board ${r.board} stuck: ${r.ready_waiting} ready card(s) and nothing started for ${stuck[r.board]} ticks; \`supercode workflow diagnostics\``); warned[r.board] = Date.now(); }
+          // Event bursts do not shorten the six-sweep stuck warning.
+          stuck[r.board] = r.ready_waiting && !r.started.length && !r.paused ? (stuck[r.board] || Date.now()) : 0;
+          if (stuck[r.board] && Date.now() - stuck[r.board] >= interval * 6000 && Date.now() - (warned[r.board] ?? 0) >= 300_000) { log(`board ${r.board} stuck: ${r.ready_waiting} ready card(s) and nothing started for ${Math.floor((Date.now() - stuck[r.board]) / 1000)}s; \`supercode workflow diagnostics\``); warned[r.board] = Date.now(); }
           for (const [t, why] of r.failed) log(`  ${t} did not start: ${why}`);
           for (const [t, why] of r.unsettled ?? []) log(`  ${t} could not be read: ${why}`);
           for (const [t, s, m] of r.started) log(`  ${t} started ${s} (${m})`);
@@ -1201,14 +1205,19 @@ async function serve(root, args = {}) {
       const newer = () => { const now = installed(); return running && now && now !== running ? now : null; };
       let moved = newer();
       // the next tick is due an interval after this one began (a long tick is not followed by a full interval's wait)
-      const rest = Math.max(1, interval - Math.floor((Date.now() - began) / 1000));
-      for (let waited = 0; waited < rest && !stopped && !moved; waited += 1) {
-        await new Promise((done) => setTimeout(done, 1000));
-        if (waited % 5 === 4) moved = newer();
+      events.refresh();
+      if (!stopped && !moved) {
+        wakeReason = await events.wait(Math.max(0, interval * 1000 - (Date.now() - began)));
+        // A busy event stream is coalesced to at most one tick per second.
+        const remaining = 1000 - (Date.now() - began);
+        if (remaining > 0 && !stopped) await new Promise(done => setTimeout(done, remaining));
+        moved = newer();
       }
       if (moved) { log(`orchestrator ${moved} is installed (this serve runs ${running}); stopping, for its keeper to start the new one`); break; }
     }
   } finally {
+    events?.close();
+    process.off('SIGTERM', stop); process.off('SIGINT', stop);
     if (args.pidfile) { try { unlinkSync(args.pidfile); } catch { /* gone */ } }
   }
   log(stopped ? 'stopped (a signal)' : 'stopped');

package/board/dispatch.mjs

@@ -1245,16 +1245,23 @@ async function send(from, label, to, body, key, { queue = false, ask = false } =
  * and marked board_message_sent. A question goes under the id its card waits on; a resend of a sent one is a no-op
  * (the id is the send's idempotency key). One that fails is tried again next tick.
  */
-async function sendBoardMessages(board, report) {
+export async function sendBoardMessages(board, report, taskId = null) {
   const rows = view(board, (db) => db.prepare(`SELECT id, task_id, payload FROM task_events e WHERE kind = 'board_message' AND NOT EXISTS
     (SELECT 1 FROM task_events s WHERE s.kind = 'board_message_sent' AND s.task_id = e.task_id AND json_extract(s.payload, '$.event') = e.id) ORDER BY id`).all());
   for (const row of rows) {
+    if (taskId && row.task_id !== taskId) continue;
     const m = json(row.payload, {}) ?? {};
     try {
       await send(boardAddress(board.label), board.label, m.to, m.text, m.message_id ?? `board-message-${row.id}`, { ask: Boolean(m.message_id) });
       tx(board, (db) => event(db, row.task_id, 'board_message_sent', { event: row.id, to: m.to, ...(m.message_id ? { message_id: m.message_id } : {}) }));
     } catch (error) {
-      report.undelivered.push([row.task_id, m.to, String(error.message).slice(-200)]);
+      const reason = String(error.message).slice(-200);
+      report.undelivered.push([row.task_id, m.to, reason]);
+      tx(board, db => {
+        const previous = db.prepare("SELECT payload,created_at FROM task_events WHERE task_id=? AND kind='board_message_failed' AND json_extract(payload,'$.event')=? ORDER BY id DESC LIMIT 1").get(row.task_id, row.id);
+        if (json(previous?.payload, {})?.reason !== reason || now() - (previous?.created_at ?? 0) >= 60)
+          event(db, row.task_id, 'board_message_failed', { event: row.id, to: m.to, message_id: m.message_id, reason });
+      });
     }
   }
 }

package/board/engine.mjs

@@ -12,7 +12,7 @@ import { existsSync, rmSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { checkWorkspace, assertWorkspaceOwner, declareWorkspace, isLocalWorkspace, isWorkspacePath } from './workspace.mjs';
 import { DatabaseSync } from 'node:sqlite';
-import { view, claimer, event, json, newTaskId, now, tx } from './store.mjs';
+import { view, actorOf, claimer, event, json, newTaskId, now, tx } from './store.mjs';
 import { addDependency, retireSupersededRuns, refreshCardInputs, requestSessionClose, eventTo, fire, loadWorkflow, setStatus, settle, startNew, statusOf, runEvent, workflowFor } from './workflow.mjs';
 
 export const STATUSES = ['triage', 'todo', 'scheduled', 'ready', 'running', 'blocked', 'review', 'done', 'archived'];
@@ -184,6 +184,10 @@ export function createCard(board, spec) {
     if (arc?.subtask_of) throw new Error(`${arc.id} is itself a subtask of ${arc.subtask_of}; a subtask belongs to an arc`);
     let id = newTaskId();
     while (one(db, 'SELECT 1 FROM tasks WHERE id = ?', id)) id = newTaskId();
+    const creationRoles = workflowFor(board.root).params.create_dependencies_by;
+    if ((parents.length || initial === 'blocked') && creationRoles && !callerRoles(db, arc?.id ?? id).some(role => creationRoles.includes(role))) {
+      throw new Error('Creating a dependency or initially blocked card requires a permitted manager role; file the task without a blocker and use request-state.');
+    }
     assertWorkspaceOwner(db, workspaceTask, checked);
     // The repository declaration stays separate from the resolved worktree path.
     if (project) {
@@ -211,7 +215,7 @@ export function createCard(board, spec) {
     // the create's own words: whether it asked to be a goal card (null: the workflow decides), triage, its arc
     const status = startNew(db, board, entry, getTask(db, id), { triage: Boolean(spec.triage), initial_status: initial,
       every: spec.every ?? null, goal: spec.goal === undefined || spec.goal === null ? null : spec.goal !== false, subtask_of: arc?.id ?? null });
-    event(db, id, 'created', { assignee: spec.assignee || null, status, parents, tenant: spec.tenant ?? null, ...(machine ? { machine } : {}), ...(arc ? { subtask_of: arc.id } : {}) });
+    event(db, id, 'created', { creator: actorOf(), assignee: spec.assignee || null, status, parents, tenant: spec.tenant ?? null, ...(machine ? { machine } : {}), ...(arc ? { subtask_of: arc.id } : {}) });
     if (parents.length) inheritSubscriptions(db, id, parents);
     if (arc) {
       // the arc's subscribers hear its subtasks, and the arc's session works them
@@ -382,6 +386,10 @@ export async function runEffects(board, effects = [], { retryNotices = false } =
       if (!await sessionNotice(board, e)) continue;
     }
     else if (e.kind === 'cleanup_workspace') cleanupWorkspace(board, e.id);
+    else if (e.kind === 'board_message') {
+      const { sendBoardMessages } = await import('./dispatch.mjs');
+      await sendBoardMessages(board, { undelivered: [] }, e.id);
+    }
     else if (e.kind === 'invalidate_descendants') tx(board, (db) => invalidateDescendants(db, board, e.id));
     else if (e.kind === 'stop_run') stopWorker(board, e.runId);
     else if (e.kind === 'close_session' || e.kind === 'send_to_actor' || e.kind === 'run_ended') {
@@ -685,7 +693,7 @@ export function runs(db, id, { stateType = null, stateName = null } = {}) {
 
 /** Delete the thread events of done and archived cards older than `seconds` (Hermes's `gc` of events). */
 export function gcEvents(board, seconds) {
-  return tx(board, (db) => Number(run(db, "DELETE FROM task_events WHERE created_at < ? AND task_id IN (SELECT id FROM tasks WHERE status IN ('done', 'archived'))", now() - seconds).changes));
+  return tx(board, (db) => Number(run(db, "DELETE FROM task_events WHERE kind != 'created' AND created_at < ? AND task_id IN (SELECT id FROM tasks WHERE status IN ('done', 'archived'))", now() - seconds).changes));
 }
 
 // ------------------------------------------------------------------ diagnostics

package/board/store.mjs

@@ -16,6 +16,7 @@ import { dirname, join } from 'node:path';
 import { DatabaseSync } from 'node:sqlite';
 import { openZtrackBoard } from './ztrack.mjs';
 import { isFilesBoard, openFilesBoard } from './files.mjs';
+import { signalBoardWrite } from './wake.mjs';
 
 export const DEFAULT_BOARD = 'default';
 
@@ -163,7 +164,11 @@ export function openBoard(root, slug = DEFAULT_BOARD, { create = false, backing
  * Run `fn(db)` in one write transaction of the board's backing: answers what `fn` answers; rolls back on a throw.
  * A read inside the transaction is the state it writes over.
  */
-export const tx = (board, fn) => board.tx(fn);
+export const tx = (board, fn) => {
+  const result = board.tx(fn);
+  signalBoardWrite(board.root, actor);
+  return result;
+};
 export const view = (board, fn) => fn(board.db);
 
 // A deferred native transaction, with the whole operation retried on an optimistic conflict.

package/board/tools.mjs

@@ -5,9 +5,9 @@
 // unblocking tools are the orchestrator's, not a worker's. Answers are JSON text: `{ ok: true, … }` or `{ error }`.
 import { mkdirSync, statSync, writeFileSync } from 'node:fs';
 import { basename, join } from 'node:path';
-import { DEFAULT_BOARD, event, json, openBoard, tx } from './store.mjs';
+import { DEFAULT_BOARD, actorOf, event, json, openBoard, setActor, tx } from './store.mjs';
 import * as engine from './engine.mjs';
-import { loadWorkflow } from './workflow.mjs';
+import { creatorOf, loadWorkflow } from './workflow.mjs';
 
 const ok = (fields = {}) => JSON.stringify({ ok: true, ...fields });
 const error = (message) => JSON.stringify({ error: message });
@@ -25,7 +25,7 @@ export function redact(value) {
   return value;
 }
 
-const LIFECYCLE = new Set(['kanban_complete', 'kanban_block', 'kanban_request_review', 'kanban_request_changes', 'kanban_heartbeat', 'kanban_attach', 'kanban_attach_url', 'kanban_unblock']);
+const LIFECYCLE = new Set(['kanban_complete', 'kanban_block', 'kanban_request_state', 'kanban_request_review', 'kanban_request_changes', 'kanban_heartbeat', 'kanban_attach', 'kanban_attach_url', 'kanban_unblock']);
 const ORCHESTRATOR_ONLY = new Set(['kanban_list', 'kanban_unblock']);
 
 /** One board tool call. `root` is the home; `env` the worker's task environment (`HERMES_KANBAN_*`). */
@@ -33,30 +33,39 @@ export async function boardTool(root, name, args = {}, env = {}) {
   const own = env.HERMES_KANBAN_TASK || null;
   const runId = env.HERMES_KANBAN_RUN_ID ? Number(env.HERMES_KANBAN_RUN_ID) : null;
   const author = env.HERMES_PROFILE || 'worker';
-  if (own && ORCHESTRATOR_ONLY.has(name)) return error(`${name} is the orchestrator's; a dispatched worker uses kanban_complete, kanban_block, kanban_heartbeat or kanban_comment for its own task`);
+  if (own && ORCHESTRATOR_ONLY.has(name)) return error(`${name} is the orchestrator's; read kanban_show for your task's declared doors, or use kanban_request_state, kanban_heartbeat or kanban_comment`);
   const tid = args.task_id || own;
   if (!['kanban_list', 'kanban_create', 'kanban_link'].includes(name) && !tid) return error('task_id is required (or HERMES_KANBAN_TASK in the environment)');
-  if (own && LIFECYCLE.has(name) && tid !== own) return error(`worker is scoped to task ${own}; refusing to change ${tid}. Use kanban_comment to hand off to other tasks, or kanban_create for follow-up work.`);
   const slug = args.board || env.HERMES_KANBAN_BOARD || DEFAULT_BOARD;
   // the board's workflow decides what each tool's event does; the worker is its run's role on its own task, and
   // nobody on another (Hermes's worker scoping)
   try { await loadWorkflow(root); } catch (e) { return error(e.message); }
   engine.setCaller((db, cardId) => {
-    if (!own || cardId !== own || !runId) return own ? [] : ['manager'];
+    if (!own || !runId) return own ? [] : ['manager'];
     const meta = json(db.prepare('SELECT metadata FROM task_runs WHERE id = ?').get(runId)?.metadata, {})?.supercode ?? {};
-    return [meta.role ?? 'implementer'];
+    const roles = cardId === own ? [meta.role ?? 'implementer'] : [];
+    if (actorOf() && creatorOf(db, cardId) === actorOf()) roles.push('creator');
+    return roles;
   });
   let board;
   try { board = openBoard(root, slug); } catch (e) { return error(e.message); }
   board.label = slug;
+  const callingRun = runId ? json(board.db.prepare('SELECT metadata FROM task_runs WHERE id=?').get(runId)?.metadata, {})?.supercode : null;
+  setActor(own && runId ? callingRun?.address ?? `hermes-run:${slug}:${runId}` : null);
+  if (own && LIFECYCLE.has(name) && tid !== own && creatorOf(board.db, tid) !== actorOf()) {
+    board.close(); return error(`worker is scoped to task ${own}; refusing to change ${tid}. Use kanban_comment to hand off to other tasks.`);
+  }
   const current = () => tx(board, (db) => engine.getTask(db, tid));
   // a worker whose run was superseded (reclaimed, re-dispatched) no longer speaks for the card
   const ownRun = () => {
-    if (!own || tid !== own || !runId) return null;
-    const t = current();
-    return t && Number(t.current_run_id) !== runId ? `run ${runId} of ${tid} is no longer its current run; nothing was changed` : null;
+    if (!own) return null;
+    const t = engine.getTask(board.db, own);
+    const r = runId && board.db.prepare('SELECT task_id, ended_at FROM task_runs WHERE id=?').get(runId);
+    return !r || r.task_id !== own || r.ended_at != null || Number(t?.current_run_id) !== runId
+      ? `run ${runId ?? '(missing)'} of ${own} is no longer its current run; nothing was changed` : null;
   };
   try {
+    if (name !== 'kanban_show' && name !== 'kanban_list') { const stale = ownRun(); if (stale) return error(stale); }
     switch (name) {
       case 'kanban_show': {
         const card = tx(board, (db) => { const c = engine.showCard(db, tid); c.context = engine.cardContext(db, tid); return c; });
@@ -104,6 +113,11 @@ export async function boardTool(root, name, args = {}, env = {}) {
         const { to: status } = await engine.block(board, tid, { reason: args.reason ? redact(String(args.reason)) : null, on: args.on ?? null, waitingOn: args.waiting_on ?? null });
         return ok({ task_id: tid, status });
       }
+      case 'kanban_request_state': {
+        const stale = ownRun(); if (stale) return error(stale);
+        await engine.act(board, tid, 'request_state', { payload: { state: args.state, reason: args.reason, on: args.on ?? null, waiting_on: args.waiting_on ?? null, evidence: args.evidence ?? null } });
+        return ok({ task_id: tid, requested: args.state, changed: false });
+      }
       case 'kanban_request_review': {
         const stale = ownRun(); if (stale) return error(stale);
         await 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 });

package/board/wake.mjs

@@ -0,0 +1,134 @@
+// Wake hints never own board state. A missed hint is repaired by the safety
+// sweep; a writer never waits for a dispatcher or for another writer.
+import { watch, existsSync, readFileSync, readdirSync, writeFileSync, renameSync, unlinkSync, realpathSync } from 'node:fs';
+import { basename, dirname, join, resolve } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { spawn } from 'node:child_process';
+import { tmpdir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+
+export function signalBoardWrite(root, actor) {
+  if (!root || actor?.includes(':board:')) return;
+  const path = join(root, '.dispatch-wake.json');
+  const temporary = `${path}.${randomUUID()}.tmp`;
+  try {
+    writeFileSync(temporary, JSON.stringify({ at: Date.now(), actor }) + '\n', { mode: 0o600 });
+    renameSync(temporary, path);
+  } catch { try { unlinkSync(temporary); } catch { /* hints cannot fail a committed verb */ } }
+}
+
+/** One coalescing queue shared by standalone serve and the hosted dispatcher. */
+export function watchBoard({ root, binary, env, log = () => {} }) {
+  const watchers = new Map();
+  let pending = null, waiter = null, closed = false, child = null, retry = null, lastError = null;
+  const wake = (source, at = Date.now()) => {
+    if (closed) return;
+    if (!pending) pending = { at, sources: new Set() };
+    pending.at = Math.min(pending.at, at);
+    pending.sources.add(source);
+    waiter?.();
+  };
+  const directory = (path, key, accept) => {
+    const id = `${path}\0${key}`;
+    if (watchers.has(id) || !existsSync(path)) return;
+    try {
+      const handle = watch(path, (_event, filename) => {
+        if (filename == null || accept(String(filename))) wake(key);
+      });
+      handle.on('error', error => {
+        handle.close(); watchers.delete(id);
+        log(`dispatch watch ${key} failed: ${error.message}; safety sweep remains active`);
+      });
+      watchers.set(id, handle);
+    } catch (error) { log(`dispatch watch ${key} unavailable: ${error.message}; safety sweep remains active`); }
+  };
+  const file = (path, key) => {
+    directory(dirname(path), key, name => name === basename(path));
+    try {
+      const target = realpathSync(path);
+      if (target !== path) directory(dirname(target), key, name => name === basename(target));
+    } catch { /* the parent watcher sees a newly created file */ }
+  };
+  const refresh = () => {
+    directory(root, 'board-write', name => {
+      if (name !== '.dispatch-wake.json') return false;
+      try { const receipt = JSON.parse(readFileSync(join(root, name), 'utf8')); wake('board-write', receipt.at); } catch { wake('board-write'); }
+      return false;
+    });
+    for (const name of ['workflow.yaml', 'config.yaml', 'installation-window.json', 'ESTOP']) file(join(root, name), name);
+    file(fileURLToPath(new URL('../package.json', import.meta.url)), 'installation');
+    const boards = join(root, 'kanban', 'boards');
+    directory(join(root, 'kanban'), 'board-registry', name => ['boards', 'ztrack.json', 'current'].includes(name));
+    directory(boards, 'board-registry', () => true);
+    const dirs = [join(root, 'kanban'), ...(existsSync(boards) ? readdirSync(boards).map(name => join(boards, name)) : [])];
+    for (const dir of dirs) {
+      file(join(dir, 'ztrack.json'), 'board-config');
+      try {
+        const config = JSON.parse(readFileSync(join(dir, 'ztrack.json'), 'utf8'));
+        const document = resolve(dir, config.document);
+        file(document, `document:${document}`);
+        file(`${document}.archive.md`, `document:${document}.archive.md`);
+      } catch { /* other backing or not yet created */ }
+    }
+    const config = env.SUPERCODE_HOME || (env.XDG_CONFIG_HOME ? join(env.XDG_CONFIG_HOME, 'supercode') : join(env.HOME ?? '', '.config', 'supercode'));
+    const mail = join(config, 'mail');
+    directory(mail, 'mailbox-registry', name => name.startsWith('board-'));
+    if (existsSync(mail)) for (const name of readdirSync(mail)) {
+      if (name.startsWith('board-')) directory(join(mail, name, 'new'), 'board-mail', name => name.endsWith('.json'));
+    }
+  };
+  // The retained Teams catalogue includes local and remote session changes.
+  // This is a read-only stream, with no model or new native harness session.
+  const follow = () => {
+    if (closed) return;
+    let buffer = '', error = '';
+    const command = env.SUPERCODE_TEAMS_ENTRY ? process.execPath : binary;
+    const args = [...(env.SUPERCODE_TEAMS_ENTRY ? [env.SUPERCODE_TEAMS_ENTRY] : []), 'sessions', 'list', '--watch', '--json'];
+    child = spawn(command, args, { cwd: tmpdir(), env, stdio: ['ignore', 'pipe', 'pipe'] });
+    child.stdout.setEncoding('utf8').on('data', chunk => {
+      buffer += chunk;
+      if (buffer.length > 8 * 1024 * 1024) { error = 'catalogue frame exceeds 8 MiB'; child.kill(); return; }
+      let end;
+      while ((end = buffer.indexOf('\n')) >= 0) {
+        const line = buffer.slice(0, end); buffer = buffer.slice(end + 1);
+        try {
+          const event = JSON.parse(line);
+          lastError = null;
+          if (!['heartbeat', 'ping', 'keepalive'].includes(event.type)) wake('session-catalogue');
+        } catch { /* CLI diagnostics are not events */ }
+      }
+    });
+    child.stderr.setEncoding('utf8').on('data', chunk => { error = (error + chunk).slice(-500); });
+    child.on('error', failure => { error = failure.message; });
+    child.on('close', () => {
+      child = null;
+      if (!closed) {
+        const reason = error.trim() || 'connection closed';
+        if (reason !== lastError) log(`dispatch session stream ended: ${reason}; reconnecting, safety sweep remains active`);
+        lastError = reason;
+        retry = setTimeout(follow, 5000);
+      }
+    });
+  };
+  refresh(); follow();
+  return {
+    refresh,
+    wake,
+    async wait(milliseconds) {
+      if (!pending && !closed) await new Promise(done => {
+        const timer = setTimeout(finish, Math.max(0, milliseconds));
+        function finish() { clearTimeout(timer); waiter = null; done(); }
+        waiter = finish;
+      });
+      // Bound coalescing: a sustained event stream cannot postpone dispatch.
+      if (pending && !closed) await new Promise(done => setTimeout(done, 100));
+      const result = pending; pending = null;
+      return result ? { at: result.at, sources: [...result.sources] } : null;
+    },
+    close() {
+      closed = true; waiter?.(); clearTimeout(retry);
+      for (const handle of watchers.values()) handle.close();
+      watchers.clear(); child?.kill('SIGTERM');
+    },
+  };
+}

package/board/worker-prompt.mjs

@@ -12,12 +12,12 @@ export function taskProtocol(taskId) {
     `You were started for board task ${taskId} (it is also in HERMES_KANBAN_TASK). The board's tools are yours:`,
     '- `kanban_show` reads your task: its body, its parents\' handoffs, earlier attempts and its thread. Read it first.',
     '- `kanban_heartbeat` says you are still working on a long step; `kanban_comment` leaves a note on any task.',
-    '- `kanban_create` files follow-up work (with `parents` to make it wait on another task); `kanban_link` adds a dependency.',
-    '- When the work is done, `kanban_complete` with a `summary` a person can read (and `metadata`, `artifacts`, `created_cards` where they apply).',
-    '- If the work needs review, `kanban_request_review` instead. If you cannot go on, `kanban_block` with a `reason` and the one',
-    '  thing that ends the wait: `on` (the task it waits on) or `waiting_on` (the id of the message whose answer it waits for).',
-    'End every run with exactly one of complete, request_review or block: a run that ends without one is counted as a failure.',
-    'You may change only your own task\'s lifecycle; other tasks hear from you through comments.',
+    '- `kanban_create` files follow-up work; dependency creation follows the declared permissions.',
+    '- Follow the workflow doors below: each home declares who may block, pause or finish a card.',
+    '- When the home requires a manager decision, `kanban_request_state` names block, pause, done or cancelled, a reason,',
+    '  its dependency (`on` or `waiting_on`) or its evidence. It mails the manager and leaves your card and run active.',
+    '- `kanban_request_review` hands completed coding to the independent reviewer when the workflow permits it.',
+    'A role does not grant terminal authority by itself. The recorded creator and the home\'s rules decide it.',
   ].join('\n');
 }
 

package/board/workflow.mjs

@@ -58,6 +58,13 @@ export function statusOf(db, task) {
   return one(db, 'SELECT stage FROM supercode_cards WHERE task_id = ?', task.id)?.stage ?? task.status;
 }
 
+/** Creation history, not an editable display name or notification subscriber. */
+export function creatorOf(db, id) {
+  const payload = json(one(db, "SELECT payload FROM task_events WHERE task_id=? AND kind='created' ORDER BY id LIMIT 1", id)?.payload, {}) ?? {};
+  const address = payload.creator ?? payload.by;
+  return payload.source !== 'document' && /^(?:sc:[^:]+:[^:]+:|hermes-run:)/.test(address ?? '') ? address : null;
+}
+
 /** What kanban.db stores for `status`. */
 export function storedAs(workflow, status) {
   return workflow.statuses[status]?.stored_as ?? status;
@@ -214,6 +221,7 @@ export function scopeOf(db, board, task, { params, event = {}, extra = {} } = {}
   const blocks = json(state.blocked_by, []) ?? [];
   const card = {
     ...task,
+    creator_address: creatorOf(db, task.id),
     status,
     blocked_by: blocks,
     paused: json(state.paused, null),
@@ -275,6 +283,7 @@ export function scopeOf(db, board, task, { params, event = {}, extra = {} } = {}
   for (const [key, expr] of Object.entries(loaded.get(board.root)?.workflow?.derived ?? {})) card[key] = evaluate(expr, { card, event, params, now: now() });
   return {
     card,
+    requester: actorOf(),
     event,
     params,
     now: now(),
@@ -751,6 +760,7 @@ const ACTIONS = {
     const id = `m-${randomBytes(12).toString('hex')}`;
     ctx.scope.asked = id;
     record(ctx.db, ctx.id, 'board_message', { to: String(to), text: `${String(text ?? '')}\n\nAnswer with reply_to ${id}.`, message_id: id }, null);
+    ctx.effects.push({ kind: 'board_message', id: ctx.id });
   },
   send_to_actor(ctx, text) { ctx.effects.push({ kind: 'send_to_actor', id: ctx.id, text }); },
 };
@@ -808,7 +818,7 @@ function runSession(ctx, change) {
  * the board: `--root …` or `--at …`) and its transition's description: what a started session is told it can do.
  */
 // the board tool a one-shot worker sends an event with (Hermes's kanban_* tools)
-const TOOL_OF = { complete: 'kanban_complete', block: 'kanban_block', request_review: 'kanban_request_review', request_changes: 'kanban_request_changes', heartbeat: 'kanban_heartbeat', comment: 'kanban_comment' };
+const TOOL_OF = { complete: 'kanban_complete', block: 'kanban_block', request_state: 'kanban_request_state', request_review: 'kanban_request_review', request_changes: 'kanban_request_changes', heartbeat: 'kanban_heartbeat', comment: 'kanban_comment' };
 
 export function doors(workflow, status, role, id, where, surface = 'pane') {
   const events = new Map();

package/board/ztrack.mjs

@@ -360,6 +360,7 @@ class ZtrackBoard {
       this.mem.prepare('UPDATE supercode_cards SET blocked_by = ? WHERE task_id = ?').run(JSON.stringify(blocks), row.task_id);
       for (const b of blocks.filter((b) => b.kind === 'card')) this.insert('task_links', { parent_id: b.id, child_id: row.task_id });
     }
+    this.checkDocumentControls();
     if (observe) this.documentEvents();
   }
   taskCards(id, card) {
@@ -379,6 +380,41 @@ class ZtrackBoard {
     const rows = this.cardRows(id, card, parent);
     this.insert('tasks', rows.task); this.insert('supercode_cards', rows.state);
   }
+  checkDocumentControls() {
+    // A raw edit cannot authenticate its author. Trusted engine writes already
+    // have matching publication hashes; check only external edits, after local
+    // subtask references have been resolved to canonical card identities.
+    if (this.seed || (this.saved.documentHashes?.open === hash(this.text) && this.saved.documentHashes?.archived === hash(this.archiveText))) return;
+    let fields = [];
+    try { fields = workflowFor(this.root).params.document_control_fields ?? []; } catch { /* no home policy */ }
+    if (!fields.length) return;
+    const tasks = new Map(this.mem.prepare('SELECT * FROM tasks').all().map(t => [t.id, t]));
+    const states = new Map(this.mem.prepare('SELECT * FROM supercode_cards').all().map(c => [c.task_id, c]));
+    const value = (task, state, field) => field === 'status' ? state?.stage ?? task?.status ?? 'todo'
+      : field === 'blocked_by' ? json(state?.blocked_by, []).map(b => [b.kind, b.id]).sort()
+      : field === 'paused' ? json(state?.paused, null)
+      : field === 'archived' ? Boolean(state?.archived) : task?.[field] ?? null;
+    for (const id of new Set([...tasks.keys(), ...Object.keys(this.rows.cachedTasks)])) {
+      if (this.errors.has(id)) continue;
+      const oldTask = this.rows.cachedTasks[id], oldState = this.rows.cachedCards[id];
+      const task = tasks.get(id), state = states.get(id);
+      const forbidden = !task ? ['card removal'] : fields.filter(field =>
+        // A new display author is not an authenticated creator.
+        (oldTask || field !== 'created_by') && JSON.stringify(value(task, state, field)) !== JSON.stringify(value(oldTask, oldState, field)));
+      if (!forbidden.length) continue;
+      this.errors.set(id, `Document edit cannot change ${forbidden.join(', ')}; use this card's role-checked workflow verbs or request-state.`);
+      const source = this.documentRecords.get(state?.subtask_of ?? oldState?.subtask_of ?? id);
+      if (source) this.preserve.get(source.path)?.add(source.record.id);
+      this.mem.prepare('DELETE FROM tasks WHERE id=?').run(id);
+      this.mem.prepare('DELETE FROM supercode_cards WHERE task_id=?').run(id);
+      this.mem.prepare('DELETE FROM task_links WHERE child_id=?').run(id);
+      if (oldTask) this.insert('tasks', oldTask);
+      if (oldState) {
+        this.insert('supercode_cards', oldState);
+        for (const b of json(oldState.blocked_by, []).filter(b => b.kind === 'card')) this.insert('task_links', { parent_id: b.id, child_id: id });
+      }
+    }
+  }
   cardRows(id, card, parent = null) {
     const meta = card.metadata ?? {};
     const stored = this.preset.serializeKanbanCard({ ...card, acceptanceCriteria: [], relations: [], metadata: undefined, paused: undefined, every: undefined, workspace: undefined, branch: undefined, machine: undefined, priority: undefined });

package/board.mjs

@@ -2,14 +2,15 @@
 // docs/plans/hermes-compat.md row 14). The board and its dispatcher are supercode's own (`board/`): Hermes Kanban's
 // format and lifecycle, each profile's lane decided by its `worker` in the IR. Where a Hermes gateway would run
 // its dispatcher, the daemon runs this one the same way: when the board's workflow says so (its `dispatch.serve`),
-// taking no file locks, one tick every `dispatch.tick` seconds
-// of the workflow (at least 1), the first after five seconds. Each tick runs as
+// taking no file locks, waking on events with `dispatch.tick` as a safety sweep.
+// Each tick runs as
 // `workflow dispatch` in a child process: a tick waits on supercode (the fleet, launches, mail), and the daemon's
 // own loop never does.
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { summary } from './board/cli.mjs';
-import { notifyChats } from './board/dispatch.mjs';
+import { commandEnv, notifyChats, supercodeBin } from './board/dispatch.mjs';
+import { watchBoard } from './board/wake.mjs';
 import { workflowEntry } from './board/workflow.mjs';
 import { evaluate, holds } from './board/expr.mjs';
 
@@ -52,8 +53,8 @@ export async function startBoard({ root, orchestration = null, log = () => {}, a
       try { await notifyChats(root, adapters, log, wake); } catch (error) { log('warn', `board: chat notices failed: ${error.message}`); }
       for (const r of reports) {
         const line = summary(r);
-        stuck[r.board] = r.ready_waiting && !r.started?.length && !r.paused ? (stuck[r.board] ?? 0) + 1 : 0;
-        if (stuck[r.board] >= 6 && Date.now() - (warned[r.board] ?? 0) >= 300_000) { log('warn', `board ${r.board} stuck: ${r.ready_waiting} ready card(s) and nothing started for ${stuck[r.board]} ticks`); warned[r.board] = Date.now(); }
+        stuck[r.board] = r.ready_waiting && !r.started?.length && !r.paused ? (stuck[r.board] || Date.now()) : 0;
+        if (stuck[r.board] && Date.now() - stuck[r.board] >= seconds * 6000 && Date.now() - (warned[r.board] ?? 0) >= 300_000) { log('warn', `board ${r.board} stuck: ${r.ready_waiting} ready card(s) and nothing started for ${Math.floor((Date.now() - stuck[r.board]) / 1000)}s`); warned[r.board] = Date.now(); }
         if (r.paused && !said.has(`paused:${r.board}`)) { said.add(`paused:${r.board}`); log('info', `board ${r.board}: new starts paused by ${r.paused}`); }
         if (!r.paused) said.delete(`paused:${r.board}`);
         if (!line.endsWith('nothing to do')) log(r.error ? 'warn' : 'info', line);
@@ -67,12 +68,22 @@ export async function startBoard({ root, orchestration = null, log = () => {}, a
       running = false;
     }
   };
-  const first = setTimeout(() => { void tick(); }, 5_000);
-  const timer = setInterval(() => { void tick(); }, seconds * 1000);
-  first.unref?.(); timer.unref?.();
-  log('info', `board: dispatching every ${seconds}s, each card as its profile's worker says`);
+  const events = watchBoard({ root, binary: supercodeBin(), env: commandEnv(), log: message => log('warn', message) });
+  void (async () => {
+    let wakeReason = null;
+    while (!stopped) {
+      const began = Date.now();
+      if (wakeReason) log('info', `board: dispatch wake ${wakeReason.sources.join(', ')}; event age ${began - wakeReason.at}ms`);
+      await tick();
+      events.refresh();
+      wakeReason = await events.wait(Math.max(0, seconds * 1000 - (Date.now() - began)));
+      const remaining = 1000 - (Date.now() - began);
+      if (remaining > 0 && !stopped) await new Promise(done => setTimeout(done, remaining));
+    }
+  })().catch(error => log('warn', `board: dispatch loop failed: ${error.message}`));
+  log('info', `board: dispatching on events, safety sweep every ${seconds}s, each card as its profile's worker says`);
   return {
-    tick,
-    stop() { stopped = true; clearTimeout(first); clearInterval(timer); },
+    tick() { events.wake('requested'); },
+    stop() { stopped = true; events.close(); },
   };
 }

package/mcp/hermes-kanban-tools.json

@@ -62,7 +62,7 @@
   },
   {
     "name": "kanban_complete",
-    "description": "Mark your current task done with a structured handoff for downstream workers and humans. Prefer ``summary`` for a human-readable 1-3 sentence description of what you did; put machine-readable facts in ``metadata`` (changed_files, tests_run, decisions, findings, etc). At least one of ``summary`` or ``result`` is required. If you created new tasks via ``kanban_create`` during this run, list their ids in ``created_cards`` — the kernel verifies them so phantom references are caught before they leak into downstream automation. If you produced deliverable files (charts, PDFs, spreadsheets, generated images), list their absolute paths in ``artifacts`` — the gateway notifier will upload them as native attachments to the human who subscribed to the task, so the deliverable lands in their chat alongside the summary instead of being a path they have to fetch by hand.",
+    "description": "Complete through the home's declared workflow permissions with a structured handoff. Homes may reserve terminal closure to the recorded creator or manager; use kanban_request_state when you need their decision. Prefer ``summary`` for a human-readable 1-3 sentence description of what you did; put machine-readable facts in ``metadata`` (changed_files, tests_run, decisions, findings, etc). At least one of ``summary`` or ``result`` is required. If you created new tasks via ``kanban_create`` during this run, list their ids in ``created_cards`` — the kernel verifies them so phantom references are caught before they leak into downstream automation. If you produced deliverable files (charts, PDFs, spreadsheets, generated images), list their absolute paths in ``artifacts`` — the gateway notifier will upload them as native attachments to the human who subscribed to the task, so the deliverable lands in their chat alongside the summary instead of being a path they have to fetch by hand.",
     "inputSchema": {
       "type": "object",
       "properties": {
@@ -106,7 +106,7 @@
   },
   {
     "name": "kanban_block",
-    "description": "Stop work on this task until one thing ends the wait, and name it: `on`, the task it waits on (it goes to todo and resumes when that task closes), or `waiting_on`, the id of the message you sent whose answer it waits for (it resumes when an answer to that message lands in your mailbox). An outside event is a task on the card of whoever makes it happen or watches for it. `reason` is shown on the board. The same block twice goes to triage.",
+    "description": "Add a typed dependency only if the home permits your role to block. Otherwise use kanban_request_state with state block, the reason and on or waiting_on; that request leaves the card active. Stop work on this task until one thing ends the wait, and name it: `on`, the task it waits on (it goes to todo and resumes when that task closes), or `waiting_on`, the id of the message you sent whose answer it waits for (it resumes when an answer to that message lands in your mailbox). An outside event is a task on the card of whoever makes it happen or watches for it. `reason` is shown on the board. The same block twice goes to triage.",
     "inputSchema": {
       "type": "object",
       "properties": {
@@ -171,7 +171,7 @@
   },
   {
     "name": "kanban_request_changes",
-    "description": "Reviewer verdict: return the current review run to the original implementer with concrete required changes. This closes the review run, reapplies parent dependency gating, and requeues the task without using block-loop accounting. Only use from a task claimed from the review column; use kanban_block only for a genuine external blocker.",
+    "description": "Reviewer verdict: return the current review run to the original implementer with concrete required changes. This closes the review run, reapplies parent dependency gating, and requeues the task without using block-loop accounting. Only use from a task claimed from the review column; use kanban_request_state when a manager must decide an external blocker.",
     "inputSchema": {
       "type": "object",
       "properties": {
@@ -471,5 +471,42 @@
         "child_id"
       ]
     }
+  },
+  {
+    "name": "kanban_request_state",
+    "description": "Request a manager decision on block, pause, done or cancelled through the home workflow. Includes its rules in manager mail and leaves card/run state unchanged.",
+    "inputSchema": {
+      "type": "object",
+      "properties": {
+        "task_id": {
+          "type": "string"
+        },
+        "state": {
+          "type": "string",
+          "enum": [
+            "block",
+            "pause",
+            "done",
+            "cancelled"
+          ]
+        },
+        "reason": {
+          "type": "string"
+        },
+        "on": {
+          "type": "string"
+        },
+        "waiting_on": {
+          "type": "string"
+        },
+        "evidence": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "state",
+        "reason"
+      ]
+    }
   }
 ]

package/package.json

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