@volter/supercode-orchestrator 0.4.126 → 0.4.128

package/board/cli.mjs

@@ -54,6 +54,8 @@ supercode's own:
   notify-subscribe <id> --address sc:<machine>:<harness>:<id> [--role creator|worker|dependency]
   Any verb … --at sc:<machine>:board:<home>: sent as mail to a board kept on another machine.
   <event> <id>... [reason] [--<field> value]: any other event the board's workflow declares, its flags the event's fields.
+  start <id>               release a --no-start hold and start through the declared workflow
+  create ... --adopt <session>  hold dispatch until that live session is attached
   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,
@@ -294,11 +296,15 @@ export async function runWorkflow(argv) {
         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(),
+        noStart: Boolean(args['no-start']), adopt: args.adopt ?? null,
         every: args.every ?? null, sessionId: callerSession(), 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 } : args['no-goal'] ? false : null,
       }), true);
       let answer = { id: created.id, existing: created.existing };
-      if (!args['no-start'] && !created.existing && !args['subtask-of']) {
+      if (args.adopt) {
+        const adopted = withBoard(b => adoptSession(b, created.id, args.adopt, { ttl: settings.ttl }));
+        answer = { ...answer, started: true, session: adopted.address, mode: adopted.mode };
+      } else if (!args['no-start'] && !created.existing && !args['subtask-of']) {
         const [report] = await tick({ root, lanes, settings, only: created.id, slugs: [slug] });
         const started = report.started.find(([t]) => t === created.id);
         const queued = report.queued.find(([t]) => t === created.id);
@@ -813,6 +819,12 @@ export async function runWorkflow(argv) {
       say(args, lifted.length ? `Resumed (removed ${lifted.join(', ')})` : 'Not paused', { ok: true, lifted });
       return 0;
     }
+    case 'start': {
+      need(1, 'a card id');
+      const { lanes, settings } = await laneState(root);
+      const session = await withBoardAsync(b => startCard(b, id, { lanes, settings, roles: rolesFor(b.db, id, sid, workflowFor(root).params) }));
+      say(args, `${id}: ${session?.address ?? 'started'}`, { ok: true, session }); return 0;
+    }
     case 'adopt': {
       need(2, 'a card id and a session');
       const { settings } = await laneState(root);

package/board/dispatch.mjs

@@ -136,7 +136,20 @@ const HARNESSES = {
 const addressOf = (s) => s?.address ?? (s?.session_id && s.machine ? `sc:${s.machine}:${s.harness ?? 'claude-code'}:${s.session_id}` : null);
 const pause = (ms) => Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
 
-const sessionAlive = (fleet, session) => Boolean(session?.session_id) && [...fleet.alive].some((a) => a.endsWith(`:${session.session_id}`));
+const sessionAlive = (fleet, session) => fleet.native?.has(addressOf(session)) ? fleet.native.get(addressOf(session)).alive : Boolean(session?.session_id) && fleet.alive.has(addressOf(session));
+
+/** Native activity comes from the machine's harness discovery, not catalogue age. */
+function nativeSessions(machine, harness) {
+  const result = sc(['discover', '--on', machine, '--harness', harness, '--limit', '2000'], { timeout: 120_000 });
+  const page = result.code === 0 ? lastJson(result.stdout) : null;
+  if (!Array.isArray(page?.sessions)) throw unavailable(`native liveness unavailable on ${machine}: ${(result.stderr || result.stdout).trim().slice(-300)}`);
+  return page.sessions;
+}
+function nativeReading(rows, session) {
+  const row = rows.find(r => r.locator?.session_id === session.session_id && r.locator?.harness === session.harness);
+  const presence = row?.activity?.presence;
+  return { row, alive: presence === 'running' ? true : presence === 'persisted' ? false : null };
+}
 
 /** Match a manual continuation by the same harness identity and an actually live machine pane. */
 function continuationPane(fleet, session, panes) {
@@ -211,6 +224,17 @@ function supervise(board, fleet, settings, report, entry, effects) {
   // The catalog can lag a pane. Read the actual machines once, before any board mutation.
   const observed = new Map();
   const exits = new Map();
+  const native = new Map(); fleet.native = new Map();
+  for (const { id } of rows) {
+    const session = currentRun(board.db, id)?.metadata?.supercode;
+    if (!session?.session_id || session.pane || session.surface === 'headless') continue;
+    const key = `${session.machine}:${session.harness}`;
+    if (!native.has(key)) {
+      try { native.set(key, nativeSessions(session.machine, session.harness)); }
+      catch (error) { native.set(key, null); report.failed.push([id, error.message]); }
+    }
+    fleet.native.set(addressOf(session), native.get(key) ? nativeReading(native.get(key), session) : { alive: null });
+  }
   for (const { id } of rows) {
     const s = currentRun(board.db, id)?.metadata?.supercode;
     if (!s?.pane || observed.has(s.machine)) continue;
@@ -288,7 +312,7 @@ function supervise(board, fleet, settings, report, entry, effects) {
       // Hermes's orphan reconciliation: a running card whose claim bookkeeping is broken, with nothing live behind it
       const paneReading = session?.pane ? observed.get(session.machine) : undefined;
       const paneLive = paneReading instanceof Set ? paneReading.has(session.pane) : null;
-      const live = session?.surface === 'headless' ? pidAlive(session.pid) : session?.pane ? paneLive !== false : session?.session_id ? (fleet.ok ? sessionAlive(fleet, session) : true) : false;
+      const live = session?.surface === 'headless' ? pidAlive(session.pid) : session?.pane ? paneLive !== false : session?.session_id ? (fleet.ok ? sessionAlive(fleet, session) !== false : true) : false;
       // (whether it is reconciled is the workflow's: its `orphaned` transitions and their guard)
       if ((!task.claim_lock || !task.claim_expires) && !live) {
         observe('orphaned', { reason: 'orphaned_running', claim_lock: task.claim_lock, claim_expires: task.claim_expires, error: 'orphaned running card (broken claim bookkeeping)' }, 'reclaimed');
@@ -325,6 +349,7 @@ function supervise(board, fleet, settings, report, entry, effects) {
         if (session.pane && paneLive === null) return; // no machine reading, no loss verdict
         if (!session.pane && !fleet.ok) return;
         const alive = session.pane ? paneLive : sessionAlive(fleet, session);
+        if (alive == null) return; // native discovery was inconclusive
         const machineUp = paneReading instanceof Set || fleet.online.has(session.machine);
         const young = t - Number(session.launched_at ?? 0) < Number(limits.grace ?? settings.grace);
         const missing = !alive && machineUp && !young;
@@ -374,6 +399,13 @@ function stopSession(board, session) {
     if (pidAlive(session.pid)) signal('SIGKILL');
     return;
   }
+  if (!session.pane && session.surface === 'native') {
+    const r = sc(['close', addressOf(session)], { timeout: 120_000, as: boardAddress(board.label) });
+    if (r.code !== 0) throw new Error(`closing native session ${addressOf(session)}: ${(r.stderr || r.stdout).trim().slice(-500)}`);
+    const reading = nativeReading(nativeSessions(session.machine, session.harness), session);
+    if (reading.alive !== false) throw new Error(`native close has no confirmed stopped receipt for ${addressOf(session)}`);
+    return;
+  }
   if (session.pane) {
     const r = sc(['teams', 'panes', 'close', session.pane, ...(session.machine ? ['--machine', session.machine] : [])], { timeout: 60_000, as: boardAddress(board.label) });
     if (r.code !== 0 || json(r.stdout.trim(), null)?.closed !== session.pane) throw new Error(`closing pane ${session.pane}: ${(r.stderr || r.stdout || `exit ${r.code}`).trim().slice(-500)}`);
@@ -421,6 +453,7 @@ function startCards(board, fleet, lanes, settings, report, entry, effects, { onl
   for (const task of everyCard) {
     if (only && task.id !== only) continue;
     const state = scopeFor(task).card;
+    if (state.dispatch_hold) continue;
     if (workflow.run && (task.subtask_of || state.paused || state.archived || state.blocked_by.length || task.current_run_id || (state.every && state.next_run_at > now()))) continue;
     if (!startable.has(statusOf(board.db, task))) continue;
     const plan = planOf(task, scopeFor(task));
@@ -565,6 +598,8 @@ export async function startCard(board, id, { roles = ['manager'], lanes, setting
   const moved = tx(board, (db) => {
     assertWorkspaceOwner(db, before, checked);
     if (checked) db.prepare('UPDATE supercode_cards SET workspace_root=? WHERE task_id=?').run(checked.mainRoot, id);
+    if (!roles.includes('manager')) throw new Error('Only the manager starts a held card; request its decision.');
+    event(db, id, 'dispatch_released', { reason: 'explicit start' });
     return fire(db, board, entry, id, entry.workflow.dispatch.start, { roles, payload: { lock: claimer() } });
   });
   const task = getTaskNow(board, id);
@@ -611,7 +646,7 @@ export function closeRequested(board, report, { taskId = null, caller = null } =
         report.undelivered.push([row.task_id, addressOf(session), error]);
       }
     }
-    if (!session?.pane || session.close_transferred_to || session.close_confirmed_at || (!row.ended_at && !session.close_requested)) continue;
+    if ((!session?.pane && session?.surface !== 'native') || session.close_transferred_to || session.close_confirmed_at || (!row.ended_at && !session.close_requested)) continue;
     if (caller && session.session_id === caller) continue; // let the command that ended its own run return
     const active = view(board, (db) => db.prepare(`SELECT r.id, r.metadata FROM task_runs r WHERE r.ended_at IS NULL OR EXISTS (SELECT 1 FROM tasks t WHERE t.current_run_id = r.id)`).all());
     // Persist retries even for historical ends that did not have a close_session action.
@@ -619,6 +654,16 @@ export function closeRequested(board, report, { taskId = null, caller = null } =
     let error = null;
     try {
       const machine = session.machine ?? localMachine();
+      if (session.surface === 'native' && !session.pane) {
+        const reading = nativeReading(nativeSessions(machine, session.harness), session);
+        if (reading.alive == null) throw new Error(`close deferred: native liveness unknown for ${addressOf(session)}`);
+        if (reading.alive) {
+          const protectedNow = active.some(r => addressOf(json(r.metadata, {})?.supercode) === addressOf(session));
+          if (protectedNow) throw new Error('close deferred: native session is owned by an unended run');
+          if (session.lifecycle_notice_pending) throw new Error(`close deferred: lifecycle notice ${session.lifecycle_notice_pending} has not been delivered`);
+          stopSession(board, session);
+        }
+      } else {
       if (!panes.has(machine)) {
         const r = sc(['teams', 'panes', 'ls', ...onMachine(machine)], { timeout: 60_000, as: boardAddress(board.label) });
         const list = r.code === 0 ? json(r.stdout.trim(), null) : null;
@@ -634,10 +679,11 @@ export function closeRequested(board, report, { taskId = null, caller = null } =
         if (protectedNow) throw new Error(`close deferred: pane ${session.pane} is owned by an unended run`);
         stopSession(board, session); observed.live.delete(session.pane);
       }
+      }
     } catch (e) { error = String(e.message).slice(-500); }
     tx(board, (db) => {
       const current = json(db.prepare('SELECT metadata FROM task_runs WHERE id = ?').get(row.id)?.metadata, {})?.supercode;
-      if (!current || current.pane !== session.pane) return;
+      if (!current || current.pane !== session.pane || current.session_id !== session.session_id) return;
       const at = now();
       if (error) {
         setRunSession(db, row.id, { ...current, close_attempted_at: at, close_attempts: Number(current.close_attempts ?? 0) + 1, close_error: error });
@@ -668,8 +714,9 @@ function observeIdle(board, fleet, settings, report, entry, effects) {
       if (!(entry.workflow.statuses[status]?.on?.session_idle || entry.workflow.on?.session_idle || entry.workflow.run?.on?.session_idle)) return;
       const runRow = currentRun(db, id);
       const session = runRow?.metadata?.supercode;
-      if (!session?.session_id || session.surface !== 'pane' || session.offline_since != null) return;
-      const live = fleet.sessions.find((x) => x.address?.endsWith(`:${session.session_id}`));
+      if (!session?.session_id || !['pane', 'native'].includes(session.surface) || session.offline_since != null) return;
+      if (session.surface === 'native' && fleet.native?.get(addressOf(session))?.alive !== true) return;
+      const live = fleet.sessions.find((x) => x.address === addressOf(session));
       const observedAt = now();
       const lastAt = Math.floor(Number(live?.last_message_at_ms) / 1000);
       const reading = {
@@ -695,7 +742,7 @@ function observeIdle(board, fleet, settings, report, entry, effects) {
       try {
         const where = whereOf(board, task);
         // the ask names what the session may do, as its run's prompt did
-        const said = doors(entry.workflow, status, session.role ?? runSpec(entry, status)?.role ?? 'implementer', id, where, session.surface === 'pane' ? 'pane' : 'headless');
+        const said = doors(entry.workflow, status, session.role ?? runSpec(entry, status)?.role ?? 'implementer', id, where, session.surface !== 'headless' ? 'pane' : 'headless');
         const r = fire(db, board, entry, id, 'session_idle', { roles: ['platform'], payload: { ...reading, turns: reading.turns_before, worked }, extra: { where, doors: said } });
         effects.push(...r.effects);
         const after = currentRun(db, id);
@@ -948,7 +995,7 @@ function launchPane(board, task, runId, lane, fleet, { input = null, slot = 'wor
   closeRequested(board, { undelivered: [] }, { taskId: task.id });
   const pending = view(board, (db) => db.prepare('SELECT id, ended_at, metadata FROM task_runs WHERE task_id = ? AND id != ?').all(task.id, runId))
     .map((r) => ({ ...r, session: json(r.metadata, {})?.supercode }))
-    .find((r) => (r.session?.pane || r.session?.launch_key) && !r.session.close_transferred_to && (r.session.slot ?? 'worker') === slot && (r.ended_at || r.session.close_requested) && !r.session.close_confirmed_at);
+    .find((r) => (r.session?.pane || r.session?.launch_key || r.session?.surface === 'native') && !r.session.close_transferred_to && (r.session.slot ?? 'worker') === slot && (r.ended_at || r.session.close_requested) && !r.session.close_confirmed_at);
   if (pending) throw unavailable(`slot ${slot} still owns pane ${pending.session.pane} from run ${pending.id}; closure must be confirmed before another session starts: ${pending.session.close_error ?? 'close pending'}`);
   let prev = view(board, (db) => lastSession(db, task.id, slot));
   if (prev?.session_id && !prev.forgotten && (prev.harness ?? 'claude-code') === harness && prev.machine === machine) {
@@ -997,6 +1044,12 @@ function launchPane(board, task, runId, lane, fleet, { input = null, slot = 'wor
   };
   let session = null;
   let replaced = null;
+  if (prev?.surface === 'native' && !prev.pane) {
+    const reading = nativeReading(nativeSessions(prev.machine, prev.harness), prev);
+    if (reading.alive == null) throw unavailable(`cannot establish native continuation liveness for ${addressOf(prev)}`);
+    fleet.native ??= new Map(); fleet.native.set(addressOf(prev), reading);
+    if (reading.alive && (prev.closed_at || prev.close_requested || prev.forgotten)) throw unavailable(`native session ${addressOf(prev)} is still live; its close must finish before replacement`);
+  }
   if (prev?.forgotten) {
     if (prev.pane && panePresent(prev.machine, prev.pane)) throw new Error(`forgotten session ${prev.session_id} still has live pane ${prev.pane}; close it before replacement`);
     replaced = { session_id: prev.session_id, why: 'the workflow let it go' };
@@ -1165,14 +1218,15 @@ export function adoptSession(board, id, who, { workspace = null, ttl, assignee =
   if (!found) throw new Error(`the fleet lists no live session ${who}`);
   const [, host, harness, sessionId] = found.address.split(':');
   if (!HARNESSES[harness]) throw new Error(`${found.address} is ${harness}; the board keeps and resumes ${Object.keys(HARNESSES).join(' and ')} sessions`);
-  if (!found.pane || !panePresent(host, found.pane)) throw new Error(`${found.address} has no verified live pane`);
+  const native = found.pane ? null : nativeReading(nativeSessions(host, harness), { session_id: sessionId, harness });
+  if (found.pane ? !panePresent(host, found.pane) : native.alive !== true) throw new Error(`${found.address} has no verified live native process or pane`);
   const beforeRun = view(board, (db) => currentRun(db, id));
   const beforeSession = beforeRun?.metadata?.supercode;
   if (beforeRun && beforeSession?.session_id !== sessionId) throw new Error(`${id} has another active run/session; end it before adopting a different identity`);
   if (beforeSession?.pane && beforeSession.pane !== found.pane && panePresent(beforeSession.machine, beforeSession.pane)) throw new Error(`${id} still has live pane ${beforeSession.pane}; close the extra pane before rebinding ${sessionId}`);
 
   // the session's own working directory, as discovery records it (where `--resume` finds it), else its pane's
-  let dir = workspace;
+  let dir = workspace ?? native?.row?.cwd;
   if (!dir) {
     const r = sc(['discover', '--on', host, '--harness', harness, '--limit', '2000'], { timeout: 120_000 });
     dir = (json(r.stdout.trim(), {})?.sessions ?? []).find((x) => x.locator?.session_id === sessionId)?.cwd ?? null;
@@ -1203,10 +1257,11 @@ export function adoptSession(board, id, who, { workspace = null, ttl, assignee =
       const implementer = lastSession(db, id, 'worker');
       if (implementer?.session_id === sessionId) throw new Error('a reviewer must be independent of the implementer session');
     }
+    event(db, id, 'dispatch_released', { reason: 'verified adoption', session: found.address });
     if (!beforeRun) fire(db, board, entry, id, entry.workflow.run ? entry.workflow.dispatch.start : 'adopt', { roles: ['manager'], payload: { lock: claimer() } });
     const runId = getTask(db, id).current_run_id;
     if (!runId) throw new Error(`${id} waits on parents that are not done`);
-    const session = { surface: 'pane', session_id: sessionId, harness, machine: host, pane: found.pane ?? null, address: found.address, mode: 'adopt', launched_at: now(), seen_at: now() };
+    const session = { surface: found.pane ? 'pane' : 'native', session_id: sessionId, harness, machine: host, pane: found.pane ?? null, address: found.address, mode: 'adopt', launched_at: now(), seen_at: now() };
     setRunSession(db, runId, { ...(currentRun(db, id)?.metadata?.supercode ?? {}), ...session, slot: currentRun(db, id)?.metadata?.supercode?.slot ?? beforeSession?.slot ?? expected?.session ?? 'worker', close_requested: null, closed_at: null, close_confirmed_at: null, close_error: null, missing_since: null });
     event(db, id, 'session_adopted', { session_id: sessionId, machine: host, pane: session.pane, address: found.address, mode: 'adopt', role: currentRun(db, id)?.metadata?.supercode?.role }, runId);
     subscribeIn(db, id, found.address, 'worker');

package/board/engine.mjs

@@ -216,6 +216,7 @@ export function createCard(board, spec) {
     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', { creator: actorOf(), assignee: spec.assignee || null, status, parents, tenant: spec.tenant ?? null, ...(machine ? { machine } : {}), ...(arc ? { subtask_of: arc.id } : {}) });
+    if ((spec.noStart || spec.adopt) && !arc) event(db, id, 'dispatch_held', { session: spec.adopt ?? null, reason: spec.adopt ? 'awaiting adoption' : 'created with --no-start' });
     if (parents.length) inheritSubscriptions(db, id, parents);
     if (arc) {
       // the arc's subscribers hear its subtasks, and the arc's session works them

package/board/workflow.mjs

@@ -222,6 +222,7 @@ export function scopeOf(db, board, task, { params, event = {}, extra = {} } = {}
   const card = {
     ...task,
     creator_address: creatorOf(db, task.id),
+    dispatch_hold: one(db, "SELECT kind FROM task_events WHERE task_id=? AND kind IN ('dispatch_held','dispatch_released','session_adopted') ORDER BY id DESC LIMIT 1", task.id)?.kind === 'dispatch_held',
     status,
     blocked_by: blocks,
     paused: json(state.paused, null),

package/board/ztrack.mjs

@@ -19,6 +19,14 @@ const CARD_MAIN = new Set(['id', 'title', 'body', 'status', 'assignee', 'priorit
 const EPHEMERAL = new Set(['tasks', 'supercode_cards', 'task_links', 'sqlite_sequence']);
 const atomic = (path, text) => { const tmp = `${path}.${process.pid}.tmp`; writeFileSync(tmp, text, { mode: 0o600 }); renameSync(tmp, path); };
 
+// Only SQLite's actual contention codes retry. Rule refusals can contain words
+// such as "blocked" or "busy" and must reach the caller unchanged.
+const sqliteContention = error => [5, 6].includes(Number(error?.errcode) & 255)
+  || ['SQLITE_BUSY', 'SQLITE_LOCKED'].includes(error?.code)
+  || /^database (?:table |schema )?is locked$/i.test(error?.message ?? '');
+const exportConflict = error => error?.message === 'Hermes wrote during board export; retained its events for the next read';
+const recoveryConflict = error => error?.message === 'document changed during recovery; retry';
+
 export function openZtrackBoard(marker, { create = false, document = null, seed = null, init, root, slug, compatPath }) {
   if (!existsSync(marker)) {
     if (!create) throw new Error(`no ztrack board ${marker}`);
@@ -60,7 +68,7 @@ class ZtrackBoard {
     const fileStamp = (path) => { try { const s = statSync(path); return `${s.ino}:${s.size}:${s.mtimeMs}`; } catch { return 'missing'; } };
     return [fileStamp(this.path), fileStamp(this.archive), fileStamp(this.compatPath), this.get('version', '')].join('|');
   }
-  readOnly(fn) { for (;;) { try { return fn(); } catch(error) { if(!/busy|locked/i.test(error.message))throw error; } } }
+  readOnly(fn) { for (;;) { try { return fn(); } catch(error) { if(!sqliteContention(error))throw error; } } }
   access(fn, reading = false) {
     if (reading && !this.reading) { this.reading=true; try {return this.readOnly(()=>this.access(fn,true));}finally{this.reading=false;} }
     if (this.active || (reading && this.mem && this.loadedStamp === this.stamp())) return fn();
@@ -112,7 +120,7 @@ class ZtrackBoard {
     this.readOnly(()=>{ if(this.runtime.prepare('PRAGMA journal_mode').get().journal_mode!=='wal')this.runtime.exec('PRAGMA journal_mode=WAL'); });
     for (;;) {
       try { this.runtime.exec('BEGIN'); }
-      catch (error) { if (!/busy|locked/i.test(error.message)) throw error; continue; }
+      catch (error) { if (!sqliteContention(error)) throw error; continue; }
       this.active = true;
       let committed = false;
       try {
@@ -173,14 +181,14 @@ class ZtrackBoard {
         this.put('export_pending', [...this.get('export_pending', []), ...changes]);
         this.put('version', randomBytes(8).toString('hex'));
         this.runtime.exec('COMMIT');
-        try { this.flushExport(); } catch (error) { if (!/busy|locked|Hermes wrote/i.test(error.message)) throw error; }
+        try { this.flushExport(); } catch (error) { if (!sqliteContention(error) && !exportConflict(error)) throw error; }
         this.loadedStamp = this.stamp();
         this.seed = null;
         return result;
       } catch (error) {
         try { this.runtime.exec('ROLLBACK'); } catch { /* intent already durable */ }
         this.invalidate();
-        if (/busy|locked|Hermes wrote|document changed during recovery/i.test(error.message)) continue;
+        if (sqliteContention(error) || exportConflict(error) || recoveryConflict(error)) continue;
         if (committed) error.message += ' (the operation reached its durable intent; inspect its recorded outcome before retrying)';
         throw error;
       } finally { this.active = false; this.computing = false; this.pendingValues = null; }

package/package.json

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