@volter/supercode-orchestrator 0.5.156 → 0.5.157

package/board/cli.mjs

@@ -1590,14 +1590,22 @@ async function answerVerbs(root, log) {
 
 /** 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). */
+ *  in this one process, any other call's that held it) and what the process used while it ran (`process`): its
+ *  processor time beside the line's `ms` says whether the time was computed or waited for, with the major page faults
+ *  and the waits (voluntary context switches) and preemptions (involuntary) the kernel counted. */
 async function answerOne(root, line) {
   const began = performance.now();
+  const before = process.resourceUsage();
   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 } });
+    if (named && ms > slowLog.SLOW_MS) {
+      const after = process.resourceUsage();
+      const used = { cpu_ms: Math.round((after.userCPUTime + after.systemCPUTime - before.userCPUTime - before.systemCPUTime) / 1000), major_faults: after.majorPageFault - before.majorPageFault,
+        waits: after.voluntaryContextSwitches - before.voluntaryContextSwitches, preempted: after.involuntaryContextSwitches - before.involuntaryContextSwitches };
+      recordSlow({ kind: 'call', name: `owner verb ${named}`, ms, slowest: null, extra: { caller: by, steps: slowLog.stepsWithin?.(began, performance.now()) ?? null, process: used } });
+    }
   }
 }
 

package/board/ztrack.mjs

@@ -21,6 +21,15 @@ 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); } };
+// One statement that takes this long is a step of its own, named by its text: a verb that only reads (`show`) runs in
+// no transaction and has no other step, so a hold inside it was a slow line that named no statement (8.7 s on
+// 2026-10-11, where every statement of `show` measures under 80 ms on a copy of the same store).
+const SLOW_STATEMENT_MS = 100;
+const timedStatement = (sql, fn) => {
+  const started = performance.now();
+  try { return fn(); }
+  finally { const ms = performance.now() - started; if (ms >= SLOW_STATEMENT_MS) noteStep(`board statement: ${String(sql).replace(/\s+/g, ' ').trim().slice(0, 120)}`, ms); }
+};
 import { fire, workflowFor } from './workflow.mjs';
 
 const require = createRequire(import.meta.url);
@@ -128,10 +137,10 @@ class ZtrackBoard {
       boardErrors: self.errors,
       prepare(sql) {
         return {
-          get: (...args) => self.read(() => self.statement(sql).get(...args)),
-          all: (...args) => self.read(() => self.statement(sql).all(...args)),
-          iterate: (...args) => self.read(() => self.statement(sql).all(...args))[Symbol.iterator](),
-          run: (...args) => self.active ? self.noting(() => self.statement(sql).run(...args)) : self.tx(() => self.statement(sql).run(...args)),
+          get: (...args) => self.read(() => timedStatement(sql, () => self.statement(sql).get(...args))),
+          all: (...args) => self.read(() => timedStatement(sql, () => self.statement(sql).all(...args))),
+          iterate: (...args) => self.read(() => timedStatement(sql, () => self.statement(sql).all(...args)))[Symbol.iterator](),
+          run: (...args) => self.active ? self.noting(() => timedStatement(sql, () => self.statement(sql).run(...args))) : self.tx(() => timedStatement(sql, () => self.statement(sql).run(...args))),
         };
       },
       exec(sql) { return self.active ? self.noting(() => self.conn.exec(sql)) : self.tx(() => self.conn.exec(sql)); },

package/package.json

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