@volter/supercode-orchestrator 0.4.65 → 0.4.67

package/board/cli.mjs

@@ -10,7 +10,7 @@ import { basename, join, resolve } from 'node:path';
 import { tmpdir } from 'node:os';
 import { read } from '../orchestration.mjs';
 import { holdDispatcherLock } from '../hermes-locks.mjs';
-import { backingOf, boardExists, boardPath, DEFAULT_BOARD, event, json, listBoards, logsDir, now, openBoard, tx } from './store.mjs';
+import { backingOf, boardExists, boardPath, DEFAULT_BOARD, event, json, listBoards, logsDir, now, openBoard, setActor, tx } from './store.mjs';
 import * as engine from './engine.mjs';
 import { adoptSession, boardAddress, boardLabel, boardSettings, callerSession, lanesOf, localMachine, observeFleet, paused, plan, startCard, tick } from './dispatch.mjs';
 import { loadWorkflow, statusOf, useWorkflow, workflowEntry, workflowFor } from './workflow.mjs';
@@ -234,6 +234,8 @@ export async function runWorkflow(argv) {
 
   // a caller that is a card's own session (its harness names it; the board recorded which session it launched)
   const sid = callerSession();
+  // what this command records is the calling session's act (its address, as its subscriptions name it)
+  if (sid) setActor(`sc:${localMachine()}:${sid === process.env.CODEX_THREAD_ID ? 'codex' : 'claude-code'}:${sid}`);
   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); });
   }

package/board/dispatch.mjs

@@ -500,11 +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') {
-    // 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') {
     const run = tx(board, (db) => currentRun(db, e.id));
     const session = run?.metadata?.supercode;
@@ -854,6 +849,25 @@ async function send(from, label, to, body, key, { queue = false, ask = 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, '-')}`;
 
@@ -917,6 +931,8 @@ async function notify(board, fleet, report, entry) {
     try {
       for (const ev of events) {
         const p = json(ev.payload, {}) ?? {};
+        // nobody is told of their own act
+        if (p.by && p.by === sub.chat_id) { cursor = ev.id; continue; }
         let text;
         if (ev.kind === 'commented') {
           if (p.author === sub.chat_id) { cursor = ev.id; continue; }
@@ -1216,6 +1232,7 @@ export async function tick({ root, lanes, settings, only = null, slugs = null, d
       supervise(board, fleet, settings, report, entry, effects); closeRequested(board, report); phase('supervise');
       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/store.mjs

@@ -196,8 +196,14 @@ export function json(text, fallback = null) {
 }
 
 /** Append one event to a card's thread (Hermes's `task_events`); answers its id. */
+// the session whose command this process runs (its address), set by the CLI: each event it records says who acted
+// (`by`), so the session is not told of its own act
+let actor = null;
+export function setActor(address) { actor = address || null; }
+
 export function event(db, taskId, kind, payload = null, runId = null) {
+  const said = actor && !(payload && 'by' in payload) ? { ...(payload ?? {}), by: actor } : payload;
   const r = db.prepare('INSERT INTO task_events (task_id, run_id, kind, payload, created_at) VALUES (?, ?, ?, ?, ?)')
-    .run(taskId, runId, kind, payload ? JSON.stringify(payload) : null, now());
+    .run(taskId, runId, kind, said ? JSON.stringify(said) : null, now());
   return Number(r.lastInsertRowid);
 }

package/board/workflow.mjs

@@ -534,15 +534,16 @@ 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;
-    ctx.effects.push({ kind: 'tell', id: ctx.id, to: String(to), text: `${String(text ?? '')}\n\nAnswer with reply_to ${id}.`, messageId: 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.65",
+  "version": "0.4.67",
   "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": {