vigiles 4.0.0 → 4.0.2

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "vigiles",
-  "version": "3.0.0",
+  "version": "4.0.1",
   "description": "Verify CLAUDE.md/AGENTS.md references, compile typed specs, and test the agent harness",
   "author": {
     "name": "zernie"

package/README.md

@@ -100,13 +100,15 @@ hijacking unrelated ones (precision). **[Full guide →](docs/harness-testing.md
 
 ## Quick start
 
-> **Paste into Claude Code or Codex:**
->
-> > Install vigiles in this repo and run it. Verify my CLAUDE.md / AGENTS.md
-> > references and show me what's stale, then write and run a harness test for one
-> > of my hooks or skills. Use good defaults (both pillars, non-interactive), but
-> > **ask me first** whether to gate it in CI, whether to add a real-model eval,
-> > and whether to enforce strictly (`--strict`).
+**Paste into Claude Code or Codex:**
+
+```text
+Install vigiles in this repo and run it. Verify my CLAUDE.md / AGENTS.md
+references and show me what's stale, then write and run a harness test for one
+of my hooks or skills. Use good defaults (both pillars, non-interactive), but
+ask me first whether to gate it in CI, whether to add a real-model eval, and
+whether to enforce strictly (--strict).
+```
 
 Or do it yourself:
 
@@ -118,21 +120,30 @@ It's interactive in a terminal and non-interactive for agents/CI (or with
 `--yes`), so "set up vigiles" from a Claude Code / Codex prompt Just Works — and
 it installs a model-invocable **`test-harness` skill**, so afterward you can just
 tell your agent _"test my skills"_ and it picks the tier and writes the test.
-Scope `init` with `--lint` / `--test` (one pillar or both). Or write harness
-tests yourself in JS **or** TS (`*.harness.{mjs,ts}`) and run `npx vigiles test`.
-`init` also adds `vigiles` to your `devDependencies` and installs the Claude Code
-plugin (skills + hooks) via the marketplace — globally, never vendored into your
-repo. It wires CI as a `zernie/vigiles@v1` workflow — a composite over the same CLI:
-
-```yaml
-- uses: actions/checkout@v4
-- uses: zernie/vigiles@v1 # lints by default; posts a sticky PR comment + a `valid` output
-```
+
+<details>
+<summary>What <code>init</code> sets up</summary>
+
+- **Both pillars** by default; scope with `--lint` / `--test` (one or both).
+- Adds `vigiles` to your `devDependencies`.
+- Installs the Claude Code plugin (skills + hooks) via the marketplace —
+  globally, never vendored into your repo.
+- Wires CI as a `zernie/vigiles@v1` workflow (a composite over the same CLI):
+
+  ```yaml
+  - uses: actions/checkout@v4
+  - uses: zernie/vigiles@v1 # lints by default; posts a sticky PR comment + a `valid` output
+  ```
+
+Prefer to write tests yourself? They can be JS **or** TS
+(`*.harness.{mjs,ts}`) — run them with `npx vigiles test`.
+
+</details>
 
 ## More
 
 - **[CLI & GitHub Action →](docs/cli.md)** — every command, the Action (inputs / output / versioning), the Claude Code plugin, and the five `lint` rules.
-- **[Skills →](docs/skills.md)** — consumer skills (`strengthen`, `migrate-to-spec`, `test-harness`, `edit-spec`, …) installed as a Claude Code plugin: `/plugin marketplace add zernie/vigiles` then `/plugin install vigiles@vigiles` (or let `vigiles init` do it).
+- **[Skills →](docs/skills.md)** — consumer skills installed as a Claude Code plugin: `/plugin marketplace add zernie/vigiles` then `/plugin install vigiles@vigiles` (or let `vigiles init` do it). The model-invocable ones (`test-harness`, `strengthen`, `edit-spec`) fire on their own — ask _"test my skills"_, _"strengthen my rules"_, or _"add a rule to CLAUDE.md"_ and the agent reaches for them; `migrate-to-spec` and `linter-docs` are user-invoked.
 - **[Docs index →](docs/README.md)** · **[Research →](research/README.md)** · **[Related tools →](docs/related-tools.md)** (ast-grep, Dependency Cruiser, Ruler, rulesync).
 - Companion to [Feedback Loop Is All You Need](https://zernie.com/blog/feedback-loop-is-all-you-need).
 

package/action.yml

@@ -11,7 +11,7 @@ inputs:
     required: false
     default: "lint"
   paths:
-    description: "Comma- or space-separated paths to operate on (.md files for audit, .spec.ts files for compile). Auto-discovers when empty."
+    description: "Comma- or space-separated paths to operate on (.md files for lint, .spec.ts files for compile). Auto-discovers when empty."
     required: false
     default: ""
   version:

package/dist/adapter-conformance.js

@@ -118,7 +118,7 @@ function assertHarnessTestable(adapter) {
     if (!adapter.capabilities.harnessTesting ||
         !adapter.runtime ||
         !adapter.modelMock) {
-        throw new Error(`Adapter "${adapter.name}" does not support harness testing (pillar 2): it is reference-verification-only (no mockable runtime). Use it for compile/scan/audit, not runHarnessTest/runEval.`);
+        throw new Error(`Adapter "${adapter.name}" does not support harness testing (pillar 2): it is reference-verification-only (no mockable runtime). Use it for compile/scan/lint, not runHarnessTest/runEval.`);
     }
     return { runtime: adapter.runtime, modelMock: adapter.modelMock };
 }

package/dist/adapters/claude-code/adapter.js

@@ -14,7 +14,7 @@ const layout_js_1 = require("./layout.js");
 const runtime_js_1 = require("./runtime.js");
 const hook_protocol_js_1 = require("./hook-protocol.js");
 const model_mock_js_1 = require("./model-mock.js");
-const harness_test_js_1 = require("./harness-test.js");
+const harness_test_js_1 = require("../../harness-test.js");
 exports.claudeCodeAdapter = {
     name: "claude-code",
     // The reference harness: every tier. Mockable transport (Anthropic SSE) and

package/dist/check.d.ts

@@ -0,0 +1,132 @@
+/**
+ * `vigiles/check` — the declarative check vocabulary (Phase 0 of the testing-API
+ * revamp; see `research/testing-api-design.md`).
+ *
+ * A **check** is *data*, not a throwing assertion: a small object that knows how
+ * to `eval` itself against a result and how to `toJSON`. One vocabulary, evaluated
+ * two ways downstream — strict (`expect`, throws on first fail) for the
+ * deterministic tiers, and scored (`measure`, 0–1 across trials) for evals — so
+ * `tool("Bash")` reads as pass/fail on one run AND as a rate across many. Because
+ * a check serializes, JSON/JUnit/baseline output and a promptfoo bridge fall out
+ * for free.
+ *
+ * Pure + model-free: every check is fully unit-testable without a `claude`
+ * subprocess. Checks over a {@link Trace} (the agent-run shape, from
+ * `runHarness`/`runEval`) and checks over a {@link HookRunResult} (the hook
+ * decision shape, from `runHook`) are distinguished at the type level, so
+ * `expect(result, checks)` only accepts checks that match the result.
+ */
+import type { Trace } from "./harness-test.js";
+import type { HookRunResult } from "./run-hook.js";
+/** The outcome of evaluating one check against one result. */
+export interface CheckResult {
+    /** Did the check hold? */
+    readonly pass: boolean;
+    /** 0..1 — `pass ? 1 : 0` for a boolean check; a fraction for graded ones. */
+    readonly score: number;
+    /** A human message: confirming on pass, actionable on failure. */
+    readonly message: string;
+}
+/** A check's serialized form (for JSON/JUnit output and the promptfoo bridge). */
+export interface CheckJSON {
+    readonly kind: string;
+    readonly [field: string]: unknown;
+}
+/** A declarative check over a result of type `T` ({@link Trace} or {@link HookRunResult}). */
+export interface Check<T> {
+    /** Discriminator, e.g. `"tool"`, `"skill"`, `"blocked"`. */
+    readonly kind: string;
+    /** Evaluate this check against a result. Pure. */
+    eval(target: T): CheckResult;
+    /** Serialize to a plain object — `expect`/`measure` use this for reports. */
+    toJSON(): CheckJSON;
+}
+/** Evaluate every check against a target. Pure — the shared core of `expect`
+ * (strict) and `measure` (scored). */
+export declare function evalChecks<T>(target: T, checks: readonly Check<T>[]): CheckResult[];
+/**
+ * Strict evaluator (Phase 1): throw if any check fails, collecting **all**
+ * failures into one actionable message (Validation-applicative, not
+ * short-circuit). The deterministic-tier verdict — use it in `node:test`, or any
+ * runner, over a `runHook` / `runHarness` result. `measure` (Phase 3) is the
+ * scored counterpart over trials.
+ */
+export declare function assertChecks<T>(target: T, checks: readonly Check<T>[]): void;
+/** The agent invoked a tool by this name (regardless of result). */
+export declare function tool(name: string): Check<Trace>;
+/** A skill resolved to this id (`<plugin>:<skill>`) without erroring. */
+export declare function skill(id: string): Check<Trace>;
+/** The agent's final output contains a substring / matches a RegExp. */
+export declare function output(matcher: string | RegExp): Check<Trace>;
+/** A hook fired for this event (e.g. `"PreToolUse"`, `"Stop"`). */
+export declare function hookFired(event: string): Check<Trace>;
+/**
+ * The model RECEIVED text matching `matcher` in some request — i.e. it actually
+ * reached the model. Covers **slash-command expansion** (a `commands/` file
+ * expands into the user prompt) and **injected context** (a SessionStart hook's
+ * text). Reads `modelRequests`, which the harness/mock tier captures; the eval
+ * tier drives the real API and captures none, so use this on `runHarness`.
+ */
+export declare function received(matcher: string | RegExp): Check<Trace>;
+/**
+ * The agent took a number of model turns in range — a **multi-turn** observable
+ * (`{ min: 2 }` asserts a back-and-forth happened, not a one-shot answer; `{ max }`
+ * caps runaway loops). The deterministic harness scripts the model turns; this
+ * checks how many the agent actually took.
+ */
+export declare function turns(opts: {
+    min?: number;
+    max?: number;
+}): Check<Trace>;
+/** The agent wrote (or left) a file at this path in the work dir. */
+export declare function wrote(path: string): Check<Trace>;
+/** The named subagent (`Task` `subagent_type`) ran and passed every nested check. */
+export declare function subagent(name: string, checks: readonly Check<Trace>[]): Check<Trace>;
+/** The hook blocked the event (exit 2 / deny / block). */
+export declare function blocked(): Check<HookRunResult>;
+/** The hook allowed the event through. */
+export declare function allowed(): Check<HookRunResult>;
+/** The agent used an MCP tool `<server>/<tool>` (CC names it `mcp__server__tool`). */
+export declare function mcp(server: string, toolName: string): Check<Trace>;
+/** A model-graded judge: grades `output` against a `rubric` → score in [0,1]. */
+export type JudgeFn = (opts: {
+    output: string;
+    rubric: string;
+    threshold?: number;
+}) => {
+    score: number;
+    pass: boolean;
+    reason?: string;
+};
+/**
+ * A model-graded check: the agent's `output` scores ≥ `min` against `rubric`,
+ * judged by a model. Unlike the deterministic checks this one calls a model
+ * (cost), so it's for the scored `measure` tier; the `judge` fn is injectable
+ * (default: the real `judge()`), so the logic is unit-testable with a fake.
+ */
+export declare function judged(rubric: string, opts?: {
+    min?: number;
+    judge?: JudgeFn;
+}): Check<Trace>;
+interface UsageTrace {
+    readonly usage: {
+        readonly costUsd: number;
+        readonly durationMs: number;
+        readonly inputTokens: number;
+        readonly outputTokens: number;
+    };
+}
+/** The run cost at most `maxUsd`. */
+export declare function cost(opts: {
+    maxUsd: number;
+}): Check<UsageTrace>;
+/** The run took at most `maxMs` of wall-clock time. */
+export declare function latency(opts: {
+    maxMs: number;
+}): Check<UsageTrace>;
+/** The run used at most `max` total (input + output) tokens. */
+export declare function tokens(opts: {
+    max: number;
+}): Check<UsageTrace>;
+export {};
+//# sourceMappingURL=check.d.ts.map

package/dist/check.js

@@ -0,0 +1,318 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evalChecks = evalChecks;
+exports.assertChecks = assertChecks;
+exports.tool = tool;
+exports.skill = skill;
+exports.output = output;
+exports.hookFired = hookFired;
+exports.received = received;
+exports.turns = turns;
+exports.wrote = wrote;
+exports.subagent = subagent;
+exports.blocked = blocked;
+exports.allowed = allowed;
+exports.mcp = mcp;
+exports.judged = judged;
+exports.cost = cost;
+exports.latency = latency;
+exports.tokens = tokens;
+const judge_js_1 = require("./judge.js");
+/** Evaluate every check against a target. Pure — the shared core of `expect`
+ * (strict) and `measure` (scored). */
+function evalChecks(target, checks) {
+    return checks.map((c) => c.eval(target));
+}
+/**
+ * Strict evaluator (Phase 1): throw if any check fails, collecting **all**
+ * failures into one actionable message (Validation-applicative, not
+ * short-circuit). The deterministic-tier verdict — use it in `node:test`, or any
+ * runner, over a `runHook` / `runHarness` result. `measure` (Phase 3) is the
+ * scored counterpart over trials.
+ */
+function assertChecks(target, checks) {
+    const failures = evalChecks(target, checks).filter((r) => !r.pass);
+    if (failures.length > 0) {
+        throw new Error(`${String(failures.length)} of ${String(checks.length)} check(s) failed:\n` +
+            failures.map((f) => `  ✗ ${f.message}`).join("\n"));
+    }
+}
+// ---------------------------------------------------------------------------
+// Internals
+// ---------------------------------------------------------------------------
+const ok = (message) => ({
+    pass: true,
+    score: 1,
+    message,
+});
+const no = (message) => ({
+    pass: false,
+    score: 0,
+    message,
+});
+function distinctToolNames(calls) {
+    const names = [...new Set(calls.map((c) => c.name))];
+    return names.length > 0 ? `[${names.join(", ")}]` : "no tools";
+}
+function truncate(s, n = 120) {
+    const flat = s.replace(/\s+/g, " ").trim();
+    return flat.length > n ? `${flat.slice(0, n)}…` : flat;
+}
+// ---------------------------------------------------------------------------
+// Trace checks (an agent run — runHarness / runEval)
+// ---------------------------------------------------------------------------
+/** The agent invoked a tool by this name (regardless of result). */
+function tool(name) {
+    return {
+        kind: "tool",
+        eval: (t) => t.toolCalls.some((c) => c.name === name)
+            ? ok(`agent used tool "${name}"`)
+            : no(`expected the agent to use tool "${name}", but it used ${distinctToolNames(t.toolCalls)}`),
+        toJSON: () => ({ kind: "tool", name }),
+    };
+}
+/** A skill resolved to this id (`<plugin>:<skill>`) without erroring. */
+function skill(id) {
+    return {
+        kind: "skill",
+        eval: (t) => {
+            const call = t.toolCalls.find((c) => c.name === "Skill" && c.input?.skill === id);
+            if (call && !call.isError)
+                return ok(`skill "${id}" resolved`);
+            const skills = t.toolCalls
+                .filter((c) => c.name === "Skill")
+                .map((c) => c.input?.skill ?? "?");
+            return no(`expected skill "${id}" to resolve; it did not (skills invoked: ${skills.length > 0 ? `[${skills.join(", ")}]` : "none"})`);
+        },
+        toJSON: () => ({ kind: "skill", id }),
+    };
+}
+/** The agent's final output contains a substring / matches a RegExp. */
+function output(matcher) {
+    const isRe = matcher instanceof RegExp;
+    return {
+        kind: "output",
+        eval: (t) => {
+            const pass = isRe ? matcher.test(t.output) : t.output.includes(matcher);
+            return pass
+                ? ok(`output matched ${String(matcher)}`)
+                : no(`expected output to ${isRe ? "match" : "contain"} ${String(matcher)}; got "${truncate(t.output) || "(empty)"}"`);
+        },
+        toJSON: () => ({ kind: "output", matcher: String(matcher), regex: isRe }),
+    };
+}
+/** A hook fired for this event (e.g. `"PreToolUse"`, `"Stop"`). */
+function hookFired(event) {
+    return {
+        kind: "hookFired",
+        eval: (t) => {
+            const fired = t.hooks.filter((h) => h.event === event);
+            return fired.length > 0
+                ? ok(`hook fired for ${event}`)
+                : no(`expected a hook to fire for ${event}; hooks that fired: ${t.hooks.length > 0 ? `[${[...new Set(t.hooks.map((h) => h.event))].join(", ")}]` : "none"}`);
+        },
+        toJSON: () => ({ kind: "hookFired", event }),
+    };
+}
+/**
+ * The model RECEIVED text matching `matcher` in some request — i.e. it actually
+ * reached the model. Covers **slash-command expansion** (a `commands/` file
+ * expands into the user prompt) and **injected context** (a SessionStart hook's
+ * text). Reads `modelRequests`, which the harness/mock tier captures; the eval
+ * tier drives the real API and captures none, so use this on `runHarness`.
+ */
+function received(matcher) {
+    const isRe = matcher instanceof RegExp;
+    return {
+        kind: "received",
+        eval: (t) => {
+            const text = t.modelRequests
+                .map((r) => `${r.system} ${r.messages.map((m) => m.text).join(" ")}`)
+                .join(" ");
+            const pass = isRe ? matcher.test(text) : text.includes(matcher);
+            return pass
+                ? ok(`the model received ${String(matcher)}`)
+                : no(`expected the model to receive ${String(matcher)} (a slash-command expansion or injected context); ${t.modelRequests.length === 0 ? "no requests captured (eval tier captures none — use runHarness)" : `got "${truncate(text)}"`}`);
+        },
+        toJSON: () => ({ kind: "received", matcher: String(matcher), regex: isRe }),
+    };
+}
+/**
+ * The agent took a number of model turns in range — a **multi-turn** observable
+ * (`{ min: 2 }` asserts a back-and-forth happened, not a one-shot answer; `{ max }`
+ * caps runaway loops). The deterministic harness scripts the model turns; this
+ * checks how many the agent actually took.
+ */
+function turns(opts) {
+    return {
+        kind: "turns",
+        eval: (t) => {
+            const n = t.turns;
+            const pass = (opts.min === undefined || n >= opts.min) &&
+                (opts.max === undefined || n <= opts.max);
+            const bound = [
+                opts.min !== undefined ? `≥ ${String(opts.min)}` : null,
+                opts.max !== undefined ? `≤ ${String(opts.max)}` : null,
+            ]
+                .filter((x) => x !== null)
+                .join(" and ");
+            return pass
+                ? ok(`${String(n)} turn(s) (${bound || "any"})`)
+                : no(`expected ${bound || "any"} turn(s), got ${String(n)}`);
+        },
+        toJSON: () => ({ kind: "turns", min: opts.min, max: opts.max }),
+    };
+}
+/** The agent wrote (or left) a file at this path in the work dir. */
+function wrote(path) {
+    return {
+        kind: "wrote",
+        eval: (t) => t.file(path) !== null
+            ? ok(`file "${path}" exists`)
+            : no(`expected the agent to create "${path}", but it does not exist`),
+        toJSON: () => ({ kind: "wrote", path }),
+    };
+}
+// ---------------------------------------------------------------------------
+// Subagent — a `Task` run as a nested trace. Run checks over what the SUBAGENT
+// did, not just that `Task` fired. Composes the whole vocabulary recursively.
+// ---------------------------------------------------------------------------
+/** Wrap a subagent's tool calls as a minimal `Trace` so checks run over it. */
+function subTrace(sub) {
+    return {
+        toolCalls: sub.toolCalls,
+        hooks: [],
+        output: "",
+        modelRequests: [],
+        turns: 0,
+        subagents: [],
+        file: () => null,
+    };
+}
+/** The named subagent (`Task` `subagent_type`) ran and passed every nested check. */
+function subagent(name, checks) {
+    return {
+        kind: "subagent",
+        eval: (t) => {
+            const subs = t.subagents ?? [];
+            const sub = subs.find((s) => s.name === name);
+            if (!sub) {
+                return no(`expected subagent "${name}" to run; subagents that ran: ${subs.length > 0 ? `[${subs.map((s) => s.name).join(", ")}]` : "none"}`);
+            }
+            const failures = checks
+                .map((c) => c.eval(subTrace(sub)))
+                .filter((r) => !r.pass);
+            return failures.length === 0
+                ? ok(`subagent "${name}" passed ${String(checks.length)} check(s)`)
+                : no(`subagent "${name}": ${failures.map((f) => f.message).join("; ")}`);
+        },
+        toJSON: () => ({
+            kind: "subagent",
+            name,
+            checks: checks.map((c) => c.toJSON()),
+        }),
+    };
+}
+// ---------------------------------------------------------------------------
+// Hook-decision checks (a single hook — runHook)
+// ---------------------------------------------------------------------------
+/** The hook blocked the event (exit 2 / deny / block). */
+function blocked() {
+    return {
+        kind: "blocked",
+        eval: (r) => r.blocked
+            ? ok("hook blocked the event")
+            : no(`expected the hook to block, but it allowed (exit ${String(r.exitCode)})`),
+        toJSON: () => ({ kind: "blocked" }),
+    };
+}
+/** The hook allowed the event through. */
+function allowed() {
+    return {
+        kind: "allowed",
+        eval: (r) => r.blocked
+            ? no(`expected the hook to allow, but it blocked (exit ${String(r.exitCode)})`)
+            : ok("hook allowed the event"),
+        toJSON: () => ({ kind: "allowed" }),
+    };
+}
+// ---------------------------------------------------------------------------
+// MCP — a tool call is just a name in the Trace; MCP tools are `mcp__srv__tool`
+// ---------------------------------------------------------------------------
+/** The agent used an MCP tool `<server>/<tool>` (CC names it `mcp__server__tool`). */
+function mcp(server, toolName) {
+    const full = `mcp__${server}__${toolName}`;
+    return {
+        kind: "mcp",
+        eval: (t) => t.toolCalls.some((c) => c.name === full)
+            ? ok(`used MCP tool ${server}/${toolName}`)
+            : no(`expected MCP tool ${server}/${toolName} (${full}), but the agent used ${distinctToolNames(t.toolCalls)}`),
+        toJSON: () => ({ kind: "mcp", server, tool: toolName }),
+    };
+}
+/**
+ * A model-graded check: the agent's `output` scores ≥ `min` against `rubric`,
+ * judged by a model. Unlike the deterministic checks this one calls a model
+ * (cost), so it's for the scored `measure` tier; the `judge` fn is injectable
+ * (default: the real `judge()`), so the logic is unit-testable with a fake.
+ */
+function judged(rubric, opts = {}) {
+    const min = opts.min ?? 0.5;
+    const judgeFn = opts.judge ?? ((o) => (0, judge_js_1.judge)(o));
+    return {
+        kind: "judged",
+        eval: (t) => {
+            const r = judgeFn({ output: t.output, rubric, threshold: min });
+            const pass = r.score >= min;
+            const tail = r.reason ? ` — ${r.reason}` : "";
+            return {
+                pass,
+                score: r.score,
+                message: pass
+                    ? `judge ${r.score.toFixed(2)} ≥ ${String(min)}${tail}`
+                    : `judge ${r.score.toFixed(2)} < ${String(min)} for "${rubric}"${tail}`,
+            };
+        },
+        toJSON: () => ({ kind: "judged", rubric, min }),
+    };
+}
+/** The run cost at most `maxUsd`. */
+function cost(opts) {
+    return {
+        kind: "cost",
+        eval: (t) => {
+            const v = t.usage.costUsd;
+            return v <= opts.maxUsd
+                ? ok(`cost $${v.toFixed(4)} ≤ $${String(opts.maxUsd)}`)
+                : no(`expected cost ≤ $${String(opts.maxUsd)}, got $${v.toFixed(4)}`);
+        },
+        toJSON: () => ({ kind: "cost", maxUsd: opts.maxUsd }),
+    };
+}
+/** The run took at most `maxMs` of wall-clock time. */
+function latency(opts) {
+    return {
+        kind: "latency",
+        eval: (t) => {
+            const v = t.usage.durationMs;
+            return v <= opts.maxMs
+                ? ok(`latency ${String(v)}ms ≤ ${String(opts.maxMs)}ms`)
+                : no(`expected latency ≤ ${String(opts.maxMs)}ms, got ${String(v)}ms`);
+        },
+        toJSON: () => ({ kind: "latency", maxMs: opts.maxMs }),
+    };
+}
+/** The run used at most `max` total (input + output) tokens. */
+function tokens(opts) {
+    return {
+        kind: "tokens",
+        eval: (t) => {
+            const v = t.usage.inputTokens + t.usage.outputTokens;
+            return v <= opts.max
+                ? ok(`${String(v)} tokens ≤ ${String(opts.max)}`)
+                : no(`expected ≤ ${String(opts.max)} tokens, got ${String(v)}`);
+        },
+        toJSON: () => ({ kind: "tokens", max: opts.max }),
+    };
+}
+//# sourceMappingURL=check.js.map

package/dist/claude-code.d.ts

@@ -6,7 +6,7 @@
  * is the adapter, so a future `vigiles/<other-harness>` can sit beside it.
  */
 export * from "./adapters/claude-code/plugin-loader.js";
-export * from "./adapters/claude-code/mock-model.js";
+export * from "./mock-model.js";
 export * from "./adapters/claude-code/dialect.js";
 export * from "./adapters/claude-code/layout.js";
 export * from "./adapters/claude-code/runtime.js";

package/dist/claude-code.js

@@ -22,7 +22,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * is the adapter, so a future `vigiles/<other-harness>` can sit beside it.
  */
 __exportStar(require("./adapters/claude-code/plugin-loader.js"), exports);
-__exportStar(require("./adapters/claude-code/mock-model.js"), exports);
+__exportStar(require("./mock-model.js"), exports);
 __exportStar(require("./adapters/claude-code/dialect.js"), exports);
 __exportStar(require("./adapters/claude-code/layout.js"), exports);
 __exportStar(require("./adapters/claude-code/runtime.js"), exports);