vigiles 33.1.0 → 33.2.0

package/dist/coverage-evidence.js

@@ -12,6 +12,9 @@ exports.matchesSurfaceGlob = matchesSurfaceGlob;
 exports.countEvidence = countEvidence;
 exports.formatEvidence = formatEvidence;
 exports.declaredSurfaceName = declaredSurfaceName;
+exports.outputStyleSurface = outputStyleSurface;
+exports.outputStyleCount = outputStyleCount;
+exports.inventoryCounts = inventoryCounts;
 /**
  * HOW a surface was decided to be covered — the provenance of every coverage
  * decision.
@@ -390,4 +393,40 @@ function declaredSurfaceName(content) {
     const name = (0, frontmatter_read_js_1.frontmatterScalar)((0, frontmatter_read_js_1.readFrontmatter)(content), "name");
     return name !== undefined && name.trim() ? name.trim() : null;
 }
+/**
+ * One output style as a coverage surface — shared by the disk detector and the
+ * browser twin, so the two name and exempt a style the same way.
+ *
+ * Named by FILE (`status-block.md` → `status-block`), not by the name a
+ * harness selects it by: the surface name is what a colocated test is spelled
+ * after, and a declared name may hold spaces or colons no file name should.
+ */
+function outputStyleSurface(path, content) {
+    return {
+        kind: "output-style",
+        path,
+        name: (0, posix_path_js_1.basename)(path).replace(/\.[^.]+$/, ""),
+        tokens: [path],
+        ignored: content.includes("vigiles:ignore-test"),
+    };
+}
+/**
+ * How many output styles a scan found, or that the harness has none. Shared by
+ * the disk and browser scan engines, so the inventory reads the one discovery
+ * pass both already ran. Exempt styles (`vigiles:ignore-test`) are counted: the
+ * marker waives the test, not the style, and a style-only repository with an
+ * exempt style is not an empty machine.
+ */
+function outputStyleCount(layouts, tier, exempt) {
+    if (layouts.every((l) => l.outputStyles === undefined))
+        return "not-supported";
+    return [...tier.covered, ...tier.untested, ...exempt].filter((s) => s.kind === "output-style").length;
+}
+/** The inventory counts both scan engines report the same way. */
+function inventoryCounts(files, isCommand, layouts, coverage) {
+    return {
+        commands: Object.keys(files).filter(isCommand).length,
+        outputStyles: outputStyleCount(layouts, coverage.harness, coverage.exemptSurfaces),
+    };
+}
 //# sourceMappingURL=coverage-evidence.js.map

package/dist/eval.d.ts

@@ -119,7 +119,11 @@ export interface EvalSpec<M extends Metrics> {
      * the cache, and never read from an env var. Omit for the harness default.
      */
     readonly effort?: string | number;
-    /** Tools the agent may use. Default: Read Edit Write Bash. */
+    /**
+     * Tools pre-approved for the run (`--allowedTools`, a permission allowlist);
+     * the default tools stay available either way. `[]` approves none.
+     * Default: Read Edit Write Bash.
+     */
     readonly allowedTools?: readonly string[];
     /** Per-run timeout ms. Default 240000. */
     readonly timeoutMs?: number;
@@ -309,6 +313,22 @@ export declare function withEffortGuard(runner: AgentRunner): AgentRunner;
  * inline there could not be asserted at all. Mirrors `buildCodexArgs`.
  */
 export declare function buildAgentArgs(a: AgentRunArgs): string[];
+/**
+ * Why a run never reached the model, or null when it did. A run that exited
+ * non-zero with no `assistant` event and no `result` event asked the model
+ * nothing — a usage error in the command line, a missing binary — and scored as
+ * a trial it reads as a miss on every check that needs output and a pass on
+ * every bound it cannot break. A run that reached the model and then broke is a
+ * scored outcome, not this. Rate-limited runs are left to the retry loop.
+ */
+export declare function startFailure(out: Readonly<RunOut>): string | null;
+/**
+ * Wrap a runner so a run that never reached the model THROWS instead of being
+ * scored — the same choice, for the same reason, as {@link withEffortGuard}:
+ * the cause is usually deterministic, so every trial would fail it. Not `async`,
+ * for the reason that guard gives.
+ */
+export declare function withStartGuard(runner: AgentRunner): AgentRunner;
 /**
  * The real `claude`-spawning runner (composition root). Exported so other
  * real-model entries (e.g. the `audit` trigger tier) bind the same runner.
@@ -391,7 +411,7 @@ export interface MeasureSpec {
      * the cache, and never read from an env var. Omit for the harness default.
      */
     readonly effort?: string | number;
-    /** Tools the agent may use. */
+    /** Tools pre-approved for the run (`--allowedTools`); `[]` approves none. */
     readonly allowedTools?: readonly string[];
     /** Per-run timeout ms. */
     readonly timeoutMs?: number;
@@ -744,7 +764,10 @@ export interface TriggerRateSpec {
      * false-negative recall. Default `"sonnet"`. Lower it deliberately for a cheap run.
      */
     readonly minModel?: string;
-    /** Tools the agent may use. Default: Read Edit Write Bash Skill. */
+    /**
+     * Tools pre-approved for the run (`--allowedTools`); `[]` approves none.
+     * Default: Read Edit Write Bash Skill.
+     */
     readonly allowedTools?: readonly string[];
     /** Per-run timeout ms. Default 240000. */
     readonly timeoutMs?: number;

package/dist/eval.js

@@ -6,6 +6,8 @@ exports.pinEffortEnv = pinEffortEnv;
 exports.effortRejection = effortRejection;
 exports.withEffortGuard = withEffortGuard;
 exports.buildAgentArgs = buildAgentArgs;
+exports.startFailure = startFailure;
+exports.withStartGuard = withStartGuard;
 exports.unregisteredSkillFiles = unregisteredSkillFiles;
 exports.runEval = runEval;
 exports.measureWith = measureWith;
@@ -215,10 +217,41 @@ function buildAgentArgs(a) {
             ? ["--plugin-dir", (0, node_path_1.resolve)(a.pluginDir)]
             : []),
         ...(a.hasSettings ? ["--settings", "settings.json"] : []),
-        "--allowedTools",
-        ...a.tools,
+        // A permission allowlist: an empty one approves nothing, so the flag is
+        // left out (a bare `--allowedTools` exits before any model turn).
+        ...(a.tools.length === 0 ? [] : ["--allowedTools", ...a.tools]),
     ];
 }
+/**
+ * Why a run never reached the model, or null when it did. A run that exited
+ * non-zero with no `assistant` event and no `result` event asked the model
+ * nothing — a usage error in the command line, a missing binary — and scored as
+ * a trial it reads as a miss on every check that needs output and a pass on
+ * every bound it cannot break. A run that reached the model and then broke is a
+ * scored outcome, not this. Rate-limited runs are left to the retry loop.
+ */
+function startFailure(out) {
+    if (out.code === 0 || (0, harness_test_js_1.parseResultEvent)(out.stdout) !== null)
+        return null;
+    if ((0, harness_test_js_1.reachedModel)(out.stdout) || isRateLimited(out))
+        return null;
+    const said = (out.stderr ?? "").trim().split("\n").slice(-5).join("\n");
+    return `the harness exited ${String(out.code)} before calling the model: ${said || "(no stderr)"}`;
+}
+/**
+ * Wrap a runner so a run that never reached the model THROWS instead of being
+ * scored — the same choice, for the same reason, as {@link withEffortGuard}:
+ * the cause is usually deterministic, so every trial would fail it. Not `async`,
+ * for the reason that guard gives.
+ */
+function withStartGuard(runner) {
+    return (a) => runner(a).then((out) => {
+        const failure = startFailure(out);
+        if (failure !== null)
+            throw new Error(failure);
+        return out;
+    });
+}
 /**
  * The real `claude`-spawning runner (composition root). Exported so other
  * real-model entries (e.g. the `audit` trigger tier) bind the same runner.
@@ -228,7 +261,7 @@ function buildAgentArgs(a) {
  * not yet written, is covered by construction. Guarding each call site instead is
  * the shape that left four of five compilers unprotected in #173.
  */
-exports.spawnAgent = withEffortGuard(spawnAgentRaw);
+exports.spawnAgent = withEffortGuard(withStartGuard(spawnAgentRaw));
 /* v8 ignore start -- real claude subprocess; exercised by bench/, not the unit gate */
 /** The unguarded spawn itself; wrapped by {@link spawnAgent}, never bound raw. */
 function spawnAgentRaw(a) {
@@ -572,6 +605,7 @@ function parseClaudeRun(out) {
         toolCalls: (0, harness_test_js_1.parseToolCalls)(out.stdout),
         hooks: (0, harness_test_js_1.parseHooks)(out.stdout),
         subagents: (0, harness_test_js_1.parseSubagents)(out.stdout),
+        replies: (0, harness_test_js_1.parseReplies)(out.stdout),
         usage: usageFrom(result),
     };
 }
@@ -592,6 +626,7 @@ function makeContext(cwd, out, parse = parseClaudeRun) {
         hooks: p.hooks,
         output: p.output,
         subagents: p.subagents,
+        ...(p.replies === undefined ? {} : { replies: p.replies }),
         usage: p.usage,
         // The eval tier drives the real API (no mock between the agent and the model),
         // so the requests can't be captured here — modelRequests is harness-tier only.
@@ -755,7 +790,10 @@ async function runWithCache(runArgs, keyParts, runner, cfg) {
         trialIndex: keyParts.trialIndex,
     });
     const hit = (0, eval_cache_js_1.readCache)(cfg.cacheDir, key);
-    if (hit) {
+    // A run that never reached the model is not replayed: the real runner now
+    // throws on one, and an entry cached before that guard existed would
+    // otherwise be scored as a trial on every later run.
+    if (hit && startFailure(hit.out) === null) {
         (0, eval_cache_js_1.restoreDir)(runArgs.cwd, hit.files);
         return hit.out;
     }
@@ -1122,14 +1160,25 @@ async function runWithRetry(runArgs, runner, retries, baseMs) {
 /** Map `worker` over `items` with at most `concurrency` in flight, order preserved. */
 async function runPool(items, concurrency, worker) {
     const results = new Array(items.length);
+    // A worker that throws rejects the whole pool; the others must stop taking
+    // items then, or they keep starting (and paying for) work nobody will read.
+    const stop = new AbortController();
     let next = 0;
     const drain = async () => {
         for (;;) {
+            if (stop.signal.aborted)
+                return;
             const i = next++;
             const item = items[i];
             if (i >= items.length || item === undefined)
                 return;
-            results[i] = await worker(item);
+            try {
+                results[i] = await worker(item);
+            }
+            catch (e) {
+                stop.abort();
+                throw e;
+            }
         }
     };
     const workers = Math.max(1, Math.min(concurrency, items.length || 1));

package/dist/harness-test.d.ts

@@ -2,10 +2,14 @@ import type { HarnessAdapter } from "./core/adapter.js";
 import type { HarnessTestDriver, ToolCall, HookFire, ParsedRun, ModelTurn } from "./core/harness-driver.js";
 import type { Trace, SubagentTrace } from "./core/eval-driver.js";
 export type { Trace, SubagentTrace } from "./core/eval-driver.js";
+import { parseReplies, reachedModel } from "./adapters/claude-code/replies.js";
+/** Re-exported for the eval tier's parser, which reads the same stream. */
+export { parseReplies, reachedModel };
 import { type SandboxMode } from "./sandbox.js";
 export { scriptModel } from "./mock-model.js";
 export type { ModelTurn, ModelRequest, ToolCall, HookFire, HarnessTestDriver, } from "./core/harness-driver.js";
-export { loadPlugin, resolveHarness, } from "./adapters/claude-code/plugin-loader.js";
+import { loadPlugin, resolveHarness } from "./adapters/claude-code/plugin-loader.js";
+export { loadPlugin, resolveHarness };
 export { decideSandbox, specTrusted, sandboxAvailable, type SandboxMode, } from "./sandbox.js";
 export interface HarnessTestSpec {
     /** Fixture files to write in a fresh temp working dir (path → contents). */
@@ -28,6 +32,21 @@ export interface HarnessTestSpec {
      * `plugin` still layer on top. Resolved to an absolute path.
      */
     readonly pluginDir?: string;
+    /**
+     * Path to an OUTPUT STYLE file to switch on for this run. The style is
+     * written where the harness keeps styles, and selected by the name the
+     * harness reads from the file — never by a name you type, because a setting
+     * that misses the name loads no style and raises no error.
+     *
+     * The run is then checked: if no model request carried the style,
+     * `runHarnessTest` THROWS instead of returning a trace, so a style that never
+     * loaded cannot pass a test. Refused up front on a harness without output
+     * styles, or when the fixture's files or settings already decide.
+     *
+     * What it proves is delivery. A scripted model does not read the style, so
+     * nothing in this tier shows that a model FOLLOWS it.
+     */
+    readonly outputStyle?: string;
     /** The scripted model turns the agent will take. */
     readonly model: readonly ModelTurn[];
     /** The user prompt. Default: "go". */
@@ -156,4 +175,14 @@ export declare function runHarnessTest(spec: HarnessTestSpec, opts?: RunHarnessT
 export declare function runHarness(spec: HarnessTestSpec, opts?: RunHarnessTestOptions & {
     model?: "mock" | "real";
 }): Promise<HarnessTestResult>;
+/**
+ * The files and settings a run with `outputStyle` writes — the style at its
+ * place, selected by the name the harness reads from it. The same fixture
+ * `runHarnessTest({ outputStyle })` runs, so an eval arm built from it gets
+ * exactly what that run proved reaches the model.
+ */
+export declare function outputStyleFixture(outputStyle: string, adapter?: HarnessAdapter): {
+    readonly files: Readonly<Record<string, string>>;
+    readonly settings: unknown;
+};
 //# sourceMappingURL=harness-test.d.ts.map

package/dist/harness-test.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.claudeCodeDriver = exports.sandboxAvailable = exports.specTrusted = exports.decideSandbox = exports.resolveHarness = exports.loadPlugin = exports.scriptModel = void 0;
+exports.claudeCodeDriver = exports.sandboxAvailable = exports.specTrusted = exports.decideSandbox = exports.resolveHarness = exports.loadPlugin = exports.scriptModel = exports.reachedModel = exports.parseReplies = void 0;
 exports.parseToolCalls = parseToolCalls;
 exports.parseSubagents = parseSubagents;
 exports.parseResultEvent = parseResultEvent;
@@ -11,6 +11,7 @@ exports.parseClaudeRun = parseClaudeRun;
 exports.claudeAvailable = claudeAvailable;
 exports.runHarnessTest = runHarnessTest;
 exports.runHarness = runHarness;
+exports.outputStyleFixture = outputStyleFixture;
 /**
  * vigiles — deterministic Claude Code harness testing.
  *
@@ -49,13 +50,17 @@ const check_count_js_1 = require("./check-count.js");
 const coverage_probe_js_1 = require("./coverage-probe.js");
 const runtime_js_1 = require("./adapters/claude-code/runtime.js");
 const mock_model_js_1 = require("./mock-model.js");
-const plugin_loader_js_1 = require("./adapters/claude-code/plugin-loader.js");
+const replies_js_1 = require("./adapters/claude-code/replies.js");
+Object.defineProperty(exports, "parseReplies", { enumerable: true, get: function () { return replies_js_1.parseReplies; } });
+Object.defineProperty(exports, "reachedModel", { enumerable: true, get: function () { return replies_js_1.reachedModel; } });
+const adapter_registry_js_1 = require("./adapter-registry.js");
+const output_style_js_1 = require("./core/output-style.js");
 const sandbox_js_1 = require("./sandbox.js");
 var mock_model_js_2 = require("./mock-model.js");
 Object.defineProperty(exports, "scriptModel", { enumerable: true, get: function () { return mock_model_js_2.scriptModel; } });
-var plugin_loader_js_2 = require("./adapters/claude-code/plugin-loader.js");
-Object.defineProperty(exports, "loadPlugin", { enumerable: true, get: function () { return plugin_loader_js_2.loadPlugin; } });
-Object.defineProperty(exports, "resolveHarness", { enumerable: true, get: function () { return plugin_loader_js_2.resolveHarness; } });
+const plugin_loader_js_1 = require("./adapters/claude-code/plugin-loader.js");
+Object.defineProperty(exports, "loadPlugin", { enumerable: true, get: function () { return plugin_loader_js_1.loadPlugin; } });
+Object.defineProperty(exports, "resolveHarness", { enumerable: true, get: function () { return plugin_loader_js_1.resolveHarness; } });
 var sandbox_js_2 = require("./sandbox.js");
 Object.defineProperty(exports, "decideSandbox", { enumerable: true, get: function () { return sandbox_js_2.decideSandbox; } });
 Object.defineProperty(exports, "specTrusted", { enumerable: true, get: function () { return sandbox_js_2.specTrusted; } });
@@ -285,8 +290,9 @@ function buildClaudeArgs(spec, hasSettings) {
             ? ["--plugin-dir", (0, node_path_1.resolve)(spec.pluginDir)]
             : []),
         ...(hasSettings ? ["--settings", "settings.json"] : []),
-        "--allowedTools",
-        ...tools,
+        // A permission allowlist: an empty one approves nothing, so the flag is
+        // left out (a bare `--allowedTools` exits before any model turn).
+        ...(tools.length === 0 ? [] : ["--allowedTools", ...tools]),
     ];
 }
 /** Build the `claude` argv from the driver context — wraps `buildClaudeArgs`. */
@@ -305,6 +311,7 @@ function parseClaudeRun(stdout) {
         toolCalls: parseToolCalls(stdout),
         hooks: parseHooks(stdout),
         output: parseOutput(stdout),
+        replies: (0, replies_js_1.parseReplies)(stdout),
     };
 }
 /* v8 ignore start -- spawns the real claude CLI + filesystem; exercised by the
@@ -399,6 +406,7 @@ function makeResult(cwd, out, parsed, turns, modelRequests) {
         toolCalls: parsed.toolCalls,
         hooks: parsed.hooks,
         output: parsed.output,
+        ...(parsed.replies === undefined ? {} : { replies: parsed.replies }),
         modelRequests,
         subagents: parseSubagents(out.stdout),
         file: (p) => {
@@ -443,12 +451,8 @@ async function runHarnessTest(spec, opts = {}) {
     if (decision.action === "sandbox" && !isClaudeCode) {
         throw new Error(`sandbox not supported for ${driver.runtime.name}: confined execution is Claude Code only. Pass sandbox: false to run ${driver.runtime.name} unconfined (you audited the code, or trust the outer container).`);
     }
+    const { files, settings, check } = fixtureFor(spec, opts.adapter);
     const cwd = (0, tmp_root_js_1.makeTmpDir)("harness");
-    const { files, settings } = (0, plugin_loader_js_1.resolveHarness)({
-        plugin: spec.plugin,
-        settings: spec.settings,
-        files: spec.files,
-    });
     writeFixture(cwd, files, settings);
     const tools = spec.allowedTools ?? ["Read", "Edit", "Write", "Bash"];
     const timeoutMs = spec.timeoutMs ?? 60000;
@@ -481,7 +485,7 @@ async function runHarnessTest(spec, opts = {}) {
         const unconsumed = (0, mock_model_js_1.scriptUnconsumedWarning)(count, sideChannelCount);
         if (unconsumed !== undefined)
             console.error(unconsumed);
-        return makeResult(cwd, out, parseClaudeRun(out.stdout), count, out.requests);
+        return check(makeResult(cwd, out, parseClaudeRun(out.stdout), count, out.requests));
     }
     // Direct path: mock runs in this process; the agent reaches it over localhost.
     // Start the mock first so its URL feeds the driver's mock-wiring args.
@@ -496,9 +500,9 @@ async function runHarnessTest(spec, opts = {}) {
         const unconsumed = (0, mock_model_js_1.scriptUnconsumedWarning)(mock.count, mock.sideChannelCount ?? 0);
         if (unconsumed !== undefined)
             console.error(unconsumed);
-        return makeResult(cwd, out, driver.parseRun(out.stdout), mock.count, [
+        return check(makeResult(cwd, out, driver.parseRun(out.stdout), mock.count, [
             ...mock.requests,
-        ]);
+        ]));
     }
     finally {
         await mock.close();
@@ -527,6 +531,52 @@ async function runHarness(spec, opts = {}) {
     }
     return runHarnessTest(spec, opts);
 }
+/**
+ * The fixture to write, and the check its result must pass. Without
+ * `outputStyle` the check returns the result as it is.
+ */
+function fixtureFor(spec, adapter) {
+    // One layout for both phases: the plugin is loaded the way the selected
+    // harness lays it out, the same layout the style is then planned against.
+    const { layout } = adapter ?? adapter_registry_js_1.defaultAdapter;
+    const resolved = (0, plugin_loader_js_1.resolveHarness)({ plugin: spec.plugin, settings: spec.settings, files: spec.files }, layout);
+    if (spec.outputStyle === undefined)
+        return { ...resolved, check: (result) => result };
+    const rules = layout.outputStyles;
+    if (rules === undefined)
+        throw new Error("outputStyle: this harness has no output styles");
+    const plan = (0, output_style_js_1.planStyleRun)(layout, { path: spec.outputStyle, text: readStyleFile(spec.outputStyle) }, resolved);
+    if (plan.kind === "refused")
+        throw new Error(`outputStyle: ${plan.reason}`);
+    return {
+        files: plan.files,
+        settings: plan.settings,
+        check: (result) => {
+            if ((0, output_style_js_1.styleReached)(rules, plan.style, result.modelRequests))
+                return result;
+            throw new Error(`outputStyle: "${plan.style.name ?? ""}" never reached the model — ` +
+                `no request carried it, so the harness did not load it. ` +
+                `Work dir kept for inspection: ${result.cwd}`);
+        },
+    };
+}
+/**
+ * The files and settings a run with `outputStyle` writes — the style at its
+ * place, selected by the name the harness reads from it. The same fixture
+ * `runHarnessTest({ outputStyle })` runs, so an eval arm built from it gets
+ * exactly what that run proved reaches the model.
+ */
+function outputStyleFixture(outputStyle, adapter) {
+    const { files, settings } = fixtureFor({ outputStyle, model: [] }, adapter);
+    return { files, settings };
+}
+/** The style file's text, or a clear error naming the path. */
+function readStyleFile(path) {
+    const abs = (0, node_path_1.resolve)(path);
+    if (!(0, node_fs_1.existsSync)(abs))
+        throw new Error(`outputStyle: no such file: ${path}`);
+    return (0, node_fs_1.readFileSync)(abs, "utf-8");
+}
 /** Pull the pillar-2 driver off an adapter, asserting it supports testing. */
 async function requireDriver(adapter) {
     (0, adapter_conformance_js_1.assertHarnessTestable)(adapter);

package/dist/optimize.js

@@ -36,10 +36,6 @@ const score_explainer_js_1 = require("./score-explainer.js");
 function actionFor(e) {
     return e.symptom === "wrong-skill-fires" ? "differentiate" : "fix";
 }
-function isEmptyMachine(r) {
-    const surfaces = r.skills.length + r.agents.length + r.hooks.length + r.commands;
-    return surfaces === 0 && !r.mcp;
-}
 /**
  * Turn a scan report into a prioritized optimization plan: the structural-health
  * score + a typed recommendation per deterministic finding (`likely` dead-ends
@@ -60,7 +56,7 @@ function optimize(report) {
         score,
         grade: (0, score_core_js_1.gradeFor)(score),
         recommendations,
-        empty: isEmptyMachine(report),
+        empty: (0, score_core_js_1.isEmptyMachine)(report),
     };
 }
 const ACTION_LABEL = {

package/dist/output-style-arms.d.ts

@@ -0,0 +1,27 @@
+import type { HarnessAdapter } from "./core/adapter.js";
+import type { EvalArm } from "./eval.js";
+/** The style on and the style off, ready for `paid_measureArms({ arms })`. */
+export interface OutputStyleArms {
+    /** The style file at its place in the work dir, selected in the settings. */
+    readonly with: EvalArm;
+    /** Every style switched off, including one the user set for all projects. */
+    readonly without: EvalArm;
+}
+/**
+ * Build the with/without arms for the style at `path` (a file in the shape the
+ * harness loads, e.g. a Claude Code `.md` style), for the harness the paid tier
+ * drives. Spends nothing: the one run it makes uses the scripted model. Throws,
+ * before any eval, when the harness has no output styles, cannot tell the
+ * style's name, or the style does not reach the model.
+ *
+ * @experimental One real-model run behind it; how arms are built may change
+ * once a style can be authored as a compiled spec with its checks attached.
+ */
+export declare function experimental_outputStyleArms(path: string): Promise<OutputStyleArms>;
+/**
+ * {@link experimental_outputStyleArms} on a given adapter. Not public: the paid
+ * tier drives only the default harness, so arms built for another one would be
+ * run by a harness they were not checked on.
+ */
+export declare function outputStyleArmsWith(path: string, adapter: HarnessAdapter): Promise<OutputStyleArms>;
+//# sourceMappingURL=output-style-arms.d.ts.map

package/dist/output-style-arms.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.experimental_outputStyleArms = experimental_outputStyleArms;
+exports.outputStyleArmsWith = outputStyleArmsWith;
+/**
+ * The two arms of a paid output-style eval — the style on, the style off — built
+ * from the style FILE, after one free run has shown the style reaches the model.
+ *
+ * Three silent failures this closes. A hand-typed arm name that misses the
+ * style's name loads no style and raises no error, so the "with" arm is the
+ * "without" arm and the eval compares a run with itself. A bare "without" arm
+ * still loads a style the user switched on for every project, which is the same
+ * comparison from the other side. And the paid tier cannot check delivery at
+ * all: it drives the real API, so no request is captured. The free run here
+ * uses the scripted model, where requests ARE captured, with the same fixture
+ * the paid arm gets — so a style that would not load stops the eval before the
+ * first billed trial.
+ */
+const adapter_registry_js_1 = require("./adapter-registry.js");
+const harness_test_js_1 = require("./harness-test.js");
+/**
+ * Build the with/without arms for the style at `path` (a file in the shape the
+ * harness loads, e.g. a Claude Code `.md` style), for the harness the paid tier
+ * drives. Spends nothing: the one run it makes uses the scripted model. Throws,
+ * before any eval, when the harness has no output styles, cannot tell the
+ * style's name, or the style does not reach the model.
+ *
+ * @experimental One real-model run behind it; how arms are built may change
+ * once a style can be authored as a compiled spec with its checks attached.
+ */
+async function experimental_outputStyleArms(path) {
+    return outputStyleArmsWith(path, adapter_registry_js_1.defaultAdapter);
+}
+/**
+ * {@link experimental_outputStyleArms} on a given adapter. Not public: the paid
+ * tier drives only the default harness, so arms built for another one would be
+ * run by a harness they were not checked on.
+ */
+async function outputStyleArmsWith(path, adapter) {
+    const preflight = await (0, harness_test_js_1.runHarnessTest)({ outputStyle: path, prompt: "hi", model: [{ text: "ok" }] }, { adapter });
+    preflight.cleanup();
+    const { files, settings } = (0, harness_test_js_1.outputStyleFixture)(path, adapter);
+    const none = adapter.layout.outputStyles?.selectNone ?? {};
+    return { with: { files, settings }, without: { settings: none } };
+}
+//# sourceMappingURL=output-style-arms.js.map

package/dist/scan-files.js

@@ -539,7 +539,7 @@ function scanFiles(files, layout = layout_js_1.claudeCodeLayout, dialect = diale
         hooks,
         inlineHooks: inline,
         manualHookCount: manual,
-        commands: Object.keys(loaded.files).filter(cls.isCommand).length,
+        ...(0, coverage_evidence_js_1.inventoryCounts)(loaded.files, cls.isCommand, [lay], coverage),
         // A declared server set counts even when the loader emitted no warning —
         // otherwise a plugin whose servers come from the Agent Plugins `mcp.json`
         // reports "MCP servers: no" while the report lists an MCP finding.

package/dist/scan.d.ts

@@ -211,6 +211,12 @@ export interface ScanReport {
      */
     readonly manualHookCount: number;
     readonly commands: number;
+    /**
+     * Output styles found, exempt ones aside, or `"not-supported"` when the
+     * harness has none — the inventory side of `untested-output-style`. Optional
+     * so a hand-built report predating the field still type-checks.
+     */
+    readonly outputStyles?: number | "not-supported";
     readonly mcp: boolean;
     /**
      * Intra-plugin file references (hook scripts, skill bodies) pointing at files

package/dist/scan.js

@@ -258,6 +258,7 @@ function scanPlugin(dir, layout, dialect, opts = {}) {
     const coverage = (0, test_coverage_js_1.findUntestedSurfaces)({
         basePath: dir,
         layout: lay,
+        harnessLayouts: declared.map((h) => h.layout),
         // The SAME `.vigilesrc.json#exclude`. Untested-surface discovery is a
         // second walk over the same trees, so leaving it out would have excluded a
         // skill from the GRADE while still naming it in "Untested surfaces: 1" — a
@@ -276,7 +277,7 @@ function scanPlugin(dir, layout, dialect, opts = {}) {
         hooks,
         inlineHooks: inline,
         manualHookCount: manual,
-        commands: Object.keys(loaded.files).filter(cls.isCommand).length,
+        ...(0, coverage_evidence_js_1.inventoryCounts)(loaded.files, cls.isCommand, declared.map((h) => h.layout), coverage),
         // A declared server set counts even when the loader emitted no warning —
         // otherwise a plugin whose servers come from the Agent Plugins `mcp.json`
         // reports "MCP servers: no" while the report lists an MCP finding.
@@ -655,6 +656,16 @@ function instructionWeightLines(w) {
         ...tail,
     ];
 }
+/** The commands and output-style lines of a scan's facts; a harness without styles says so. */
+function inventoryFacts(r) {
+    const commands = r.commands > 0 ? [`Commands: ${String(r.commands)}`] : [];
+    if (r.outputStyles === "not-supported")
+        return [...commands, "Output styles: n/a (this harness has none)"];
+    const styles = r.outputStyles ?? 0;
+    return styles > 0
+        ? [...commands, `Output styles: ${String(styles)}`]
+        : commands;
+}
 function formatScanReport(r) {
     const out = [`Scan: ${r.dir}`, ""];
     if (r.instructions) {
@@ -715,15 +726,14 @@ function formatScanReport(r) {
     out.push(...section("Ineffective hook guards (false confidence)", r.hookBlockFindings.map((h) => `  ✗ [${h.event}] ${h.scriptPath ?? "(inline)"}: ${h.message}`)));
     out.push(...section("Hook matchers that don't fire as written", r.hookMatcherFindings.map((m) => `  ✗ ${m.message}`)));
     const facts = [];
-    if (r.commands > 0)
-        facts.push(`Commands: ${String(r.commands)}`);
+    facts.push(...inventoryFacts(r));
     facts.push(`MCP servers: ${r.mcp ? "yes" : "no"}`);
     facts.push(`Untested surfaces: ${String(r.untested)}`);
     // The two tiers, named separately — a surface with a deterministic harness and
     // no eval is NOT the same position as one with neither. Shown only when the
     // producer supplied the split (a hand-built report may not have).
     if (r.untestedHarness !== undefined && r.unevaluated !== undefined) {
-        facts.push(`  no harness: ${String(r.untestedHarness)} · firing never measured: ${String(r.unevaluated)}`);
+        facts.push(`  no harness: ${String(r.untestedHarness)} · never measured with a real model: ${String(r.unevaluated)}`);
     }
     // …and HOW the rest passed. Without this the count is unfalsifiable from the
     // outside: "28 covered" and "28 names that appear in some file" print the same.

package/dist/score-core.d.ts

@@ -180,6 +180,9 @@ export declare function reportDeductions(r: ScanReport): Deduction[];
  * surface of any kind", because it reads as "this plugin is broken" — a
  * different statement from "this plugin has no skills or subagents".
  *
+ * An output style counts too: a repo can ship only a style, and "nothing to
+ * audit" for it would hide the untested-output-style finding.
+ *
  * Hooks count in BOTH forms: `hooks[]` is the script-backed ones, `inlineHooks`
  * the shell one-liners that carry no script file to path-check. The second is
  * still a gate that runs.

package/dist/score-core.js

@@ -332,6 +332,9 @@ function reportDeductions(r) {
  * surface of any kind", because it reads as "this plugin is broken" — a
  * different statement from "this plugin has no skills or subagents".
  *
+ * An output style counts too: a repo can ship only a style, and "nothing to
+ * audit" for it would hide the untested-output-style finding.
+ *
  * Hooks count in BOTH forms: `hooks[]` is the script-backed ones, `inlineHooks`
  * the shell one-liners that carry no script file to path-check. The second is
  * still a gate that runs.
@@ -341,7 +344,8 @@ function isEmptyMachine(r) {
         r.agents.length +
         r.hooks.length +
         r.inlineHooks +
-        r.commands;
+        r.commands +
+        (typeof r.outputStyles === "number" ? r.outputStyles : 0);
     return surfaces === 0 && !r.mcp;
 }
 /**

package/dist/setup-plan.d.ts

@@ -118,7 +118,7 @@ export declare const STRUCTURAL_RULES: readonly ["subagent-tool-contract", "suba
  * here: they're acknowledged-noisy recommendations we never gate on (see
  * research/install-enforcement-dx.md).
  */
-export declare const WORKFLOW_RULES: readonly ["require-instructions-spec", "untested-skill", "untested-subagent", "untested-hook"];
+export declare const WORKFLOW_RULES: readonly ["require-instructions-spec", "untested-skill", "untested-subagent", "untested-hook", "untested-output-style"];
 /**
  * The **`nudge`** group — recommendations / acknowledged-noisy checks that NEVER
  * gate (not even under `--strict`): `frontmatter-valid` (js-yaml is stricter than

package/dist/setup-plan.js

@@ -114,6 +114,7 @@ exports.WORKFLOW_RULES = [
     "untested-skill",
     "untested-subagent",
     "untested-hook",
+    "untested-output-style",
 ];
 /**
  * The **`nudge`** group — recommendations / acknowledged-noisy checks that NEVER