@volter/supercode-orchestrator 0.5.91 → 0.5.93

package/board/cli.mjs

@@ -348,6 +348,7 @@ export async function runVerb(argv) {
   // a caller that is a card's own session (its harness names it; the board recorded which session it launched)
   const listing = ['list','ls'].includes(verb);
   await loadWorkflow(root).catch((error) => { if (verb !== 'init' && verb !== 'boards') throw error; });
+  await readAgentMains(root);
   const sid = listing && !args.mine ? null : callerSession();
   // what this command records is the calling session's act (its address, as its subscriptions name it)
   current().recorded = sid && boardExists(root, slug) ? withBoard((b) => b.db.prepare("SELECT json_extract(metadata, '$.supercode.address') AS address FROM task_runs WHERE json_extract(metadata, '$.supercode.session_id') = ? ORDER BY id DESC LIMIT 1").get(sid)?.address) ?? null : null;
@@ -1371,16 +1372,22 @@ function ownCard(db, sessionId) {
 
 const READS = new Set(['list', 'ls', 'show', 'context', 'runs', 'log', 'tail', 'watch', 'stats', 'assignees', 'diagnostics', 'diag', 'attachments', 'notify-list', 'capacity', 'help', 'init']);
 
-/** The main session of the agent an address names (`sc:<machine>:agent:<name>`, supercode docs/adr/0008-agent-mailbox.md),
- * from its record in the machine's mail root; null for any other address. A manager named by its agent address is
- * that agent's main session on the board. */
-function agentMain(address) {
-  const name = /^sc:[^:\s]+:agent:([^:\s]+)$/.exec(address)?.[1];
-  if (!name) return null;
-  const root = process.env.SUPERCODE_HOME || join(process.env.XDG_CONFIG_HOME || join(homedir(), '.config'), 'supercode');
-  try { return String(JSON.parse(readFileSync(join(root, 'mail', 'agents', `${name}.json`), 'utf8')).main_session ?? '') || null; }
-  catch { return null; }
+/** The main session of each agent the workflow names a manager (`sc:<machine>:agent:<name>`), asked of this machine's
+ *  daemon, which keeps agents' records (mail step 1c), once per call before its verb runs: a manager named by its agent
+ *  address is that agent's main session on the board. None for an agent the daemon does not know, or when it is down. */
+const agentMains = new Map();
+async function readAgentMains(root) {
+  const managers = [(await loadWorkflow(root).catch(() => null))?.params?.managers ?? []].flat().map(String);
+  for (const address of managers) {
+    const name = /^sc:[^:\s]+:agent:([^:\s]+)$/.exec(address)?.[1];
+    if (!name || agentMains.has(address)) continue;
+    let main = null;
+    try { main = (await machineCall(null, 'harness.v1.agent.show', { name, claim: { pid: process.pid, ppid: process.ppid, session: null, named: null, owner: null } }, { timeoutMs: 5_000 }))?.agents?.[0]?.main_session ?? null; }
+    catch { /* not known: the agent is no manager's session in this call */ }
+    agentMains.set(address, typeof main === 'string' && main ? main : null);
+  }
 }
+function agentMain(address) { return agentMains.get(address) ?? null; }
 
 /**
  * Who a caller is on card `cardId`, in the workflow's roles: a signed-in terminal person retains their creator role;
@@ -1665,7 +1672,10 @@ async function serve(root, args = {}) {
   // a refresh's own reports (a configuration it could not read) never start another refresh
   let refreshing = false;
   const refreshNow = () => { if (refreshing) return; refreshing = true; try { events?.refresh(); } finally { refreshing = false; } };
-  events = watchBoard({ root, binary: supercodeBin(), env: commandEnv(), log, onEvent: (key, { uncertain = false, watched, id, board = null } = {}) => {
+  // each board's mail, waited for on this machine's daemon (mail step 1c): the home's boards' own addresses
+  const boardMailboxes = () => ['default', ...(existsSync(join(root, 'kanban', 'boards')) ? readdirSync(join(root, 'kanban', 'boards')) : [])].map((slug) => boardAddress(boardLabel(root, slug)));
+  const mailWaiter = async () => (await machineCall(null, 'harness.v1.mail.board_wait', { boards: boardMailboxes(), timeout: 60 }, { timeoutMs: 90_000 }))?.woken ?? [];
+  events = watchBoard({ root, binary: supercodeBin(), env: commandEnv(), log, mailWaiter, onEvent: (key, { uncertain = false, watched, id, board = null } = {}) => {
     if (key === 'board-registry') { retireHeldBoards(); refreshNow(); return; }
     if (key === 'board-config') {
       if (watched !== undefined && board) heldConfigWatched(board, id ?? key, watched);

package/board/dispatch.mjs

@@ -2466,18 +2466,6 @@ function fireHooks(board, settings, report) {
 
 // ------------------------------------------------------------------ the board's mailbox
 
-/** 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;
-}
-
 /**
  * The board's mailbox takes answers to the questions the board asked (what a card waits on, read by the card's
  * workflow) and notices about it (a machine's event, a delivery notice about a message the board sent), each filed as
@@ -2485,12 +2473,13 @@ function mailboxOf(address) {
  * only once that refusal is filed.
  */
 async 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; }
+  // the board's unread mail, claimed for it by this machine's daemon, the mail folder's one reader (mail step 1c): a
+  // daemon that does not answer leaves it unread for the next round
+  const r = await runtimeDoor(null, 'harness.v1.mail.board_inbox', { root: board.root }, { timeout: 30_000, as: address });
+  const answer = r.code === 0 ? lastJson(r.stdout) : null;
+  if (!answer?.token) return;
+  const handled = [];
+  for (const envelope of answer.envelopes ?? []) {
     const notice = envelope.kind === 'notice' || envelope.reply_via?.mode === 'none';
     // mail that came through a link claims its return address (D200): the board sends nothing there on its own, its
     // refusal included; the refusal is said in the board's report instead
@@ -2500,12 +2489,14 @@ async function readMailbox(board, address, report) {
     } else if (!envelope.in_reply_to && !notice) {
       try {
         await fileMail(board, envelope.from, `${address} takes answers to its questions and notices only; this message was not taken.`, `board-refused-${envelope.id}`);
-      } catch (error) { report.undelivered.push(['mail', envelope.from, String(error.message).slice(-200)]); continue; }
+      } catch (error) { report.undelivered.push(['mail', envelope.from, String(error.message).slice(-200)]); continue; } // given back, unread
       report.mailed.push([envelope.from, 'refused']);
     }
-    try { renameSync(path, join(box, 'cur', name)); } catch { continue; } // another reader took it
+    handled.push(envelope.id);
     if (!envelope.in_reply_to && notice) report.mailed.push([envelope.from, envelope.from === `sc:${localMachine()}:operator:teams-events` ? 'machine_event' : 'notice']);
   }
+  // what was handled is read; the rest is given back unread (a refusal that could not be filed is tried again)
+  await runtimeDoor(null, 'harness.v1.mail.board_ack', { root: board.root, token: answer.token, ids: handled }, { timeout: 30_000, as: address });
 }
 
 // ------------------------------------------------------------------ goals and triage

package/board/wake.mjs

@@ -16,7 +16,7 @@ export function signalBoardWrite(root, actor) {
 }
 
 /** One coalescing queue shared by standalone serve and the hosted dispatcher. */
-export function watchBoard({ root, binary, env, log = () => {}, onEvent = () => {} }) {
+export function watchBoard({ root, binary, env, log = () => {}, onEvent = () => {}, mailWaiter = null }) {
   const watchers = new Map();
   let pending = null, waiter = null, closed = false;
   const wake = (source, at = Date.now(), info = {}) => {
@@ -100,19 +100,20 @@ export function watchBoard({ root, binary, env, log = () => {}, onEvent = () =>
         file(`${store}-wal`, 'board-storage', board);
       }
     }
-    const config = env.SUPERCODE_HOME || (env.XDG_CONFIG_HOME ? join(env.XDG_CONFIG_HOME, 'supercode') : join(env.HOME ?? '', '.config', 'supercode'));
-    const mail = join(config, 'mail');
-    directory(mail, 'mailbox-registry', name => name.startsWith('board-'));
-    if (existsSync(mail)) for (const name of readdirSync(mail)) {
-      if (name.startsWith('board-')) {
-        const inbox = join(mail, name, 'new');
-        // Reading mail moves it out of new/. That removal is not new work and
-        // must not make the dispatcher schedule another tick for its own read.
-        directory(inbox, 'board-mail', file => file.endsWith('.json') && existsSync(join(inbox, file)));
-      }
-    }
   };
   refresh();
+  // A board's mail arriving: waited for on this machine's daemon (mail step 1c), which keeps the mail; never by watching
+  // the mail folder. Woken, it pauses a moment, so a round that has not read it yet does not wake it again at once; a
+  // daemon that does not answer is waited on again after a while (the safety sweep covers what was missed).
+  if (mailWaiter) void (async () => {
+    while (!closed) {
+      let woken = null;
+      try { woken = await mailWaiter(); }
+      catch (error) { tell('board-mail', { uncertain: true }); log(`dispatch wait for board mail: ${error.message}; asked again in 30 s`); await new Promise(done => setTimeout(done, 30_000).unref?.()); continue; }
+      if (closed) break;
+      if (woken?.length) { wake('board-mail'); await new Promise(done => setTimeout(done, 2_000).unref?.()); }
+    }
+  })();
   return {
     refresh,
     wake,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-orchestrator",
-  "version": "0.5.91",
+  "version": "0.5.93",
   "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": {
@@ -25,7 +25,7 @@
   },
   "dependencies": {
     "@volter/supercode-harness-sdk": "^0.3.60",
-    "@volter/teams": "0.2.34",
+    "@volter/teams": "0.2.35",
     "@volter/ztrack": "^2.4.23",
     "yaml": "^2.9.0"
   },