@volter/supercode-orchestrator 0.4.39 → 0.4.41

package/bin/orchestrator.mjs

@@ -539,13 +539,18 @@ async function runApply(argv) {
   return 0;
 }
 
+// exit once what was written reached the pipe: a write to a pipe is asynchronous, and process.exit() right after one
+// cuts the output at the pipe's buffer (a board's `list --json` past 64 KiB arrived truncated)
+const flushed = (stream) => new Promise((done) => stream.write('', done));
+const exitAfterFlush = async (code) => { await Promise.all([flushed(process.stdout), flushed(process.stderr)]); process.exit(code); };
+
 async function main() {
   const argv = process.argv.slice(2);
   if (OPERATOR_OPS.includes(argv[0])) {
     try {
       const code = await runOperator(argv[0], argv.slice(1));
       await closeWorld();
-      process.exit(code);
+      await exitAfterFlush(code);
     } catch (error) {
       process.stdout.write(`${JSON.stringify({ ok: false, error: String(error.message ?? error) })}\n`);
       process.exit(1);
@@ -555,7 +560,7 @@ async function main() {
     try {
       const code = await (argv[0] === 'import' ? runImport(argv.slice(1)) : runExport(argv.slice(1)));
       await closeWorld();
-      process.exit(code);
+      await exitAfterFlush(code);
     } catch (error) {
       say('error', { verb: argv[0], message: String(error.message ?? error), name: error.name ?? 'Error' });
       await closeWorld();
@@ -568,11 +573,11 @@ async function main() {
     try {
       const code = await runWorkflow(argv.slice(1));
       await closeWorld();
-      process.exit(code);
+      await exitAfterFlush(code);
     } catch (error) {
       process.stderr.write(`supercode workflow: ${error.message ?? error}\n`);
       await closeWorld();
-      process.exit(1);
+      await exitAfterFlush(1);
     }
   }
   if (argv[0] === 'access') {

package/board/dispatch.mjs

@@ -595,10 +595,10 @@ function launchPane(board, task, runId, lane, fleet, { input = null, slot = 'wor
   tx(board, (db) => {
     setRunSession(db, runId, session);
     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; a session no longer working it does not
-    for (const s of subscriptions(db, task.id)) {
-      if (s.delivery_metadata?.role === 'worker' && s.chat_id !== session.address) db.prepare("DELETE FROM kanban_notify_subs WHERE task_id = ? AND platform = 'supercode' AND chat_id = ?").run(task.id, s.chat_id);
-    }
+    // 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;
+    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
     for (const p of db.prepare('SELECT parent_id FROM task_links WHERE child_id = ?').all(task.id)) subscribeIn(db, p.parent_id, session.address, 'dependency');
@@ -783,11 +783,10 @@ async function notify(board, fleet, report, entry) {
   // 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';
-    // 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));
-      return;
-    }
+    // 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
+    if (role !== 'creator' && fleet.ok && !fleet.alive.has(sub.chat_id)) return;
     const kinds = heardBy(entry, role);
     if (!kinds.length) return;
     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`)

package/board/engine.mjs

@@ -337,12 +337,12 @@ export async function act(board, id, name, { roles = null, payload = {}, extra =
 /** Take card `id` to `status` by the event the workflow says goes there for this caller (`goto`). */
 export async function goto(board, id, status, { roles = null, payload = {} } = {}) {
   const entry = await loadWorkflow(board.root);
-  const { name, from } = tx(board, (db) => {
+  const { name, refusal, from } = tx(board, (db) => {
     roles ??= callerRoles(db, id);
-    return { name: eventTo(db, board, entry, id, status, { roles, payload }), from: statusOf(db, getTask(db, id)) };
+    return { ...eventTo(db, board, entry, id, status, { roles, payload }), from: statusOf(db, getTask(db, id)) };
   });
   if (from === status) return { from, to: status, moved: false, event: null };
-  if (!name) throw new Error(`${id} is ${from}; no event you may send takes it to ${status}`);
+  if (!name) throw new Error(refusal ?? `${id} is ${from}; no event you may send takes it to ${status}`);
   return { ...(await act(board, id, name, { roles, payload })), event: name };
 }
 

package/board/workflow.mjs

@@ -170,8 +170,9 @@ export function fire(db, board, entry, id, name, { roles = [], payload = {}, ext
 
 /**
  * The event that takes card `id` to `status` for a sender in `roles`: the first the card's status (then the workflow)
- * declares whose transition for that sender, with `payload`, goes there. Null when none does. Its validators are
- * the event's own, checked when it is sent.
+ * declares whose transition for that sender, with `payload`, goes there and whose validators hold. Answers
+ * `{ name }`, or `{ name: null, refusal }` with the first validator that stood in the way (null when no event goes
+ * there at all).
  */
 export function eventTo(db, board, entry, id, status, { roles = [], payload = {} } = {}) {
   const { workflow, params } = entry;
@@ -179,11 +180,15 @@ export function eventTo(db, board, entry, id, status, { roles = [], payload = {}
   const task = cardOf(db, id);
   const from = statusOf(db, task);
   const scope = scopeOf(db, board, task, { params, event: payload, extra: { lanes: lanesIn(entry), sender: roles } });
+  let refusal = null;
   for (const name of new Set([...Object.keys(workflow.statuses[from]?.on ?? {}), ...Object.keys(workflow.on ?? {})])) {
     const taken = transitionsFor(workflow, from, name).filter((t) => !t.by?.length || t.by.some((r) => roles.includes(r))).find((t) => holds(t.guard ?? null, scope));
-    if (taken?.target && String(templateValue(taken.target, scope) ?? '') === status) return name;
+    if (!taken?.target || String(templateValue(taken.target, scope) ?? '') !== status) continue;
+    const failed = (taken.validate ?? []).find((v) => !holds(v.expr, scope));
+    if (!failed) return { name };
+    refusal ??= failed.message;
   }
-  return null;
+  return { name: null, refusal };
 }
 
 function cardOf(db, id) {

package/package.json

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