@volter/supercode-orchestrator 0.5.15 → 0.5.17

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' && entry.harness && 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

package/board/git-document.mjs

@@ -7,11 +7,11 @@
 // 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, spawn } from 'node:child_process';
-import { readFileSync, statSync, writeFileSync } from 'node:fs';
+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) => {
@@ -24,6 +24,10 @@ const indexed = (cwd, args) => {
 };
 
 const FETCH_EVERY_MS = 15_000;
+/** The background push: `git push`, then its error kept for `behind()` (or the last one cleared when it landed). */
+const PUSH = `const {spawnSync}=require('node:child_process'),fs=require('node:fs');const [branch,failure,temporary]=process.argv.slice(1);
+const r=spawnSync('git',['push','--quiet','origin','HEAD:'+branch],{encoding:'utf8',windowsHide:true});
+try{if(r.status===0)fs.rmSync(failure,{force:true});else{fs.writeFileSync(temporary,String(r.stderr||r.error||'push failed'));fs.renameSync(temporary,failure);}}catch{}`;
 /** 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; } };
 
@@ -84,20 +88,53 @@ export class GitDocument {
     // 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; };
+    // 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();
+    // Node, not a shell: a Windows checkout outside Git Bash has no `sh`. Each push keeps its error in a file of its own
+    // until it ends, so two pushes never write one.
+    const pushing = spawn(process.execPath, ['-e', PUSH, branch, failure, `${failure}.${process.pid}.${Date.now()}.tmp`], { cwd: this.root, stdio: 'ignore', detached: true, windowsHide: 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;
-    if (quiet(this.root, ['fetch', '--quiet', 'origin', branch]) === null) return; // offline: the next round tries again
+    // 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');
   }
 
@@ -109,7 +146,7 @@ export class GitDocument {
   /** 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

@@ -72,6 +72,8 @@ export function openZtrackBoard(marker, { create = false, document = null, seed
   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.15",
+  "version": "0.5.17",
   "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": {