@volter/supercode-orchestrator 0.5.73 → 0.5.75

package/board/cli.mjs

@@ -14,12 +14,14 @@ import { taskStatusOf } from './published.mjs';
 import { createServer } from 'node:net';
 import { chmodSync, existsSync, mkdirSync, readdirSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, copyFileSync, readFileSync, appendFileSync, writeFileSync } from 'node:fs';
 import { notRuntime, ownHome } from './owner-files.mjs';
-import { spawnSync } from 'node:child_process';
+import { execFile, spawnSync } from 'node:child_process';
 import { holdLock } from './lock-holder.mjs';
 import { takeEpoch } from './fence.mjs';
 import { dispatcherNotice, holdOwnerHealth, holdRound, holdSwitch } from './owner-health.mjs';
 import { boardTool } from './tools.mjs';
 import { recordSlow, takeSteps } from '@volter/supercode-harness-sdk/slow-log';
+// read by name, so an older harness SDK without them still loads: the owner then keeps no per-verb or loop lines
+import * as slowLog from '@volter/supercode-harness-sdk/slow-log';
 import { basename, dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { homedir, tmpdir, userInfo } from 'node:os';
@@ -28,19 +30,23 @@ import { isLocalWorkspace } from './workspace.mjs';
 import { openZtrackBoard } from './ztrack.mjs';
 import * as engine from './engine.mjs';
 
+// A mailbox read through the mailbox's own command, awaited (never a wait that holds the event loop). Gap A31: a
+// helper process until the daemon owns mail (order 3 PR 4).
+const mailRead = (verb) => new Promise((resolve) => execFile(supercodeBin(), ['message', verb, '--json'], { encoding: 'utf8', env: commandEnv(), timeout: 15_000, maxBuffer: 64 * 1024 * 1024 }, (_, stdout) => resolve(stdout ?? '')));
+
 /** The messages on this machine the mailbox still has to deliver (`supercode message waiting`), by message id. */
-function mailWaiting() {
-  const r = spawnSync(supercodeBin(), ['message', 'waiting', '--json'], { encoding: 'utf8', env: commandEnv(), timeout: 15_000 });
-  try { return new Map((JSON.parse(r.stdout) ?? []).map((mail) => [mail.id, mail])); } catch { return new Map(); }
+async function mailWaiting() {
+  const stdout = await mailRead('waiting');
+  try { return new Map((JSON.parse(stdout) ?? []).map((mail) => [mail.id, mail])); } catch { return new Map(); }
 }
 
 /**
  * The messages on this machine whose delivery the mailbox gave up on (`supercode message expired`), by message id:
  * filed by the board, never delivered within the mailbox's bound, kept unread. Empty when the mailbox does not answer.
  */
-function mailExpiries() {
-  const r = spawnSync(supercodeBin(), ['message', 'expired', '--json'], { encoding: 'utf8', env: commandEnv(), timeout: 15_000 });
-  try { return new Map((JSON.parse(r.stdout) ?? []).map((expiry) => [expiry.id, expiry])); } catch { return new Map(); }
+async function mailExpiries() {
+  const stdout = await mailRead('expired');
+  try { return new Map((JSON.parse(stdout) ?? []).map((expiry) => [expiry.id, expiry])); } catch { return new Map(); }
 }
 
 /**
@@ -319,34 +325,6 @@ const metadataOf = (v) => {
   return got;
 };
 
-/**
- * What is wrong with this orchestrator's version, or null: a build no release names (a hand install of a branch) or one
- * older than npm's latest. Every workflow call says it and the dispatcher tells its managers; action is required until
- * the release is installed. The latest is read from the registry at most once an hour.
- */
-function releaseBehind() {
-  let running;
-  try { running = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version; } catch { return null; }
-  const cache = join(tmpdir(), 'supercode-orchestrator-latest.json');
-  let latest = null;
-  let fresh = false;
-  try { const seen = JSON.parse(readFileSync(cache, 'utf8')); if (Date.now() - seen.at < 3_600_000) { fresh = true; latest = seen.latest; } } catch { /* read below */ }
-  if (!fresh) {
-    // a failed read is kept for the hour too: offline, no call waits on the registry more than once an hour
-    const r = spawnSync('npm', ['view', '@volter/supercode-orchestrator', 'version'], { encoding: 'utf8', timeout: 5000 });
-    latest = r.status === 0 ? r.stdout.trim() || null : null;
-    try { writeFileSync(cache, JSON.stringify({ at: Date.now(), latest })); } catch { /* read again next call */ }
-  }
-  if (!latest || running === latest) return null;
-  const parts = (v) => v.split('-')[0].split('.').map(Number);
-  const [a, b] = [parts(running), parts(latest)];
-  const older = a[0] - b[0] || a[1] - b[1] || a[2] - b[2];
-  const fix = `npm install -g @volter/supercode-orchestrator@${latest} (and each install's pinned copy)`;
-  if (running.includes('-')) return { key: `${running}>${latest}`, text: `orchestrator ${running} is not a published release (latest ${latest}); action required: ${fix}` };
-  if (older < 0) return { key: `${running}>${latest}`, text: `orchestrator ${running} is behind the published ${latest}; action required: ${fix}` };
-  return null;
-}
-
 /** One verb in full, in the call it runs in (call.mjs): a caller's in the owner, or the process's own here. */
 export async function runVerb(argv) {
   await knowLocalMachine();
@@ -362,7 +340,7 @@ export async function runVerb(argv) {
   const slug = viewTag ? DEFAULT_BOARD : named;
   const open = (create = false) => { const b = openBoard(root, slug, { create, document: args.document ?? null, backing: create ? args.backing ?? null : null }); b.label = boardLabel(root, slug); return b; };
   const withBoard = (fn, create = false) => { const b = open(create); try { return fn(b); } finally { b.close(); } };
-  const withBoardAsync = async (fn) => { const b = open(); try { return await fn(b); } finally { b.close(); } };
+  const withBoardAsync = async (fn, create = false) => { const b = open(create); try { return await fn(b); } finally { b.close(); } };
   const id = rest[0];
   const need = (n, what) => { if (rest.length < n) throw new Error(`${verb} needs ${what}`); };
   const ids = (first = rest) => [...first, ...(args.ids ?? [])];
@@ -380,7 +358,7 @@ export async function runVerb(argv) {
   if (sid && !READS.has(verb) && boardExists(root, slug)) {
     // binding the caller's launch is a write: only the owner, answering the caller's own verb, makes it (a local read
     // never writes)
-    withBoard((b) => { if (isCallersCall()) reconcileCallerLaunch(b, sid); const own = ownCard(b.db, sid); if (own) authorize(b.db, verb, rest, args, own); });
+    await withBoardAsync(async (b) => { if (isCallersCall()) await reconcileCallerLaunch(b, sid); const own = ownCard(b.db, sid); if (own) authorize(b.db, verb, rest, args, own); });
   }
   // the board's workflow (the IR's): what each verb does, and who may send it, is its
   // every verb reads the board through its workflow (a list settles cards too), so every verb loads it
@@ -472,7 +450,7 @@ export async function runVerb(argv) {
       // --goal / --no-goal are the create's words; without either, the workflow's initial decides
       // a person filing for themselves sponsors it; an agent filing a person's request names them (proven) or records them unverified
       const sponsorship = args.sponsor || args['requested-by'] ? await requestedSponsor(args) : principalOf()?.startsWith('person:') ? { sponsor: principalOf().slice('person:'.length) } : {};
-      const created = withBoard((b) => engine.createCard(b, {
+      const created = await withBoardAsync(async (b) => engine.createCard(b, await engine.prepareCard(b, {
         title: rest.join(' '), body: textFrom(args['body-file'], args.body), assignee: args.assignee === 'none' ? null : args.assignee, machine: args.machine,
         workspace, branch: args.branch, parents: args.parent, priority: args.priority, tenant: args.tenant,
         triage: args.triage, idempotencyKey: args['idempotency-key'], maxRuntime: duration(args['max-runtime']),
@@ -482,7 +460,7 @@ export async function runVerb(argv) {
         project: args.project ?? meta.project_id ?? null, goal: args.goal ? { maxTurns: args['goal-max-turns'] ? Number(args['goal-max-turns']) : null } : args['no-goal'] ? false : null,
         tags: [...(viewTag ? [viewTag] : []), ...(args.tag ?? [])],
         ...sponsorship,
-      }), true);
+      })), true);
       await withBoardAsync(b=>engine.runEffects(b,created.effects??[]));
       let answer = { id: created.id, existing: created.existing };
       if (args.adopt) {
@@ -881,10 +859,9 @@ export async function runVerb(argv) {
 
     case 'diagnostics': case 'diag': {
       const { settings } = await laneState(root).catch(() => ({ settings: boardSettings({}) }));
-      const fleet = observeFleet(root);
+      const fleet = await observeFleet(root);
       const publishing = await boardPublishing(root);
-      const expiredMail = mailExpiries();
-      const waitingMail = mailWaiting();
+      const [expiredMail, waitingMail] = await Promise.all([await mailExpiries(), await mailWaiting()]);
       const order = ['warning', 'error', 'critical'];
       const found = withBoard((b) => {
         const cards = args.task ? [engine.getTask(b.db, args.task)].filter(Boolean) : engine.listCards(b.db, {});
@@ -1146,7 +1123,7 @@ export async function runVerb(argv) {
     }
     case 'close': {
       need(1, 'a card id');
-      const closed = withBoard((b) => closeSession(b, id));
+      const closed = await withBoardAsync((b) => closeSession(b, id));
       say(args, closed ? closed.map((c) => `closed ${c.session_id} (pane ${c.pane} on ${c.machine})`).join('\n') : `${id} has no live session`, { ok: true, closed });
       return 0;
     }
@@ -1453,13 +1430,13 @@ function authorize(db, verb, rest, args, own) {
 }
 
 /** Close the live sessions of a card that is not running (its worker's and its reviewers'), freeing its machine's place. */
-function closeSession(board, id) {
+async function closeSession(board, id) {
   const task = engine.getTask(board.db, id);
   if (!task) throw new Error(`no card ${id}`);
   if (task.current_run_id != null) throw new Error(`${id} has an active run; pause, block or reclaim it before closing its session`);
   tx(board, (db) => requestSessionClose(db, id));
   const report = { undelivered: [], closed: [] };
-  closeRequested(board, report, { taskId: id, caller: callerSession() });
+  await closeRequested(board, report, { taskId: id, caller: callerSession() });
   if (report.undelivered.length) throw new Error(`close remains queued for retry: ${report.undelivered.map((r) => r[2]).join('; ')}`);
   return report.closed.length ? report.closed : null;
 }
@@ -1543,8 +1520,20 @@ async function answerVerbs(root, log) {
   return () => { server.close(); try { unlinkSync(path); } catch { /* gone */ } lock.release(); };
 }
 
-/** One request to the owner, answered whole: the verb run in the caller's call, its output kept for the answer. */
+/** One request to the owner, answered whole: the verb run in the caller's call, its output kept for the answer. A
+ *  verb that takes more than a second is a slow line of its own, with the steps that ended while it ran (its own and,
+ *  in this one process, any other call's that held it). */
 async function answerOne(root, line) {
+  const began = performance.now();
+  let named = null, by = null;
+  try { return await answerRequest(root, line, (verb, caller) => { named = verb; by = caller; }); }
+  finally {
+    const ms = performance.now() - began;
+    if (named) recordSlow({ kind: 'call', name: `owner verb ${named}`, ms, slowest: null, extra: { caller: by, steps: slowLog.stepsWithin?.(began, performance.now()) ?? null } });
+  }
+}
+
+async function answerRequest(root, line, naming) {
   try {
     const request = JSON.parse(line);
     const tool = request?.tool && typeof request.tool.name === 'string' ? request.tool : null;
@@ -1554,6 +1543,7 @@ async function answerOne(root, line) {
     if (BOARD_OPERATION_VERBS.has(verb)) return { code: 1, stdout: '', stderr: `supercode workflow: ${verb} is run on the board's machine as its own act, not sent to the owner\n` };
     const session = request.session && typeof request.session.id === 'string' && ['claude-code', 'codex'].includes(request.session.harness) ? request.session : null;
     const caller = typeof request.caller === 'string' ? request.caller : session ? `sc:${localMachine()}:${session.harness}:${session.id}` : null;
+    naming(tool ? `tool ${tool.name}` : verb, caller);
     const facts = Object.fromEntries(Object.entries(request.facts ?? {}).filter(([key, value]) => CALLER_FACTS.includes(key) && typeof value === 'string'));
     // a caller names its Teams context (the CLI and the daemon always do): one that names none is refused before anything
     // is done, never answered with the owner's
@@ -1604,17 +1594,7 @@ async function serve(root, args = {}) {
   const FAILED_ROUNDS_ALERT = 5;
   const failing = new Map();
   let round = 0;
-  // A dispatcher that is not the published release is told up the chain, once per version pair: it keeps running, and
-  // its manager hears that action is required (a caller's stderr line alone reached no one).
-  const versionsTold = new Set();
-  const tellReleaseBehind = async () => {
-    const behind = releaseBehind();
-    if (!behind || versionsTold.has(behind.key)) return;
-    // the send's key makes a retry safe; a pair counts as told only once a manager got it
-    if (await alertManagers(root, 'default', `The dispatcher of ${root} runs ${behind.text}`, `release-behind-${behind.key}`) > 0) versionsTold.add(behind.key);
-  };
   const watchRounds = async (reports) => {
-    await tellReleaseBehind().catch(() => {});
     if (reports.every((r) => !r.error)) {
       // A publication the team refused holds this home's publishing where it is (nothing after it is skipped): a fact of
       // the same kind as rounds that stopped, so it goes where every board verb's error line reads it. Only a refusal
@@ -1660,8 +1640,13 @@ async function serve(root, args = {}) {
     onChange: (name) => log(`home changed (${name}): read again on its next use`),
     onLost: (error) => { log(`the home's files can no longer be watched (${error.message}); stopping, for the keeper to start the owner again`); stop(); },
   });
+  // Hermes's install is located once per process (a launch's memory snapshot reads it): here, before any verb is
+  // answered, so no verb or round waits on it
+  try { (await import('../hermes-cli.mjs')).hermesInstall(); } catch { /* none installed */ }
   let closeVerbs;
   try { closeVerbs = await answerVerbs(root, log); } catch (error) { unfollowHome(); throw error; }
+  // a held event loop is every caller's wait at once: each hold over a second is a slow line naming what held it
+  const unwatchLoop = slowLog.watchEventLoop?.({ name: 'board owner event loop blocked' });
   log(`owning the boards of ${root} on ${localMachine()} (orchestrator ${running ?? 'unknown'}); dispatching where a board's dispatching is on (\`supercode workflow dispatching\`)`);
   events = watchBoard({ root, binary: supercodeBin(), env: commandEnv(), log });
   // The board's events are published by this machine's connector, not by the dispatcher (D137, D138 step 4): the home is
@@ -1748,7 +1733,9 @@ async function serve(root, args = {}) {
       if (moved) { log(`orchestrator ${moved} is installed (this serve runs ${running}); stopping, for its keeper to start the new one`); break; }
     }
   } finally {
-    closeVerbs();
+    // a fetch in flight lands, and what it brought is merged, while this owner still holds the home's lock
+    try { const { settleDocuments } = await import('./git-document.mjs'); await settleDocuments(); } catch { /* nothing in flight */ }
+    unwatchLoop?.(); closeVerbs();
     unfollowHome();
     await closeDoors();
     events?.close();