session-orchestrator 5.7.0 → 5.8.0

package/scripts/lib/test-sibling-coverage.mjs

@@ -0,0 +1,167 @@
+#!/usr/bin/env node
+/**
+ * test-sibling-coverage.mjs — THE measurement behind the Test-Sibling Expansion
+ * figures (#970) in skills/wave-executor/references/wave-loop-scope-manifest.md.
+ *
+ * ## Why this file exists
+ *
+ * The expansion grants a GLOB (`tests/**\/{basename}*.test.mjs`) instead of a
+ * computed path, and the manifest justified that with three hand-measured counts
+ * (439 / 375 / 272 at `730ee9d`). Those numbers lived in prose, went stale, and a
+ * second contradicting copy appeared in a code comment (#1026.5, #1030 P3). Same
+ * cure as `tests-src-ratio.mjs`: the recipe is code, the `--json` envelope
+ * carries its own definition, and the docs point here instead of restating it.
+ *
+ * ## The recipe
+ *
+ *   universe     `git ls-files` (the index — tracked paths only)
+ *   tests        tracked files matching DEFAULT_TEST_PATH_PATTERNS (scope-gate)
+ *   production   tracked files matching a DEFAULT_TEST_SIBLING_RULES `source`
+ *                that are NOT tests — defined by negation, so a new top-level
+ *                directory is counted the moment it is committed
+ *   glob         production files where a sibling glob from `testSiblingsFor()`
+ *                matches a test via `pathMatchesPattern()` — the exact matcher
+ *                the scope gate grants with, reused rather than re-derived
+ *   exact        production files with a test under `tests/` whose basename is
+ *                exactly `<stem>.test<ext>`
+ *   mirror       production files whose 1:1 mirror exists: `tests/` + the path
+ *                with a leading `scripts/` dropped, `<ext>` → `.test<ext>`
+ *
+ * By construction mirror ⊆ exact ⊆ glob ⊆ production, so the counts must obey
+ * mirror ≤ exact ≤ glob ≤ total; a violation means a broken definition.
+ *
+ * Usage: test-sibling-coverage.mjs [<repo-root>] [--json]
+ * Exit:  0 measured · 2 tool error (not a git repo, bad argument)
+ */
+
+import { execFileSync } from 'node:child_process';
+import path from 'node:path';
+
+import {
+  DEFAULT_TEST_PATH_PATTERNS,
+  DEFAULT_TEST_SIBLING_RULES,
+  pathMatchesPattern,
+  testSiblingsFor,
+} from './scope-gate.mjs';
+import { isMainModule } from './is-main-module.mjs';
+
+/** Machine-readable schema tag for the --json envelope. */
+export const SCHEMA = 'test-sibling-coverage/1';
+
+const isTest = (p) => DEFAULT_TEST_PATH_PATTERNS.some((pat) => pathMatchesPattern(p, pat));
+const isProduction = (p) =>
+  !isTest(p) && DEFAULT_TEST_SIBLING_RULES.some((r) => pathMatchesPattern(p, r.source));
+
+/** `scripts/lib/x.mjs` → { stem: 'x', ext: '.mjs' } */
+function stemOf(p) {
+  const ext = path.posix.extname(p);
+  return { stem: path.posix.basename(p, ext), ext };
+}
+
+/** The 1:1 mirror path the manifest's "naive mirror" figure counts. */
+export function mirrorPathOf(p) {
+  const { ext } = stemOf(p);
+  const rel = p.startsWith('scripts/') ? p.slice('scripts/'.length) : p;
+  return `tests/${rel.slice(0, rel.length - ext.length)}.test${ext}`;
+}
+
+/**
+ * Measure the three coverage counts over a path list. Pure.
+ * @param {string[]} files — repo-relative POSIX paths
+ * @returns {{total: number, glob: number, exact: number, mirror: number, uncovered: string[]}}
+ */
+export function measure(files) {
+  const tests = files.filter(isTest);
+  const testSet = new Set(tests);
+  const testBasenames = new Set(tests.filter((t) => t.startsWith('tests/')).map((t) => path.posix.basename(t)));
+  const production = files.filter(isProduction);
+  let glob = 0;
+  let exact = 0;
+  let mirror = 0;
+  const uncovered = [];
+  for (const p of production) {
+    const globs = testSiblingsFor([p]);
+    // Linear scan of every test per glob — 0.3 s wall for the whole CLI at 571
+    // production files (2026-10-03); revisit if the tracked test count passes ~5000.
+    if (globs.some((g) => tests.some((t) => pathMatchesPattern(t, g)))) glob += 1;
+    else uncovered.push(p);
+    const { stem, ext } = stemOf(p);
+    if (testBasenames.has(`${stem}.test${ext}`)) exact += 1;
+    if (testSet.has(mirrorPathOf(p))) mirror += 1;
+  }
+  return { total: production.length, glob, exact, mirror, uncovered };
+}
+
+/** The self-describing definition block shipped inside every --json envelope. */
+export function definition() {
+  return {
+    source: 'git ls-files (tracked paths only)',
+    tests: `tracked paths matching scope-gate DEFAULT_TEST_PATH_PATTERNS: ${DEFAULT_TEST_PATH_PATTERNS.join(', ')}`,
+    total: `production files: tracked paths matching a sibling-rule source (${DEFAULT_TEST_SIBLING_RULES.map((r) => r.source).join(', ')}) that are not tests`,
+    glob: `production files where a scope-gate testSiblingsFor() glob (${DEFAULT_TEST_SIBLING_RULES.map((r) => r.sibling).join(', ')}) matches a test via pathMatchesPattern`,
+    exact: 'production files with a test under tests/ whose basename is exactly <stem>.test<ext>',
+    mirror: 'production files whose mirror tests/<path minus leading scripts/, <ext> -> .test<ext>> is tracked',
+    invariant: 'mirror <= exact <= glob <= total',
+  };
+}
+
+function git(root, args) {
+  return execFileSync('git', args, { cwd: root, encoding: 'utf8', maxBuffer: 64 * 1024 * 1024, stdio: ['ignore', 'pipe', 'ignore'] });
+}
+
+const pct = (n, d) => (d === 0 ? null : Math.round((n / d) * 1000) / 10);
+
+function main(argv) {
+  let json = false;
+  let root = process.cwd();
+  for (const a of argv) {
+    if (a === '--json') json = true;
+    else if (a.startsWith('--')) {
+      process.stderr.write(`Unknown argument '${a}'. Usage: test-sibling-coverage.mjs [<repo-root>] [--json]\n`);
+      return 2;
+    } else root = path.resolve(a);
+  }
+  let files;
+  let ref;
+  let dirty;
+  try {
+    files = git(root, ['ls-files']).split('\n').filter(Boolean);
+    ref = git(root, ['rev-parse', '--short', 'HEAD']).trim();
+    // The index IS the measured population: only a staged add/delete/rename
+    // makes (ref, counts) unreproducible. --no-optional-locks: no index refresh
+    // under a parallel session (PSA-007).
+    dirty = git(root, ['--no-optional-locks', 'diff', '--cached', '--name-only', '--diff-filter=ADR']).trim() !== '';
+  } catch (error) {
+    process.stderr.write(`ERROR: git failed in ${root}: ${error.message}\n`);
+    return 2;
+  }
+  const r = measure(files);
+  const envelope = {
+    schema: SCHEMA,
+    ref,
+    dirty,
+    measuredAt: new Date().toISOString().slice(0, 10),
+    total: r.total,
+    glob: r.glob,
+    exact: r.exact,
+    mirror: r.mirror,
+    percent: { glob: pct(r.glob, r.total), exact: pct(r.exact, r.total), mirror: pct(r.mirror, r.total) },
+    uncovered: r.uncovered,
+    definition: definition(),
+  };
+  if (json) {
+    process.stdout.write(`${JSON.stringify(envelope, null, 2)}\n`);
+  } else {
+    const line = (k) => `  ${k.padEnd(7)} ${String(r[k]).padStart(5)} / ${r.total}  (${envelope.percent[k]} %)`;
+    process.stdout.write(
+      `test-sibling coverage at ${ref}${dirty ? ' (index differs from HEAD)' : ''}, ${envelope.measuredAt}\n`
+      + `${line('glob')}\n${line('exact')}\n${line('mirror')}\n`
+      + `  uncovered by the glob: ${r.uncovered.length} (list: --json)\n`,
+    );
+  }
+  return 0;
+}
+
+if (isMainModule(import.meta.url)) {
+  process.exitCode = main(process.argv.slice(2));
+}

package/scripts/lib/tmux-layout/telemetry-stats.mjs

@@ -15,11 +15,9 @@
  */
 
 import path from 'node:path';
-import { readEventsWithRotations } from '../events.mjs';
+import { eventsFilePath, readEventsWithRotations } from '../events.mjs';
 import { isMainModule } from '../is-main-module.mjs';
 
-const EVENTS_PATH = '.orchestrator/metrics/events.jsonl';
-
 /** Every event this module reports on carries this prefix. */
 const TMUX_EVENT_PREFIX = 'tmux-layout.';
 
@@ -58,11 +56,11 @@ export const REQUIRED_EVENTS_WINDOW_DAYS = null;
  * the session path. Revisit if this module gains a hot-path caller or if
  * `max-size-mb` is raised past ~100.
  *
- * @param {string} [eventsPath=.orchestrator/metrics/events.jsonl]
+ * @param {string} [eventsPath=eventsFilePath()]  the repo's one ledger (#1514)
  * @returns {{events: Array<object>, complete: boolean|null, gaps: Array<object>,
  *            notices: Array<object>}}
  */
-export function readTmuxEventsEnvelope(eventsPath = EVENTS_PATH) {
+export function readTmuxEventsEnvelope(eventsPath = eventsFilePath()) {
   const { events, gaps, complete, notices } = readEventsWithRotations(undefined, {
     filePath: eventsPath,
   });
@@ -83,10 +81,10 @@ export function readTmuxEventsEnvelope(eventsPath = EVENTS_PATH) {
  * existing caller expects. Use the envelope when the completeness of the read
  * matters to the answer.
  *
- * @param {string} [eventsPath=.orchestrator/metrics/events.jsonl]
+ * @param {string} [eventsPath=eventsFilePath()]  the repo's one ledger (#1514)
  * @returns {Array<object>}  parsed event records (filtered to tmux-layout.* events)
  */
-export function readTmuxEvents(eventsPath = EVENTS_PATH) {
+export function readTmuxEvents(eventsPath = eventsFilePath()) {
   return readTmuxEventsEnvelope(eventsPath).events;
 }
 

package/scripts/lib/tmux-layout/telemetry.mjs

@@ -19,17 +19,15 @@ import { appendFileSync, mkdirSync, existsSync } from 'node:fs';
 import path from 'node:path';
 
 import { findProjectRoot } from '../common.mjs';
+import { eventsFilePath } from '../events.mjs';
 import { stampEventSchemaVersion, validateEventRecord } from '../events-schema.mjs';
 
-/**
- * Path FRAGMENT joined against a resolved repo root at write time — NOT a
- * relative path constant. A relative constant resolves against process.cwd(),
- * which is how ~8k test-emitted tmux events landed in the real ledger: the
- * suite spawns scripts/tmux-layout.mjs with cwd = repo root, so every
- * telemetry write went straight into production telemetry.
- * Same shape as scripts/lib/session-close-backfill.mjs § EVENTS_REL.
- */
-const EVENTS_REL = ['.orchestrator', 'metrics', 'events.jsonl'];
+// The ledger path is resolved against a repo root at write time — NEVER a
+// relative path constant. A relative constant resolves against process.cwd(),
+// which is how ~8k test-emitted tmux events landed in the real ledger: the
+// suite spawns scripts/tmux-layout.mjs with cwd = repo root, so every
+// telemetry write went straight into production telemetry. The path is
+// `eventsFilePath(<root>)` (#1514: the repo's one ledger).
 
 /**
  * True when this process is a vitest run, or a child spawned by one
@@ -56,7 +54,7 @@ function isTestRunner() {
 export function emit(eventType, payload = {}, { repoRoot } = {}) {
   try {
     if (!repoRoot && isTestRunner()) return;
-    const eventsPath = path.join(repoRoot || findProjectRoot(), ...EVENTS_REL);
+    const eventsPath = eventsFilePath(repoRoot || findProjectRoot()); // #1514: the repo's one ledger
     const dir = path.dirname(eventsPath);
     if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
     // `stampEventSchemaVersion()` rather than an inline `schema_version:` —

package/scripts/lib/user-invocable-skills.mjs

@@ -6,11 +6,13 @@
  * Since the #1370 command→skill fold (2026-09-16) `commands/` holds only the two
  * names that cannot be a skill (`session`, `templates-ack` — see
  * `tests/commands/headless-bare-command-availability.test.mjs` for the measured
- * mechanism). Every other slash command IS a skill, marked by an EXPLICIT
- * `user-invocable: true` in its SKILL.md frontmatter. Consumers that used to
+ * mechanism). Every other slash command IS a skill. Claude Code lists a skill in
+ * the `/` picker unless its frontmatter says `user-invocable: false` — a MISSING
+ * key counts as `true` (#1515, measured 2026-10-03: 37 picker entries against a
+ * documented 27, because 10 skills carried no key). Consumers that used to
  * count or link `commands/*.md` therefore need the union:
  *
- *   commands/*.md  ∪  skills with explicit `user-invocable: true`
+ *   commands/*.md  ∪  skills whose `user-invocable` is absent or `true`
  *
  * This module exists so that union has one implementation rather than one per
  * consumer (site-numbers tile, sunset walker linkage, the guard tests). It is
@@ -29,6 +31,7 @@
 import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
 import path from 'node:path';
 import { parseAgentFrontmatter } from './agent-frontmatter.mjs';
+import { isHiddenSourceName } from './plugin-surface.mjs';
 
 /**
  * YAML 1.1 boolean lookalikes that YAML 1.2 / js-yaml's CORE_SCHEMA (what
@@ -85,9 +88,10 @@ function normaliseScalar(text) {
  * route through this function; four private re-implementations disagreeing on a
  * quoted value is the defect this replaces.
  *
- * Explicit-true only. `undefined` (flag absent) is NOT user-invocable: the whole
- * point of the marker is that it is written down, so a skill that forgot it is a
- * defect to surface, not a default to guess.
+ * Judges a PRESENT value only: `undefined` returns `false`. Whether an ABSENT
+ * `user-invocable` key makes a skill a slash command is a question about the
+ * whole frontmatter, answered by {@link isUserInvocableSkill} (absent = true,
+ * as Claude Code reads it — #1515).
  *
  * Accepted: the boolean `true`, and a string that normalises to `true`
  * case-insensitively — so `"true"`, `'true'`, `True`, `true # note` and
@@ -155,7 +159,30 @@ export function parseSkillFrontmatter(content) {
 }
 
 /**
- * Names of skills carrying an explicit `user-invocable: true`, sorted.
+ * Claude Code's picker semantics for one parsed SKILL.md frontmatter: the key
+ * ABSENT means invocable; a present key goes through
+ * {@link isUserInvocableValue}. Kept apart from that predicate on purpose —
+ * the sibling marker `disable-model-invocation` shares the value normaliser
+ * but defaults to `false` when absent.
+ *
+ * Every generator (Cursor, Pi, Codex, agents surface) and every counter routes
+ * the skill-level question through here, so an absent key cannot be a slash
+ * command for the census and a non-command for the adapters (#1515 MED-2).
+ * `check-skills` additionally requires the key to be written down, so the
+ * absent branch is the harness-parity fallback, not the expected path.
+ *
+ * @param {Record<string, unknown>|null|undefined} frontmatter
+ * @param {string} [file] path named in a lookalike WARN
+ * @returns {boolean} `false` for a missing/non-object frontmatter (fail-closed)
+ */
+export function isUserInvocableSkill(frontmatter, file) {
+  if (!frontmatter || typeof frontmatter !== 'object') return false;
+  if (!Object.hasOwn(frontmatter, 'user-invocable')) return true;
+  return isUserInvocableValue(frontmatter['user-invocable'], file);
+}
+
+/**
+ * Names of skills that appear in the `/` picker (key absent or `true`), sorted.
  *
  * @param {string} repoRoot plugin root (the directory holding `skills/`)
  * @returns {string[]}
@@ -165,7 +192,7 @@ export function userInvocableSkills(repoRoot) {
   if (!existsSync(dir) || !statSync(dir).isDirectory()) return [];
   const names = [];
   for (const entry of readdirSync(dir, { withFileTypes: true })) {
-    if (!entry.isDirectory() || entry.name.startsWith('.')) continue;
+    if (!entry.isDirectory() || isHiddenSourceName(entry.name)) continue;
     const file = path.join(dir, entry.name, 'SKILL.md');
     if (!existsSync(file) || !statSync(file).isFile()) continue;
     let fm;
@@ -174,7 +201,7 @@ export function userInvocableSkills(repoRoot) {
     } catch {
       continue;
     }
-    if (fm && isUserInvocableValue(fm['user-invocable'], file)) names.push(entry.name);
+    if (fm && isUserInvocableSkill(fm, file)) names.push(entry.name);
   }
   return names.sort();
 }
@@ -184,7 +211,7 @@ export function commandFileNames(repoRoot) {
   const dir = path.join(repoRoot, 'commands');
   if (!existsSync(dir) || !statSync(dir).isDirectory()) return [];
   return readdirSync(dir)
-    .filter((f) => f.endsWith('.md') && !f.startsWith('.'))
+    .filter((f) => f.endsWith('.md') && !isHiddenSourceName(f))
     .map((f) => f.replace(/\.md$/, ''))
     .sort();
 }

package/scripts/lib/ux-grill/run-record.mjs

@@ -32,6 +32,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 
+import { atomicWriteWithBackup, envelopeToError } from '../io.mjs';
 import { findingsPath, runRecordPath } from './paths.mjs';
 import { makeRunRecord } from './schema.mjs';
 
@@ -290,9 +291,10 @@ export function updateRunRecordCompare(repoRoot, runId, compare) {
     out.push(raw);
   }
 
-  const tmp = `${ledger}.${process.pid}.tmp`;
-  fs.writeFileSync(tmp, out.length > 0 ? `${out.join('\n')}\n` : '', 'utf8');
-  fs.renameSync(tmp, ledger);
+  const res = atomicWriteWithBackup(ledger, out.length > 0 ? `${out.join('\n')}\n` : '', {
+    tmpPrefix: `.${path.basename(ledger)}.tmp`,
+  });
+  if (!res.ok) throw envelopeToError(res);
   return { updated, skippedLines };
 }
 

package/scripts/lib/validate/check-banner-parity.mjs

@@ -187,6 +187,7 @@ export function collectMarkdownFiles(pluginRoot) {
       const output = execFileSync('git', ['ls-files', '-z', '--', ...SCAN_DIRS], {
         cwd: pluginRoot,
         encoding: 'utf8',
+        maxBuffer: 64 * 1024 * 1024,
         stdio: ['ignore', 'pipe', 'ignore'],
         env,
       });

package/scripts/lib/validate/check-skills.mjs

@@ -93,7 +93,7 @@ function collectSkillFiles(skillsDir) {
  *
  * Rules: R1 frontmatter block present · R8 block parses as a YAML mapping ·
  * R2 `name` present · R3 `name` is kebab-case · R5 `name` === directory name ·
- * R6 `description` present and non-empty.
+ * R6 `description` present and non-empty · R9 `user-invocable` stated explicitly.
  *
  * @param {{ dirName: string, relPath: string, absPath: string }} skill
  * @returns {boolean} true when every rule holds
@@ -148,6 +148,16 @@ function validateSkillFrontmatter(skill) {
     fail(`${skill.relPath}: missing or empty required frontmatter field: description`);
   }
 
+  // R9 — `user-invocable` written down. Claude Code lists a skill WITHOUT the
+  // key in the `/` picker (#1515: 37 entries against a documented 27, from 10
+  // keyless skills). The census and the adapter generators now follow that
+  // reading (`isUserInvocableSkill`), but a forgotten key is still an
+  // unreviewed picker entry — so the decision must be explicit: `true` for an
+  // operator command, `false` for a helper the model dispatches.
+  if (!Object.hasOwn(frontmatter, 'user-invocable')) {
+    fail(`${skill.relPath}: missing required frontmatter field: user-invocable (Claude Code treats an absent key as true and lists the skill in the / picker — write \`user-invocable: true\` for an operator command or \`user-invocable: false\` for a helper)`);
+  }
+
   return failed === before;
 }
 
@@ -180,7 +190,7 @@ if (!existsSync(skillsDir)) {
     }
 
     if (valid === skills.length) {
-      pass(`all ${skills.length} ${SKILL_FILE} frontmatter blocks parse as YAML and carry a kebab-case name matching their directory plus a non-empty description`);
+      pass(`all ${skills.length} ${SKILL_FILE} frontmatter blocks parse as YAML and carry a kebab-case name matching their directory, a non-empty description and an explicit user-invocable`);
     }
   }
 }

package/scripts/lib/validate/check-test-fixture-shapes.mjs

@@ -154,10 +154,10 @@ const MAGIC_COMMENT_SCAN_LINES = 5;
 function getTrackedTestFiles() {
   let output;
   try {
-    output = execFileSync('git', ['ls-files'], { cwd: pluginRoot, encoding: 'utf8' });
+    output = execFileSync('git', ['ls-files'], { cwd: pluginRoot, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], maxBuffer: 64 * 1024 * 1024 });
   } catch {
-    // Not a git repo or git unavailable — return empty (caller treats as pass)
-    return [];
+    console.error('Error: unable to enumerate tracked test files with git ls-files');
+    process.exit(2);
   }
   return output
     .split('\n')

package/scripts/lib/validate/check-test-value-bans.mjs

@@ -461,9 +461,10 @@ const LOCAL_IMPORT = new RegExp(
 function trackedTestFiles() {
   let out;
   try {
-    out = execFileSync('git', ['ls-files'], { cwd: repoRoot, encoding: 'utf8' });
+    out = execFileSync('git', ['ls-files'], { cwd: repoRoot, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], maxBuffer: 64 * 1024 * 1024 });
   } catch {
-    return []; // not a git repo — nothing to scan
+    console.error('Error: unable to enumerate tracked test files with git ls-files');
+    process.exit(2);
   }
   return out
     .split('\n')

package/scripts/lib/validate/check-unicode-safety.mjs

@@ -114,7 +114,7 @@ function walkDir(root, dir, acc = []) {
 export function getTrackedFiles(root) {
   let files;
   try {
-    const output = execFileSync('git', ['ls-files'], { cwd: root, encoding: 'utf8' });
+    const output = execFileSync('git', ['ls-files'], { cwd: root, encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 });
     files = output.split('\n').filter(Boolean).map((f) => join(root, f));
   } catch {
     files = walkDir(root, root);

package/scripts/lib/validate/check-unwired-features.mjs

@@ -451,7 +451,7 @@ const ALLOWLIST = Object.freeze({
   'auto-skill-dispatch':
     'prose-only consumer — skills/using-orchestrator/SKILL.md + skills/_shared/bootstrap-gate.md read this key as an LLM instruction; there is no .mjs gate by design',
   'auto-commit-per-wave':
-    'prose-only consumer — skills/wave-executor/wave-loop.md gates the per-wave commit step on this key; the commit itself is a coordinator action, not a script',
+    'planned no-op (#1219) — only skills/wave-executor/references/wave-loop-review.md names this key, as contract prose; no per-wave commit step runs on it yet (scripts/lib/auto-commit.mjs does not exist)',
   'instruction-budget':
     'dedicated reader outside the parser layer — scripts/lib/instruction-budget-guard.mjs parses this block itself (S2 exemption only; S1 evidence is real)',
 });

package/scripts/lib/vault-archive.mjs

@@ -16,10 +16,8 @@
  *
  * ── Frontmatter schema (mirror, not import) ─────────────────────────────────
  * The canonical vault frontmatter schema is the GENERATED Zod block in
- * skills/vault-sync/validator.mjs (Z.104-134). That schema is NOT exported, and
- * `zod` is not a dependency of scripts/ (it lives only as a skill-local shim in
- * skills/vault-sync/node_modules/). So the field constraints below are a
- * hand-rolled MIRROR of that schema. If the canonical schema changes, update the
+ * skills/vault-sync/validator.mjs (Z.104-134). That schema is NOT exported, so
+ * the field constraints below are a hand-rolled MIRROR of that schema. If the canonical schema changes, update the
  * constants here to match. The mirror is proven equivalent by an integration
  * test that runs the REAL validator subprocess over generated output
  * (tests/lib/vault-archive.test.mjs § "REAL validator").