@volter/supercode-orchestrator 0.5.86 → 0.5.87

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/package.json

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