@volter/supercode-orchestrator 0.4.55 → 0.4.57

package/board/cli.mjs

@@ -164,7 +164,7 @@ async function laneState(root) {
 
 /** The caller's own supercode address, when it is a session supercode can reach (for its card's notices). */
 function callerAddress() {
-  const id = process.env.CLAUDE_CODE_SESSION_ID || process.env.CODEX_THREAD_ID;
+  const id = callerSession();
   if (!id) return null;
   const fleet = observeFleet();
   return [...fleet.alive].find((a) => a.endsWith(`:${id}`)) ?? null;
@@ -233,7 +233,7 @@ export async function runWorkflow(argv) {
   const ids = (first = rest) => [...first, ...(args.ids ?? [])];
 
   // a caller that is a card's own session (its harness names it; the board recorded which session it launched)
-  const sid = process.env.CLAUDE_CODE_SESSION_ID || process.env.CODEX_THREAD_ID;
+  const sid = callerSession();
   if (sid && !READS.has(verb) && boardExists(root, slug)) {
     withBoard((b) => { const own = ownCard(b.db, sid); if (own) authorize(b.db, verb, rest, args, own); });
   }
@@ -266,7 +266,7 @@ 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(),
-        sessionId: process.env.CLAUDE_CODE_SESSION_ID ?? null, subtaskOf: args['subtask-of'] ?? null, initialStatus: args['initial-status'] ?? 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 };

package/board/dispatch.mjs

@@ -72,6 +72,31 @@ const lastJson = (text) => {
  * What supercode reports about the fleet now: `{ ok, alive: Set<address>, online: Set<machine>, error }`. `alive` is
  * every session that can be messaged on every machine; `online` every enrolled machine connected to the team.
  */
+/**
+ * The session a command runs in. Each harness names its own in a variable (Claude Code CLAUDE_CODE_SESSION_ID, Codex
+ * CODEX_THREAD_ID), and a pane inherits every variable the program that started its terminal server had, so a Codex
+ * pane can carry a Claude session's id too: the nearest harness among the command's ancestors says which is its own.
+ */
+export function callerSession() {
+  const claude = process.env.CLAUDE_CODE_SESSION_ID || null;
+  const codex = process.env.CODEX_THREAD_ID || null;
+  if (!claude || !codex) return claude ?? codex;
+  const table = spawnSync('ps', ['-A', '-o', 'pid=,ppid=,comm='], { encoding: 'utf8' });
+  const processes = new Map();
+  for (const row of String(table.stdout ?? '').split('\n')) {
+    const m = row.trim().match(/^(\d+)\s+(\d+)\s+(.*)$/);
+    if (m) processes.set(Number(m[1]), { parent: Number(m[2]), name: basename(m[3]) });
+  }
+  for (let pid = process.ppid, depth = 0; pid > 1 && depth < 64; depth++) {
+    const p = processes.get(pid);
+    if (!p) break;
+    if (p.name === 'codex') return codex;
+    if (/^claude(\.exe)?$/.test(p.name)) return claude;
+    pid = p.parent;
+  }
+  return claude;
+}
+
 export function observeFleet() {
   const list = sc(['message', 'list', '--json']);
   const sessions = list.code === 0 ? json(list.stdout.trim(), null) : null;
@@ -491,7 +516,7 @@ export async function sessionEffect(board, e) {
       const session = json(row.metadata, {})?.supercode;
       if ((session?.slot ?? 'worker') !== e.slot || !session?.pane || session.closed_at) continue;
       // the session that sent the event is not closed under its own command: the dispatcher closes it next tick
-      const caller = process.env.CLAUDE_CODE_SESSION_ID || process.env.CODEX_THREAD_ID;
+      const caller = callerSession();
       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
@@ -837,6 +862,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] ?? {});
 
@@ -844,7 +890,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
@@ -1164,6 +1210,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.55",
+  "version": "0.4.57",
   "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": {