@volter/supercode-orchestrator 0.5.85 → 0.5.86

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

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