vigiles 15.4.0 → 16.0.0

package/dist/audit-score.d.ts

@@ -23,7 +23,7 @@
  * design). NB the EXECUTING
  * "do your hooks actually block?" disaster-battery is STILL not an `audit` ring:
  * running arbitrary hooks safely needs cross-platform confinement that isn't
- * shipped yet, so the battery lives in the `vigiles/testing` API via
+ * shipped yet, so the battery lives in the `vigiles` testing API via
  * `guardrail-check`/`assertBlocksDisasters`, where you opt in explicitly.
  *
  * TESTED vs EVALUATED are two rings, not one, because a harness and an eval differ

package/dist/audit-score.js

@@ -28,7 +28,7 @@ exports.formatAuditScore = formatAuditScore;
  * design). NB the EXECUTING
  * "do your hooks actually block?" disaster-battery is STILL not an `audit` ring:
  * running arbitrary hooks safely needs cross-platform confinement that isn't
- * shipped yet, so the battery lives in the `vigiles/testing` API via
+ * shipped yet, so the battery lives in the `vigiles` testing API via
  * `guardrail-check`/`assertBlocksDisasters`, where you opt in explicitly.
  *
  * TESTED vs EVALUATED are two rings, not one, because a harness and an eval differ
@@ -49,7 +49,7 @@ const score_core_js_1 = require("./score-core.js");
 const W_UNTESTED = 3;
 /** The command that answers the firing question — named, not alluded to. */
 const MEASURE_FIRING_COMMAND = "run `npx vigiles audit` interactively to measure, or add a `*.eval.mjs` " +
-    "(`measureTriggerRate`, vigiles/testing)";
+    "(`paid_measureTriggerRate`, vigiles/eval)";
 /** Resolve the terse "thing(s)" plural placeholder against a count:
  * n===1 drops the "(s)" ("1 tool"); otherwise it becomes "s" ("3 tools"). */
 function pluralizeLabel(n, label) {

package/dist/check-count.js

@@ -46,7 +46,7 @@ exports.armCheckReport = armCheckReport;
  * tool avoids.
  *
  * WHAT A MISSING COUNT MEANS: nothing at all. A script that never imports
- * `vigiles/testing` cannot report, so the runner sees no file and treats it
+ * `vigiles` cannot report, so the runner sees no file and treats it
  * exactly as before — a plain pass. Silence is the legacy branch, never a
  * verdict; only a count of literally zero is a finding. (The alternative —
  * force-loading this module into every child with `node --import` so silence

package/dist/claude-code.d.ts

@@ -2,7 +2,7 @@
  * `vigiles/claude-code` — the Claude Code-specific harness pieces a *different*
  * harness would swap out: the plugin/repo loader (reads real Claude Code plugin
  * layouts) and the scriptable Anthropic Messages mock. Split from
- * `vigiles/testing` on purpose — the test API above is the stable surface; this
+ * the `vigiles` root on purpose — the test API above is the stable surface; this
  * is the adapter, so a future `vigiles/<other-harness>` can sit beside it.
  */
 export * from "./adapters/claude-code/plugin-loader.js";

package/dist/claude-code.js

@@ -19,7 +19,7 @@ exports.formatSelectionReport = exports.assertNoCollision = exports.measureSelec
  * `vigiles/claude-code` — the Claude Code-specific harness pieces a *different*
  * harness would swap out: the plugin/repo loader (reads real Claude Code plugin
  * layouts) and the scriptable Anthropic Messages mock. Split from
- * `vigiles/testing` on purpose — the test API above is the stable surface; this
+ * the `vigiles` root on purpose — the test API above is the stable surface; this
  * is the adapter, so a future `vigiles/<other-harness>` can sit beside it.
  */
 __exportStar(require("./adapters/claude-code/plugin-loader.js"), exports);
@@ -28,7 +28,7 @@ __exportStar(require("./mock-model.js"), exports);
 // helpers + the `claude` capability probe. Agnostic users never need these
 // (`runHarnessTest` defaults to the CC driver), but they're exposed here — beside
 // the Codex driver in `vigiles/codex` — for CC-specific tests/tooling. They are
-// deliberately NOT on the agnostic `vigiles/testing` surface.
+// deliberately NOT on the agnostic `vigiles` surface.
 var harness_test_js_1 = require("./harness-test.js");
 Object.defineProperty(exports, "claudeCodeDriver", { enumerable: true, get: function () { return harness_test_js_1.claudeCodeDriver; } });
 Object.defineProperty(exports, "buildClaudeArgs", { enumerable: true, get: function () { return harness_test_js_1.buildClaudeArgs; } });
@@ -50,7 +50,7 @@ Object.defineProperty(exports, "agent", { enumerable: true, get: function () { r
 Object.defineProperty(exports, "experimental_skill", { enumerable: true, get: function () { return typed_spec_js_1.experimental_skill; } });
 // Selection-collision — a Claude-Code-ONLY behavioral measurement (Codex has no
 // skill-selection event to read), so it lives on this surface, not the agnostic
-// `vigiles/testing`. `measureSelectionMatrix` builds the N×N "which skill fired?"
+// `vigiles`. `measureSelectionMatrix` builds the N×N "which skill fired?"
 // matrix (diagonal = recall, off-diagonal = collision); `assertNoCollision` gates it.
 var scan_behavioral_js_1 = require("./scan-behavioral.js");
 Object.defineProperty(exports, "measureSelectionMatrix", { enumerable: true, get: function () { return scan_behavioral_js_1.measureSelectionMatrix; } });

package/dist/cli.js

@@ -1702,7 +1702,7 @@ function formatTriggerNudge(triggerableSkills) {
         return "";
     const n = triggerableSkills;
     return (`ℹ Do your ${String(n)} skill${n === 1 ? "" : "s"} actually fire? The deterministic read can't tell — ` +
-        `run \`audit\` interactively to measure, or test with \`measureTriggerRate\` (vigiles/testing).`);
+        `run \`audit\` interactively to measure, or test with \`paid_measureTriggerRate\` (vigiles/eval).`);
 }
 /** A terminal summary of the rule map: the CONFIDENT lane counts + the POSSIBLE
  * (review) and SKIPPED tiers, with the honest caveat that detection is a
@@ -1973,7 +1973,7 @@ function vigilesWorkflow(plan, harnesses, hasPackageJson) {
 `
         : "";
     // The test pillar's harness job runs `*.harness.mjs` files that
-    // `import "vigiles/testing"`, so it needs vigiles RESOLVABLE — a package.json +
+    // `import "vigiles"`, so it needs vigiles RESOLVABLE — a package.json +
     // install. A repo with no package.json can't run the JS test tier in CI at all
     // (the import won't resolve even though the CLI itself came from npx), so the
     // harness job is emitted ONLY when a package.json exists (Codex review / #111 /
@@ -2136,7 +2136,7 @@ const STARTER_HARNESS = `/**
  *
  * Guide: https://github.com/zernie/vigiles/blob/main/docs/harness-testing.md
  */
-import { runHook } from "vigiles/testing";
+import { runHook } from "vigiles";
 import assert from "node:assert/strict";
 
 // EXAMPLE — replace with one of YOUR hooks. This PreToolUse Bash guard blocks a
@@ -4384,7 +4384,7 @@ const COMMAND_HELP = {
         usage: "  vigiles audit [dir...]          Lighthouse for your harness — a LOCAL report: rings + what's broken + fixes (a deterministic read; 2+ dirs → leaderboard)",
         detail: [
             "                                 writes vigiles-report.html + .json (auto-gitignored; --out=<dir> · --no-html/--no-json · --no-open · --json for machine output). NOT a CI step — use `vigiles lint` in CI.",
-            "                                 the executing checks (run your hooks · live MCP · do skills fire?) run only interactively — `audit` asks once (remembered); automation uses the vigiles/testing API",
+            "                                 the executing checks (run your hooks · live MCP · do skills fire?) run only interactively — `audit` asks once (remembered); automation uses the vigiles testing API",
             "                                 --serve opens a LIVE local report whose buttons create specs in one click (own repo only; loopback + token-guarded) · --no-serve to skip the prompt",
         ],
     },
@@ -4970,7 +4970,7 @@ function refsHookCommand() {
 // ---------------------------------------------------------------------------
 /**
  * Load a compiled-hook program's default export — the SHARED loader, also the
- * public `vigiles/testing` `loadHook` a `.harness.mjs` test uses, so a hook that
+ * public `vigiles` `loadHook` a `.harness.mjs` test uses, so a hook that
  * loads in a test loads identically here (one loader, no drift).
  */
 const loadHookProgram = load_hook_js_1.loadHook;
@@ -6135,7 +6135,7 @@ async function main() {
             // uses `vigiles lint`). The executing checks (safety battery + live MCP +
             // skill firing) run only on consent: at a TTY `audit` asks once (remembered
             // in `.vigilesrc.json`), headless it stays a read + a one-line nudge. There
-            // is NO execution flag — automation tests the harness via the vigiles/testing
+            // is NO execution flag — automation tests the harness via the vigiles testing
             // API + skills, not the report verb. See the `audit-side-effect-free` rule.
             const dirs = restArgs.length > 0 ? restArgs : ["."];
             const json = args.includes("--json");
@@ -6337,10 +6337,10 @@ async function main() {
                 // linter also executes it). A plain `audit` is a deterministic READ;
                 // these run only on consent — ASK once at a TTY (remembered); headless
                 // stays a read + a nudge (no execution flag — automation uses the
-                // vigiles/testing API). Resolved AFTER the report (so the read leads) but
+                // vigiles testing API). Resolved AFTER the report (so the read leads) but
                 // BEFORE the rule map is routed, so a first-time "yes" enriches THIS run.
                 // (The safety battery is NOT here — it needs cross-platform confinement
-                // that isn't shipped, so it lives in the vigiles/testing API.)
+                // that isn't shipped, so it lives in the vigiles testing API.)
                 // `surfaces` + `execDecision` were resolved above (the ring needed them);
                 // this only turns an `ask` into a prompt and remembers the answer.
                 const { execute, note: execNote } = await resolveExecution(surfaces, execDecision, json, adapter.name);

package/dist/codex.d.ts

@@ -1,6 +1,6 @@
 /**
  * `vigiles/codex` — the OpenAI Codex harness adapter. Sits beside
- * `vigiles/claude-code`: same harness-agnostic `vigiles/testing` core, a
+ * `vigiles/claude-code`: same harness-agnostic `vigiles` testing core, a
  * different transport (the `codex` binary + the OpenAI **Responses** SSE mock).
  *
  * Pillar 2 (harness testing) is proven here — `startCodexMock` serves the

package/dist/codex.js

@@ -16,7 +16,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * `vigiles/codex` — the OpenAI Codex harness adapter. Sits beside
- * `vigiles/claude-code`: same harness-agnostic `vigiles/testing` core, a
+ * `vigiles/claude-code`: same harness-agnostic `vigiles` testing core, a
  * different transport (the `codex` binary + the OpenAI **Responses** SSE mock).
  *
  * Pillar 2 (harness testing) is proven here — `startCodexMock` serves the

package/dist/core/spec.d.ts

@@ -399,12 +399,21 @@ export interface SkillStep {
     /** Max attempts to satisfy the gate before the step fails (default 1). */
     readonly retry?: number;
 }
-/** Declare a skill input (compiles to argument-hint + an Arguments entry). */
-export declare function input(name: string, hint: string, opts?: {
+/**
+ * Declare a skill input (compiles to argument-hint + an Arguments entry).
+ *
+ * Deliberately NOT a standalone export — reached as `experimental_skill.input`.
+ * The reason is on `experimental_skill` below.
+ */
+declare function input(name: string, hint: string, opts?: {
     required?: boolean;
 }): SkillInput;
-/** Declare a gated pipeline step. */
-export declare function step(instr: string | InstructionFragment[], opts?: {
+/**
+ * Declare a gated pipeline step.
+ *
+ * Deliberately NOT a standalone export — reached as `experimental_skill.step`.
+ */
+declare function step(instr: string | InstructionFragment[], opts?: {
     gate?: Gate;
     retry?: number;
 }): SkillStep;
@@ -504,9 +513,32 @@ export type SkillSpecInput<P extends AuthoredPurity | undefined, V extends ToolV
  * DIFFERENT function — a `Check<Trace>` taking an id string, asking whether a
  * skill fired. This one authors a skill; that one observes one.
  *
+ * Its helper vocabulary hangs off it — `experimental_skill.input(…)` and
+ * `experimental_skill.step(…)` — rather than being exported beside it. Both are
+ * used ONLY by skill specs (measured: zero uses in agent/claude specs, against
+ * `cmd`/`file`/`ref`/`result`, which are shared and therefore stay top-level).
+ * Hanging them here makes the experimental marking STRUCTURAL for the whole
+ * family: you cannot reach `input()` without naming `experimental_skill` first.
+ * The prefix convention alone could not do that — it is a habit, and it had
+ * already leaked once when `skill()` shipped stable-named against its own docs.
+ *
+ * Honest limit: `const { input } = experimental_skill` strips the marker again
+ * inside one file. What the shape actually guarantees is narrower and still
+ * worth having — an unmarked name never crosses the package boundary.
+ *
+ * `Object.assign` rather than `export namespace`: the latter is banned by this
+ * repo's own lint (`no-namespace: error`, inherited from strict-type-checked).
+ *
+ * @experimental
+ */
+declare function skillSpec<const P extends AuthoredPurity | undefined = undefined, V extends ToolVocabulary = OpenToolVocabulary>(spec: SkillSpecInput<P, V>): SkillSpec;
+/**
  * @experimental
  */
-export declare function experimental_skill<const P extends AuthoredPurity | undefined = undefined, V extends ToolVocabulary = OpenToolVocabulary>(spec: SkillSpecInput<P, V>): SkillSpec;
+export declare const experimental_skill: typeof skillSpec & {
+    input: typeof input;
+    step: typeof step;
+};
 /**
  * A subagent definition (compiles to `agents/<name>.md`). Unlike a skill —
  * reference material the model reads on activation — a subagent is a *delegated

package/dist/core/spec.js

@@ -10,7 +10,7 @@
  *   guidance() — prose only, no mechanical enforcement
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BUILTIN_LINTERS = void 0;
+exports.experimental_skill = exports.BUILTIN_LINTERS = void 0;
 exports.enforce = enforce;
 exports.guidance = guidance;
 exports.guard = guard;
@@ -24,9 +24,6 @@ exports.instructions = instructions;
 exports.experimental_effect = experimental_effect;
 exports.claude = claude;
 exports.project = project;
-exports.input = input;
-exports.step = step;
-exports.experimental_skill = experimental_skill;
 exports.agent = agent;
 exports.result = result;
 exports.delegate = delegate;
@@ -222,11 +219,20 @@ function claude(spec) {
 function project(role) {
     return { _ref: "role", role };
 }
-/** Declare a skill input (compiles to argument-hint + an Arguments entry). */
+/**
+ * Declare a skill input (compiles to argument-hint + an Arguments entry).
+ *
+ * Deliberately NOT a standalone export — reached as `experimental_skill.input`.
+ * The reason is on `experimental_skill` below.
+ */
 function input(name, hint, opts = {}) {
     return { name, hint, required: opts.required };
 }
-/** Declare a gated pipeline step. */
+/**
+ * Declare a gated pipeline step.
+ *
+ * Deliberately NOT a standalone export — reached as `experimental_skill.step`.
+ */
 function step(instr, opts = {}) {
     return { do: instr, gate: opts.gate, retry: opts.retry };
 }
@@ -245,11 +251,31 @@ function step(instr, opts = {}) {
  * DIFFERENT function — a `Check<Trace>` taking an id string, asking whether a
  * skill fired. This one authors a skill; that one observes one.
  *
+ * Its helper vocabulary hangs off it — `experimental_skill.input(…)` and
+ * `experimental_skill.step(…)` — rather than being exported beside it. Both are
+ * used ONLY by skill specs (measured: zero uses in agent/claude specs, against
+ * `cmd`/`file`/`ref`/`result`, which are shared and therefore stay top-level).
+ * Hanging them here makes the experimental marking STRUCTURAL for the whole
+ * family: you cannot reach `input()` without naming `experimental_skill` first.
+ * The prefix convention alone could not do that — it is a habit, and it had
+ * already leaked once when `skill()` shipped stable-named against its own docs.
+ *
+ * Honest limit: `const { input } = experimental_skill` strips the marker again
+ * inside one file. What the shape actually guarantees is narrower and still
+ * worth having — an unmarked name never crosses the package boundary.
+ *
+ * `Object.assign` rather than `export namespace`: the latter is banned by this
+ * repo's own lint (`no-namespace: error`, inherited from strict-type-checked).
+ *
  * @experimental
  */
-function experimental_skill(spec) {
+function skillSpec(spec) {
     return { _specType: "skill", ...spec };
 }
+/**
+ * @experimental
+ */
+exports.experimental_skill = Object.assign(skillSpec, { input, step });
 /**
  * Define a subagent specification (compiles to `agents/<name>.md`).
  *

package/dist/eval-surface.d.ts

@@ -0,0 +1,122 @@
+/**
+ * `vigiles/eval` — the **paid** surface: every runtime export here can call a
+ * model, and therefore can spend money.
+ *
+ * That single property is the whole reason this subpath exists. The package used
+ * to split its testing API by TEST TIER (`vigiles/unit`, `vigiles/integration`,
+ * `vigiles/e2e`, `vigiles/testing`); it now splits on COST. Everything free is on
+ * the package root, [`vigiles`](./test.ts). Everything that bills is here. The
+ * name rhymes with the `vigiles eval` CLI verb.
+ *
+ * ## Why every runtime export is also named `paid_`
+ *
+ * The import path warns ONCE, at the top of the file. The name warns EVERY time,
+ * at the call site. Reading `await judged(trace, "did it refuse?")` on line 140,
+ * the import line is long out of view — `await paid_judged(...)` still says what
+ * it costs. This is not a new idiom in this package: `vigiles/experimental`
+ * already pairs a quarantined subpath with an `experimental_` name prefix for
+ * exactly this reason. The same device, applied to a second axis.
+ *
+ * ⚠️ **The prefix slightly OVERSTATES the cost, and that is a deliberate trade
+ * rather than an oversight.** `paid_judged` takes an injectable judge:
+ * `paid_judged(rubric, { judge: myFn })` calls no model and spends nothing — only
+ * the DEFAULT judge bills. `paid_measureTriggerRate` and friends likewise accept
+ * an injected `evalDriver`. The strictly accurate prefix would be `metered_`, but
+ * it reads a beat slower, and a warning that is not absorbed at a glance is not a
+ * warning. Clarity wins; the imprecision is recorded here and on each symbol
+ * rather than left for a reader to discover.
+ *
+ * ## Why the split had to be cost, not tier
+ *
+ * The old `vigiles/unit` docstring promised "no `claude`, no model, no
+ * bubblewrap, no network" — and re-exported `judged`, whose default judge is a
+ * real model call (`check.ts` resolves `opts.judge ?? ((o) => runJudge(o))`). A
+ * test importing only from that barrel could still spend money, and the one line
+ * a reader would have relied on to know otherwise was the false one. `judged`
+ * moved HERE and became `paid_judged`, which makes that class of defect
+ * unrepresentable rather than apologised for: on this path, billing is the
+ * advertised property, in the subpath and in every name.
+ *
+ * ## What is NOT here, and why
+ *
+ * The ~two dozen helpers that read an eval RESULT — `assertImproves`,
+ * `assertNoRegression`, `assertReliable`, `assertSignificant`, `assertTriggerRate`,
+ * `reliable`, `improvement`, `significantlyBeats`, `compareArms`, `diffReports`,
+ * `diffToJUnit`, `formatBaselineDiff`, `parseBaselineFile`, `readBaseline`,
+ * `toBaselineFile`, `writeBaseline`, `cost`, `latency`, `tokens`, `inputTokens`,
+ * `outputTokens`, `cacheTokens`, `formatEvalReport`, `formatCheckReport`,
+ * `formatTriggerRateReport`, `checkReportToJUnit`, `assertRates` — spend nothing,
+ * so they live on the free root barrel, unprefixed, even though their subject
+ * matter is evals.
+ *
+ * That is the one seam the split cannot make clean: the free helpers are typed
+ * over report shapes DEFINED here. The coupling is real and irreducible, so both
+ * barrels re-export the same report types. **The types are NOT prefixed** — the
+ * prefix is a warning about calling something, and a type is never called;
+ * `paid_EvalReport` would be noise on a symbol that cannot bill. Importing
+ * `vigiles/eval` for a type alone should never be necessary; importing it for a
+ * FUNCTION means you accepted a bill.
+ *
+ * Harness-specific eval drivers are not here either — `codexEvalDriver` /
+ * `codexEvalRunner` / `codexEvalAgentRunner` live on `vigiles/codex`, and
+ * `measureSelectionMatrix` / `assertNoCollision` on `vigiles/claude-code`, because
+ * those surfaces are chosen by harness, not by cost.
+ */
+/**
+ * Run an A/B eval across arms with a real model. Spends money.
+ *
+ * ⚠️ The `paid_` prefix overstates slightly: pass your own `evalDriver` and no
+ * model of ours is called. The DEFAULT path bills.
+ */
+export { runEval as paid_runEval } from "./eval.js";
+/**
+ * Score checks over N trials of one task with a real model. Spends money.
+ *
+ * ⚠️ `paid_` overstates slightly: with an injected `evalDriver` this drives
+ * whatever you supply. The DEFAULT path bills.
+ */
+export { measure as paid_measure } from "./eval.js";
+/**
+ * Score the same checks per arm (a hook/skill/rule on vs off) with a real model.
+ * Spends money.
+ *
+ * ⚠️ `paid_` overstates slightly: an injected `evalDriver` replaces the billed
+ * path. The DEFAULT path bills.
+ */
+export { measureArms as paid_measureArms } from "./eval.js";
+/**
+ * Measure whether a skill's description actually FIRES (recall + precision) by
+ * running real prompts against a real model. Spends money.
+ *
+ * ⚠️ `paid_` overstates slightly: an injected `evalDriver` replaces the billed
+ * path, and `stubSkillBodies` makes the default path much cheaper without making
+ * it free. The DEFAULT path bills.
+ */
+export { measureTriggerRate as paid_measureTriggerRate } from "./eval.js";
+/**
+ * The model-graded judge (harness-agnostic — grades text against a rubric).
+ * Shells out to the `claude` CLI synchronously; needs model auth. Spends money.
+ *
+ * ⚠️ Unlike the others this one has no injection seam — it always calls a model,
+ * so here `paid_` is exact.
+ */
+export { judge as paid_judge } from "./judge.js";
+/**
+ * The one member of the declarative check vocabulary that bills: its default
+ * judge is a real model call. Every other `Check` is deterministic and lives
+ * unprefixed on the free root barrel.
+ *
+ * ⚠️ The `paid_` prefix overstates slightly, and this is the symbol it overstates
+ * most: `paid_judged(rubric, { judge: myFn })` calls YOUR function and spends
+ * nothing. Only `paid_judged(rubric)` — the default — bills.
+ */
+export { judged as paid_judged } from "./check.js";
+/**
+ * The Claude-Code eval driver: the transport `paid_runEval` and friends use by
+ * default. Naming it here is how you pass it explicitly; using it spends money.
+ */
+export { claudeEvalDriver as paid_claudeEvalDriver } from "./eval.js";
+export type { Check, CheckResult, JudgeFn } from "./check.js";
+export type { Trace } from "./harness-test.js";
+export type { EvalArm, EvalDriver, EvalSpec, EvalReport, EvalUsage, MeasureSpec, ArmsMeasureSpec, ArmReport, ArmUsage, ArmsCheckReport, CheckRate, CheckReport, MetricStat, Metrics, ModelOutputParser, ParsedModelRun, PromptDiversityIssue, PromptTriggerStat, RunContext, RunOut, SelectionTrialResult, TriggerRateReport, TriggerRateSpec, AgentRunArgs, AgentRunner, } from "./eval.js";
+//# sourceMappingURL=eval-surface.d.ts.map

package/dist/eval-surface.js

@@ -0,0 +1,130 @@
+"use strict";
+/**
+ * `vigiles/eval` — the **paid** surface: every runtime export here can call a
+ * model, and therefore can spend money.
+ *
+ * That single property is the whole reason this subpath exists. The package used
+ * to split its testing API by TEST TIER (`vigiles/unit`, `vigiles/integration`,
+ * `vigiles/e2e`, `vigiles/testing`); it now splits on COST. Everything free is on
+ * the package root, [`vigiles`](./test.ts). Everything that bills is here. The
+ * name rhymes with the `vigiles eval` CLI verb.
+ *
+ * ## Why every runtime export is also named `paid_`
+ *
+ * The import path warns ONCE, at the top of the file. The name warns EVERY time,
+ * at the call site. Reading `await judged(trace, "did it refuse?")` on line 140,
+ * the import line is long out of view — `await paid_judged(...)` still says what
+ * it costs. This is not a new idiom in this package: `vigiles/experimental`
+ * already pairs a quarantined subpath with an `experimental_` name prefix for
+ * exactly this reason. The same device, applied to a second axis.
+ *
+ * ⚠️ **The prefix slightly OVERSTATES the cost, and that is a deliberate trade
+ * rather than an oversight.** `paid_judged` takes an injectable judge:
+ * `paid_judged(rubric, { judge: myFn })` calls no model and spends nothing — only
+ * the DEFAULT judge bills. `paid_measureTriggerRate` and friends likewise accept
+ * an injected `evalDriver`. The strictly accurate prefix would be `metered_`, but
+ * it reads a beat slower, and a warning that is not absorbed at a glance is not a
+ * warning. Clarity wins; the imprecision is recorded here and on each symbol
+ * rather than left for a reader to discover.
+ *
+ * ## Why the split had to be cost, not tier
+ *
+ * The old `vigiles/unit` docstring promised "no `claude`, no model, no
+ * bubblewrap, no network" — and re-exported `judged`, whose default judge is a
+ * real model call (`check.ts` resolves `opts.judge ?? ((o) => runJudge(o))`). A
+ * test importing only from that barrel could still spend money, and the one line
+ * a reader would have relied on to know otherwise was the false one. `judged`
+ * moved HERE and became `paid_judged`, which makes that class of defect
+ * unrepresentable rather than apologised for: on this path, billing is the
+ * advertised property, in the subpath and in every name.
+ *
+ * ## What is NOT here, and why
+ *
+ * The ~two dozen helpers that read an eval RESULT — `assertImproves`,
+ * `assertNoRegression`, `assertReliable`, `assertSignificant`, `assertTriggerRate`,
+ * `reliable`, `improvement`, `significantlyBeats`, `compareArms`, `diffReports`,
+ * `diffToJUnit`, `formatBaselineDiff`, `parseBaselineFile`, `readBaseline`,
+ * `toBaselineFile`, `writeBaseline`, `cost`, `latency`, `tokens`, `inputTokens`,
+ * `outputTokens`, `cacheTokens`, `formatEvalReport`, `formatCheckReport`,
+ * `formatTriggerRateReport`, `checkReportToJUnit`, `assertRates` — spend nothing,
+ * so they live on the free root barrel, unprefixed, even though their subject
+ * matter is evals.
+ *
+ * That is the one seam the split cannot make clean: the free helpers are typed
+ * over report shapes DEFINED here. The coupling is real and irreducible, so both
+ * barrels re-export the same report types. **The types are NOT prefixed** — the
+ * prefix is a warning about calling something, and a type is never called;
+ * `paid_EvalReport` would be noise on a symbol that cannot bill. Importing
+ * `vigiles/eval` for a type alone should never be necessary; importing it for a
+ * FUNCTION means you accepted a bill.
+ *
+ * Harness-specific eval drivers are not here either — `codexEvalDriver` /
+ * `codexEvalRunner` / `codexEvalAgentRunner` live on `vigiles/codex`, and
+ * `measureSelectionMatrix` / `assertNoCollision` on `vigiles/claude-code`, because
+ * those surfaces are chosen by harness, not by cost.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paid_claudeEvalDriver = exports.paid_judged = exports.paid_judge = exports.paid_measureTriggerRate = exports.paid_measureArms = exports.paid_measure = exports.paid_runEval = void 0;
+// --- the runners: each one drives a real model ---
+/**
+ * Run an A/B eval across arms with a real model. Spends money.
+ *
+ * ⚠️ The `paid_` prefix overstates slightly: pass your own `evalDriver` and no
+ * model of ours is called. The DEFAULT path bills.
+ */
+var eval_js_1 = require("./eval.js");
+Object.defineProperty(exports, "paid_runEval", { enumerable: true, get: function () { return eval_js_1.runEval; } });
+/**
+ * Score checks over N trials of one task with a real model. Spends money.
+ *
+ * ⚠️ `paid_` overstates slightly: with an injected `evalDriver` this drives
+ * whatever you supply. The DEFAULT path bills.
+ */
+var eval_js_2 = require("./eval.js");
+Object.defineProperty(exports, "paid_measure", { enumerable: true, get: function () { return eval_js_2.measure; } });
+/**
+ * Score the same checks per arm (a hook/skill/rule on vs off) with a real model.
+ * Spends money.
+ *
+ * ⚠️ `paid_` overstates slightly: an injected `evalDriver` replaces the billed
+ * path. The DEFAULT path bills.
+ */
+var eval_js_3 = require("./eval.js");
+Object.defineProperty(exports, "paid_measureArms", { enumerable: true, get: function () { return eval_js_3.measureArms; } });
+/**
+ * Measure whether a skill's description actually FIRES (recall + precision) by
+ * running real prompts against a real model. Spends money.
+ *
+ * ⚠️ `paid_` overstates slightly: an injected `evalDriver` replaces the billed
+ * path, and `stubSkillBodies` makes the default path much cheaper without making
+ * it free. The DEFAULT path bills.
+ */
+var eval_js_4 = require("./eval.js");
+Object.defineProperty(exports, "paid_measureTriggerRate", { enumerable: true, get: function () { return eval_js_4.measureTriggerRate; } });
+/**
+ * The model-graded judge (harness-agnostic — grades text against a rubric).
+ * Shells out to the `claude` CLI synchronously; needs model auth. Spends money.
+ *
+ * ⚠️ Unlike the others this one has no injection seam — it always calls a model,
+ * so here `paid_` is exact.
+ */
+var judge_js_1 = require("./judge.js");
+Object.defineProperty(exports, "paid_judge", { enumerable: true, get: function () { return judge_js_1.judge; } });
+/**
+ * The one member of the declarative check vocabulary that bills: its default
+ * judge is a real model call. Every other `Check` is deterministic and lives
+ * unprefixed on the free root barrel.
+ *
+ * ⚠️ The `paid_` prefix overstates slightly, and this is the symbol it overstates
+ * most: `paid_judged(rubric, { judge: myFn })` calls YOUR function and spends
+ * nothing. Only `paid_judged(rubric)` — the default — bills.
+ */
+var check_js_1 = require("./check.js");
+Object.defineProperty(exports, "paid_judged", { enumerable: true, get: function () { return check_js_1.judged; } });
+/**
+ * The Claude-Code eval driver: the transport `paid_runEval` and friends use by
+ * default. Naming it here is how you pass it explicitly; using it spends money.
+ */
+var eval_js_5 = require("./eval.js");
+Object.defineProperty(exports, "paid_claudeEvalDriver", { enumerable: true, get: function () { return eval_js_5.claudeEvalDriver; } });
+//# sourceMappingURL=eval-surface.js.map

package/dist/harness-assert.d.ts

@@ -309,7 +309,7 @@ interface MatcherOutput {
  * Custom matchers compatible with both vitest and jest. Register once:
  *
  *   import { expect } from "vitest"; // or "@jest/globals"
- *   import { vigilesMatchers } from "vigiles/testing";
+ *   import { vigilesMatchers } from "vigiles";
  *   expect.extend(vigilesMatchers);
  *
  *   expect(result).toHaveCreated("RESULT");

package/dist/harness-assert.js

@@ -69,7 +69,7 @@ const agent_result_js_1 = require("./adapters/claude-code/agent-result.js");
 const stats_js_1 = require("./stats.js");
 const eval_baseline_js_1 = require("./eval-baseline.js");
 // Re-export the significance primitives so the whole eval-analysis surface lives
-// re-exported from `vigiles/testing` (there is no `vigiles/harness-assert` entry
+// re-exported from the `vigiles` root (there is no `vigiles/harness-assert` entry
 // point — it was advertised in this very comment and never existed).
 var stats_js_2 = require("./stats.js");
 Object.defineProperty(exports, "compareArms", { enumerable: true, get: function () { return stats_js_2.compareArms; } });
@@ -690,7 +690,7 @@ function assertTriggerRate(report, opts) {
  * Custom matchers compatible with both vitest and jest. Register once:
  *
  *   import { expect } from "vitest"; // or "@jest/globals"
- *   import { vigilesMatchers } from "vigiles/testing";
+ *   import { vigilesMatchers } from "vigiles";
  *   expect.extend(vigilesMatchers);
  *
  *   expect(result).toHaveCreated("RESULT");

package/dist/load-hook.d.ts

@@ -8,7 +8,7 @@ import { type AnyHook } from "./core/hook-program.js";
  * points at authoring the hook as `.mjs`.
  *
  * ```js
- * import { loadHook, assertHookDenies } from "vigiles/testing";
+ * import { loadHook, assertHookDenies } from "vigiles";
  *
  * const guard = await loadHook(".vigiles/hooks/guard.mjs");
  * assertHookDenies(guard, {

package/dist/load-hook.js

@@ -27,7 +27,7 @@ const hook_program_js_1 = require("./core/hook-program.js");
  * points at authoring the hook as `.mjs`.
  *
  * ```js
- * import { loadHook, assertHookDenies } from "vigiles/testing";
+ * import { loadHook, assertHookDenies } from "vigiles";
  *
  * const guard = await loadHook(".vigiles/hooks/guard.mjs");
  * assertHookDenies(guard, {

package/dist/run-hook.js

@@ -11,7 +11,7 @@ const hook_protocol_js_1 = require("./adapters/claude-code/hook-protocol.js");
 const proofs_js_1 = require("./core/proofs.js");
 const hook_program_js_1 = require("./core/hook-program.js");
 const run_script_js_1 = require("./run-script.js");
-// The general runner this module specializes. Re-exported so `vigiles/unit`'s
+// The general runner this module specializes. Re-exported so the `vigiles` root's
 // hook surface and the script surface stay one import away from each other.
 var run_script_js_2 = require("./run-script.js");
 Object.defineProperty(exports, "runScript", { enumerable: true, get: function () { return run_script_js_2.runScript; } });