@volter/supercode-orchestrator 0.4.64 → 0.4.66

package/board/cli.mjs

@@ -1133,6 +1133,7 @@ async function serve(root, args = {}) {
           stuck[r.board] = r.ready_waiting && !r.started.length && !r.paused ? (stuck[r.board] ?? 0) + 1 : 0;
           if (stuck[r.board] >= 6 && Date.now() - (warned[r.board] ?? 0) >= 300_000) { log(`board ${r.board} stuck: ${r.ready_waiting} ready card(s) and nothing started for ${stuck[r.board]} ticks; \`supercode workflow diagnostics\``); warned[r.board] = Date.now(); }
           for (const [t, why] of r.failed) log(`  ${t} did not start: ${why}`);
+          for (const [t, why] of r.unsettled ?? []) log(`  ${t} could not be read: ${why}`);
           for (const [t, s, m] of r.started) log(`  ${t} started ${s} (${m})`);
           for (const [t, to, why] of r.undelivered) log(`  notice for ${t} to ${to} not delivered: ${why}`);
         }

package/board/dispatch.mjs

@@ -500,10 +500,6 @@ function observeIdle(board, fleet, settings, report, entry, effects) {
 
 /** A session effect a committed move asked for: a message to the card's current actor, or closing a slot's pane. */
 export async function sessionEffect(board, e) {
-  if (e.kind === 'tell') {
-    await send(boardAddress(board.label), board.label, e.to, e.text, `board-tell-${e.id}-${now()}`);
-    return;
-  }
   if (e.kind === 'send_to_actor') {
     const run = tx(board, (db) => currentRun(db, e.id));
     const session = run?.metadata?.supercode;
@@ -840,10 +836,11 @@ function deliverNow(board, to, body, key) {
   sc(['message', 'remote-deliver'], { input: JSON.stringify(request), timeout: 120_000 });
 }
 
-async function send(from, label, to, body, key, { queue = false } = {}) {
+async function send(from, label, to, body, key, { queue = false, ask = false } = {}) {
   const request = {
     op: 'send', from, from_name: `${label} board`, to, queue, id: key,
-    body: `[Board notice from the ${label} board] ${body}\n\n(An automated notice from the board's dispatcher; replies to this address go nowhere.)`,
+    // a question the board waits on is answered by a reply; a notice is not
+    body: ask ? `[A question from the ${label} board] ${body}` : `[Board notice from the ${label} board] ${body}\n\n(An automated notice from the board's dispatcher; replies to this address go nowhere.)`,
   };
   // a delivery to a busy session can take a minute on a loaded machine; what it answered is the verdict (a process
   // killed after it answered `code: 0` delivered)
@@ -852,6 +849,25 @@ async function send(from, label, to, body, key, { queue = false } = {}) {
   if (answer.code !== 0) throw new Error((answer.text || r.stderr || `no answer (exit ${r.code})`).trim().slice(-300));
 }
 
+/**
+ * The messages the workflow has the board send (`tell`, `ask`: board_message events) that it has not sent yet, sent now
+ * and marked board_message_sent. A question goes under the id its card waits on; a resend of a sent one is a no-op
+ * (the id is the send's idempotency key). One that fails is tried again next tick.
+ */
+async function sendBoardMessages(board, report) {
+  const rows = tx(board, (db) => db.prepare(`SELECT id, task_id, payload FROM task_events e WHERE kind = 'board_message' AND NOT EXISTS
+    (SELECT 1 FROM task_events s WHERE s.kind = 'board_message_sent' AND s.task_id = e.task_id AND json_extract(s.payload, '$.event') = e.id) ORDER BY id`).all());
+  for (const row of rows) {
+    const m = json(row.payload, {}) ?? {};
+    try {
+      await send(boardAddress(board.label), board.label, m.to, m.text, m.message_id ?? `board-message-${row.id}`, { ask: Boolean(m.message_id) });
+      tx(board, (db) => event(db, row.task_id, 'board_message_sent', { event: row.id, to: m.to, ...(m.message_id ? { message_id: m.message_id } : {}) }));
+    } catch (error) {
+      report.undelivered.push([row.task_id, m.to, String(error.message).slice(-200)]);
+    }
+  }
+}
+
 /** 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, '-')}`;
 
@@ -1097,6 +1113,8 @@ function readMailbox(board, address, report) {
     let envelope;
     try { envelope = JSON.parse(readFileSync(path, 'utf8')); } catch { continue; }
     try { renameSync(path, join(box, 'cur', name)); } catch { continue; } // another reader took it
+    // an answer to a question the board asked is what a card waits on (read by the card's workflow), not a verb
+    if (envelope.in_reply_to) continue;
     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(', ')}`;
@@ -1210,7 +1228,9 @@ export async function tick({ root, lanes, settings, only = null, slugs = null, d
       readMailbox(board, boardAddress(board.label), report); phase('mailbox');
       const effects = [];
       supervise(board, fleet, settings, report, entry, effects); closeRequested(board, report); phase('supervise');
-      report.promoted = recomputeReady(board);
+      report.unsettled = [];
+      report.promoted = recomputeReady(board, effects, report.unsettled);
+      await sendBoardMessages(board, report);
       const before = report.started.length;
       if (dispatch) startCards(board, fleet, lanes, settings, report, entry, effects, { only, hostRunning });
       hostRunning += report.started.length - before; phase('start');

package/board/engine.mjs

@@ -367,14 +367,18 @@ function stopWorker(board, runId) {
   if (worker?.surface === 'headless' && worker.pid) terminate(Number(worker.pid));
 }
 
-/** Every card whose workflow status has an `always` move that holds takes it (the tick's recompute). Answers how many moved. */
-export function recomputeReady(board) {
+/**
+ * Every card whose workflow status has an `always` or due `after` move that holds takes it (the tick's recompute).
+ * What the moves ask for (a message, a closed pane) joins `effects`; a card whose moves could not be read (a door its
+ * expressions call failed) is left where it is and named in `errors`. Answers how many moved.
+ */
+export function recomputeReady(board, effects = [], errors = []) {
   const entry = workflowFor(board.root);
   return tx(board, (db) => {
     let moved = 0;
     for (const { id } of all(db, "SELECT id FROM tasks WHERE status NOT IN ('done', 'archived')")) {
       const before = statusOf(db, getTask(db, id));
-      settle(db, board, entry, id);
+      try { settle(db, board, entry, id, effects); } catch (error) { errors.push([id, String(error.message).slice(-300)]); continue; }
       if (statusOf(db, getTask(db, id)) !== before) moved += 1;
     }
     return moved;

package/board/workflow.mjs

@@ -5,6 +5,7 @@
 // the engine's primitives (the rows Hermes's tables hold); the I/O an action asks for (stopping a worker, closing a
 // pane, sending a session a message, cleaning a workspace) is answered as effects the caller runs after commit.
 import { spawnSync } from 'node:child_process';
+import { randomBytes } from 'node:crypto';
 import { event as record, json, now } from './store.mjs';
 import { evaluate, holds, render } from './expr.mjs';
 
@@ -83,7 +84,11 @@ function lastCommitAt(path, id) {
 function answerTo(id) {
   if (!id) return null;
   const r = spawnSync(process.env.SUPERCODE_BIN || 'supercode', ['message', 'show', '--replies', id, '--json'], { encoding: 'utf8', timeout: 20_000 });
-  try { return JSON.parse(r.stdout)?.[0]?.replies?.[0]?.id ?? null; } catch { return null; }
+  let rows = null;
+  try { rows = JSON.parse(r.stdout); } catch { /* read below */ }
+  // a door that cannot answer is said, never read as "no answer yet": a wait would silently never end
+  if (!Array.isArray(rows)) throw new Error(`the answer to ${id} could not be read (supercode message show --replies): ${(r.stderr || r.stdout || r.error?.message || `exit ${r.status}`).trim().slice(-200)}`);
+  return rows[0]?.replies?.[0]?.id ?? null;
 }
 
 const OPEN_OUTCOME = /^(\s*[-*] )\[ \] (.+)$/;
@@ -107,7 +112,10 @@ function onlyTicks(was, body) {
 function askedOf(id) {
   if (!id) return null;
   const r = spawnSync(process.env.SUPERCODE_BIN || 'supercode', ['message', 'show', id, '--json'], { encoding: 'utf8', timeout: 20_000 });
-  try { return JSON.parse(r.stdout)?.[0]?.message?.session ?? null; } catch { return null; }
+  let rows = null;
+  try { rows = JSON.parse(r.stdout); } catch { /* read below */ }
+  if (!Array.isArray(rows)) throw new Error(`who ${id} was sent to could not be read (supercode message show): ${(r.stderr || r.stdout || r.error?.message || `exit ${r.status}`).trim().slice(-200)}`);
+  return rows[0]?.message?.session ?? null;
 }
 
 /** The scope an expression is evaluated in: the card (with its relations), the event, params, time, extras. */
@@ -526,8 +534,17 @@ const ACTIONS = {
       return;
     }
   },
-  // a message from the board to a session (`to`: its address)
-  tell(ctx, { to, text }) { if (to) ctx.effects.push({ kind: 'tell', id: ctx.id, to: String(to), text: String(text ?? '') }); },
+  // a message from the board to a session (`to`: its address), kept on the card as a board_message event until the
+  // dispatcher has sent it: a move settled by any verb (a list settles too) is never lost with its effects
+  tell(ctx, { to, text }) { if (to) record(ctx.db, ctx.id, 'board_message', { to: String(to), text: String(text ?? '') }, null); },
+  // a question from the board to a session, sent under a message id chosen now: `{{asked}}` in the actions after it is
+  // that id (what a block waits on), and the answer to it lands in the board's mailbox
+  ask(ctx, { to, text }) {
+    if (!to) throw new Error(`the workflow asks nobody about ${ctx.id} (ask.to is empty)`);
+    const id = `m-${randomBytes(12).toString('hex')}`;
+    ctx.scope.asked = id;
+    record(ctx.db, ctx.id, 'board_message', { to: String(to), text: `${String(text ?? '')}\n\nAnswer with reply_to ${id}.`, message_id: id }, null);
+  },
   send_to_actor(ctx, text) { ctx.effects.push({ kind: 'send_to_actor', id: ctx.id, text }); },
 };
 

package/package.json

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