@volter/supercode-orchestrator 0.5.14 → 0.5.15

package/board/dispatch.mjs

@@ -2192,6 +2192,9 @@ export async function tick({ root, lanes, settings, only = null, slugs = null, d
     try {
       board = openBoard(root, slug);
       board.label = boardLabel(root, slug);
+      // A board document committed by a write whose push the remote refused (or never answered) is published by the
+      // round, not left for the next write: a quiet board still reaches its remote.
+      try { board.publishPending?.(); } catch (error) { report.queued.push(['board document', `push pending: ${error.message}`]); }
       // what the dispatcher records on its own is the board's act
       setActor(boardAddress(board.label));
       // where the tick's time goes, phase by phase (ms), printed by `serve --verbose` and in `--json`

package/board/git-document.mjs

@@ -6,8 +6,8 @@
 // the two texts of a board document merged by ztrack's own document merge, in which a hand edit wins its cards. Nothing
 // either side wrote is dropped; a merge that cannot be made stops the push and says why, leaving both texts in the
 // checkout's history.
-import { execFileSync } from 'node:child_process';
-import { readFileSync, writeFileSync } from 'node:fs';
+import { execFileSync, spawn } from 'node:child_process';
+import { readFileSync, statSync, writeFileSync } from 'node:fs';
 import { basename, dirname, relative } from 'node:path';
 
 const git = (cwd, args, input) => execFileSync('git', args, { cwd, encoding: 'utf8', stdio: [input === undefined ? 'ignore' : 'pipe', 'pipe', 'pipe'], ...(input === undefined ? {} : { input }), timeout: 120_000 });
@@ -23,6 +23,10 @@ const indexed = (cwd, args) => {
   }
 };
 
+const FETCH_EVERY_MS = 15_000;
+/** When this checkout last asked its remote (git writes FETCH_HEAD on every fetch, whichever process ran it). */
+const fetchedAt = (root) => { try { return statSync(git(root, ['rev-parse', '--git-path', 'FETCH_HEAD']).trim().replace(/^(?!\/)/, `${root}/`)).mtimeMs; } catch { return 0; } };
+
 export class GitDocument {
   constructor(paths, merge) {
     this.paths = paths;
@@ -46,11 +50,16 @@ export class GitDocument {
     this.warnedDetached = true;
   }
 
-  // Before a write: take what was pushed, so a merged pull request's edit is the document the write starts from.
+  // Before a write: take what was pushed, so a merged pull request's edit is the document the write starts from. The
+  // remote is asked at most every FETCH_EVERY_MS (git's own FETCH_HEAD is the stamp, so every board process shares it):
+  // a fetch on every write put a network round trip on each one. A checkout holding commits its background push did
+  // not land (refused: something was pushed meanwhile) takes what was pushed now and pushes before writing again.
   pull() {
     if (!this.usable) return;
     const branch = this.branch();
     if (!branch) return this.detached();
+    if (this.unpushed(branch)) return this.pushing ? undefined : this.publish(branch, 'board');
+    if (Date.now() - fetchedAt(this.root) < FETCH_EVERY_MS) return;
     if (quiet(this.root, ['fetch', '--quiet', 'origin', branch]) === null) return; // offline: the next write tries again
     const behind = Number(git(this.root, ['rev-list', '--count', `HEAD..origin/${branch}`]).trim());
     if (behind === 0) return;
@@ -72,6 +81,33 @@ export class GitDocument {
     indexed(this.root, ['-c', `user.name=${who}`, '-c', 'user.email=board@supercode.invalid', 'commit', '--quiet', '--author', `${who} <board@supercode.invalid>`, '-m', message, '--', ...files]);
     const branch = this.branch();
     if (!branch) return this.detached();
+    // The push leaves the write's path: the commit is the write, and a push the remote refuses is taken up by the next
+    // write's pull (unpushed commits), which merges what was pushed and pushes before it writes.
+    // While it runs, this process's next write does not push the same commits beside it.
+    const pushing = spawn('git', ['push', '--quiet', 'origin', `HEAD:${branch}`], { cwd: this.root, stdio: 'ignore', detached: true });
+    this.pushing = pushing;
+    const done = () => { if (this.pushing === pushing) this.pushing = null; };
+    pushing.on('error', done); pushing.on('exit', done);
+    pushing.unref();
+  }
+
+  /** The board's round: publish what an earlier write committed and the remote has not taken (a refused or failed
+   *  background push), with the same merge and three attempts a write's pull uses. */
+  publishPending() {
+    if (!this.usable || this.pushing) return;
+    const branch = this.branch();
+    if (!branch || !this.unpushed(branch)) return;
+    if (quiet(this.root, ['fetch', '--quiet', 'origin', branch]) === null) return; // offline: the next round tries again
+    if (this.unpushed(branch)) this.publish(branch, 'board');
+  }
+
+  /** Whether this checkout holds board commits the remote does not have. */
+  unpushed(branch) {
+    return Number(quiet(this.root, ['rev-list', '--count', `origin/${branch}..HEAD`])?.trim() || 0) > 0;
+  }
+
+  /** Push what this checkout holds, taking anything pushed meanwhile. */
+  publish(branch, who) {
     for (let attempt = 0; attempt < 3; attempt++) {
       if (quiet(this.root, ['push', '--quiet', 'origin', `HEAD:${branch}`]) !== null) return;
       if (quiet(this.root, ['fetch', '--quiet', 'origin', branch]) === null) throw new Error('the board documents were committed here but could not be pushed: the remote did not answer');

package/board/ztrack.mjs

@@ -69,7 +69,7 @@ export function openZtrackBoard(marker, { create = false, document = null, seed
   const backing = new ZtrackBoard({ ...config, seed, marker, init, root, slug, compatPath });
   // A board made here is in Hermes's kanban.db at once, not after its first write.
   if (create) backing.exportFollowing();
-  return { db: backing.db, tx: (fn) => backing.tx(fn), close: () => backing.close(), document: backing.path };
+  return { db: backing.db, tx: (fn) => backing.tx(fn), publishPending: () => backing.git?.publishPending(), close: () => backing.close(), document: backing.path };
 }
 
 class ZtrackBoard {

package/package.json

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