@volter/supercode-orchestrator 0.4.16 → 0.4.17

package/board/cli.mjs

@@ -269,7 +269,7 @@ function callerName() {
 export function summary(r) {
   const parts = [`board ${r.board}:`];
   if (r.error) parts.push(`error ${r.error}`);
-  for (const [k, label] of [['started', 'started'], ['queued', 'waiting'], ['failed', 'failed'], ['lost', 'lost'], ['crashed', 'crashed'], ['timed_out', 'timed out'], ['reclaimed', 'reclaimed'], ['auto_blocked', 'gave up'], ['notified', 'notices']]) {
+  for (const [k, label] of [['mailed', 'mailed updates'], ['started', 'started'], ['queued', 'waiting'], ['failed', 'failed'], ['lost', 'lost'], ['crashed', 'crashed'], ['timed_out', 'timed out'], ['reclaimed', 'reclaimed'], ['auto_blocked', 'gave up'], ['notified', 'notices']]) {
     if (r[k]?.length) parts.push(`${label} ${r[k].length}`);
   }
   if (r.promoted) parts.push(`promoted ${r.promoted}`);

package/board/dispatch.mjs

@@ -15,7 +15,7 @@
 // subscriber's cursor moves only after its notice was delivered, so two dispatchers over one board never both
 // launch and a crash between the two steps is answered by the next tick.
 import { spawn as spawnChild, spawnSync } from 'node:child_process';
-import { existsSync, mkdirSync, readFileSync, openSync } from 'node:fs';
+import { existsSync, mkdirSync, openSync, readdirSync, readFileSync, renameSync } from 'node:fs';
 import { hostname, tmpdir } from 'node:os';
 import { basename, dirname, join } from 'node:path';
 import { randomUUID } from 'node:crypto';
@@ -276,10 +276,11 @@ function opening(board, task, label) {
   const skills = task.skills?.length ? `\nSkills pinned to this card: ${task.skills.join(', ')}.` : '';
   const at = `--root ${board.root}${board.slug !== 'default' ? ` --board ${board.slug}` : ''}`;
   // the board's own door is on the machine that keeps it; a session elsewhere writes to its card through its manager
-  const door = normalMachine(task.machine) === localMachine()
-    ? `\nYour card is yours to keep current: \`supercode workflow show ${task.id} ${at}\` reads it; \`comment\`, \`block --kind <needs_input|capability|transient|dependency>\` `
-      + `and \`review\` update it; \`create <title> --subtask-of ${task.id}\` files a subtask, and \`complete <subtask>\` marks one done. Its reviewers, not you, mark the card itself done.`
-    : '';
+  const local = normalMachine(task.machine) === localMachine();
+  const where = local ? at : `--at ${boardAddress(label)}`;
+  const door = `\nYour card is yours to keep current: \`supercode workflow comment ${task.id} "<text>" ${where}\`, \`block ${task.id} "<why>" --kind <needs_input|capability|transient|dependency> ${where}\` `
+    + `and \`review ${task.id} --summary "<what>" ${where}\` update it; \`create "<title>" --subtask-of ${task.id} ${where}\` files a subtask, and \`complete <subtask> ${where}\` marks one done`
+    + `${local ? '' : ' (each is filed with the board and answered by a board notice)'}. Its reviewers, not you, mark the card itself done.`;
   return `You are the session working card ${task.id} on the ${label} board. The board started you; updates to the card `
     + `(comments, reassignment, blocks, completion) and to the cards it waits on reach you as board notices.${door}${skills}\n\n${context}`;
 }
@@ -479,11 +480,19 @@ function send(from, label, to, body, key) {
   if (r.code !== 0 || answer.code !== 0) throw new Error((answer.text || r.stderr || 'no answer').trim().slice(-300));
 }
 
-function notify(board, report) {
-  const from = `sc:${localMachine()}:board:${board.label.replace(/[^A-Za-z0-9_.-]/g, '-')}`;
+/** The board's own address: where its notices come from and where card updates are mailed. */
+export const boardAddress = (label) => `sc:${localMachine()}:board:${label.replace(/[^A-Za-z0-9_.-]/g, '-')}`;
+
+function notify(board, fleet, report) {
+  const from = boardAddress(board.label);
   for (const sub of subscriptions(board.db)) {
     if (sub.platform !== 'supercode') continue;
     const role = ['worker', 'dependency'].includes(sub.delivery_metadata?.role) ? sub.delivery_metadata.role : 'creator';
+    // a session that worked or watched a card and is gone hears nothing more; a creator is retried until it is back
+    if (role !== 'creator' && fleet.ok && !fleet.alive.has(sub.chat_id)) {
+      tx(board, (db) => db.prepare("DELETE FROM kanban_notify_subs WHERE task_id = ? AND platform = 'supercode' AND chat_id = ?").run(sub.task_id, sub.chat_id));
+      continue;
+    }
     const kinds = MAIL_KINDS[role];
     const events = board.db.prepare(`SELECT id, kind, payload, created_at FROM task_events WHERE task_id = ? AND id > ? AND kind IN (${kinds.map(() => '?').join(', ')}) ORDER BY id`)
       .all(sub.task_id, sub.last_event_id, ...kinds);
@@ -516,6 +525,53 @@ function notify(board, report) {
   }
 }
 
+// ------------------------------------------------------------------ the board's mailbox
+
+const ENTRY = fileURLToPath(new URL('../bin/orchestrator.mjs', import.meta.url));
+const NOT_BY_MAIL = new Set(['serve', 'dispatch', 'init', 'attach']);
+
+/** The board's mailbox on this machine: the directory supercode files mail for `address` in, or null. */
+function mailboxOf(address) {
+  const config = process.env.SUPERCODE_HOME || (process.env.XDG_CONFIG_HOME ? join(process.env.XDG_CONFIG_HOME, 'supercode') : join(process.env.HOME ?? '', '.config', 'supercode'));
+  const root = join(config, 'mail');
+  if (!existsSync(root)) return null;
+  for (const dir of readdirSync(root)) {
+    if (!dir.startsWith('board-')) continue;
+    try { if (readFileSync(join(root, dir, 'address'), 'utf8').trim() === address) return join(root, dir); } catch { /* not a mailbox */ }
+  }
+  return null;
+}
+
+/**
+ * Card updates filed as mail (`supercode workflow <verb> … --at <this board's address>`, from any machine): each is
+ * run as its sender, the session supercode found the command running under, so a card's session gets exactly what
+ * it may do on this machine; the answer goes back as a notice and the envelope is filed as read.
+ */
+function readMailbox(board, address, report) {
+  const box = mailboxOf(address);
+  if (!box || !existsSync(join(box, 'new'))) return;
+  for (const name of readdirSync(join(box, 'new')).filter((n) => n.endsWith('.json')).sort()) {
+    const path = join(box, 'new', name);
+    let envelope;
+    try { envelope = JSON.parse(readFileSync(path, 'utf8')); } catch { continue; }
+    try { renameSync(path, join(box, 'cur', name)); } catch { continue; } // another reader took it
+    const argv = json(envelope.body, {})?.workflow;
+    let answer;
+    if (!Array.isArray(argv) || !argv.length || NOT_BY_MAIL.has(argv[0])) answer = `not applied: a mailed card update is one \`supercode workflow\` verb other than ${[...NOT_BY_MAIL].join(', ')}`;
+    else {
+      const clean = [];
+      for (let i = 0; i < argv.length; i += 1) { if (argv[i] === '--root' || argv[i] === '--board') i += 1; else clean.push(String(argv[i])); }
+      const sid = String(envelope.from ?? '').split(':')[3] ?? '';
+      const r = spawnSync(process.execPath, [ENTRY, 'workflow', ...clean, '--root', board.root, '--board', board.slug], {
+        encoding: 'utf8', timeout: 180_000, env: { ...process.env, CLAUDE_CODE_SESSION_ID: sid, CODEX_THREAD_ID: '' },
+      });
+      answer = `${clean.slice(0, 2).join(' ')}: ${(r.status === 0 ? r.stdout : r.stderr || r.stdout).trim().slice(-600) || `exit ${r.status}`}`;
+    }
+    report.mailed.push([envelope.from, argv?.[0] ?? '?']);
+    try { send(address, board.label, envelope.from, answer, `board-answer-${envelope.id}`); } catch (error) { report.undelivered.push(['mail', envelope.from, String(error.message).slice(-200)]); }
+  }
+}
+
 // ------------------------------------------------------------------ the tick
 
 /** The board's name in notices: the home's owner folder (`…/volter-manager/home` → `volter-manager`), and the slug. */
@@ -533,15 +589,16 @@ export function tick({ root, lanes, settings, only = null, slugs = null, dispatc
   const fleet = needFleet ? observeFleet() : { ok: false, alive: new Set(), online: new Set(), error: 'no pane lanes' };
   const out = [];
   for (const slug of slugs ?? listBoards(root)) {
-    const report = { board: slug, started: [], queued: [], failed: [], lost: [], crashed: [], timed_out: [], reclaimed: [], auto_blocked: [], promoted: 0, unassigned: [], nonspawnable: [], notified: [], undelivered: [], fleet: fleet.ok ? 'read' : fleet.error };
+    const report = { board: slug, mailed: [], started: [], queued: [], failed: [], lost: [], crashed: [], timed_out: [], reclaimed: [], auto_blocked: [], promoted: 0, unassigned: [], nonspawnable: [], notified: [], undelivered: [], fleet: fleet.ok ? 'read' : fleet.error };
     let board;
     try {
       board = openBoard(root, slug);
       board.label = boardLabel(root, slug);
+      readMailbox(board, boardAddress(board.label), report);
       supervise(board, fleet, settings, report);
       report.promoted = recomputeReady(board, settings.failureLimit);
       if (dispatch) start(board, fleet, lanes, settings, report, { only });
-      notify(board, report);
+      notify(board, fleet, report);
       // what a Hermes gateway serves around its dispatcher and this one does not: said by the caller
       report.chat_subscriptions = Number(board.db.prepare("SELECT COUNT(*) AS n FROM kanban_notify_subs WHERE platform != 'supercode'").get().n);
       report.triage = Number(board.db.prepare("SELECT COUNT(*) AS n FROM tasks WHERE status = 'triage'").get().n);

package/package.json

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