@volter/supercode-orchestrator 0.5.85 → 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/git-document.mjs

@@ -91,21 +91,23 @@ const SETTLE_MS = 10_000;
  *  write awaits this first. A commit waiting out a busy index is not waited for: it stays owed, said. */
 export async function settleDocuments(within = SETTLE_MS) {
   const deadline = Date.now() + within;
+  // until none is left: a step that ran may have queued another (a commit its push follows); a retry whose timer fires
+  // meanwhile joins the chain and is waited for too
+  while (fetching.size || chains.size) {
+    const left = deadline - Date.now();
+    if (left <= 0) { current().err(`board: ${chains.size + fetching.size} git step(s) of the board documents were still running as this process ended; what they owed stays in the checkout for the next process\n`); break; }
+    await Promise.race([Promise.all([...fetching.values(), ...chains.values()]), new Promise((done) => setTimeout(done, left).unref?.())]);
+  }
+  // then what still waits on a timer, said: after the chains, so a retry a step set while settling is said too
   for (const boards of boardsAt.values()) for (const board of boards) if (board.retryTimer) {
     clearTimeout(board.retryTimer); board.retryTimer = null;
     current().err(`board: ${board.owed.length} write${board.owed.length === 1 ? '' : 's'} of the board documents not committed as this process ends (git would not move HEAD); ${board.owed.length === 1 ? 'it stays' : 'they stay'} owed in the checkout (documents that differ from HEAD) for the next process\n`);
   }
-  for (const [root, moves] of filesOwed) if (moves.timer) { clearTimeout(moves.timer); moves.timer = null; current().err(`board: ${moves.files.size} file(s) in ${root} still differ from HEAD as this process ends (what was pushed, not yet written there)\n`); }
+  for (const [root, moves] of filesOwed) if (moves.timer) { clearTimeout(moves.timer); moves.timer = null; current().err(`board: ${moves.files.size} file(s) in ${root} still differ from HEAD as this process ends (what was pushed, not yet written there); the next process to open a board there writes them\n`); }
   for (const [root, sync] of indexOwed) if (sync.timer) {
     clearTimeout(sync.timer); sync.timer = null;
     current().err(`board: git's index in ${root} is still locked as this process ends; its board documents' index entries stay behind HEAD until the next process opens the board\n`);
   }
-  // until none is left: a step that ran may have queued another (a commit its push follows)
-  while (fetching.size || chains.size) {
-    const left = deadline - Date.now();
-    if (left <= 0) { current().err(`board: ${chains.size + fetching.size} git step(s) of the board documents were still running as this process ended; what they owed stays in the checkout for the next process\n`); return; }
-    await Promise.race([Promise.all([...fetching.values(), ...chains.values()]), new Promise((done) => setTimeout(done, left).unref?.())]);
-  }
 }
 /** How long a busy index may hold an index sync before it is said (with its age), once per stretch. */
 const BUSY_SAID_MS = 60_000;
@@ -153,9 +155,28 @@ const filesOwed = new Map();
 function moveFiles(root, files, from, to) {
   const moves = filesOwed.get(root) ?? { files: new Map(), since: null, said: false, delay: 0, timer: null };
   filesOwed.set(root, moves);
-  for (const file of files) moves.files.set(file, { from, to });
+  // a file a second take moves again keeps the base of the first: its working text is still that one's until written
+  for (const file of files) moves.files.set(file, { from: moves.files.get(file)?.from ?? from, to });
+  keepMoves(root);
   if (!moves.timer) onChain(root, () => moveNow(root));
 }
+/** The moves still owed, kept in the checkout's git dir until each is written: a process that ends first leaves them for
+ *  the next one to open a board there (`derive`). */
+const movesPath = (root) => { const checkout = checkoutOf(root); return checkout ? join(checkout.gitDir, 'supercode-board-moves.json') : null; };
+function keepMoves(root) {
+  const path = movesPath(root); if (!path) return;
+  const moves = filesOwed.get(root);
+  try {
+    if (!moves?.files.size) rmSync(path, { force: true });
+    else writeAtomically(path, JSON.stringify(Object.fromEntries(moves.files)));
+  } catch (error) { current().err(`board: the moves owed in ${root} could not be kept (${error.message}); a process that ends before they are written leaves those files differing from HEAD\n`); }
+}
+/** Moves an earlier process left owed, queued again (once per checkout per process). */
+function deriveMoves(root) {
+  const path = movesPath(root); if (!path) return;
+  let kept = null; try { kept = JSON.parse(readFileSync(path, 'utf8')); } catch { return; }
+  for (const [file, { from, to }] of Object.entries(kept ?? {})) if (from && to) moveFiles(root, [file], from, to);
+}
 async function moveNow(root) {
   const moves = filesOwed.get(root);
   if (!moves) return;
@@ -165,13 +186,26 @@ async function moveNow(root) {
       const was = (await quiet(root, ['rev-parse', '-q', '--verify', `${from}:${file}`]))?.trim() || null;
       let exists = true; try { statSync(join(root, file)); } catch { exists = false; }
       const now = exists ? (await git(root, ['hash-object', '--', file])).trim() : null;
-      if (now !== was) { current().err(`board: ${file} in ${root} changed here since what was pushed was merged; it is left as it is (HEAD has the pushed text)\n`); moves.files.delete(file); continue; }
+      if (now !== was) {
+        // already what the take brought (written before a process ended): done; else changed here since, left and said
+        const brought = (await quiet(root, ['rev-parse', '-q', '--verify', `${to}:${file}`]))?.trim() || null;
+        if (now !== brought) current().err(`board: ${file} in ${root} changed here since what was pushed was merged; it is left as it is (HEAD has the pushed text)\n`);
+        // written before a process ended whose index sync was still owed: the index entry follows HEAD now (a file HEAD
+        // lacks leaves the index, so it is not left staged against HEAD)
+        else await git(root, ['reset', '-q', 'HEAD', '--', file]);
+        moves.files.delete(file); continue;
+      }
       const kept = Boolean((await quiet(root, ['rev-parse', '-q', '--verify', `${to}:${file}`]))?.trim());
       if (kept) await git(root, ['checkout', to, '--', file]);
-      else rmSync(join(root, file), { force: true });
+      else {
+        // the index entry first (a busy index retries with the file still in place), then the file
+        await git(root, ['rm', '--cached', '-q', '--ignore-unmatch', '--', file]);
+        rmSync(join(root, file), { force: true });
+      }
       moves.files.delete(file);
     } catch (error) { failed ??= error; }
   }
+  keepMoves(root);
   if (!moves.files.size) { filesOwed.delete(root); return; }
   moves.since ??= Date.now();
   if (!moves.said && Date.now() - moves.since >= BUSY_SAID_MS) {
@@ -234,6 +268,7 @@ export class GitDocument {
     syncIndex(this.root, this.paths.map((path) => this.rel(path)));
     if (pushDerived.has(this.root)) return;
     pushDerived.add(this.root);
+    deriveMoves(this.root);
     const branch = this.branch();
     if (branch) onChain(this.root, async () => { if (await this.unpushed(branch) && !this.pushing) this.pushInBackground(branch); });
   }

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.85",
+  "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"
   },