@volter/supercode-orchestrator 0.5.86 → 0.5.88

package/board/cli.mjs

@@ -970,6 +970,11 @@ export async function runVerb(argv) {
         say(args, lines.length ? lines.join('\n') : 'nothing would start', args.json ? { would, would_review: reviews } : would);
         return 0;
       }
+      // This process holds the home's lock for the round, so it is the board's owner for it: it registers its pid, which
+      // the daemon takes only because that pid holds the lock, so the card panes it launches as the board are the
+      // board's (SUPERCODE_BOARD_OWNER_PID, commandEnv). A later owner's registration replaces it.
+      try { await machineCall(null, 'harness.v1.boards.register', { root, claim: { pid: process.pid, ppid: process.ppid } }, { timeoutMs: 30_000 }); }
+      catch (error) { current().err(`supercode workflow: the machine daemon did not register this round as the board's owner (${error.message}); card panes it launches may not be the board's\n`); }
       const reports = await tick({ root, lanes, settings, params });
       if (args.json) say(args, '', reports);
       else for (const r of reports) current().out(`${summary(r)}\n`);
@@ -1678,7 +1683,8 @@ async function serve(root, args = {}) {
   // The board's events are published by this machine's connector, not by the dispatcher (D137, D138 step 4): the home is
   // named to the daemon once, and the connector follows its `workflow events` from then on, with or without this serve.
   { let named = null, refusal = null;
-    try { named = await machineCall(null, 'harness.v1.boards.register', { root }, { timeoutMs: 30_000 }); } catch (error) { refusal = error.message; }
+    // this process is the home's owner: it names its pid (its claim), which the daemon takes only if it holds the home's lock
+    try { named = await machineCall(null, 'harness.v1.boards.register', { root, claim: { pid: process.pid, ppid: process.ppid } }, { timeoutMs: 30_000 }); } catch (error) { refusal = error.message; }
     const refused = named?.refused ?? null;
     log(refusal ? `board events: not published; the machine daemon did not take this home: ${refusal}`
       : refused ? `board events: registered, but the team refused this machine's credential (${refused.status}); nothing is published until it is re-enrolled`

package/board/dispatch.mjs

@@ -76,9 +76,11 @@ export function localMachine() {
 /** The supercode command the dispatcher drives. */
 export const supercodeBin = () => process.env.SUPERCODE_BIN || 'supercode';
 
-/** Public CLI calls carry caller attribution; installed clients own transport selection. */
+/** Public CLI calls carry caller attribution; installed clients own transport selection. A command acting as a board
+ *  also names this process, the board's owner (the pid the machine daemon registered it by), so the daemon can hold
+ *  the board's name to its owner (docs/architecture/overview.md, "Who is calling"). */
 export function commandEnv(as = null) {
-  return { ...process.env, ...(as ? { SUPERCODE_CALLER: as } : {}) };
+  return { ...process.env, ...(as ? { SUPERCODE_CALLER: as, SUPERCODE_BOARD_OWNER_PID: String(process.pid) } : {}) };
 }
 
 /**

package/board/runtime-door.mjs

@@ -4,13 +4,18 @@
 import { machineCall } from './doors.mjs';
 
 /**
- * One door call. `machine` null for this machine. `as`: the board this call acts for (`sc:<machine>:board:<name>`),
- * named to the daemon as the caller, which it takes from the process that registered that board's home (machine.mjs).
+ * One door call. `machine` null for this machine. `as`: the board this call acts for (`sc:<machine>:board:<name>`). To
+ * this machine's daemon it is this process's claim, naming the board, from the board's owner (this process, the pid the
+ * daemon registered for its home); to another machine, the board's name as the caller, which that machine takes from
+ * this machine's link (machine.mjs #callerOf).
  */
 export async function runtimeDoor(machine, method, params = {}, { timeout = 60_000, as = null } = {}) {
   try {
     if (!method.startsWith('harness.v1.')) throw Object.assign(new Error('the runtime door accepts harness.v1 methods'), { code: 'invalid_request' });
-    const named = as && !method.startsWith('harness.v1.sessions.') ? { ...params, caller: as } : params;
+    const acting = as && !method.startsWith('harness.v1.sessions.');
+    const named = !acting ? params
+      : machine ? { ...params, caller: as }
+      : { ...params, claim: { pid: process.pid, ppid: process.ppid, session: null, named: as, owner: String(process.pid) } };
     const result = await machineCall(machine, method, named, { timeoutMs: timeout });
     return { code: 0, stdout: `${JSON.stringify(result ?? null)}\n`, stderr: '' };
   } catch (error) {

package/board/workflow.mjs

@@ -6,6 +6,7 @@
 // pane, sending a session a message, cleaning a workspace) is answered as effects the caller runs after commit.
 import { current } from './call.mjs';
 import { notRuntime } from './owner-files.mjs';
+import { machineCall } from './doors.mjs';
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { existsSync, readdirSync, realpathSync, watch, readFileSync } from 'node:fs';
@@ -275,14 +276,16 @@ export async function refreshRelationAnswers(board) {
     const id = json(row.payload, {})?.waiting_on; if (id) ids.add(id);
   }
   const list = [...ids];
-  for (let at = 0; at < list.length; at += 4) await Promise.all(list.slice(at, at + 4).map(async (id) => {
-    try {
-      const { stdout } = await execFileAsync(process.env.SUPERCODE_BIN || 'supercode', ['message', 'show', '--replies', id, '--json'], { encoding: 'utf8', timeout: 20_000, maxBuffer: 1024 * 1024 });
-      const rows = JSON.parse(stdout);
-      if (!Array.isArray(rows)) throw new Error('message door returned no message list');
-      mailboxAnswers.set(id, { answer: rows[0]?.replies?.[0]?.id ?? null, askedOf: rows[0]?.message?.session ?? null });
-    } catch (error) { mailboxAnswers.set(id, { error: `the answer to ${id} could not be read: ${error.message.slice(0, 200)}` }); }
-  }));
+  if (!list.length) return;
+  // one read of this machine's daemon for every id (its header index answers, no process per message)
+  try {
+    const { rows } = await machineCall(null, 'harness.v1.mail.show', { ids: list, replies: true }, { timeoutMs: 20_000 });
+    if (!Array.isArray(rows)) throw new Error('the mail door returned no message list');
+    for (const id of list) {
+      const row = rows.find((item) => item?.id === id);
+      mailboxAnswers.set(id, { answer: row?.replies?.[0]?.id ?? null, askedOf: row?.session ?? null });
+    }
+  } catch (error) { for (const id of list) mailboxAnswers.set(id, { error: `the answer to ${id} could not be read: ${String(error.message).slice(0, 200)}` }); }
 }
 function answerTo(id) {
   const observed = mailboxAnswers.get(id);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-orchestrator",
-  "version": "0.5.86",
+  "version": "0.5.88",
   "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.31",
+    "@volter/teams": "0.2.32",
     "@volter/ztrack": "^2.4.23",
     "yaml": "^2.9.0"
   },