@volter/supercode-orchestrator 0.4.54 → 0.4.56

package/board/dispatch.mjs

@@ -4,10 +4,11 @@
 // review lane, failure breaker, caps, notify); what it adds is how a session runs, which the IR decides per
 // profile (`worker.surface`):
 //
-// - `pane`: an interactive session on the card's machine (`supercode open --new … --on <machine>`), started with a
-//   session id the dispatcher chose (`--session-id`) and recorded on the run. It stays open. It is live while
-//   supercode's fleet lists it; one missing for the whole grace on an online machine is lost, and the next start
-//   resumes it (`--resume`) before it ever replaces it from the card. Nothing asks the session about itself.
+// - `pane`: an interactive session of the lane's harness (Claude Code or Codex) on the card's machine (`supercode open
+//   --new … --on <machine>`), its session id recorded on the run: one the dispatcher chose (Claude Code's
+//   `--session-id`) or the one the harness named, read from the fleet by its pane (Codex). It stays open. It is live
+//   while supercode's fleet lists it; one missing for the whole grace on an online machine is lost, and the next start
+//   resumes it in its own harness. Nothing asks the session about itself.
 // - `headless`: the profile's worker for one query on this machine (`bin/hermes-worker.mjs`, Hermes's worker
 //   argv and task environment), watched by its pid as Hermes watches its own.
 //
@@ -82,6 +83,17 @@ export function observeFleet() {
   return { ok: true, sessions, alive: new Set(sessions.map((s) => s.address).filter(Boolean)), online, error: rows ? null : 'teams machines list gave no answer; only this machine counts as online' };
 }
 
+// how the launcher opens each harness a pane lane can run, and how it names the session: Claude Code is told the id
+// it will have (`--session-id`) and resumed by it (`--resume`); Codex names its own session, which the board reads from
+// the fleet by the pane it opened, and is resumed by it (`codex resume <id>`)
+const HARNESSES = {
+  'claude-code': { program: 'claude', fresh: (sid) => ['--session-id', sid], resume: (sid) => ['--resume', sid], namesItself: false },
+  codex: { program: 'codex', fresh: () => [], resume: (sid) => ['resume', sid], namesItself: true },
+};
+/** A recorded session's fleet address (older records carry no harness: those were Claude Code's). */
+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}`));
 
 function pidAlive(pid) {
@@ -422,7 +434,7 @@ function closeRequested(board, report) {
     const session = json(row.metadata, {})?.supercode;
     if (!session?.pane) continue;
     try { stopSession(board, session); } catch (error) { report.undelivered.push([row.task_id, session.address, `closing it: ${String(error.message).slice(-200)}`]); continue; }
-    const address = session.address ?? `sc:${session.machine}:claude-code:${session.session_id}`;
+    const address = addressOf(session);
     tx(board, (db) => {
       setRunSession(db, row.id, { ...session, closed_at: now() });
       db.prepare("DELETE FROM kanban_notify_subs WHERE task_id = ? AND platform = 'supercode' AND chat_id = ?").run(row.task_id, address);
@@ -466,7 +478,7 @@ export async function sessionEffect(board, e) {
   if (e.kind === 'send_to_actor') {
     const run = tx(board, (db) => currentRun(db, e.id));
     const session = run?.metadata?.supercode;
-    const address = session?.address ?? (session?.session_id && session.machine ? `sc:${session.machine}:claude-code:${session.session_id}` : null);
+    const address = addressOf(session);
     if (!address) return;
     await send(boardAddress(board.label), board.label, address, e.text, `board-actor-${e.id}-${now()}`);
     return;
@@ -483,7 +495,7 @@ export async function sessionEffect(board, e) {
       if (caller && caller === session.session_id) { tx(board, (db) => setRunSession(db, row.id, { ...session, close_requested: now() })); return; }
       stopSession(board, session);
       // a closed session hears nothing more of the card
-      const address = session.address ?? `sc:${session.machine}:claude-code:${session.session_id}`;
+      const address = addressOf(session);
       tx(board, (db) => {
         setRunSession(db, row.id, { ...session, closed_at: now() });
         db.prepare("DELETE FROM kanban_notify_subs WHERE task_id = ? AND platform = 'supercode' AND chat_id = ?").run(e.id, address);
@@ -521,7 +533,7 @@ function launcherCheck(db, task, lane, fleet) {
   // a card on this machine gets its workspace made here (scratch, dir or worktree, as Hermes makes it); another
   // machine's card names its directory there
   if (machine !== localMachine() && (task.workspace_kind !== 'dir' || !task.workspace_path)) return `a pane session on ${machine} starts in a directory there: the card's workspace is dir:<absolute path>, not ${task.workspace_kind}`;
-  if (lane.harness !== 'claude-code') return `a pane session's id is chosen at launch, which ${lane.harness} does not take; the lane's worker is claude-code`;
+  if (!HARNESSES[lane.harness]) return `the board opens pane sessions of ${Object.keys(HARNESSES).join(' and ')}; the lane's worker is ${lane.harness}`;
   return null;
 }
 
@@ -578,7 +590,9 @@ function launchPane(board, task, runId, lane, fleet, { input = null, slot = 'wor
   }
   const model = task.model_override ?? lane.model;
   const tail = model ? ['--model', model] : [];
-  const base = ['open', '--new', 'claude', '--detach', '--on', task.machine, '--cwd', task.workspace_path];
+  const harness = HARNESSES[lane.harness] ? lane.harness : 'claude-code';
+  const how = HARNESSES[harness];
+  const base = ['open', '--new', how.program, '--detach', '--on', task.machine, '--cwd', task.workspace_path];
   // the slot's last session: kept when live, resumed when lost, never another slot's (a reviewer's is its own)
   // a close its session's own command asked for is carried out first, so its pane is gone before the slot's next
   // session starts (never two processes on one session)
@@ -601,16 +615,18 @@ function launchPane(board, task, runId, lane, fleet, { input = null, slot = 'wor
       const { missing_since: _m, goal_turns: _t, goal_nudged_at: _n, close_requested: _q, closed_at: _c, ...kept } = prev;
       session = { ...kept, mode: 'adopt', launched_at: now(), seen_at: now() };
       // a kept session is told what this run is for (its card came back to it, with what happened since)
-      if (input) deliverNow(board, prev.address ?? `sc:${prev.machine}:claude-code:${prev.session_id}`, input, `board-run-${task.id}-r${runId}`);
+      if (input) deliverNow(board, addressOf(prev), input, `board-run-${task.id}-r${runId}`);
     } else if (prev.resumable !== false) {
       // a resumed session is told what this run is for, as a kept one is: the run's own prompt (a reviewer resumed for
       // its next round gets that round's prompt, its arc's context with it), not only that it was resumed
       const told = input ? `The board resumed this session for this run of card ${task.id}.\n\n${input}` : `The board resumed this session after it was lost; you are still on card ${task.id}: ${task.title}. Carry on.`;
-      const r = sc([...base, '--key', `board-${task.id}-r${runId}-resume`, '--input', told, '--', '--resume', prev.session_id, ...tail], { timeout: 180_000, as: boardAddress(board.label) });
+      // a session is resumed in its own harness, whatever the lane's is now
+      const its = HARNESSES[prev.harness ?? 'claude-code'] ?? HARNESSES['claude-code'];
+      const r = sc(['open', '--new', its.program, ...base.slice(3), '--key', `board-${task.id}-r${runId}-resume`, '--input', told, '--', ...its.resume(prev.session_id), ...tail], { timeout: 180_000, as: boardAddress(board.label) });
       const pane = r.code === 0 ? lastJson(r.stdout)?.pane ?? null : null;
       // a resume the harness refuses (its transcript is gone) ends the pane at once; another machine's launch
       // answers before that shows, so the pane is looked for again a moment later
-      if (pane && paneSurvives(task.machine, pane)) session = { surface: 'pane', session_id: prev.session_id, machine, pane, mode: 'resume', launched_at: now() };
+      if (pane && paneSurvives(task.machine, pane)) session = { surface: 'pane', session_id: prev.session_id, harness: prev.harness ?? 'claude-code', machine, pane, mode: 'resume', launched_at: now() };
       else replaced = { session_id: prev.session_id, why: r.code === 0 ? `its resume ended as soon as it started (pane ${pane})` : (r.stderr || r.stdout).trim().slice(-300) };
     } else replaced = { session_id: prev.session_id, why: 'its resume never came up' };
   } else if (prev) replaced = { session_id: prev.session_id, why: `the card moved from ${prev.machine} to ${machine}` };
@@ -622,13 +638,20 @@ function launchPane(board, task, runId, lane, fleet, { input = null, slot = 'wor
     throw failed;
   }
   if (!session) {
-    const sid = randomUUID();
-    const r = sc([...base, '--key', `board-${task.id}-r${runId}-${sid.slice(0, 8)}`, '--input', input ?? `Card ${task.id}: ${task.title}`, '--', '--session-id', sid, ...tail], { timeout: 180_000, as: boardAddress(board.label) });
+    let sid = how.namesItself ? null : randomUUID();
+    const r = sc([...base, '--key', `board-${task.id}-r${runId}-${(sid ?? randomUUID()).slice(0, 8)}`, '--input', input ?? `Card ${task.id}: ${task.title}`, '--', ...(sid ? how.fresh(sid) : how.fresh()), ...tail], { timeout: 180_000, as: boardAddress(board.label) });
     if (r.code !== 0) throw new Error(`supercode open --on ${task.machine}: ${(r.stderr || r.stdout).trim().slice(-500)}`);
-    session = { surface: 'pane', session_id: sid, machine, pane: lastJson(r.stdout)?.pane ?? null, mode: 'fresh', launched_at: now(), ...(replaced ? { replaces: replaced.session_id } : {}) };
+    const pane = lastJson(r.stdout)?.pane ?? null;
+    // a harness that names its own session is found in the fleet by the pane the board opened for it
+    for (let waited = 0; !sid && pane && waited < 90_000; waited += 3000) {
+      pause(3000);
+      sid = observeFleet().sessions?.find((f) => f.pane === pane && String(f.address).split(':')[2] === harness)?.address.split(':')[3] ?? null;
+    }
+    if (!sid) throw new Error(`${harness} in pane ${pane ?? '(none)'} on ${task.machine} named no session within 90 s`);
+    session = { surface: 'pane', session_id: sid, machine, pane, mode: 'fresh', launched_at: now(), ...(replaced ? { replaces: replaced.session_id } : {}) };
   }
-  session.harness = 'claude-code';
-  session.address = `sc:${machine}:claude-code:${session.session_id}`;
+  session.harness = session.harness ?? harness;
+  session.address = `sc:${machine}:${session.harness}:${session.session_id}`;
   Object.assign(session, meta);
   const kind = { adopt: 'session_adopted', resume: 'session_resumed', fresh: replaced ? 'session_replaced' : 'session_started' }[session.mode];
   tx(board, (db) => {
@@ -636,7 +659,7 @@ function launchPane(board, task, runId, lane, fleet, { input = null, slot = 'wor
     event(db, task.id, kind, { session_id: session.session_id, machine, pane: session.pane, address: session.address, mode: session.mode, ...(replaced ? { replaced } : {}) }, runId);
     // the working session hears updates to its card; the slot's previous session no longer does (a reviewer starting
     // leaves the implementer's, and a subtask's arc session's, subscription alone)
-    const before = prev ? prev.address ?? `sc:${prev.machine}:claude-code:${prev.session_id}` : null;
+    const before = prev ? addressOf(prev) : null;
     if (before && before !== session.address) db.prepare("DELETE FROM kanban_notify_subs WHERE task_id = ? AND platform = 'supercode' AND chat_id = ?").run(task.id, before);
     subscribeIn(db, task.id, session.address, 'worker');
     // it sees the cards its own depends on change, and works its subtasks
@@ -737,7 +760,7 @@ export function adoptSession(board, id, who, { workspace = null, ttl, assignee =
   const found = fleet.sessions.find((s) => s.address === who || s.address.endsWith(`:${who}`) || s.name === who);
   if (!found) throw new Error(`the fleet lists no live session ${who}`);
   const [, host, harness, sessionId] = found.address.split(':');
-  if (harness !== 'claude-code') throw new Error(`${found.address} is ${harness}; the board resumes claude-code sessions by id`);
+  if (!HARNESSES[harness]) throw new Error(`${found.address} is ${harness}; the board keeps and resumes ${Object.keys(HARNESSES).join(' and ')} sessions`);
   // the session's own working directory, as discovery records it (where `--resume` finds it), else its pane's
   let dir = workspace;
   if (!dir) {
@@ -814,6 +837,27 @@ export function noticeOf(entry, audience, kind, task, payload, comment = null) {
   return text.trim() ? text : null;
 }
 
+/**
+ * Who hears a card without having asked: each running card's session hears its card and its subtasks (a subscription a
+ * launch or a missed fleet read lost comes back), and each of the workflow's managers (`params.managers`) hears every
+ * open card as the `manager` audience, whoever filed it, when the workflow's notify names one.
+ */
+function ensureSubscriptions(board, entry) {
+  const managers = Array.isArray(entry.params.managers) ? entry.params.managers.map(String) : [];
+  const toManagers = Object.keys(entry.workflow.notify?.manager ?? {}).length > 0;
+  tx(board, (db) => {
+    for (const t of db.prepare("SELECT id, current_run_id FROM tasks WHERE status NOT IN ('done', 'archived')").all()) {
+      if (toManagers) for (const m of managers) subscribeIn(db, t.id, m, 'manager');
+      if (!t.current_run_id) continue;
+      const session = json(db.prepare('SELECT metadata FROM task_runs WHERE id = ?').get(t.current_run_id)?.metadata, {})?.supercode;
+      const address = addressOf(session);
+      if (!address || (session.slot ?? 'worker') !== 'worker') continue;
+      subscribeIn(db, t.id, address, 'worker');
+      for (const st of db.prepare('SELECT task_id FROM supercode_cards WHERE subtask_of = ?').all(t.id)) subscribeIn(db, st.task_id, address, 'worker');
+    }
+  });
+}
+
 /** The event kinds an audience hears (the workflow's notify). */
 const heardBy = (entry, audience) => Object.keys(entry.workflow.notify?.[audience] ?? {});
 
@@ -821,7 +865,7 @@ async function notify(board, fleet, report, entry) {
   const from = boardAddress(board.label);
   // each subscription's notices go in order; different subscribers are told side by side
   await pool(subscriptions(board.db).filter((sub) => sub.platform === 'supercode'), SEND_CONCURRENCY, async (sub) => {
-    const role = ['worker', 'dependency'].includes(sub.delivery_metadata?.role) ? sub.delivery_metadata.role : 'creator';
+    const role = ['worker', 'dependency', 'manager'].includes(sub.delivery_metadata?.role) ? sub.delivery_metadata.role : 'creator';
     // a session the fleet does not list this tick is told next tick: one reading is not a loss (a loaded box drops
     // sessions from a read, and a dropped subscription never came back), and a session that is replaced on its card
     // has its subscription moved when the new one starts
@@ -1141,6 +1185,7 @@ export async function tick({ root, lanes, settings, only = null, slugs = null, d
       // what the moves asked for, once they are committed (messages to actors, closed panes, cleaned workspaces)
       await runEffects(board, effects);
       phase('goals');
+      ensureSubscriptions(board, entry);
       await notify(board, fleet, report, entry); phase('notify');
       fireHooks(board, settings, report);
       if (String(board.db.prepare('PRAGMA journal_mode').get()?.journal_mode).toLowerCase() === 'wal') board.db.prepare('PRAGMA wal_checkpoint(PASSIVE)').get();

package/package.json

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