vigiles 4.0.1 → 4.1.0

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

@@ -143,7 +143,7 @@ Prefer to write tests yourself? They can be JS **or** TS
 ## 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/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/adapter-registry.d.ts

@@ -31,12 +31,56 @@ export interface DetectResult {
 export declare function detectAdapterResult(root: string): DetectResult;
 /** The detected adapter (highest specificity), else the default (Claude Code). */
 export declare function detectAdapter(root: string): HarnessAdapter;
-/** Look up a registered adapter by `name` (e.g. for a `--harness` override). */
+/** Lower-case, trim, and map a short alias to its canonical adapter name. */
+export declare function normalizeHarnessName(name: string): string;
+/** Look up a registered adapter by `name` (alias-aware, e.g. `claude`). */
 export declare function getAdapter(name: string): HarnessAdapter | undefined;
+/**
+ * The adapter whose instruction file is `filename` (e.g. `AGENTS.md` → codex,
+ * `CLAUDE.md` → claude-code), if any. The per-spec disambiguation signal: a
+ * `<file>.spec.ts` compiles a `<file>` instruction file, so the filename names
+ * the harness more specifically than config/detect for THAT spec.
+ */
+export declare function adapterForInstructionFile(filename: string): HarnessAdapter | undefined;
 /**
  * Resolve the adapter for a command: an explicit `--harness <name>` wins (throws
  * if unknown); otherwise auto-detect from `root`. The single entry point the CLI
  * uses so detection + override live in one place.
  */
 export declare function resolveAdapter(root: string, harness?: string): HarnessAdapter;
+/** Normalize a config `harness` value (string | string[]) to a canonical list. */
+export declare function normalizeHarnessList(harness?: string | readonly string[]): string[];
+/**
+ * The adapter chosen for a single-dialect operation. A discriminated union so an
+ * invalid state — a "notice" with no message, or a clean pick carrying a stray
+ * string — is unrepresentable: `kind: "ok"` has no `notice`, `kind: "notice"`
+ * always carries a non-empty one. Both variants carry the `adapter`.
+ */
+export type HarnessSelection = {
+    readonly kind: "ok";
+    readonly adapter: HarnessAdapter;
+} | {
+    readonly kind: "notice";
+    readonly adapter: HarnessAdapter;
+    readonly notice: string;
+};
+/**
+ * Resolve the single harness a compile/lint operation should use, with explicit
+ * precedence — the deterministic replacement for sniffing the cwd:
+ *
+ *   1. `--harness=` flag (wins; throws if unknown).
+ *   2. config `harness` resolving to a single entry → use it.
+ *   3. config `harness` with multiple entries → use the first, with a loud notice.
+ *   4. no config → auto-detect, with a loud notice when the repo is ambiguous.
+ *
+ * `configHarness` is parsed once (alias-normalized) at the call site and passed
+ * in; this function re-normalizes idempotently so it's safe either way. Pure
+ * (besides reading `root`'s layout for detection) so the precedence is
+ * unit-testable without a real compile. See research/multi-harness-compile.md.
+ */
+export declare function resolveHarnessSelection(opts: {
+    root: string;
+    flag?: string;
+    configHarness?: string | readonly string[];
+}): HarnessSelection;
 //# sourceMappingURL=adapter-registry.d.ts.map

package/dist/adapter-registry.js

@@ -3,8 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ADAPTERS = exports.defaultAdapter = void 0;
 exports.detectAdapterResult = detectAdapterResult;
 exports.detectAdapter = detectAdapter;
+exports.normalizeHarnessName = normalizeHarnessName;
 exports.getAdapter = getAdapter;
+exports.adapterForInstructionFile = adapterForInstructionFile;
 exports.resolveAdapter = resolveAdapter;
+exports.normalizeHarnessList = normalizeHarnessList;
+exports.resolveHarnessSelection = resolveHarnessSelection;
 const adapter_js_1 = require("./adapters/claude-code/adapter.js");
 const adapter_js_2 = require("./adapters/codex/adapter.js");
 /** The default adapter when detection finds no harness markers. */
@@ -32,9 +36,32 @@ function detectAdapterResult(root) {
 function detectAdapter(root) {
     return detectAdapterResult(root).adapter;
 }
-/** Look up a registered adapter by `name` (e.g. for a `--harness` override). */
+/**
+ * Short-name aliases accepted anywhere a harness name is supplied (config,
+ * `--harness=`). `init` historically uses `"claude"`; the canonical adapter name
+ * is `"claude-code"`. Normalizing here keeps selection and the registry in sync.
+ */
+const HARNESS_ALIASES = {
+    claude: "claude-code",
+};
+/** Lower-case, trim, and map a short alias to its canonical adapter name. */
+function normalizeHarnessName(name) {
+    const n = name.trim().toLowerCase();
+    return HARNESS_ALIASES[n] ?? n;
+}
+/** Look up a registered adapter by `name` (alias-aware, e.g. `claude`). */
 function getAdapter(name) {
-    return exports.ADAPTERS.find((a) => a.name === name);
+    const canonical = normalizeHarnessName(name);
+    return exports.ADAPTERS.find((a) => a.name === canonical);
+}
+/**
+ * The adapter whose instruction file is `filename` (e.g. `AGENTS.md` → codex,
+ * `CLAUDE.md` → claude-code), if any. The per-spec disambiguation signal: a
+ * `<file>.spec.ts` compiles a `<file>` instruction file, so the filename names
+ * the harness more specifically than config/detect for THAT spec.
+ */
+function adapterForInstructionFile(filename) {
+    return exports.ADAPTERS.find((a) => a.layout.instructionFile === filename);
 }
 /**
  * Resolve the adapter for a command: an explicit `--harness <name>` wins (throws
@@ -42,7 +69,7 @@ function getAdapter(name) {
  * uses so detection + override live in one place.
  */
 function resolveAdapter(root, harness) {
-    if (harness !== undefined) {
+    if (harness !== undefined && harness !== "") {
         const a = getAdapter(harness);
         if (!a) {
             const known = exports.ADAPTERS.map((x) => x.name).join(", ");
@@ -52,4 +79,52 @@ function resolveAdapter(root, harness) {
     }
     return detectAdapter(root);
 }
+/** Normalize a config `harness` value (string | string[]) to a canonical list. */
+function normalizeHarnessList(harness) {
+    if (harness === undefined)
+        return [];
+    const arr = Array.isArray(harness) ? harness : [harness];
+    return arr.map(normalizeHarnessName).filter(Boolean);
+}
+/**
+ * Resolve the single harness a compile/lint operation should use, with explicit
+ * precedence — the deterministic replacement for sniffing the cwd:
+ *
+ *   1. `--harness=` flag (wins; throws if unknown).
+ *   2. config `harness` resolving to a single entry → use it.
+ *   3. config `harness` with multiple entries → use the first, with a loud notice.
+ *   4. no config → auto-detect, with a loud notice when the repo is ambiguous.
+ *
+ * `configHarness` is parsed once (alias-normalized) at the call site and passed
+ * in; this function re-normalizes idempotently so it's safe either way. Pure
+ * (besides reading `root`'s layout for detection) so the precedence is
+ * unit-testable without a real compile. See research/multi-harness-compile.md.
+ */
+function resolveHarnessSelection(opts) {
+    const { root, flag, configHarness } = opts;
+    if (flag !== undefined && flag !== "") {
+        return { kind: "ok", adapter: resolveAdapter(root, flag) };
+    }
+    const list = normalizeHarnessList(configHarness);
+    if (list.length === 1) {
+        return { kind: "ok", adapter: resolveAdapter(root, list[0]) };
+    }
+    if (list.length > 1) {
+        const adapter = resolveAdapter(root, list[0]);
+        return {
+            kind: "notice",
+            adapter,
+            notice: `repo targets ${list.join(", ")} — compiling for ${adapter.name}; override with --harness=`,
+        };
+    }
+    const det = detectAdapterResult(root);
+    if (det.ambiguousWith.length > 0) {
+        return {
+            kind: "notice",
+            adapter: det.adapter,
+            notice: `repo matches ${[det.adapter.name, ...det.ambiguousWith].join(", ")} — set "harness" in .vigilesrc.json or use --harness=`,
+        };
+    }
+    return { kind: "ok", adapter: det.adapter };
+}
 //# sourceMappingURL=adapter-registry.js.map

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