vigiles 15.4.0 → 16.0.0

package/dist/scaffold-test.js

@@ -57,7 +57,7 @@ import {
   verifyGuardrail,
   formatGuardrailReport,
   // assertBlocksDisasters, // uncomment to gate CI on the battery (see below)
-} from "vigiles/unit";
+} from "vigiles";
 
 const cmd = ${JSON.stringify(cmd)};
 
@@ -89,19 +89,15 @@ function skillScaffold(input) {
         ? "\n// NOTE: this skill is user-invoked (disableModelInvocation). Trigger-rate\n// measures MODEL-invocable skills; either make it model-invocable or test its\n// slash-command invocation with runHarnessTest instead.\n"
         : "";
     return `${header(`Starter trigger-rate eval for the \`${id}\` skill (recall + precision).`, `npx vigiles eval ${suggestedPath(input)}   # real model, on your subscription`)}
-import {
-  measureTriggerRate,
-  formatTriggerRateReport,
-  assertTriggerRate,
-  skillResolved,
-} from "vigiles/testing";
+import { paid_measureTriggerRate } from "vigiles/eval"; // paid_ = a real model runs
+import { formatTriggerRateReport, assertTriggerRate, skillResolved } from "vigiles";
 import { fileURLToPath } from "node:url";
 ${note}
 // TODO: point at the plugin root (the dir holding .claude-plugin/ or skills/).
 const pluginDir = fileURLToPath(new URL("../../", import.meta.url));
 const skill = ${JSON.stringify(id)};
 
-const report = await measureTriggerRate({
+const report = await paid_measureTriggerRate({
   pluginDir,
   stubSkillBodies: true, // firing is a frontmatter property — stub bodies, pay less
   prompts: [
@@ -152,7 +148,7 @@ function outcomeSection(input, contract) {
         : "";
     return `import assert from "node:assert/strict";
 import { result } from "vigiles/spec";
-import { assertAgentOk } from "vigiles/testing";
+import { assertAgentOk } from "vigiles";
 
 // Reconstructed from ${input.name}'s ## Output contract (its compiled .md) — the
 // typed result() the spec wrote. assertAgentOk parses + validates the outcome
@@ -177,7 +173,7 @@ function fallbackSection(input) {
     const toolHint = input.tools && input.tools.length > 0
         ? `assertToolUsed(r, ${JSON.stringify(input.tools[0])}); // its declared contract: ${input.tools.join(", ")}`
         : `assertToolUsed(r, "Task"); // TODO: assert what the subagent should do`;
-    return `import { runHarnessTest, assertToolUsed } from "vigiles/testing";
+    return `import { runHarnessTest, assertToolUsed } from "vigiles";
 
 // ${input.name} has no result() contract, so its outcome can't be asserted
 // deterministically — add one (result() on its agent() spec) for a no-judge
@@ -239,7 +235,7 @@ ${checks.join("\n")}
 function agentScaffold(input) {
     const head = header(`Starter harness test for the \`${input.name}\` subagent.`, `npx vigiles test ${suggestedPath(input)}`);
     const safetyImport = input.sideEffectingTools && input.sideEffectingTools.length > 0
-        ? `import { notTool, didNotWrite, assertChecks } from "vigiles/testing";\n`
+        ? `import { notTool, didNotWrite, assertChecks } from "vigiles";\n`
         : "";
     const body = input.resultContract
         ? outcomeSection(input, input.resultContract)

package/dist/scan-trigger-suggest.d.ts

@@ -7,7 +7,7 @@
  * remembers in `.vigilesrc.json` `audit.measure`); headless (an agent / `--json` /
  * `--no-interactive` / a pipe) it stays a read + a one-line nudge — never hangs,
  * never silently executes. There is deliberately NO execution flag: automation
- * tests the harness through the `vigiles/testing` API + skills (the layered tiers),
+ * tests the harness through the `vigiles` testing API + skills (the layered tiers),
  * not through the report verb. The IO (prompt / run / remember) lives in the CLI;
  * this is the pure decision + helpers.
  */
@@ -69,7 +69,7 @@ export interface ExecuteEnv {
  * the executing checks need a human to consent:
  *  1. nothing executable → skip "nothing" (a clean read; no nudge)
  *  2. headless (`--json` / `--no-interactive` / non-TTY — an agent, a pipe, CI) →
- *     skip "headless" (no one to ask; automation uses the `vigiles/testing` API)
+ *     skip "headless" (no one to ask; automation uses the `vigiles` testing API)
  *  3. sticky no → skip "remembered-no"
  *  4. sticky yes → run
  *  5. interactive human, no sticky choice → ask (then remember)
@@ -79,7 +79,7 @@ export declare function decideExecute(o: ExecuteEnv): ExecuteDecision;
  * The one-line "executing checks not run" nudge for a skipped read (the
  * no-silent-skips corollary). Returns null for `nothing` (nothing to run — not a
  * gap). There is no flag to point at — `audit` runs them only interactively, and
- * automation uses the `vigiles/testing` API.
+ * automation uses the `vigiles` testing API.
  */
 export declare function formatExecuteSkip(reason: ExecuteSkipReason): string | null;
 /**

package/dist/scan-trigger-suggest.js

@@ -8,7 +8,7 @@
  * remembers in `.vigilesrc.json` `audit.measure`); headless (an agent / `--json` /
  * `--no-interactive` / a pipe) it stays a read + a one-line nudge — never hangs,
  * never silently executes. There is deliberately NO execution flag: automation
- * tests the harness through the `vigiles/testing` API + skills (the layered tiers),
+ * tests the harness through the `vigiles` testing API + skills (the layered tiers),
  * not through the report verb. The IO (prompt / run / remember) lives in the CLI;
  * this is the pure decision + helpers.
  */
@@ -45,7 +45,7 @@ function isMeteredAccess(env) {
  * the executing checks need a human to consent:
  *  1. nothing executable → skip "nothing" (a clean read; no nudge)
  *  2. headless (`--json` / `--no-interactive` / non-TTY — an agent, a pipe, CI) →
- *     skip "headless" (no one to ask; automation uses the `vigiles/testing` API)
+ *     skip "headless" (no one to ask; automation uses the `vigiles` testing API)
  *  3. sticky no → skip "remembered-no"
  *  4. sticky yes → run
  *  5. interactive human, no sticky choice → ask (then remember)
@@ -65,7 +65,7 @@ function decideExecute(o) {
  * The one-line "executing checks not run" nudge for a skipped read (the
  * no-silent-skips corollary). Returns null for `nothing` (nothing to run — not a
  * gap). There is no flag to point at — `audit` runs them only interactively, and
- * automation uses the `vigiles/testing` API.
+ * automation uses the `vigiles` testing API.
  */
 function formatExecuteSkip(reason) {
     switch (reason) {
@@ -74,7 +74,7 @@ function formatExecuteSkip(reason) {
         case "headless":
             return ("\nℹ Executing checks (safety battery · live MCP · skill firing) skipped — " +
                 "`audit` runs them only interactively (a terminal). For automation, test the " +
-                "harness with the `vigiles/testing` API.");
+                "harness with the `vigiles` testing API.");
         case "remembered-no":
             return ("\nℹ Executing checks not run (you disabled them — edit .vigilesrc.json " +
                 "`audit.measure` to re-enable).");

package/dist/test-coverage.js

@@ -595,7 +595,7 @@ function evalTierQuestion(kind) {
             //
             // ⚠️ It does NOT offer `{ evalDriver }` here, and that is checked rather
             // than assumed: `runEval`/`measure`/`measureArms` all hard-wire
-            // `spawnAgent`, and `runEvalWith` is not exported from `vigiles/testing` —
+            // `spawnAgent`, and `runEvalWith` is not exported from `vigiles/eval` —
             // `measureTriggerRate` is the only public call with that seam. Suggesting
             // an argument the function does not take is this finding's own defect.
             return (`A deterministic test covers it, but that test drove a SCRIPTED model. ` +

package/dist/test.d.ts

@@ -0,0 +1,75 @@
+/**
+ * `vigiles` (the package root) — the **free** testing surface: everything you can
+ * run without a model call, and therefore without a bill.
+ *
+ * This is the front door. There is no `vigiles/test` subpath: the bare package
+ * name IS the testing surface, because a second name for the same door is the
+ * duplication this reorganisation removed (the old `.` + `./spec` pair pointed at
+ * one module under two names). A subpath is warranted when something genuinely
+ * DIFFERENT lives behind it — another runtime, another driver, another protocol.
+ * Here the one real difference is whether a call can spend money, so there are
+ * exactly two doors: this one, and [`vigiles/eval`](./eval-surface.ts).
+ *
+ * ## What replaced what
+ *
+ * The old split was by TEST TIER — `vigiles/unit`, `vigiles/integration`,
+ * `vigiles/e2e`, `vigiles/testing`. Tiers are a property of test-file layout and
+ * runner config, not of a module graph: this repo already expresses them as
+ * vitest projects (`test:unit`, `test:integration`, `test:e2e`), so the exports
+ * map was a second, competing implementation of the same idea. `src/e2e.ts` had
+ * degenerated to `export * from "./integration.js"` — a barrel adding zero
+ * symbols, which its own docstring called "the definition of a non-tier".
+ *
+ * ## Two honest costs of the new split
+ *
+ * **1. The type coupling crosses the boundary and cannot be removed.** About two
+ * dozen helpers here — `assertImproves`, `assertNoRegression`, `assertReliable`,
+ * `assertSignificant`, `assertTriggerRate`, `reliable`, `improvement`,
+ * `significantlyBeats`, `compareArms`, `diffReports`, `diffToJUnit`,
+ * `formatBaselineDiff`, `parseBaselineFile`, `readBaseline`, `toBaselineFile`,
+ * `writeBaseline`, `cost`, `latency`, `tokens`, `inputTokens`, `outputTokens`,
+ * `cacheTokens`, plus `formatEvalReport` / `formatCheckReport` /
+ * `formatTriggerRateReport` / `checkReportToJUnit` / `assertRates` — operate on
+ * eval RESULTS while spending nothing themselves. They belong on the free path.
+ * Their TYPES (`EvalReport`, `CheckReport`, `TriggerRateReport`, `Metrics`, …)
+ * are defined on the paid side. So those types are re-exported from BOTH barrels:
+ * a user of the free surface must never import `vigiles/eval` for a type alone.
+ * The duplication is deliberate and is the price of splitting on cost.
+ *
+ * **2. Free is not the same as fast.** The old "real CLI, no API key" tier
+ * (`vigiles/integration`) collapses into this barrel, so the import path no longer
+ * warns you that `runHarnessTest` spawns a real `claude` binary under bubblewrap
+ * and can take ~40 seconds. Nothing here bills you; plenty here is slow. Duration
+ * now lives where duration always lived in practice — in the runner config
+ * (`--project integration`), not in the import.
+ *
+ * **What was lost, stated plainly:** the symmetry with the CLI verbs is now
+ * one-sided. `vigiles/eval` rhymes with `vigiles eval`, but the free half answers
+ * to the plain package name rather than to `vigiles test`. That is accepted, not
+ * overlooked. `@playwright/test` — an end-to-end tool by definition — ships no
+ * subpath naming a test type at all, and keeps the whole fast/slow/expensive
+ * distinction in its config rather than in its imports.
+ */
+export { recordCheck } from "./check-count.js";
+export { runScript } from "./run-script.js";
+export type { RunScriptOptions, ScriptRunResult } from "./run-script.js";
+export { runHook, parseHookOutput, decideHook, propertyHook, fileToolEvents, egressRoutes, } from "./run-hook.js";
+export type { HookRunResult, RunHookOptions, HookInput, HookOutput, HookPropertyResult, FileToolEventOptions, } from "./run-hook.js";
+export * from "./harness-assert.js";
+export { loadHook } from "./load-hook.js";
+export { evalChecks, assertChecks, tool, toolWith, notTool, onlyTools, skill, output, hookFired, received, turns, wrote, didNotWrite, subagent, blocked, allowed, mcp, cost, latency, tokens, inputTokens, outputTokens, cacheTokens, } from "./check.js";
+export type { ArgMatcher, Check, CheckJSON, CheckResult, JudgeFn, } from "./check.js";
+export { DISASTER_CATALOG, verifyGuardrail, unblockedDisasters, assertBlocksDisasters, formatGuardrailReport, } from "./guardrail-check.js";
+export type { DisasterEvent, DisasterCategory, GuardrailResult, VerifyGuardrailOptions, } from "./guardrail-check.js";
+export * from "./tool-stub.js";
+export { runHarnessTest, runHarness, parseToolCalls, parseSubagents, parseResultEvent, parseOutput, parseHooks, decideSandbox, specTrusted, sandboxAvailable, } from "./harness-test.js";
+export type { HarnessTestSpec, Trace, SubagentTrace, HarnessTestResult, RunHarnessTestOptions, ModelTurn, ModelRequest, ToolCall, HookFire, HarnessTestDriver, SandboxMode, } from "./harness-test.js";
+export { commandsIn, mustInclude, mustNotInclude } from "./doc-commands.js";
+export type { DocCommand } from "./doc-commands.js";
+export { skillContract } from "./skill-contract.js";
+export type { SkillContract, SkillContractOptions } from "./skill-contract.js";
+export { compareContainment, formatContainment, } from "./trigger-containment.js";
+export type { ContainmentInput, ContainmentVerdict, } from "./trigger-containment.js";
+export { assertRates, assertPromptDiversity, checkPromptDiversity, checkReportToJUnit, formatCheckReport, formatEvalReport, formatTriggerRateReport, parseClaudeRun, stubSkillBody, } from "./eval.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=test.d.ts.map

package/dist/test.js

@@ -0,0 +1,192 @@
+"use strict";
+/**
+ * `vigiles` (the package root) — the **free** testing surface: everything you can
+ * run without a model call, and therefore without a bill.
+ *
+ * This is the front door. There is no `vigiles/test` subpath: the bare package
+ * name IS the testing surface, because a second name for the same door is the
+ * duplication this reorganisation removed (the old `.` + `./spec` pair pointed at
+ * one module under two names). A subpath is warranted when something genuinely
+ * DIFFERENT lives behind it — another runtime, another driver, another protocol.
+ * Here the one real difference is whether a call can spend money, so there are
+ * exactly two doors: this one, and [`vigiles/eval`](./eval-surface.ts).
+ *
+ * ## What replaced what
+ *
+ * The old split was by TEST TIER — `vigiles/unit`, `vigiles/integration`,
+ * `vigiles/e2e`, `vigiles/testing`. Tiers are a property of test-file layout and
+ * runner config, not of a module graph: this repo already expresses them as
+ * vitest projects (`test:unit`, `test:integration`, `test:e2e`), so the exports
+ * map was a second, competing implementation of the same idea. `src/e2e.ts` had
+ * degenerated to `export * from "./integration.js"` — a barrel adding zero
+ * symbols, which its own docstring called "the definition of a non-tier".
+ *
+ * ## Two honest costs of the new split
+ *
+ * **1. The type coupling crosses the boundary and cannot be removed.** About two
+ * dozen helpers here — `assertImproves`, `assertNoRegression`, `assertReliable`,
+ * `assertSignificant`, `assertTriggerRate`, `reliable`, `improvement`,
+ * `significantlyBeats`, `compareArms`, `diffReports`, `diffToJUnit`,
+ * `formatBaselineDiff`, `parseBaselineFile`, `readBaseline`, `toBaselineFile`,
+ * `writeBaseline`, `cost`, `latency`, `tokens`, `inputTokens`, `outputTokens`,
+ * `cacheTokens`, plus `formatEvalReport` / `formatCheckReport` /
+ * `formatTriggerRateReport` / `checkReportToJUnit` / `assertRates` — operate on
+ * eval RESULTS while spending nothing themselves. They belong on the free path.
+ * Their TYPES (`EvalReport`, `CheckReport`, `TriggerRateReport`, `Metrics`, …)
+ * are defined on the paid side. So those types are re-exported from BOTH barrels:
+ * a user of the free surface must never import `vigiles/eval` for a type alone.
+ * The duplication is deliberate and is the price of splitting on cost.
+ *
+ * **2. Free is not the same as fast.** The old "real CLI, no API key" tier
+ * (`vigiles/integration`) collapses into this barrel, so the import path no longer
+ * warns you that `runHarnessTest` spawns a real `claude` binary under bubblewrap
+ * and can take ~40 seconds. Nothing here bills you; plenty here is slow. Duration
+ * now lives where duration always lived in practice — in the runner config
+ * (`--project integration`), not in the import.
+ *
+ * **What was lost, stated plainly:** the symmetry with the CLI verbs is now
+ * one-sided. `vigiles/eval` rhymes with `vigiles eval`, but the free half answers
+ * to the plain package name rather than to `vigiles test`. That is accepted, not
+ * overlooked. `@playwright/test` — an end-to-end tool by definition — ships no
+ * subpath naming a test type at all, and keeps the whole fast/slow/expensive
+ * distinction in its config rather than in its imports.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mustNotInclude = exports.mustInclude = exports.commandsIn = exports.sandboxAvailable = exports.specTrusted = exports.decideSandbox = exports.parseHooks = exports.parseOutput = exports.parseResultEvent = exports.parseSubagents = exports.parseToolCalls = exports.runHarness = exports.runHarnessTest = exports.formatGuardrailReport = exports.assertBlocksDisasters = exports.unblockedDisasters = exports.verifyGuardrail = exports.DISASTER_CATALOG = exports.cacheTokens = exports.outputTokens = exports.inputTokens = exports.tokens = exports.latency = exports.cost = exports.mcp = exports.allowed = exports.blocked = exports.subagent = exports.didNotWrite = exports.wrote = exports.turns = exports.received = exports.hookFired = exports.output = exports.skill = exports.onlyTools = exports.notTool = exports.toolWith = exports.tool = exports.assertChecks = exports.evalChecks = exports.loadHook = exports.egressRoutes = exports.fileToolEvents = exports.propertyHook = exports.decideHook = exports.parseHookOutput = exports.runHook = exports.runScript = exports.recordCheck = void 0;
+exports.stubSkillBody = exports.parseClaudeRun = exports.formatTriggerRateReport = exports.formatEvalReport = exports.formatCheckReport = exports.checkReportToJUnit = exports.checkPromptDiversity = exports.assertPromptDiversity = exports.assertRates = exports.formatContainment = exports.compareContainment = exports.skillContract = void 0;
+// --- reporting: how much did this script actually do? ---
+// `vigiles test` can otherwise see only an exit code, so a file that runs NOTHING
+// prints the same `✓` as one that ran and passed (measured 2026-08-08 on a file
+// exporting an object of tests nobody calls). Call `recordCheck()` yourself when
+// you assert some OTHER way — `node:assert`, vitest's `expect` — so those are
+// visible to the runner too. See check-count.ts.
+var check_count_js_1 = require("./check-count.js");
+Object.defineProperty(exports, "recordCheck", { enumerable: true, get: function () { return check_count_js_1.recordCheck; } });
+// --- the process primitives: runScript (any program) + runHook (plus a decision) ---
+// `runScript` runs any program and reports what it DID (exit, both streams,
+// writes, egress). `runHook` is that plus the hook protocol: event to stdin,
+// exit code to allow/deny. Testing a plain helper script? Reach for runScript —
+// its result carries no `decision`, because a script does not have one.
+var run_script_js_1 = require("./run-script.js");
+Object.defineProperty(exports, "runScript", { enumerable: true, get: function () { return run_script_js_1.runScript; } });
+var run_hook_js_1 = require("./run-hook.js");
+Object.defineProperty(exports, "runHook", { enumerable: true, get: function () { return run_hook_js_1.runHook; } });
+Object.defineProperty(exports, "parseHookOutput", { enumerable: true, get: function () { return run_hook_js_1.parseHookOutput; } });
+Object.defineProperty(exports, "decideHook", { enumerable: true, get: function () { return run_hook_js_1.decideHook; } });
+Object.defineProperty(exports, "propertyHook", { enumerable: true, get: function () { return run_hook_js_1.propertyHook; } });
+Object.defineProperty(exports, "fileToolEvents", { enumerable: true, get: function () { return run_hook_js_1.fileToolEvents; } });
+Object.defineProperty(exports, "egressRoutes", { enumerable: true, get: function () { return run_hook_js_1.egressRoutes; } });
+// --- assertions and the eval-RESULT analysis helpers (free; see cost #1 above) ---
+__exportStar(require("./harness-assert.js"), exports);
+// The compiled-hook LOADER. The in-process assertions above take the hook
+// OBJECT, but a `.harness.mjs` test only has its PATH — without this the
+// intended in-process test path is unreachable from the file format
+// `vigiles test` actually runs, and authors fall back to spawning the runtime as
+// a subprocess (the very plumbing compiled hooks exist to remove). Same loader
+// the CLI runtime uses, so a hook that loads in a test loads identically in prod.
+var load_hook_js_1 = require("./load-hook.js");
+Object.defineProperty(exports, "loadHook", { enumerable: true, get: function () { return load_hook_js_1.loadHook; } });
+// --- the declarative check vocabulary ---
+// Enumerated rather than `export *` ON PURPOSE: `judged` also lives in check.ts
+// and its default judge is a real model call, so it is the one member of this
+// module that belongs on the paid barrel (as `paid_judged`). Listing the members
+// makes "a free import that can bill you" unrepresentable here rather than merely
+// documented — the previous barrel carried a paragraph apologising for exactly
+// that. `hookFired` is re-exported explicitly so this `Check<Trace>` wins over the
+// legacy boolean predicate of the same name from harness-assert.
+var check_js_1 = require("./check.js");
+Object.defineProperty(exports, "evalChecks", { enumerable: true, get: function () { return check_js_1.evalChecks; } });
+Object.defineProperty(exports, "assertChecks", { enumerable: true, get: function () { return check_js_1.assertChecks; } });
+Object.defineProperty(exports, "tool", { enumerable: true, get: function () { return check_js_1.tool; } });
+Object.defineProperty(exports, "toolWith", { enumerable: true, get: function () { return check_js_1.toolWith; } });
+Object.defineProperty(exports, "notTool", { enumerable: true, get: function () { return check_js_1.notTool; } });
+Object.defineProperty(exports, "onlyTools", { enumerable: true, get: function () { return check_js_1.onlyTools; } });
+Object.defineProperty(exports, "skill", { enumerable: true, get: function () { return check_js_1.skill; } });
+Object.defineProperty(exports, "output", { enumerable: true, get: function () { return check_js_1.output; } });
+Object.defineProperty(exports, "hookFired", { enumerable: true, get: function () { return check_js_1.hookFired; } });
+Object.defineProperty(exports, "received", { enumerable: true, get: function () { return check_js_1.received; } });
+Object.defineProperty(exports, "turns", { enumerable: true, get: function () { return check_js_1.turns; } });
+Object.defineProperty(exports, "wrote", { enumerable: true, get: function () { return check_js_1.wrote; } });
+Object.defineProperty(exports, "didNotWrite", { enumerable: true, get: function () { return check_js_1.didNotWrite; } });
+Object.defineProperty(exports, "subagent", { enumerable: true, get: function () { return check_js_1.subagent; } });
+Object.defineProperty(exports, "blocked", { enumerable: true, get: function () { return check_js_1.blocked; } });
+Object.defineProperty(exports, "allowed", { enumerable: true, get: function () { return check_js_1.allowed; } });
+Object.defineProperty(exports, "mcp", { enumerable: true, get: function () { return check_js_1.mcp; } });
+Object.defineProperty(exports, "cost", { enumerable: true, get: function () { return check_js_1.cost; } });
+Object.defineProperty(exports, "latency", { enumerable: true, get: function () { return check_js_1.latency; } });
+Object.defineProperty(exports, "tokens", { enumerable: true, get: function () { return check_js_1.tokens; } });
+Object.defineProperty(exports, "inputTokens", { enumerable: true, get: function () { return check_js_1.inputTokens; } });
+Object.defineProperty(exports, "outputTokens", { enumerable: true, get: function () { return check_js_1.outputTokens; } });
+Object.defineProperty(exports, "cacheTokens", { enumerable: true, get: function () { return check_js_1.cacheTokens; } });
+// Guardrail verification — "prove your safety hook actually blocks" (over runHook).
+var guardrail_check_js_1 = require("./guardrail-check.js");
+Object.defineProperty(exports, "DISASTER_CATALOG", { enumerable: true, get: function () { return guardrail_check_js_1.DISASTER_CATALOG; } });
+Object.defineProperty(exports, "verifyGuardrail", { enumerable: true, get: function () { return guardrail_check_js_1.verifyGuardrail; } });
+Object.defineProperty(exports, "unblockedDisasters", { enumerable: true, get: function () { return guardrail_check_js_1.unblockedDisasters; } });
+Object.defineProperty(exports, "assertBlocksDisasters", { enumerable: true, get: function () { return guardrail_check_js_1.assertBlocksDisasters; } });
+Object.defineProperty(exports, "formatGuardrailReport", { enumerable: true, get: function () { return guardrail_check_js_1.formatGuardrailReport; } });
+// Tool stubs on PATH (rung R2): shadow a CLI tool with a recorded canned result.
+__exportStar(require("./tool-stub.js"), exports);
+// The assembled machine — AGNOSTIC SURFACE ONLY. The Claude-Code transport
+// (`scriptModel`, `claudeCodeDriver`, `buildClaudeArgs`, `claudeAvailable`,
+// `loadPlugin`, `resolveHarness`) is deliberately NOT re-exported here, so this
+// surface stays harness-agnostic — import those from `vigiles/claude-code` (or
+// your harness's package). See `research/code-adapter-architecture.md`.
+// Slow but free: see cost #2 in the module doc.
+var harness_test_js_1 = require("./harness-test.js");
+Object.defineProperty(exports, "runHarnessTest", { enumerable: true, get: function () { return harness_test_js_1.runHarnessTest; } });
+Object.defineProperty(exports, "runHarness", { enumerable: true, get: function () { return harness_test_js_1.runHarness; } });
+Object.defineProperty(exports, "parseToolCalls", { enumerable: true, get: function () { return harness_test_js_1.parseToolCalls; } });
+Object.defineProperty(exports, "parseSubagents", { enumerable: true, get: function () { return harness_test_js_1.parseSubagents; } });
+Object.defineProperty(exports, "parseResultEvent", { enumerable: true, get: function () { return harness_test_js_1.parseResultEvent; } });
+Object.defineProperty(exports, "parseOutput", { enumerable: true, get: function () { return harness_test_js_1.parseOutput; } });
+Object.defineProperty(exports, "parseHooks", { enumerable: true, get: function () { return harness_test_js_1.parseHooks; } });
+Object.defineProperty(exports, "decideSandbox", { enumerable: true, get: function () { return harness_test_js_1.decideSandbox; } });
+Object.defineProperty(exports, "specTrusted", { enumerable: true, get: function () { return harness_test_js_1.specTrusted; } });
+Object.defineProperty(exports, "sandboxAvailable", { enumerable: true, get: function () { return harness_test_js_1.sandboxAvailable; } });
+// A document's own rule about its own COMMANDS, made checkable. vigiles cannot
+// infer "always pass -g" from prose; what was missing was a cheap way to declare
+// it — measured at ~95 lines of markdown parsing around ~5 lines of rule, which
+// is why nobody wrote the check and the rule stayed prose.
+var doc_commands_js_1 = require("./doc-commands.js");
+Object.defineProperty(exports, "commandsIn", { enumerable: true, get: function () { return doc_commands_js_1.commandsIn; } });
+Object.defineProperty(exports, "mustInclude", { enumerable: true, get: function () { return doc_commands_js_1.mustInclude; } });
+Object.defineProperty(exports, "mustNotInclude", { enumerable: true, get: function () { return doc_commands_js_1.mustNotInclude; } });
+// A skill's own `allowed-tools:` frontmatter, read back as checks — the wiring
+// from a declaration to the existing check vocabulary, not new machinery.
+var skill_contract_js_1 = require("./skill-contract.js");
+Object.defineProperty(exports, "skillContract", { enumerable: true, get: function () { return skill_contract_js_1.skillContract; } });
+// Is a WEAKER model a valid lower bound for trigger-rate? Pure comparison of two
+// runs; the open question the model floor makes people ask.
+var trigger_containment_js_1 = require("./trigger-containment.js");
+Object.defineProperty(exports, "compareContainment", { enumerable: true, get: function () { return trigger_containment_js_1.compareContainment; } });
+Object.defineProperty(exports, "formatContainment", { enumerable: true, get: function () { return trigger_containment_js_1.formatContainment; } });
+// --- free analysis OVER eval results (the coupling from cost #1) ---
+// These read a report that `vigiles/eval` produced. They spend nothing, so they
+// live here and carry no `paid_` prefix; their argument types are defined over
+// there, so those types are re-exported below from this barrel too.
+var eval_js_1 = require("./eval.js");
+Object.defineProperty(exports, "assertRates", { enumerable: true, get: function () { return eval_js_1.assertRates; } });
+Object.defineProperty(exports, "assertPromptDiversity", { enumerable: true, get: function () { return eval_js_1.assertPromptDiversity; } });
+Object.defineProperty(exports, "checkPromptDiversity", { enumerable: true, get: function () { return eval_js_1.checkPromptDiversity; } });
+Object.defineProperty(exports, "checkReportToJUnit", { enumerable: true, get: function () { return eval_js_1.checkReportToJUnit; } });
+Object.defineProperty(exports, "formatCheckReport", { enumerable: true, get: function () { return eval_js_1.formatCheckReport; } });
+Object.defineProperty(exports, "formatEvalReport", { enumerable: true, get: function () { return eval_js_1.formatEvalReport; } });
+Object.defineProperty(exports, "formatTriggerRateReport", { enumerable: true, get: function () { return eval_js_1.formatTriggerRateReport; } });
+Object.defineProperty(exports, "parseClaudeRun", { enumerable: true, get: function () { return eval_js_1.parseClaudeRun; } });
+Object.defineProperty(exports, "stubSkillBody", { enumerable: true, get: function () { return eval_js_1.stubSkillBody; } });
+//# sourceMappingURL=test.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vigiles",
-  "version": "15.4.0",
+  "version": "16.0.0",
   "description": "Audit, test and measure the harness your AI agent runs on — grade your CLAUDE.md / AGENTS.md, skills, subagents and hooks, run them against a scripted model, and measure whether they actually fire.",
   "keywords": [
     "claude-code",
@@ -35,17 +35,14 @@
   "bin": {
     "vigiles": "dist/cli.js"
   },
-  "main": "./dist/core/spec.js",
-  "types": "./dist/core/spec.d.ts",
+  "main": "./dist/test.js",
+  "types": "./dist/test.d.ts",
   "exports": {
-    ".": "./dist/core/spec.js",
+    ".": "./dist/test.js",
     "./spec": "./dist/core/spec.js",
+    "./eval": "./dist/eval-surface.js",
     "./linting": "./dist/linting.js",
-    "./testing": "./dist/testing.js",
-    "./unit": "./dist/unit.js",
     "./hook": "./dist/hook.js",
-    "./integration": "./dist/integration.js",
-    "./e2e": "./dist/e2e.js",
     "./claude-code": "./dist/claude-code.js",
     "./codex": "./dist/codex.js",
     "./adapter": "./dist/adapter.js",
@@ -92,7 +89,9 @@
     "test:types": "npm run build && tsc --noEmit -p test/types/tsconfig.json",
     "api:report": "npm run build && node scripts/api-extractor.mjs --local",
     "api:check": "npm run build && node scripts/api-extractor.mjs",
+    "check": "node scripts/check.mjs",
     "docs:check": "npm run build && node scripts/check-doc-imports.mjs . docs README.md",
+    "exports:check": "npm run build && node scripts/check-export-prefixes.mjs .",
     "experimental:check": "npm run api:check && node scripts/check-experimental-naming.mjs",
     "docs:api": "typedoc"
   },
@@ -100,6 +99,7 @@
     "@eslint/js": "^10.0.1",
     "@jackchuka/mdschema": "^0.12.8",
     "@microsoft/api-extractor": "^7.58.9",
+    "@semantic-release/commit-analyzer": "^13.0.1",
     "@types/js-yaml": "^4.0.9",
     "@types/markdown-it": "^14.1.2",
     "@types/minimatch": "^5.1.2",
@@ -107,6 +107,7 @@
     "@typescript-eslint/eslint-plugin": "^8.58.0",
     "@typescript-eslint/parser": "^8.58.0",
     "@vitest/coverage-v8": "^4.1.8",
+    "conventional-changelog-conventionalcommits": "^10.3.0",
     "eslint": "^10.1.0",
     "eslint-import-resolver-typescript": "^4.4.5",
     "eslint-plugin-boundaries": "^6.0.2",

package/skills/test-harness/SKILL.md

@@ -58,7 +58,7 @@ anything; every one of them ships today.
 
 | The question you're actually asking                                     | Use                                                                                    |
 | ----------------------------------------------------------------------- | -------------------------------------------------------------------------------------- |
-| Which tools did it call, and with what arguments?                       | `trace.toolCalls` · `tool` / `toolWith` checks · `parseToolCalls` (`vigiles/e2e`)      |
+| Which tools did it call, and with what arguments?                       | `trace.toolCalls` · `tool` / `toolWith` checks · `parseToolCalls` (`vigiles`)          |
 | Did it call a tool it must not?                                         | `notTool(name)`                                                                        |
 | Did it call **only** tools from a known set?                            | `onlyTools([...])` — the white-list, symmetric to `assertWroteOnly`                    |
 | Did it stay inside the `allowed-tools` its own frontmatter declares?    | `skillContract(dir).surface` — builds that check FROM the declaration                  |
@@ -80,7 +80,7 @@ the `allowed-tools:` the skill already claims and hands back ready checks, so
 the claim is verified instead of restated:
 
 ```ts
-import { skillContract, assertChecks } from "vigiles/testing";
+import { skillContract, assertChecks } from "vigiles";
 
 const c = skillContract(".claude/skills/my-skill");
 assertChecks(trace, [c.activation, ...c.surface]);
@@ -157,7 +157,7 @@ Pick one concrete thing to pin down — a specific `PreToolUse` hook, a specific
 **Unit (`runHook`)** — hand a hook a synthesized event, assert the decision:
 
 ```ts
-import { runHook, assertHookBlocked } from "vigiles/testing";
+import { runHook, assertHookBlocked } from "vigiles";
 
 const r = runHook(hookCommand, {
   hook_event_name: "PreToolUse",
@@ -188,9 +188,9 @@ import {
   runHarnessTest,
   assertHookFired,
   assertRequestContains,
-} from "vigiles/testing";
+} from "vigiles";
 // `scriptModel` is the Claude-Code TRANSPORT, deliberately not re-exported from
-// the harness-agnostic `vigiles/testing` — import it from the harness package:
+// the harness-agnostic root surface — import it from the harness package:
 import { scriptModel } from "vigiles/claude-code";
 
 const r = await runHarnessTest({
@@ -202,34 +202,36 @@ assertHookFired(r, "SessionStart");
 assertRequestContains(r, "expected injected text"); // did it actually land?
 ```
 
-**Eval — absolute (`measure` + `judged`)** — testing _one_ skill, the usual case:
+**Eval — absolute (`paid_measure` + `paid_judged`)** — testing _one_ skill, the usual case:
 score its output directly against a rubric. No on/off baseline — this is the
 "is it any good?" oracle (what promptfoo/DeepEval lead with), and the right
 default when there's nothing to compare against:
 
 ```ts
-import { measure, judged, skill, assertRates } from "vigiles/testing";
+import { paid_measure, paid_judged } from "vigiles/eval"; // `paid_` = these call a model
+import { skill, assertRates } from "vigiles";
 
-const report = await measure({
+const report = await paid_measure({
   pluginDir: "./",
   task: "…a task the skill should handle…",
   checks: [
     skill("my-plugin:my-skill"), // it fired
-    judged("the answer correctly does X and avoids Y"), // …and the output is good
+    paid_judged("the answer correctly does X and avoids Y"), // …and the output is good
   ],
   trials: 6,
 });
 assertRates(report, { min: 0.8 }); // each check passes ≥ 80% of trials
 ```
 
-**Eval — relative (`runEval` + `assertSignificant`)** — when the question is
+**Eval — relative (`paid_runEval` + `assertSignificant`)** — when the question is
 _lift over no-skill_ (regression, or proving a change isn't noise): A/B the
 change on vs off and gate on significance, not eyeballing:
 
 ```ts
-import { runEval, assertSignificant } from "vigiles/testing";
+import { paid_runEval } from "vigiles/eval"; // `paid_` = a real model runs
+import { assertSignificant } from "vigiles";
 
-const report = await runEval({
+const report = await paid_runEval({
   arms: { off: {}, on: { pluginDir: "./" } },
   task: "…a task the harness change should affect…",
   measure: (ctx) => ({ ok: /* a bare predicate over the trace */ true }),
@@ -261,7 +263,7 @@ unrepresentable:
 Use **`runScript`** — it runs any command and reports what it did:
 
 ```ts
-import { runScript } from "vigiles/testing";
+import { runScript } from "vigiles";
 
 const r = runScript("bash scripts/check-links.sh", { cwd: repoDir });
 assert.equal(r.exitCode, 0);
@@ -293,7 +295,7 @@ npx vigiles eval --trials=6      # *.eval.{mjs,ts} — real model (local / night
 Unit-tier `runHook` tests need no `claude` and **always run** — write and run them
 even with no `claude` installed. A tier that genuinely can't run reports a loud
 `⊘ SKIPPED` (tallied separately, never a fake `✓`); a standalone script emits one
-via `skip(reason)` from `vigiles/testing`. A skip passes by default, but in a CI
+via `skip(reason)` from `vigiles`. A skip passes by default, but in a CI
 job that asserts the capability is present, run **`vigiles test --no-skip`** so a
 skipped tier fails — a green-with-skips is untested surface. Keep unit +
 deterministic tests in CI (free); run evals locally or on a schedule with auth.

package/dist/e2e.d.ts

@@ -1,18 +0,0 @@
-/**
- * `vigiles/e2e` — DEPRECATED back-compat alias for [`vigiles/integration`](./integration.ts).
- *
- * There is no separate "e2e" tier: real **egress** is a *capability* of the
- * harness/integration scope (`egressRoutes()` + `runHook`'s `egress: { allow }`),
- * not a different kind of test — the old `e2e` barrel added exactly one symbol
- * over `integration`, which is the definition of a non-tier. It now lives on
- * `vigiles/integration`; this entry re-exports it unchanged so existing imports
- * keep working. See `research/testing-api-design.md` Part 4 (two scopes, not
- * four tiers). Prefer `vigiles/integration`.
- *
- * NOT here: **evals** (`runEval` / `measure` / `measureTriggerRate` / `judge`) —
- * those are non-deterministic measurement, a different axis. (They live on
- * `vigiles/testing`; `vigiles/eval` is named here in the original comment and does
- * not exist as an entry point.)
- */
-export * from "./integration.js";
-//# sourceMappingURL=e2e.d.ts.map

package/dist/e2e.js

@@ -1,34 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * `vigiles/e2e` — DEPRECATED back-compat alias for [`vigiles/integration`](./integration.ts).
- *
- * There is no separate "e2e" tier: real **egress** is a *capability* of the
- * harness/integration scope (`egressRoutes()` + `runHook`'s `egress: { allow }`),
- * not a different kind of test — the old `e2e` barrel added exactly one symbol
- * over `integration`, which is the definition of a non-tier. It now lives on
- * `vigiles/integration`; this entry re-exports it unchanged so existing imports
- * keep working. See `research/testing-api-design.md` Part 4 (two scopes, not
- * four tiers). Prefer `vigiles/integration`.
- *
- * NOT here: **evals** (`runEval` / `measure` / `measureTriggerRate` / `judge`) —
- * those are non-deterministic measurement, a different axis. (They live on
- * `vigiles/testing`; `vigiles/eval` is named here in the original comment and does
- * not exist as an entry point.)
- */
-__exportStar(require("./integration.js"), exports);
-//# sourceMappingURL=e2e.js.map