@volter/supercode-orchestrator 0.5.14 → 0.5.16

package/board/capacity.mjs

@@ -46,7 +46,7 @@ function sessionsOf(db, taskId) {
  * own transcript reports it runs, or null where none can be read; `machineOf` normalises a machine name; `lanes` gives
  * a profile's harness and model.
  */
-export function holdings(board, { lanes, fleetOk, alive, liveRecord, modelOf = () => null, storedOf = null, machineOf }) {
+export function holdings(board, { lanes, fleetOk, alive, liveRecord, modelOf = () => null, storedOf = null, machineOf, home = null }) {
   const out = [];
   const rows = board.db.prepare("SELECT t.id, t.status, t.assignee, t.current_run_id, t.model_override, c.machine, c.subtask_of FROM tasks t LEFT JOIN supercode_cards c ON c.task_id = t.id WHERE t.status != 'archived'").all();
   for (const row of rows) {
@@ -56,7 +56,8 @@ export function holdings(board, { lanes, fleetOk, alive, liveRecord, modelOf = (
       // what the board stores for an arc is read through its workflow's stored_as rules now, never the column a write has
       // not yet brought up to date (a paused card counted as running until its row caught up)
       stored: !row.subtask_of && storedOf ? storedOf(row.id) : row.status,
-      machine: row.machine ? machineOf(row.machine) : null,
+      // a card that names no machine runs on this home's: a cap on this machine counts it
+      machine: row.machine ? machineOf(row.machine) : home,
       model: row.model_override ?? lane.model ?? null, harness: lane.harness ?? null,
     };
     // a session's model: what its transcript reports, else what its launch resolved, else the card's
@@ -165,7 +166,10 @@ export function capacity(caps, held, evaluate) {
       for (const counts of ['runs', 'cards', 'sessions', 'turns', 'starts']) {
         const had = things.find((x) => x.card === entry.card && x.counts === counts);
         // the card is counted already: it is now in the status its start moved it to
-        if (had) { if (counts === 'cards') Object.assign(had, { status: entry.status, stored: entry.stored, model: had.model ?? entry.model, harness: had.harness ?? entry.harness }); }
+        // the start is the card's next run, in its assignee's harness and model now (a card reassigned from Codex to
+        // Claude Code counts against Claude Code's caps from this start, not as the harness its last session ran)
+        if (had && counts === 'sessions' && had.harness !== entry.harness) things.push({ ...entry, counts });
+        else if (had) { if (counts !== 'sessions' && counts !== 'turns') Object.assign(had, { status: entry.status, stored: entry.stored, model: entry.model ?? had.model, harness: entry.harness ?? had.harness, machine: entry.machine ?? had.machine }); }
         else things.push({ ...entry, counts });
       }
     },

package/board/dispatch.mjs

@@ -459,7 +459,7 @@ function homeHoldings(root, slugs, lanes, fleet, entry) {
       try {
         b.slug ??= slug; b.label ??= boardLabel(root, slug);
         const storedOf = (id) => storedStatus(b.db, b, entry, id).stored;
-        out.push(...holdings(b, { lanes, fleetOk: fleet.ok, alive: (s) => sessionAlive(fleet, s), liveRecord: live, modelOf: transcriptModel, storedOf, machineOf: normalMachine }));
+        out.push(...holdings(b, { lanes, fleetOk: fleet.ok, alive: (s) => sessionAlive(fleet, s), liveRecord: live, modelOf: transcriptModel, storedOf, machineOf: normalMachine, home: localMachine() }));
       }
       finally { b.close(); }
     } catch { /* its own tick reports it */ }
@@ -569,7 +569,7 @@ function startCards(board, fleet, lanes, settings, report, entry, effects, { onl
   });
   // the caps, over what the home holds now; what each candidate would be once started
   const caps = capacity(d.capacity, held, evaluate);
-  const entryOf = (c) => ({ card: c.task.id, board: board.slug, machine: c.task.machine ? normalMachine(c.task.machine) : null, assignee: c.plan.profile ?? null,
+  const entryOf = (c) => ({ card: c.task.id, board: board.slug, machine: normalMachine(c.task.machine ?? localMachine()), assignee: c.plan.profile ?? null,
     status: c.plan.target, stored: c.plan.target, model: c.task.model_override ?? c.plan.lane?.model ?? held.defaults?.[c.plan.lane?.harness] ?? null, harness: c.plan.lane?.harness ?? null });
   const waitingEntries = candidates.map(entryOf);
   // a dry run (dispatch --dry-run) plans the same way and writes nothing: no notes, no moves, no launches
@@ -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,12 +6,12 @@
 // 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, rmSync, 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 });
-const quiet = (cwd, args) => { try { return git(cwd, args); } catch { return null; } };
+const git = (cwd, args, input, timeout = 120_000) => execFileSync('git', args, { cwd, encoding: 'utf8', stdio: [input === undefined ? 'ignore' : 'pipe', 'pipe', 'pipe'], ...(input === undefined ? {} : { input }), timeout });
+const quiet = (cwd, args, timeout) => { try { return git(cwd, args, undefined, timeout); } catch { return null; } };
 // Another board process (or the manager's own git) may hold git's index for a moment: its index.lock is waited out, not
 // raced. The board keeps no lock of its own (ADR 0003).
 const indexed = (cwd, args) => {
@@ -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,8 +81,66 @@ 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.
+    // Writes that land while it runs are one more push after it (a burst publishes in two pushes, not one per write).
+    if (this.pushing) { this.again = true; return; }
+    this.pushInBackground(branch);
+  }
+
+  /** `git push` beside the process, outliving it. Its refusal is kept where `behind()` reads it, and cleared by a push
+   *  that lands. */
+  pushInBackground(branch) {
+    const failure = this.failurePath();
+    const pushing = spawn('sh', ['-c', 'git push --quiet origin "HEAD:$1" 2>"$2.tmp" && rm -f "$2" "$2.tmp" || mv -f "$2.tmp" "$2"', 'push', branch, failure], { cwd: this.root, stdio: 'ignore', detached: true });
+    this.pushing = pushing; this.again = false;
+    const done = () => {
+      if (this.pushing !== pushing) return;
+      this.pushing = null;
+      if (this.again) this.pushInBackground(branch);
+    };
+    pushing.on('error', done); pushing.on('exit', done);
+    pushing.unref();
+  }
+
+  failurePath() {
+    return git(this.root, ['rev-parse', '--git-path', 'supercode-board-push.err']).trim().replace(/^(?!\/)/, `${this.root}/`);
+  }
+
+  /** The board documents' publish when it is behind: commits the remote lacks, the oldest one's time and the last push's
+   *  error; null when the remote has everything (or this checkout pushes nowhere). Local reads only, no network. */
+  behind() {
+    if (!this.usable) return null;
+    const branch = this.branch();
+    if (!branch) return null;
+    const times = (quiet(this.root, ['log', '--format=%ct', `origin/${branch}..HEAD`]) ?? '').trim().split('\n').filter(Boolean).map(Number);
+    if (!times.length) return null;
+    let error = null;
+    try { error = readFileSync(this.failurePath(), 'utf8').split('\n').map((line) => line.replace(/\s+/g, ' ').trim()).find(Boolean) ?? null; } catch { /* none recorded */ }
+    return { commits: times.length, since: Math.min(...times) * 1000, error };
+  }
+
+  /** 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;
+    // A remote that hangs costs the round 15 s, not git's two minutes.
+    if (quiet(this.root, ['fetch', '--quiet', 'origin', branch], 15_000) === 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, ['push', '--quiet', 'origin', `HEAD:${branch}`]) !== null) { try { rmSync(this.failurePath(), { force: true }); } catch { /* none */ } 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');
       this.integrate(branch, who);
     }

package/board/ztrack.mjs

@@ -69,9 +69,11 @@ 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 };
 }
 
+const behindSaid = new Set();
+
 class ZtrackBoard {
   constructor({ document, seed, marker, init, root, slug, compatPath, commit = false, manager = null }) {
     this.path = resolve(dirname(marker), document);
@@ -83,6 +85,14 @@ class ZtrackBoard {
     // own work; the backing commits only the writes the manager does not make.
     this.manager = manager;
     this.git = commit ? new GitDocument([this.path, this.archive], (base, theirs, ours, path) => { try { return this.codec.mergeBoardDocument(base, theirs, ours, path)?.text ?? null; } catch { return null; } }) : null;
+    // A publish that is behind is said once per process, on whichever workflow verb opened the board: a refused push
+    // surfaces on the next call instead of only in the dispatcher's report, and stops being said once the push lands.
+    if (this.git && !behindSaid.has(this.path)) {
+      behindSaid.add(this.path);
+      const late = this.git.behind();
+      // A push younger than a minute is still on its way.
+      if (late && Date.now() - late.since > 60_000) process.stderr.write(`board: warning: ${late.commits} board document commit${late.commits === 1 ? '' : 's'} not published since ${new Date(late.since).toISOString().slice(0, 16)}Z${late.error ? ` (last push: ${late.error})` : ''}; the dispatcher's next round retries\n`);
+    }
     this.seed = seed; this.root = root; this.slug = slug; this.init = init; this.compatPath = compatPath;
     this.file = `${marker}.board.db`;
     mkdirSync(dirname(this.path), { recursive: true });

package/package.json

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