@volter/supercode-orchestrator 0.5.74 → 0.5.75

package/board/cli.mjs

@@ -20,6 +20,8 @@ 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';
@@ -1518,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;
@@ -1529,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
@@ -1630,6 +1645,8 @@ async function serve(root, args = {}) {
   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
@@ -1718,7 +1735,7 @@ async function serve(root, args = {}) {
   } finally {
     // 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 */ }
-    closeVerbs();
+    unwatchLoop?.(); closeVerbs();
     unfollowHome();
     await closeDoors();
     events?.close();

package/board/store.mjs

@@ -217,7 +217,7 @@ export const tx = (board, fn) => {
   const caller = /at (?:async )?([\w.$<>]+) /.exec(String(new Error().stack).split('\n')[2] ?? '')?.[1] ?? 'unknown';
   const started = performance.now();
   try {
-    const result = board.tx(db => {const result=fn(db);recordCardPublications(db,actorOf());return result;});
+    const result = board.tx(db => {const result=fn(db);const began=performance.now();try{recordCardPublications(db,actorOf());}finally{noteStep('board tx publications',performance.now()-began);}return result;});
     signalBoardWrite(board.root, actorOf());
     return result;
   } finally { noteStep(`board tx from ${caller}`, performance.now() - started); }

package/board/ztrack.mjs

@@ -17,6 +17,7 @@ import { DatabaseSync } from 'node:sqlite';
 import { actorOf, contention, event, json, now, principalOf } from './store.mjs';
 import { GitDocument } from './git-document.mjs';
 import { noteStep, recordSlow } from '@volter/supercode-harness-sdk/slow-log';
+import * as slowLog from '@volter/supercode-harness-sdk/slow-log';
 
 /** Run `fn` as a named step of the running command (the slow log names its slowest step). */
 const timedStep = (step, fn) => { const started = performance.now(); try { return fn(); } finally { noteStep(step, performance.now() - started); } };
@@ -100,7 +101,7 @@ class ZtrackBoard {
     const said = current().said;
     if (this.git && !said.has(`behind:${this.path}`)) {
       said.add(`behind:${this.path}`);
-      const late = this.git.behind();
+      const late = timedStep('board open git behind', () => this.git.behind());
       // A push younger than a minute is still on its way.
       if (late && Date.now() - late.since > 60_000) current().err(`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`);
     }
@@ -112,12 +113,12 @@ class ZtrackBoard {
     // `sqlite3 <store> "select …"` made the empty file the next release then opened instead of importing).
     if (existsSync(this.file) && statSync(this.file).size === 0) unlinkSync(this.file);
     if (!existsSync(this.file)) this.create(legacy);
-    this.conn = new DatabaseSync(this.file);
+    this.conn = timedStep('board open connection', () => new DatabaseSync(this.file));
     this.refuseUnimported(legacy);
     this.errors = new Map(); this.statements = new Map(); this.hashes = new Map();
     this.active = false; this.overlay = false; this.seen = null; this.refused = new Set();
-    this.prepareConnection();
-    this.loadErrors();
+    timedStep('board open schema', () => this.prepareConnection());
+    timedStep('board open errors', () => this.loadErrors());
     const self = this;
     this.db = {
       boardErrors: self.errors,
@@ -396,8 +397,7 @@ class ZtrackBoard {
       try {
         txStarted = performance.now();
         this.dropOverlay();
-        this.conn.exec('BEGIN');
-        fenced(this.conn);
+        timedStep('board tx begin', () => { this.conn.exec('BEGIN'); fenced(this.conn); });
         this.active = true; this.contended = false;
         this.conn.exec('DELETE FROM temp.board_dirty; DELETE FROM temp.board_touched');
         this.refused = new Set();
@@ -418,12 +418,12 @@ class ZtrackBoard {
           this.put('pending', { intent, files });
           this.put('pending_hashes', Object.fromEntries(files.map((f) => [f.role, { before: f.before, after: f.after }])));
         }
-        this.conn.exec('COMMIT');
+        timedStep('board tx commit', () => this.conn.exec('COMMIT'));
         // A long transaction holds every other writer of this board (the dispatcher's tick included), so it is a line
         // of its own in the slow log, from whichever process ran it.
         const held = performance.now() - txStarted;
         noteStep('board transaction', held);
-        recordSlow({ kind: 'call', name: 'board transaction', ms: held, slowest: null, extra: { board: this.path } });
+        recordSlow({ kind: 'call', name: 'board transaction', ms: held, slowest: null, extra: { board: this.path, steps: slowLog.stepsWithin?.(txStarted, performance.now()) ?? null } });
         outcome = { result, files, intent, recovered };
       } catch (error) {
         try { this.conn.exec('ROLLBACK'); } catch { /* not begun */ }

package/package.json

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