@volter/supercode-orchestrator 0.4.63 → 0.4.65

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

@@ -501,7 +501,8 @@ 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()}`);
+    // an ask is sent under the id the card's block waits on
+    await send(boardAddress(board.label), board.label, e.to, e.text, e.messageId ?? `board-tell-${e.id}-${now()}`, { ask: Boolean(e.messageId) });
     return;
   }
   if (e.kind === 'send_to_actor') {
@@ -840,10 +841,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)
@@ -1097,6 +1099,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 +1214,8 @@ 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);
       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,14 +84,38 @@ 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*[-*] )\[ \] (.+)$/;
+/** Whether `body` is `was` with only outcomes ticked: each changed line was `- [ ] X` and is now `- [x] X` or
+ *  `- [x] X: <pointer>`; no other line added, removed or changed. */
+function onlyTicks(was, body) {
+  if (typeof body !== 'string') return false;
+  const before = String(was ?? '').split('\n');
+  const after = body.split('\n');
+  if (before.length !== after.length) return false;
+  return before.every((line, i) => {
+    if (line === after[i]) return true;
+    const open = OPEN_OUTCOME.exec(line);
+    if (!open) return false;
+    const ticked = `${open[1]}[x] ${open[2]}`;
+    return after[i] === ticked || (after[i].startsWith(`${ticked}: `) && after[i].length > ticked.length + 2);
+  });
 }
 
 /** The session message `id` was filed for (`supercode message show`): who was asked; or null. */
 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. */
@@ -130,6 +155,8 @@ export function scopeOf(db, board, task, { params, event = {}, extra = {} } = {}
     // the message whose answer the standing block waits for (`block --waiting-on`), and that answer's id once it has landed
     waiting_on: waitingOn,
     answer: () => answerTo(waitingOn),
+    // whether an edit of its text only ticks outcome lines (the card's own session's door to its acceptance)
+    only_ticks: (body) => onlyTicks(task.body, body),
     asked_of: () => askedOf(waitingOn),
     last_block_event: one(db, "SELECT kind FROM task_events WHERE task_id = ? AND kind IN ('blocked', 'unblocked') ORDER BY id DESC LIMIT 1", task.id)?.kind ?? null,
     // where the latest interruption says the card resumes (any status the workflow declares); none recorded: null
@@ -509,6 +536,14 @@ const ACTIONS = {
   },
   // 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 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;
+    ctx.effects.push({ kind: 'tell', id: ctx.id, to: String(to), text: `${String(text ?? '')}\n\nAnswer with reply_to ${id}.`, messageId: id });
+  },
   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.63",
+  "version": "0.4.65",
   "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": {