@inerrata-corporation/errata 2.0.6-dev.2657 → 2.0.6-dev.2681

package/errata.mjs

@@ -71184,7 +71184,7 @@ var init_report_render = __esm({
 init_src6();
 import { closeSync as closeSync2, existsSync as existsSync34, openSync as openSync2, readFileSync as readFileSync34, renameSync as renameSync4, statSync as statSync8 } from "node:fs";
 import { join as join39, resolve as pathResolve2 } from "node:path";
-import { spawn as spawn3 } from "node:child_process";
+import { spawn as spawn4 } from "node:child_process";
 
 // src/daemon.ts
 import { existsSync as existsSync26, writeFileSync as writeFileSync22 } from "node:fs";
@@ -78536,7 +78536,7 @@ function createWatchBreaker(deps) {
 }
 
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.6-dev.2657" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.6-dev.2681" : "2.0.0-alpha.0";
 var IGNORED_PATH = /[\\/](?:\.git|node_modules|\.errata|\.claude|\.codex|\.cursor|\.turbo|\.next|dist|coverage|test-results|playwright-report|__pycache__)(?:[\\/]|$)/;
 var IGNORED_NOISE = /castalia\.db|eventlog\.sqlite|turn-cursors/;
 var GIT_OP_MUTE_MS = 4e3;
@@ -82710,6 +82710,17 @@ function isGeneratedPath(path2) {
 function isReleaseSubject(subject) {
   return RELEASE_SUBJECT_RE.test(subject.trim());
 }
+var FORGE_MARK_RES = [/^See merge request \S+!\d+$/i, /^Merge pull request #\d+ from \S+$/i];
+var TRAILER_RES = [
+  /^(Closes|Fixes|Resolves|Related to|Part of)\b.*$/i,
+  /^(Co-Authored-By|Signed-off-by|Reviewed-by|Approved-by):/i
+];
+function isForgeTrailerBody(body2) {
+  const lines = body2.split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
+  if (!lines.some((l) => FORGE_MARK_RES.some((re) => re.test(l)))) return false;
+  const own = lines.filter((l) => !FORGE_MARK_RES.some((re) => re.test(l)) && !TRAILER_RES.some((re) => re.test(l)));
+  return own.length <= 1;
+}
 function classifySkip(subject, files, tags) {
   if (files.length > 0 && files.every((f) => f.binary || isLockfilePath(f.path) || isGeneratedPath(f.path))) {
     return "lockfile-only";
@@ -82718,6 +82729,7 @@ function classifySkip(subject, files, tags) {
   return void 0;
 }
 var GIT_OPTS = ["-c", "core.quotepath=false", "-c", "color.ui=never", "--no-pager"];
+var MERGE_SIDE_CONCURRENCY = 6;
 var META_FMT = ["%H", "%P", "%aI", "%s", "%b"].join("%x00") + "%x00";
 function parseMeta(head2) {
   const [sha2, parents, authorDate, subject, body2] = head2.split("\0");
@@ -82756,6 +82768,38 @@ async function readCommit(root, sha2) {
   const rest2 = parts2.slice(5).join("\0");
   return { ...parseMeta(head2), files: parseNumstat(rest2) };
 }
+async function readCommitsBulk(root, branch, since) {
+  const out2 = await git(root, [
+    ...GIT_OPTS,
+    "log",
+    "--numstat",
+    "-M",
+    "--diff-merges=first-parent",
+    `--format=%x1e${META_FMT}`,
+    ...since ? [`^${since}`] : [],
+    branch
+  ]);
+  const map2 = /* @__PURE__ */ new Map();
+  for (const rec of out2.split("")) {
+    if (!rec) continue;
+    const parts2 = rec.split("\0");
+    const meta3 = parseMeta(parts2.slice(0, 5).join("\0"));
+    if (meta3.sha) map2.set(meta3.sha, { ...meta3, files: parseNumstat(parts2.slice(5).join("\0")) });
+  }
+  return map2;
+}
+async function mapBounded(items, limit, fn) {
+  const out2 = new Array(items.length);
+  let next = 0;
+  const worker = async () => {
+    while (next < items.length) {
+      const i2 = next++;
+      out2[i2] = await fn(items[i2]);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
+  return out2;
+}
 async function firstParentLine(root, branch) {
   const out2 = await git(root, [...GIT_OPTS, "rev-list", "--first-parent", "--reverse", "--parents", branch]);
   return out2.split(/\r?\n/).filter((l) => l.trim().length > 0).map((l) => {
@@ -82795,11 +82839,18 @@ async function enumerateUnits(root, opts = {}) {
   }
   const tags = await tagsByCommit(root);
   const tagsOf = (sha2) => tags.get(sha2) ?? [];
+  if (start2 >= line.length) return [];
+  const commits = await readCommitsBulk(root, branch, start2 > 0 ? line[start2 - 1].sha : null);
+  const commit = async (sha2) => commits.get(sha2) ?? await readCommit(root, sha2);
+  const merges = line.slice(start2).filter((c) => c.parents.length >= 2);
+  const sides = /* @__PURE__ */ new Map();
+  const sideLists = await mapBounded(merges, MERGE_SIDE_CONCURRENCY, (m) => mergeSide(root, m.parents[0], m.parents[1]));
+  merges.forEach((m, i2) => sides.set(m.sha, sideLists[i2]));
   const units = [];
   for (let index = start2; index < line.length; index++) {
     const { sha: sha2, parents } = line[index];
     if (parents.length < 2) {
-      const c = await readCommit(root, sha2);
+      const c = await commit(sha2);
       const skip = classifySkip(c.subject, c.files, tagsOf(sha2));
       units.push({
         index,
@@ -82815,11 +82866,11 @@ async function enumerateUnits(root, opts = {}) {
       });
       continue;
     }
-    const side = await mergeSide(root, parents[0], parents[1]);
+    const side = sides.get(sha2) ?? await mergeSide(root, parents[0], parents[1]);
     const group = [];
     for (const s of side) {
       if (s.parents.length >= 2) continue;
-      const c = await readCommit(root, s.sha);
+      const c = await commit(s.sha);
       const skip = classifySkip(c.subject, c.files, tagsOf(s.sha));
       group.push({
         index,
@@ -82835,8 +82886,9 @@ async function enumerateUnits(root, opts = {}) {
         groupSha: sha2
       });
     }
-    const merge2 = await readCommit(root, sha2);
-    if (merge2.body.length > 0) {
+    const merge2 = await commit(sha2);
+    const hasMembers = group.some((g) => !g.skip);
+    if (merge2.body.length > 0 && !(hasMembers && isForgeTrailerBody(merge2.body))) {
       const skip = classifySkip(merge2.subject, merge2.files, tagsOf(sha2));
       group.push({
         index,
@@ -84068,13 +84120,115 @@ async function buildUnitBundle(root, unit, opts = {}) {
   };
 }
 
+// src/git-batch.ts
+import { spawn as spawn3 } from "node:child_process";
+var GitBlobReader = class {
+  constructor(root, maxCached = 4096) {
+    this.root = root;
+    this.maxCached = maxCached;
+  }
+  proc = null;
+  buf = Buffer.alloc(0);
+  queue = [];
+  cache = /* @__PURE__ */ new Map();
+  failed = null;
+  start() {
+    if (this.proc) return this.proc;
+    const proc = spawn3("git", ["-C", this.root, "cat-file", "--batch"], { windowsHide: true });
+    proc.stdout.on("data", (chunk) => {
+      this.buf = this.buf.length === 0 ? chunk : Buffer.concat([this.buf, chunk]);
+      this.drain();
+    });
+    const fail = (err2) => {
+      this.failed = err2;
+      this.proc = null;
+      for (const p of this.queue.splice(0)) p.reject(err2);
+    };
+    proc.on("error", fail);
+    proc.stdin.on("error", fail);
+    proc.on("exit", (code) => {
+      if (this.queue.length > 0) fail(new Error(`git cat-file --batch exited (${code}) with ${this.queue.length} reads pending`));
+      this.proc = null;
+    });
+    this.proc = proc;
+    return proc;
+  }
+  drain() {
+    for (; ; ) {
+      const nl = this.buf.indexOf(10);
+      if (nl < 0 || this.queue.length === 0) return;
+      const header = this.buf.subarray(0, nl).toString("utf8");
+      if (header.endsWith(" missing") || header.endsWith(" ambiguous")) {
+        this.buf = this.buf.subarray(nl + 1);
+        this.queue.shift().resolve(null);
+        continue;
+      }
+      const size = Number(header.slice(header.lastIndexOf(" ") + 1));
+      if (!Number.isFinite(size)) {
+        const err2 = new Error(`git cat-file --batch: unexpected header ${JSON.stringify(header.slice(0, 120))}`);
+        this.queue.shift().reject(err2);
+        this.buf = this.buf.subarray(nl + 1);
+        continue;
+      }
+      if (this.buf.length < nl + 1 + size + 1) return;
+      const body2 = this.buf.subarray(nl + 1, nl + 1 + size).toString("utf8");
+      this.buf = this.buf.subarray(nl + 1 + size + 1);
+      const oid = header.slice(0, header.indexOf(" "));
+      this.remember(oid, body2);
+      this.queue.shift().resolve(body2);
+    }
+  }
+  remember(oid, text) {
+    if (this.cache.size >= this.maxCached) {
+      const first = this.cache.keys().next().value;
+      if (first !== void 0) this.cache.delete(first);
+    }
+    this.cache.set(oid, text);
+  }
+  /** Read one object by blob id (served from cache when seen) or `<rev>:<path>`. */
+  read(spec) {
+    const hit = this.cache.get(spec);
+    if (hit !== void 0) return Promise.resolve(hit);
+    if (this.failed) return Promise.reject(this.failed);
+    if (/[\r\n]/.test(spec)) return Promise.resolve(null);
+    const proc = this.start();
+    return new Promise((resolve7, reject) => {
+      this.queue.push({ resolve: resolve7, reject });
+      proc.stdin.write(`${spec}
+`);
+    });
+  }
+  /**
+   * End the process and wait for it to exit: on Windows a live cat-file keeps
+   * the repo's pack files open, so a caller that removes or moves the checkout
+   * right after the walk (EPERM) must not race it. Bounded, never throws.
+   */
+  close(timeoutMs = 5e3) {
+    const proc = this.proc;
+    this.proc = null;
+    if (!proc || proc.exitCode !== null) return Promise.resolve();
+    return new Promise((resolve7) => {
+      const timer = setTimeout(() => {
+        proc.kill();
+        resolve7();
+      }, timeoutMs);
+      proc.once("exit", () => {
+        clearTimeout(timer);
+        resolve7();
+      });
+      proc.stdin.end();
+    });
+  }
+};
+
 // src/project-history.ts
 init_profile2();
 var execFileAsync = promisify(execFile3);
-var HISTORY_EXTRACTOR_VERSION = "history-1";
+var HISTORY_EXTRACTOR_VERSION = "history-2";
 var LEASE_POLL_MS = 2e4;
 var RECOVERY_DEADLINE_MS = 15 * 6e4;
 var MAX_ANCHORS_PER_TOKEN = 20;
+var DEFAULT_LOOKAHEAD = 2;
 async function defaultGit(root, args2) {
   const { stdout } = await execFileAsync("git", ["-C", root, ...args2], { maxBuffer: 64 * 1024 * 1024, windowsHide: true });
   return stdout;
@@ -84087,27 +84241,38 @@ function readIgnoreLines(root, profile) {
   }
   return [...lines, ...profile.ignoreExtra ?? []].map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
 }
-async function spineForUnit(git3, root, unit) {
-  const listing = await git3(root, ["ls-tree", "-r", "--name-only", unit.sha]);
-  const manifestPaths2 = listing.split("\n").map((l) => l.trim()).filter((p) => p && isManifestPath(p));
-  if (manifestPaths2.length === 0) return void 0;
-  const texts = /* @__PURE__ */ new Map();
-  for (const p of manifestPaths2) {
+function readBlobViaGit(git3, root) {
+  return async (spec) => {
     try {
-      texts.set(p, await git3(root, ["show", `${unit.sha}:${p}`]));
+      return await git3(root, ["show", spec]);
     } catch {
+      return null;
     }
+  };
+}
+function manifestBlobs(listing) {
+  const out2 = /* @__PURE__ */ new Map();
+  for (const line of listing.split("\n")) {
+    const tab = line.indexOf("	");
+    if (tab < 0) continue;
+    const path2 = line.slice(tab + 1).trim();
+    const [, type, oid] = line.slice(0, tab).split(" ");
+    if (type === "blob" && oid && path2 && isManifestPath(path2)) out2.set(path2, oid);
   }
+  return out2;
+}
+async function spineForUnit(git3, root, unit, readBlob) {
+  const blobs = manifestBlobs(await git3(root, ["ls-tree", "-r", unit.sha]));
+  if (blobs.size === 0) return void 0;
+  const texts = /* @__PURE__ */ new Map();
+  const read2 = await Promise.all([...blobs].map(async ([p, oid]) => [p, await readBlob(oid).catch(() => null)]));
+  for (const [p, text] of read2) if (text !== null) texts.set(p, text);
   const spine = buildSpine(unit.sha, [...texts.keys()], (p) => texts.get(p) ?? "");
   const parentTexts = /* @__PURE__ */ new Map();
   const readParent = (p) => parentTexts.get(p) ?? null;
   for (const f of unit.files) {
     if (!isManifestPath(f.path) || parentTexts.has(f.path)) continue;
-    try {
-      parentTexts.set(f.path, await git3(root, ["show", `${unit.sha}^:${f.path}`]));
-    } catch {
-      parentTexts.set(f.path, null);
-    }
+    parentTexts.set(f.path, await readBlob(`${unit.sha}^:${f.path}`).catch(() => null));
   }
   const rings = depsForUnit(spine, unit.files.map((f) => f.path), readParent);
   const wire = (d) => ({ ecosystem: d.ecosystem, name: d.name, version: d.version, kind: d.kind, manifest: d.manifest });
@@ -84150,16 +84315,37 @@ function stage(profile, patch, now) {
       headSha: patch.headSha !== void 0 ? patch.headSha : prev?.headSha ?? null,
       startedAt: prev?.startedAt ?? at,
       updatedAt: at,
-      ...patch.lastError !== void 0 ? { lastError: patch.lastError } : prev?.lastError ? { lastError: prev.lastError } : {},
+      // `lastError: undefined` in the patch CLEARS it (a resumed walk must not
+      // keep showing the error it recovered from); an absent key keeps it.
+      ..."lastError" in patch ? patch.lastError ? { lastError: patch.lastError } : {} : prev?.lastError ? { lastError: prev.lastError } : {},
       ...patch.counts ? { counts: patch.counts } : prev?.counts ? { counts: prev.counts } : {}
     }
   };
 }
+function unitTiming(postStarted, prepMs, receipt) {
+  const s = (ms) => `${(ms / 1e3).toFixed(1)}s`;
+  const parts2 = [`local ${s(prepMs)}`];
+  const g = receipt.gate;
+  if (g) parts2.push(g.pRoutine === null ? `jev ${g.error ?? "n/a"}` : `jev ${s(g.ms)} p=${g.pRoutine}${g.skipped ? " skipped" : ""}`);
+  if (receipt.timing?.modelMs !== void 0) parts2.push(`model ${s(receipt.timing.modelMs)}`);
+  if (receipt.timing?.orderWaitMs) parts2.push(`waited ${s(receipt.timing.orderWaitMs)} for the previous write`);
+  if (receipt.timing?.ingestMs !== void 0) parts2.push(`ingest ${s(receipt.timing.ingestMs)}`);
+  return ` in ${s(Date.now() - postStarted + prepMs)} (${parts2.join(", ")})`;
+}
 function addCounts(a, b) {
   const sum = (k) => (a[k] ?? 0) + (b[k] ?? 0);
   return { commitsWalked: sum("commitsWalked"), changesExtracted: sum("changesExtracted"), pairs: sum("pairs"), claims: sum("claims"), anchors: sum("anchors"), packages: sum("packages") };
 }
 async function runHistoryWalk(root, input, client, opts = {}) {
+  const reader = opts.git ? null : new GitBlobReader(root);
+  const readBlob = reader ? (spec) => reader.read(spec) : readBlobViaGit(opts.git ?? defaultGit, root);
+  try {
+    return await walk10(root, input, client, opts, readBlob);
+  } finally {
+    await reader?.close();
+  }
+}
+async function walk10(root, input, client, opts, readBlob) {
   const log = opts.log ?? ((line) => console.warn(line));
   const now = opts.now ?? (() => /* @__PURE__ */ new Date());
   const sleep = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
@@ -84199,8 +84385,77 @@ async function runHistoryWalk(root, input, client, opts = {}) {
   let processed = 0;
   const byIndex = /* @__PURE__ */ new Map();
   for (const u of units) byIndex.set(u.index, [...byIndex.get(u.index) ?? [], u]);
-  for (const u of units) {
-    if (opts.maxUnits !== void 0 && processed >= opts.maxUnits) break;
+  const lookahead = dryRun ? 0 : Math.max(0, opts.lookahead ?? DEFAULT_LOOKAHEAD);
+  let doorOrders = false;
+  const settle = (p) => p.then((res) => ({ res }), (err2) => ({ err: err2 }));
+  const prepared = /* @__PURE__ */ new Map();
+  const launched = /* @__PURE__ */ new Map();
+  const cap = opts.maxUnits;
+  const predecessor = (k) => {
+    for (let j = k - 1; j >= 0; j--) if (!units[j].skip) return units[j];
+    return void 0;
+  };
+  const prepare = (k) => {
+    const hit = prepared.get(k);
+    if (hit) return hit;
+    const p = (async () => {
+      const u = units[k];
+      const prepStarted = Date.now();
+      const group = byIndex.get(u.index) ?? [u];
+      const bundle = await buildUnitBundle(root, u, {
+        ignorePatterns: ignoreLines,
+        narrative: narrative(u, u.isMerge ? group : void 0)
+      });
+      const prev = dryRun ? void 0 : predecessor(k);
+      const body2 = {
+        unit: {
+          sha: u.sha,
+          index: u.index,
+          subIndex: u.subIndex,
+          isMerge: u.isMerge,
+          ...u.groupSha ? { groupSha: u.groupSha } : {},
+          ...u.authorDate ? { authorDate: u.authorDate } : {}
+        },
+        narrative: bundle.narrative,
+        fileList: bundle.fileList,
+        diff: bundle.diff,
+        pathTokens: Object.keys(bundle.pathTokens),
+        extractorVersion: HISTORY_EXTRACTOR_VERSION,
+        ...opts.frame ? { frame: opts.frame } : {},
+        ...dryRun ? { dryRun: true } : {},
+        ...prev ? { after: { sha: prev.sha, subIndex: prev.subIndex } } : {}
+      };
+      const spine = await spineForUnit(git3, root, u, readBlob);
+      if (spine) body2.spine = spine;
+      const anchors = anchorsFor(bundle.pathTokens, ignoreLines, projectId, opts.anchors);
+      if (anchors) {
+        body2.anchors = anchors;
+        body2.observedAtCommit = headSha;
+      }
+      return { body: body2, prepMs: Date.now() - prepStarted };
+    })();
+    prepared.set(k, p);
+    return p;
+  };
+  const launch = async (k) => {
+    if (launched.has(k)) return;
+    const { body: body2 } = await prepare(k);
+    if (launched.has(k)) return;
+    launched.set(k, { at: Date.now(), settled: settle(Promise.resolve().then(() => post(projectId, body2))) });
+  };
+  const launchAhead = async (k) => {
+    if (!doorOrders || lookahead === 0) return;
+    let ahead = 0;
+    for (let j = k + 1; j < units.length && ahead < lookahead; j++) {
+      if (cap !== void 0 && processed + (j - k) >= cap) break;
+      if (units[j].skip) continue;
+      ahead += 1;
+      await launch(j);
+    }
+  };
+  for (let k = 0; k < units.length; k++) {
+    const u = units[k];
+    if (cap !== void 0 && processed >= cap) break;
     const label = `${u.sha.slice(0, 12)}${u.subIndex ? `/${u.subIndex}` : ""}`;
     const doneSoFar = (profile.historyStage?.unitsDone ?? 0) + 1;
     const group = byIndex.get(u.index) ?? [u];
@@ -84214,34 +84469,7 @@ async function runHistoryWalk(root, input, client, opts = {}) {
       log(`[errata] history ${label} skipped (${u.skip})`);
       continue;
     }
-    const bundle = await buildUnitBundle(root, u, {
-      ignorePatterns: ignoreLines,
-      narrative: narrative(u, u.isMerge ? group : void 0)
-    });
-    const body2 = {
-      unit: {
-        sha: u.sha,
-        index: u.index,
-        subIndex: u.subIndex,
-        isMerge: u.isMerge,
-        ...u.groupSha ? { groupSha: u.groupSha } : {},
-        ...u.authorDate ? { authorDate: u.authorDate } : {}
-      },
-      narrative: bundle.narrative,
-      fileList: bundle.fileList,
-      diff: bundle.diff,
-      pathTokens: Object.keys(bundle.pathTokens),
-      extractorVersion: HISTORY_EXTRACTOR_VERSION,
-      ...opts.frame ? { frame: opts.frame } : {},
-      ...dryRun ? { dryRun: true } : {}
-    };
-    const spine = await spineForUnit(git3, root, u);
-    if (spine) body2.spine = spine;
-    const anchors = anchorsFor(bundle.pathTokens, ignoreLines, projectId, opts.anchors);
-    if (anchors) {
-      body2.anchors = anchors;
-      body2.observedAtCommit = headSha;
-    }
+    const { body: body2, prepMs } = await prepare(k);
     profile = stage(profile, { state: dryRun ? "extracting" : "contributing", unitsDone: doneSoFar - 1, lastError: void 0 }, now);
     persist(profile);
     response = await reportHistoryStage(client, profile, log);
@@ -84251,15 +84479,21 @@ async function runHistoryWalk(root, input, client, opts = {}) {
       await reportHistoryStage(client, profile, log);
       return { profile, processed, state: "refused" };
     }
-    const started2 = Date.now();
+    await launch(k);
+    await launchAhead(k);
+    const head2 = launched.get(k);
+    launched.delete(k);
+    prepared.delete(k);
+    const started2 = head2.at;
+    let first = head2.settled;
     let outcome = null;
     let attempt = 0;
     while (outcome === null) {
       attempt += 1;
-      let res;
-      try {
-        res = await post(projectId, body2);
-      } catch (err2) {
+      const settled = await (first ?? settle(Promise.resolve().then(() => post(projectId, body2))));
+      first = null;
+      if ("err" in settled) {
+        const err2 = settled.err;
         const status = err2 instanceof CloudError ? err2.status : 0;
         const elapsed = Math.round((Date.now() - started2) / 1e3);
         if (Date.now() - started2 > RECOVERY_DEADLINE_MS) {
@@ -84272,6 +84506,8 @@ async function runHistoryWalk(root, input, client, opts = {}) {
         await sleep(attempt === 1 ? 1e4 : Math.min(3e4 * attempt, 12e4));
         continue;
       }
+      const res = settled.res;
+      if (res.ordered) doorOrders = true;
       if (res.status === "in_progress") {
         const retryAt = new Date(Date.now() + res.retryAfterMs).toISOString();
         if (Date.now() - started2 > RECOVERY_DEADLINE_MS) {
@@ -84280,12 +84516,14 @@ async function runHistoryWalk(root, input, client, opts = {}) {
           await reportHistoryStage(client, profile, log);
           return { profile, processed, state: "paused" };
         }
-        log(`[errata] history ${label}: run held by the door (lease), polling in ${Math.min(LEASE_POLL_MS, res.retryAfterMs) / 1e3}s`);
+        const why = res.waitingOn === "predecessor" ? `sent ahead, its predecessor ${res.predecessor === "failed" ? "failed" : "had not landed"} \u2014 re-POSTing in turn` : "run held by the door (lease)";
+        log(`[errata] history ${label}: ${why}, polling in ${Math.min(LEASE_POLL_MS, res.retryAfterMs) / 1e3}s`);
         await sleep(Math.min(LEASE_POLL_MS, Math.max(1e3, res.retryAfterMs)));
         continue;
       }
       outcome = res;
     }
+    await launchAhead(k);
     switch (outcome.status) {
       case "completed": {
         if (outcome.result.nodes.length !== outcome.counts.nodes || outcome.result.edges.length !== outcome.counts.edges) {
@@ -84296,7 +84534,7 @@ async function runHistoryWalk(root, input, client, opts = {}) {
         }
         const packages = new Set(outcome.result.nodes.filter((n) => n.decision !== "rejected" && n.canonicalId.startsWith("pkg:")).map((n) => n.canonicalId)).size;
         counts = addCounts(counts, { commitsWalked: 1, changesExtracted: 1, pairs: outcome.receipt.keptPairs, claims: outcome.receipt.claims, anchors: outcome.receipt.anchors, packages });
-        log(`[errata] history ${label}: ${outcome.result.nodes.length} nodes, ${outcome.result.edges.length} edges (${outcome.receipt.keptPairs} pairs, ${outcome.receipt.claims} claims)`);
+        log(`[errata] history ${label}: ${outcome.result.nodes.length} nodes, ${outcome.result.edges.length} edges (${outcome.receipt.keptPairs} pairs, ${outcome.receipt.claims} claims)${unitTiming(started2, prepMs, outcome.receipt)}`);
         break;
       }
       case "replayed": {
@@ -84307,7 +84545,7 @@ async function runHistoryWalk(root, input, client, opts = {}) {
       case "empty":
       case "dry-run":
         counts = addCounts(counts, { commitsWalked: 1, changesExtracted: outcome.status === "dry-run" ? 1 : 0, pairs: outcome.receipt.keptPairs, claims: outcome.receipt.claims });
-        log(`[errata] history ${label}: ${outcome.status} (${outcome.receipt.keptPairs} pairs, dropped ${outcome.receipt.droppedByEvidence} by evidence, ${outcome.receipt.droppedByAnchor} by anchor)`);
+        log(`[errata] history ${label}: ${outcome.status} (${outcome.receipt.keptPairs} pairs, dropped ${outcome.receipt.droppedByEvidence} by evidence, ${outcome.receipt.droppedByAnchor} by anchor)${unitTiming(started2, prepMs, outcome.receipt)}`);
         break;
       case "refused":
         profile = stage(profile, { state: "refused", lastError: `unit ${label} refused: ${outcome.reason}` }, now);
@@ -84389,12 +84627,12 @@ function applyStopRequest(profile, now = () => /* @__PURE__ */ new Date()) {
     }
   };
 }
-async function startHistoryStage(root, input, client, walk10 = {}) {
+async function startHistoryStage(root, input, client, walk11 = {}) {
   let profile = input;
   if (!profile.projectId) return { started: false, reason: "no-project", profile };
   const response = await reportHistoryStage(client, profile);
-  if (response?.consents && walk10.applyConsents) {
-    profile = walk10.applyConsents(profile, response.consents);
+  if (response?.consents && walk11.applyConsents) {
+    profile = walk11.applyConsents(profile, response.consents);
   }
   const consents = historyConsents(profile);
   if (response?.stopRequested && profile.historyStage && profile.historyStage.state !== "refused") {
@@ -84403,7 +84641,7 @@ async function startHistoryStage(root, input, client, walk10 = {}) {
     return { started: false, reason: "stopped", profile: stopped };
   }
   if (!consents.mineHistory) return { started: false, reason: "consent-pending", profile };
-  const outcome = await runHistoryWalk(root, profile, client, walk10);
+  const outcome = await runHistoryWalk(root, profile, client, walk11);
   return { started: true, profile: outcome.profile };
 }
 
@@ -87100,9 +87338,9 @@ function deriveAuthBase(verificationUri) {
 }
 function openInBrowser(url2) {
   try {
-    void import("node:child_process").then(({ spawn: spawn4 }) => {
+    void import("node:child_process").then(({ spawn: spawn5 }) => {
       const [cmd2, args2] = process.platform === "win32" ? ["cmd", ["/c", "start", "", url2]] : process.platform === "darwin" ? ["open", [url2]] : ["xdg-open", [url2]];
-      spawn4(cmd2, args2, { detached: true, stdio: "ignore" }).unref();
+      spawn5(cmd2, args2, { detached: true, stdio: "ignore" }).unref();
     });
   } catch {
   }
@@ -89745,7 +89983,7 @@ function spawnDaemonDetached(options = {}) {
     out2 = openSync2(logPath, "a");
   } catch {
   }
-  spawn3(cmd2, args2, {
+  spawn4(cmd2, args2, {
     detached: true,
     stdio: ["ignore", out2, out2],
     windowsHide: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inerrata-corporation/errata",
-  "version": "2.0.6-dev.2657",
+  "version": "2.0.6-dev.2681",
   "description": "errata - local-first observation engine for AI coding agents",
   "type": "module",
   "bin": {