@volter/supercode-orchestrator 0.5.57 → 0.5.59

package/board/ci.mjs

@@ -4,7 +4,7 @@ import { spawnSync } from 'node:child_process';
 import { readFileSync, realpathSync, writeFileSync, renameSync, statSync } from 'node:fs';
 import { dirname, join, relative } from 'node:path';
 import { createHash } from 'node:crypto';
-import { branchCheckouts, checkoutOf, resolveWorkspace } from './workspace.mjs';
+import { branchCheckouts, checkoutOf, isLocalWorkspace, resolveWorkspace } from './workspace.mjs';
 
 // GitHub is read through its REST API with Node's own fetch, not the gh binary: Node takes a World's trust bundle and
 // injector (NODE_EXTRA_CA_CERTS, NODE_OPTIONS), so a review World's GitHub twin answers it, where gh (Go) trusts only
@@ -128,17 +128,23 @@ export const candidatePullRequests = (ci) => ci?.prs ?? (ci?.pr ? [{ repository:
 // The repository a checkout declares (remote.origin.url), not where a URL rewrite sends its transport.
 const originOf = (path) => /(?:github\.com[:/])([^/]+\/[^/]+?)(?:\.git)?$/.exec(run('git', ['config', '--get', 'remote.origin.url'], path))?.[1] ?? null;
 
+/** The card's checkout as its machine answers for it (path, repository, branch), and whether it is on this machine:
+ *  git runs only in a checkout here, and another machine's is known by what its door said. */
 function repositoryWorkspace(board, id) {
   const task = board.db.prepare('SELECT t.*,c.subtask_of,c.workspace_anchor,c.machine FROM tasks t LEFT JOIN supercode_cards c ON c.task_id=t.id WHERE t.id=?').get(id);
   const parent = task?.subtask_of && board.db.prepare('SELECT t.*,c.workspace_anchor,c.machine FROM tasks t LEFT JOIN supercode_cards c ON c.task_id=t.id WHERE t.id=?').get(task.subtask_of);
   const workspace = task?.workspace_kind === 'scratch' ? parent : task;
-  return workspace?.workspace_kind !== 'scratch' && workspace?.workspace_anchor ? resolveWorkspace(workspace, false).path : workspace?.workspace_kind !== 'scratch' ? workspace?.workspace_path : null;
+  if (!workspace || workspace.workspace_kind === 'scratch') return null;
+  const here = isLocalWorkspace(workspace);
+  if (workspace.workspace_anchor) return { ...resolveWorkspace(workspace, false), here };
+  return workspace.workspace_path ? { path: workspace.workspace_path, here } : null;
 }
 
 const pullRequestLists = new Map();
 
 function branchCheckout(board, id, repository, branch) {
   const task = board.db.prepare('SELECT c.machine FROM tasks t LEFT JOIN supercode_cards c ON c.task_id=t.id WHERE t.id=?').get(id);
+  if (!isLocalWorkspace(task ?? {})) return null;
   try { return checkoutOf(task?.machine, repository, branch)?.path ?? null; } catch { return null; }
 }
 
@@ -179,9 +185,9 @@ export function openReviewPullRequests(board, id) {
   const own = repositoryWorkspace(board, id);
   if (!own) return null;
   const task = board.db.prepare('SELECT branch_name FROM tasks WHERE id=?').get(id);
-  const ownRepository = originOf(own);
+  const ownRepository = own.repository ?? (own.here ? originOf(own.path) : null);
   if (!ownRepository) return null;
-  const current = task?.branch_name ? null : run('git', ['branch', '--show-current'], own);
+  const current = task?.branch_name ? null : own.branch ?? (own.here ? run('git', ['branch', '--show-current'], own.path) : null);
   let branch = task?.branch_name ?? (current || null);
   const registered = registeredBranches(board, id);
   const mine = (repository, head) => (repository === ownRepository && head === branch) || namedWorkBranch(id, head)
@@ -200,13 +206,13 @@ export function openReviewPullRequests(board, id) {
     }
     // The repository's default branch is not a work branch, declared or checked out (a card working in a `dir` on main).
     if (repository === ownRepository && branch) {
-      const defaultBranch = list.items.find((pr) => pr.defaultBranch)?.defaultBranch ?? (() => { try { return run('git', ['symbolic-ref', '--quiet', '--short', 'refs/remotes/origin/HEAD'], own).replace(/^origin\//, ''); } catch { return null; } })();
+      const defaultBranch = list.items.find((pr) => pr.defaultBranch)?.defaultBranch ?? (() => { try { return run('git', ['symbolic-ref', '--quiet', '--short', 'refs/remotes/origin/HEAD'], own.path).replace(/^origin\//, ''); } catch { return null; } })();
       if (branch === defaultBranch) branch = null;
     }
     // a draft is not handed over yet: its review starts when it is marked ready; a PR to another base (main→prod) is a release, not the arc's work
     for (const pr of list.items) if (!pr.isCrossRepository && !pr.isDraft && pr.baseRefName === pr.defaultBranch && mine(repository, pr.headRefName)) prs.push({ url: pr.url, head: pr.headRefOid });
   }
-  if (!prs.length) return branch ? null : { waits: `the card has no work branch (${task?.branch_name ? `it declares ${task.branch_name}, its repository's default` : current ? `its checkout ${own} is on ${current}, its repository's default` : `its checkout ${own} is on no branch`}): give it one with --branch, or open its PR from a wt/${id} branch` };
+  if (!prs.length) return branch ? null : { waits: `the card has no work branch (${task?.branch_name ? `it declares ${task.branch_name}, its repository's default` : current ? `its checkout ${own.path} is on ${current}, its repository's default` : `its checkout ${own.path} is on no branch`}): give it one with --branch, or open its PR from a wt/${id} branch` };
   return { pr: prs.map((p) => p.url), pr_head: prs.map((p) => p.head), branch };
 }
 
@@ -214,8 +220,9 @@ export function openReviewPullRequests(board, id) {
  *  beyond its repository's default branch, locally or on origin, its checkout holds no uncommitted work, no PR was
  *  ever opened from it, and it registered no other branch. Answers what its review reads instead of a diff, or null when the arc carries (or may carry) code. */
 export function noCodeChange(board, id) {
-  const own = repositoryWorkspace(board, id);
-  if (!own) return null;
+  const checkout = repositoryWorkspace(board, id);
+  if (!checkout?.here) return null;
+  const own = checkout.path;
   try {
     const repository = originOf(own);
     const task = board.db.prepare('SELECT branch_name FROM tasks WHERE id=?').get(id);
@@ -291,7 +298,7 @@ export function inspectCompletionEvidence(board, id, entry, payload = {}, stage
     if (stage === 'completion' || stage === 'acceptance') {
       const supplied = payload.commit ?? payload.metadata?.commit;
       if (supplied) {
-        const path = repositoryWorkspace(board, id);
+        const path = repositoryWorkspace(board, id)?.path;
         if (!path) throw new Error('The named commit needs a resolved repository workspace.');
         Object.assign(state, { repository: originOf(path), commit: run('git', ['rev-parse', '--verify', `${supplied}^{commit}`], path) });
       }
@@ -351,9 +358,9 @@ function verifyPullRequest(board, id, entry, own, url, supplied, stage) {
   const repository = new URL(url).pathname.split('/').slice(1, 3).join('/');
   // An arc may change several repositories. A PR is read from GitHub; its pushed head is the reviewed one. The
   // card's own checkout, and this machine's checkout of the PR's branch when it keeps one, must also hold that head
-  // with nothing uncommitted.
+  // with nothing uncommitted. A card on another machine is reviewed at its pushed head: its checkout is not read from here.
   const observed = readPullRequest(url);
-  const path = originOf(own) === repository && run('git', ['branch', '--show-current'], own) === observed.headRefName ? own : branchCheckout(board, id, repository, observed.headRefName);
+  const path = !own.here ? null : originOf(own.path) === repository && run('git', ['branch', '--show-current'], own.path) === observed.headRefName ? own.path : branchCheckout(board, id, repository, observed.headRefName);
   // A PR merged before its review (an outage fix landed first) is still reviewed: its head is fixed for good, so the
   // verdict is recorded on that head, and nothing about a worktree or its base can move under it any more.
   const merged = observed.state === 'MERGED';

package/board/dispatch.mjs

@@ -640,7 +640,7 @@ function startCards(board, fleet, lanes, settings, report, entry, effects, { onl
   const candidates = [];
   const waiting = (task, why) => {
     report.queued.push([task.id, why]);
-    if (!dry) tx(board, db => noteGuard(db, task.id, why));
+    if (!dry && !guardNoted(board.db, task.id, why)) tx(board, db => noteGuard(db, task.id, why));
   };
   for (const task of everyCard) {
     if (only && task.id !== only) continue;
@@ -673,7 +673,7 @@ function startCards(board, fleet, lanes, settings, report, entry, effects, { onl
     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
-  const note = (id, why) => { if (!dry) tx(board, (db) => noteGuard(db, id, why)); };
+  const note = (id, why) => { if (!dry && !guardNoted(board.db, id, why)) tx(board, (db) => noteGuard(db, id, why)); };
   for (const [i, c] of candidates.entries()) {
     const { task, plan, scope } = c;
     if (!plan.profile) { report.unassigned.push(task.id); note(task.id, 'no profile runs it (no assignee, and the workflow names none)'); continue; }
@@ -714,7 +714,7 @@ function startCards(board, fleet, lanes, settings, report, entry, effects, { onl
     } catch (error) {
       const reason = error.refusal ?? String(error.message).slice(-300);
       // another round's start is that round's to say; this one writes nothing for it
-      if (!error.claimedElsewhere) tx(board, (db) => noteGuard(db, task.id, reason));
+      if (!error.claimedElsewhere && !guardNoted(board.db, task.id, reason)) tx(board, (db) => noteGuard(db, task.id, reason));
       report.queued.push([task.id, reason]);
       continue;
     }
@@ -1247,12 +1247,16 @@ function memoryPressure() {
 
 /** Record a guard reason once per change, not once per tick. */
 function noteGuard(db, id, reason) {
-  // once per reason per entry into the status: a card back in ready (a new `since`) is noted again, so the workflow's
-  // after-timers that read the reason (card.queue_reason) see it
+  if (guardNoted(db, id, reason)) return;
+  event(db, id, 'respawn_guarded', { reason });
+}
+/** Whether `reason` is already noted: once per reason per entry into the status (a card back in ready, a new `since`, is
+ *  noted again, so the workflow's after-timers that read the reason, card.queue_reason, see it). Read before a write
+ *  is opened too: a card that waits for the same reason round after round costs no transaction. */
+function guardNoted(db, id, reason) {
   const since = Number(db.prepare('SELECT since FROM supercode_cards WHERE task_id = ?').get(id)?.since ?? 0);
   const last = db.prepare("SELECT payload FROM task_events WHERE task_id = ? AND kind IN ('respawn_guarded', 'claimed') AND created_at >= ? ORDER BY id DESC LIMIT 1").get(id, since);
-  if (json(last?.payload, {})?.reason === reason) return;
-  event(db, id, 'respawn_guarded', { reason });
+  return json(last?.payload, {})?.reason === reason;
 }
 
 /** Hermes's emergency stop: the `ESTOP` sentinel in the home or in `~/.hermes` stops new starts (running ones go on). */

package/package.json

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