vigiles 33.1.0 → 33.2.0

package/dist/audit-score.js

@@ -450,12 +450,12 @@ function evaluated(r, firingMeasured) {
             score: null,
             weight: 1,
             advisory: true,
-            findings: ["no surface whose firing could be measured"],
+            findings: ["no surface a real model could be measured on"],
         };
     }
     const unevaluated = r.unevaluated ?? evaluable;
     const evalCovered = evaluable - unevaluated;
-    const gap = `${String(unevaluated)} ${pluralizeLabel(unevaluated, "surface(s) whose firing was never measured")}`;
+    const gap = `${String(unevaluated)} ${pluralizeLabel(unevaluated, "surface(s) never measured with a real model")}`;
     // Nothing on disk measures firing AND nothing ran this session → the question
     // was never asked. Say that, and name the command — do NOT score it a 0.
     if (evalCovered === 0 && !firingMeasured) {

package/dist/check.d.ts

@@ -137,6 +137,26 @@ export declare function onlyTools(allowed: readonly string[]): Check<Trace>;
 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>;
+/**
+ * EVERY reply of the run contains a substring / matches a RegExp — for a rule
+ * about each reply ("end with a status block"), where `output` sees only the
+ * last one. A run with no replies fails: there is nothing the rule held for.
+ *
+ * @experimental The matcher may grow a function form, and a check may come to
+ * be attached to a spec rule (vigiles#323).
+ */
+export declare function experimental_eachReply(matcher: string | Readonly<RegExp>): Readonly<Check<Trace>>;
+/**
+ * How many replies of the run match, within bounds — `{ max: 1 }` is "at most
+ * one status block for one user message", which a Stop hook that makes the
+ * agent reply again can break while `output` still shows one.
+ *
+ * @experimental See {@link experimental_eachReply}.
+ */
+export declare function experimental_replyCount(matcher: string | Readonly<RegExp>, opts: {
+    readonly min?: number;
+    readonly max?: number;
+}): Readonly<Check<Trace>>;
 /** A hook fired for this event (e.g. `"PreToolUse"`, `"Stop"`). */
 export declare function hookFired(event: string): Check<Trace>;
 /**

package/dist/check.js

@@ -8,6 +8,8 @@ exports.notTool = notTool;
 exports.onlyTools = onlyTools;
 exports.skill = skill;
 exports.output = output;
+exports.experimental_eachReply = experimental_eachReply;
+exports.experimental_replyCount = experimental_replyCount;
 exports.hookFired = hookFired;
 exports.received = received;
 exports.turns = turns;
@@ -75,6 +77,29 @@ function truncate(s, n = 120) {
     const flat = s.replace(/\s+/g, " ").trim();
     return flat.length > n ? `${flat.slice(0, n)}…` : flat;
 }
+/**
+ * Does `text` match? A RegExp is copied first: with `g` / `y`, `test` advances
+ * `lastIndex` on the object it is called on, so reusing the caller's object
+ * would miss on its second reply or its second trial.
+ */
+const matches = (matcher, text) => typeof matcher === "string"
+    ? text.includes(matcher)
+    : new RegExp(matcher).test(text);
+/** A matcher as the report prints it: the string, or the RegExp literal. */
+const show = (matcher) => typeof matcher === "string" ? matcher : `/${matcher.source}/${matcher.flags}`;
+/** Why a reply check cannot run: the trace carries no replies to read. */
+const NO_REPLIES = "the run has no `replies` (the harness does not tell replies apart, or the run was not streamed — pass `transcript: true`)";
+/** Why a `{ min, max }` bound cannot mean anything, or null when it can. */
+function boundsProblem(opts) {
+    const given = [opts.min, opts.max].filter((n) => n !== undefined);
+    if (given.length === 0)
+        return "give `min`, `max` or both";
+    if (given.some((n) => !Number.isInteger(n) || n < 0))
+        return "bounds are whole numbers, 0 or more";
+    if (opts.min !== undefined && opts.max !== undefined && opts.min > opts.max)
+        return `min ${String(opts.min)} is above max ${String(opts.max)}`;
+    return null;
+}
 // ---------------------------------------------------------------------------
 // Trace checks (an agent run — runHarness / runEval)
 // ---------------------------------------------------------------------------
@@ -248,7 +273,7 @@ function output(matcher) {
     return {
         kind: "output",
         eval: (t) => {
-            const pass = isRe ? matcher.test(t.output) : t.output.includes(matcher);
+            const pass = matches(matcher, t.output);
             return pass
                 ? ok(`output matched ${String(matcher)}`)
                 : no(`expected output to ${isRe ? "match" : "contain"} ${String(matcher)}; got "${truncate(t.output) || "(empty)"}"`);
@@ -256,6 +281,66 @@ function output(matcher) {
         toJSON: () => ({ kind: "output", matcher: String(matcher), regex: isRe }),
     };
 }
+/**
+ * EVERY reply of the run contains a substring / matches a RegExp — for a rule
+ * about each reply ("end with a status block"), where `output` sees only the
+ * last one. A run with no replies fails: there is nothing the rule held for.
+ *
+ * @experimental The matcher may grow a function form, and a check may come to
+ * be attached to a spec rule (vigiles#323).
+ */
+function experimental_eachReply(matcher) {
+    return {
+        kind: "eachReply",
+        eval: (t) => {
+            if (t.replies === undefined)
+                return no(NO_REPLIES);
+            if (t.replies.length === 0)
+                return no("the run wrote no replies");
+            const miss = t.replies.findIndex((r) => !matches(matcher, r));
+            return miss === -1
+                ? ok(`all ${String(t.replies.length)} replies matched ${show(matcher)}`)
+                : no(`reply ${String(miss + 1)} of ${String(t.replies.length)} did not match ${show(matcher)}: "${truncate(t.replies[miss] ?? "") || "(empty)"}"`);
+        },
+        toJSON: () => ({
+            kind: "eachReply",
+            matcher: show(matcher),
+            regex: typeof matcher !== "string",
+        }),
+    };
+}
+/**
+ * How many replies of the run match, within bounds — `{ max: 1 }` is "at most
+ * one status block for one user message", which a Stop hook that makes the
+ * agent reply again can break while `output` still shows one.
+ *
+ * @experimental See {@link experimental_eachReply}.
+ */
+function experimental_replyCount(matcher, opts) {
+    const problem = boundsProblem(opts);
+    if (problem !== null)
+        throw new Error(`replyCount: ${problem}`);
+    return {
+        kind: "replyCount",
+        eval: (t) => {
+            if (t.replies === undefined)
+                return no(NO_REPLIES);
+            const n = t.replies.filter((r) => matches(matcher, r)).length;
+            const pass = (opts.min === undefined || n >= opts.min) &&
+                (opts.max === undefined || n <= opts.max);
+            const bound = `min ${String(opts.min ?? "-")}, max ${String(opts.max ?? "-")}`;
+            const says = `${String(n)} of ${String(t.replies.length)} replies matched ${show(matcher)} (${bound})`;
+            return pass ? ok(says) : no(`expected ${bound}; ${says}`);
+        },
+        toJSON: () => ({
+            kind: "replyCount",
+            matcher: show(matcher),
+            regex: typeof matcher !== "string",
+            min: opts.min,
+            max: opts.max,
+        }),
+    };
+}
 /** A hook fired for this event (e.g. `"PreToolUse"`, `"Stop"`). */
 function hookFired(event) {
     return {
@@ -284,7 +369,7 @@ function received(matcher) {
             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);
+            const pass = matches(matcher, text);
             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)}"`}`);

package/dist/cli-main.js

@@ -3595,6 +3595,18 @@ function harnessLayoutFor(root, config, flag) {
         return adapter_registry_js_1.defaultAdapter.layout;
     }
 }
+/**
+ * The rule that gates each surface kind, one row per kind. `satisfies` makes a
+ * missing row a compile error: the nested ternary this replaced ended in the
+ * hook rule, so a kind it did not name was gated by `untested-hook` and still
+ * compiled.
+ */
+const UNTESTED_RULE = {
+    skill: "untested-skill",
+    agent: "untested-subagent",
+    hook: "untested-hook",
+    "output-style": "untested-output-style",
+};
 /**
  * The `untested-*` rules AS THE DETECTOR TAKES THEM: which kinds this repo
  * enabled, and the discovery options merged from whichever of the three rules
@@ -3611,21 +3623,21 @@ function harnessLayoutFor(root, config, flag) {
  */
 function untestedRules(config) {
     const rules = config?.rules;
-    const skillSev = (0, types_js_1.ruleSeverity)(rules?.["untested-skill"]);
-    const agentSev = (0, types_js_1.ruleSeverity)(rules?.["untested-subagent"]);
-    const hookSev = (0, types_js_1.ruleSeverity)(rules?.["untested-hook"]);
-    const opts = {
-        ...(0, types_js_1.ruleOptions)(rules?.["untested-skill"]),
-        ...(0, types_js_1.ruleOptions)(rules?.["untested-subagent"]),
-        ...(0, types_js_1.ruleOptions)(rules?.["untested-hook"]),
-    };
+    const severity = (kind) => (0, types_js_1.ruleSeverity)(rules?.[UNTESTED_RULE[kind]]);
+    const names = Object.values(UNTESTED_RULE);
+    const opts = names.reduce((acc, rule) => ({
+        ...acc,
+        ...(0, types_js_1.ruleOptions)(rules?.[rule]),
+    }), {});
+    const on = (kind) => severity(kind) !== false;
     return {
-        severity: (kind) => kind === "skill" ? skillSev : kind === "agent" ? agentSev : hookSev,
-        anyEnabled: skillSev !== false || agentSev !== false || hookSev !== false,
+        severity,
+        anyEnabled: names.some((rule) => (0, types_js_1.ruleSeverity)(rules?.[rule]) !== false),
         options: {
-            skills: skillSev !== false,
-            agents: agentSev !== false,
-            hooks: hookSev !== false,
+            skills: on("skill"),
+            agents: on("agent"),
+            hooks: on("hook"),
+            outputStyles: on("output-style"),
             include: opts.include,
             exclude: opts.exclude,
             // Without this the `testExtension` documented on TestCoverageOptions was a

package/dist/core/config-schema.d.ts

@@ -109,6 +109,15 @@ export declare const vigilesConfigSchema: z.ZodObject<{
             exclude: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<readonly string[], string | string[]>>>;
             testExtension: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>], null>]>>;
+        "untested-output-style": z.ZodDefault<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "warn" | "error" | "off">>, z.ZodTuple<[z.ZodLiteral<"warn">, z.ZodObject<{
+            include: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<readonly string[], string | string[]>>>;
+            exclude: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<readonly string[], string | string[]>>>;
+            testExtension: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>], null>, z.ZodTuple<[z.ZodLiteral<"error">, z.ZodObject<{
+            include: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<readonly string[], string | string[]>>>;
+            exclude: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<readonly string[], string | string[]>>>;
+            testExtension: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>], null>]>>;
         "unmarked-refs": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "warn" | "error" | "off">>>;
         "subagent-tool-contract": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "warn" | "error" | "off">>>;
         "hook-events": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "warn" | "error" | "off">>>;

package/dist/core/config-schema.js

@@ -141,6 +141,7 @@ const rulesSchema = zod_1.z
     "untested-skill": withOptions(testCoverageConfig).default("warn"),
     "untested-subagent": withOptions(testCoverageConfig).default("warn"),
     "untested-hook": withOptions(testCoverageConfig).default("warn"),
+    "untested-output-style": withOptions(testCoverageConfig).default("warn"),
     "unmarked-refs": severitySchema.default("warn"),
     "subagent-tool-contract": severitySchema.default("warn"),
     "hook-events": severitySchema.default("warn"),

package/dist/core/eval-driver.d.ts

@@ -71,6 +71,14 @@ export interface Trace {
     readonly hooks: readonly HookFire[];
     /** The agent's final answer text (the terminal `result` event), or "". */
     readonly output: string;
+    /**
+     * Every reply the agent ended a turn with, in order — the `output` is only
+     * the last. A run a Stop hook continued has two, and anything the first one
+     * printed (a status footer) shows only here. Text the agent writes before a
+     * tool call is narration, not a reply. Absent when the harness's run output
+     * does not tell replies apart, or the run was not streamed (`transcript: true`).
+     */
+    readonly replies?: readonly string[];
     /**
      * The requests the model received, captured by the scripted mock — each with
      * its `system` prompt and `messages`, flattened to text. Lets a test assert
@@ -153,6 +161,8 @@ export interface ParsedModelRun {
     readonly toolCalls: ToolCall[];
     readonly hooks: HookFire[];
     readonly subagents: SubagentTrace[];
+    /** Every reply, in order; absent when the harness cannot tell them apart. */
+    readonly replies?: readonly string[];
     readonly usage: EvalUsage;
 }
 export type ModelOutputParser = (out: RunOut) => ParsedModelRun;

package/dist/core/frontmatter-read.d.ts

@@ -1,3 +1,34 @@
+/**
+ * Lenient frontmatter reader — ONE reader for the SKILL.md / subagent `---` block,
+ * shared by `scan` and the PreToolUse rail (`agent-runtime`). It is deliberately
+ * fault-tolerant: it audits arbitrary third-party files, so it must never throw
+ * and must salvage the few scalar/list fields it needs even from a block that
+ * isn't valid YAML.
+ *
+ * The strategy is "real parser, with a safety net": try `js-yaml` (so block
+ * scalars, quoted/multi-line values, and flow arrays parse correctly for free);
+ * if the block isn't valid YAML, fall back to a regex salvage of the requested
+ * field and record `malformed: true` (the signal the `frontmatter-valid` rule
+ * reports). A single bad line therefore never blanks out a whole file's metadata.
+ *
+ * This replaces three divergent hand-parsers (the old `readField` in scan.ts and
+ * the regex parse in agent-runtime.ts); `core/frontmatter.ts` is a DIFFERENT
+ * concern (the Level-1 `vigiles:` rule block) and is untouched.
+ */
+/**
+ * 🔴 `js-yaml` IS REQUIRED LAZILY, AND THAT IS A MEASUREMENT, NOT A STYLE. The
+ * same wrapper is in `core/settings-codec.ts` and `core/markdown.ts` with the
+ * reason recorded: a top-level import puts the parser into the module graph of
+ * every HOOK DECISION, because the hook runtime reaches the adapter registry
+ * and from there a layout. This module became reachable that way on 2026-09-21
+ * through `PluginLayout.instructionChain` (a rule's `paths:` frontmatter is
+ * what decides whether it loads at launch) — measured by
+ * `src/hook-runtime-graph.test.ts`: 37 modules became 71 with an eager import.
+ * `tsc` lowers this to CommonJS, so the `require` does not run until a
+ * frontmatter block is actually parsed, and {@link frontmatterBody}, which needs
+ * no YAML at all, never triggers it.
+ */
+export declare const yaml: () => typeof import("js-yaml");
 export interface FrontmatterRead {
     /** Parsed mapping when the block is valid YAML, else null (malformed or scalar). */
     readonly data: Record<string, unknown> | null;

package/dist/core/frontmatter-read.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.yaml = void 0;
 exports.frontmatterBody = frontmatterBody;
 exports.readFrontmatter = readFrontmatter;
 exports.frontmatterScalar = frontmatterScalar;
@@ -35,6 +36,7 @@ exports.frontmatterList = frontmatterList;
  * no YAML at all, never triggers it.
  */
 const yaml = () => require("js-yaml");
+exports.yaml = yaml;
 // Frontmatter is the very first thing in the file. Anchoring at the start — not
 // `(?:^|\n)` — means a `---` horizontal rule in the BODY is never mistaken for
 // frontmatter (which matters for the malformed-YAML verdict). A leading BOM is
@@ -67,7 +69,7 @@ function readFrontmatter(markdown) {
         return { data: null, block: null, malformed: false };
     const block = m[1];
     try {
-        const parsed = yaml().load(block);
+        const parsed = (0, exports.yaml)().load(block);
         if (parsed !== null &&
             typeof parsed === "object" &&
             !Array.isArray(parsed)) {
@@ -82,7 +84,7 @@ function readFrontmatter(markdown) {
         return { data: null, block, malformed: false };
     }
     catch (e) {
-        if (e instanceof yaml().YAMLException)
+        if (e instanceof (0, exports.yaml)().YAMLException)
             return { data: null, block, malformed: true };
         throw e;
     }

package/dist/core/harness-driver.d.ts

@@ -130,6 +130,8 @@ export interface ParsedRun {
     readonly hooks: readonly HookFire[];
     /** The agent's final answer text, or "". */
     readonly output: string;
+    /** Every reply the agent ended a turn with; absent when the output is not a stream. */
+    readonly replies?: readonly string[];
 }
 /**
  * What a harness brings so `runHarnessTest` can drive it. Implemented in each

package/dist/core/layout.d.ts

@@ -10,6 +10,7 @@
  * Paths are repo-relative (POSIX-style, `join`-friendly). The Claude Code
  * implementation is `claudeCodeLayout` in `src/adapters/claude-code/layout.ts`.
  */
+import type { OutputStyleRules } from "./output-style.js";
 import type { InstructionChain } from "./instruction-chain.js";
 import type { SettingsCodec } from "./settings-codec.js";
 /**
@@ -127,6 +128,12 @@ export interface PluginLayout {
      * docblock there for the count behind that.
      */
     readonly rulesDir?: string;
+    /**
+     * Where this harness keeps output styles and how it switches one on (absent =
+     * this harness has none). Not a {@link SurfaceKind}: like a rules file, a
+     * style is read into the session, not invoked. See `output-style.ts`.
+     */
+    readonly outputStyles?: OutputStyleRules;
     /**
      * The WORD a per-machine settings sibling inserts before the extension, e.g.
      * `local` → `.claude/settings.local.json` (absent = this harness has no

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

@@ -0,0 +1,84 @@
+/**
+ * Output styles: files that set how the agent talks for a whole session,
+ * chosen by a name in the harness settings.
+ *
+ * The core knows only that idea. Where the files live, how a name is read from
+ * one, which setting selects it and how a run shows that it arrived are each
+ * harness's own rules, given by its layout as `outputStyles`. A layout without
+ * them is a harness that has no output styles.
+ */
+import type { ModelRequest } from "./harness-driver.js";
+import type { PluginLayout } from "./layout.js";
+/** One style, read by its harness's rules. */
+export interface OutputStyle {
+    /**
+     * Relative to the directory the caller scanned (a bundle), `/`-separated,
+     * exactly as the caller's file map keyed it. A plain string by the same
+     * contract as every scan-core path; `Bundle.scanned` in `frame.ts` gives it
+     * a frame. Not the `BundlePath` brand: that type is internal and must not
+     * reach this public interface.
+     */
+    readonly path: string;
+    /** The name a setting must spell, or null when the harness cannot tell. */
+    readonly name: string | null;
+    /** The text the harness delivers, frontmatter removed. */
+    readonly body: string;
+}
+/** How one harness keeps output styles and switches one on. */
+export interface OutputStyleRules {
+    /** The folder of style files, e.g. `output-styles`. */
+    readonly dir: string;
+    /** Whether a path inside that folder is a file the harness loads. */
+    readonly isStyleFile: (pathInDir: string) => boolean;
+    /** Reads one style file as this harness does. */
+    readonly read: (path: string, text: string) => OutputStyle;
+    /** The settings that switch the named style on. */
+    readonly select: (name: string) => Readonly<Record<string, unknown>>;
+    /**
+     * The settings that switch every style off, so a run without the style does
+     * not pick up one the user turned on for all their projects.
+     */
+    readonly selectNone: Readonly<Record<string, unknown>>;
+    /** Whether one model request carries the style. */
+    readonly reached: (style: OutputStyle, request: ModelRequest) => boolean;
+}
+/** What a repository holds, or that its harness has no such thing. */
+export type OutputStyleScan = {
+    readonly kind: "not-supported";
+} | {
+    readonly kind: "found";
+    readonly styles: readonly OutputStyle[];
+};
+type StyleLayout = Pick<PluginLayout, "outputStyles" | "userSurfaceRoot">;
+/** The folders a harness reads styles from: a plugin's root and the user surface root. */
+export declare function outputStyleHomes(layout: StyleLayout): readonly string[];
+/** Every style among `files` (repository path → text). Pure: the caller reads the disk. */
+export declare function findOutputStyles(layout: StyleLayout, files: ReadonlyMap<string, string>): OutputStyleScan;
+/** A run with one style switched on, or why it cannot be set up. */
+export type StyleRunPlan = {
+    readonly kind: "refused";
+    readonly reason: string;
+} | {
+    readonly kind: "planned";
+    /** The style as the harness will read it, at its place in the work dir. */
+    readonly style: OutputStyle;
+    readonly files: Readonly<Record<string, string>>;
+    readonly settings: Readonly<Record<string, unknown>>;
+};
+/**
+ * Put one style file into a test's fixture and switch it on BY THE NAME THE
+ * HARNESS READS from it — never a name the caller types. Pure: the caller reads
+ * the file. Refuses instead of guessing when the harness has no styles, would
+ * not load such a file, cannot tell its name, or the fixture already decides.
+ */
+export declare function planStyleRun(layout: StyleLayout, source: {
+    readonly path: string;
+    readonly text: string;
+}, fixture: {
+    readonly files: Readonly<Record<string, string>>;
+    readonly settings: unknown;
+}): StyleRunPlan;
+/** Whether any request of a run carried the style, by its harness's own rule. */
+export declare function styleReached(rules: OutputStyleRules, style: OutputStyle, requests: readonly ModelRequest[]): boolean;
+export {};
+//# sourceMappingURL=output-style.d.ts.map

package/dist/core/output-style.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.outputStyleHomes = outputStyleHomes;
+exports.findOutputStyles = findOutputStyles;
+exports.planStyleRun = planStyleRun;
+exports.styleReached = styleReached;
+/** The folders a harness reads styles from: a plugin's root and the user surface root. */
+function outputStyleHomes(layout) {
+    const dir = layout.outputStyles?.dir;
+    if (dir === undefined)
+        return [];
+    const root = layout.userSurfaceRoot;
+    return root === undefined || root === "" ? [dir] : [dir, `${root}/${dir}`];
+}
+const pathInside = (home, path) => path.startsWith(`${home}/`) ? path.slice(home.length + 1) : null;
+/** Every style among `files` (repository path → text). Pure: the caller reads the disk. */
+function findOutputStyles(layout, files) {
+    const rules = layout.outputStyles;
+    if (rules === undefined)
+        return { kind: "not-supported" };
+    const homes = outputStyleHomes(layout);
+    const isStyle = (path) => homes.some((home) => {
+        const rest = pathInside(home, path);
+        return rest !== null && rules.isStyleFile(rest);
+    });
+    const styles = [...files]
+        .filter(([path]) => isStyle(path))
+        .map(([path, text]) => rules.read(path, text));
+    return {
+        kind: "found",
+        styles: [...styles].sort((a, b) => a.path.localeCompare(b.path)),
+    };
+}
+const isPlainObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+/** Where the style goes and what it is called there, or why it cannot go. */
+function placeStyle(layout, source) {
+    const rules = layout.outputStyles;
+    const home = outputStyleHomes(layout).at(-1);
+    if (rules === undefined || home === undefined)
+        return "this harness has no output styles";
+    // Either separator: a Windows path from `path.resolve` uses backslashes.
+    const file = source.path.split(/[\\/]/).at(-1) ?? source.path;
+    if (!rules.isStyleFile(file))
+        return `this harness would not load "${file}" as an output style`;
+    const style = rules.read(`${home}/${file}`, source.text);
+    return style.name === null
+        ? `cannot tell which name selects "${source.path}"`
+        : style;
+}
+/** The fixture's settings with the selection added, or why they clash. */
+function selectIn(settings, selection) {
+    const base = settings ?? {};
+    if (!isPlainObject(base))
+        return "the fixture's settings are not an object";
+    const clash = Object.keys(selection).find((key) => key in base);
+    return clash === undefined
+        ? { ...base, ...selection }
+        : `the fixture's settings already set "${clash}"; the style option sets it`;
+}
+/**
+ * Put one style file into a test's fixture and switch it on BY THE NAME THE
+ * HARNESS READS from it — never a name the caller types. Pure: the caller reads
+ * the file. Refuses instead of guessing when the harness has no styles, would
+ * not load such a file, cannot tell its name, or the fixture already decides.
+ */
+function planStyleRun(layout, source, fixture) {
+    const style = placeStyle(layout, source);
+    if (typeof style === "string")
+        return { kind: "refused", reason: style };
+    if (style.path in fixture.files)
+        return {
+            kind: "refused",
+            reason: `the fixture already has a file at ${style.path}`,
+        };
+    const selection = layout.outputStyles?.select(style.name ?? "") ?? {};
+    const settings = selectIn(fixture.settings, selection);
+    return typeof settings === "string"
+        ? { kind: "refused", reason: settings }
+        : {
+            kind: "planned",
+            style,
+            files: { ...fixture.files, [style.path]: source.text },
+            settings,
+        };
+}
+/** Whether any request of a run carried the style, by its harness's own rule. */
+function styleReached(rules, style, requests) {
+    return requests.some((request) => rules.reached(style, request));
+}
+//# sourceMappingURL=output-style.js.map

package/dist/core/rule-meta.d.ts

@@ -37,7 +37,7 @@ import type { RulesConfig } from "./types.js";
  */
 export type RuleBucket = "structural-closed" | "external-decidable" | "heuristic-behavioral";
 /** The artifact surface a rule reads (coarse; a rule may span several). */
-export type RuleSurface = "instruction" | "skill" | "subagent" | "hook" | "mcp" | "plugin" | "docs";
+export type RuleSurface = "instruction" | "skill" | "subagent" | "hook" | "output-style" | "mcp" | "plugin" | "docs";
 /** Where a rule sits by default — `"off"` is the normalized form of `false`. */
 export type RuleDefaultSeverity = "error" | "warn" | "off";
 /** Every named rule: the `RulesConfig` keys plus the built-in `orphan-docs`. */

package/dist/core/rule-meta.js

@@ -69,6 +69,14 @@ exports.RULE_META = {
         summary: "A file-backed hook script ships with a test or eval.",
         detector: "findUntestedSurfaces",
     },
+    "untested-output-style": {
+        id: "untested-output-style",
+        bucket: "external-decidable",
+        surface: ["output-style"],
+        defaultSeverity: "warn",
+        summary: "An output style ships with a test or eval.",
+        detector: "findUntestedSurfaces",
+    },
     // --- Reference marking ----------------------------------------------------
     "unmarked-refs": {
         id: "unmarked-refs",

package/dist/core/types.d.ts

@@ -167,6 +167,8 @@ export interface RulesConfig {
     "untested-subagent"?: RuleWithOptions<TestCoverageConfig>;
     /** Flag a hook script that ships with no test or eval. Default: "warn". */
     "untested-hook"?: RuleWithOptions<TestCoverageConfig>;
+    /** Flag an output style that ships with no test or eval. Default: "warn". */
+    "untested-output-style"?: RuleWithOptions<TestCoverageConfig>;
     /**
      * Nudge (or block) when an instruction file has code-shaped references that
      * aren't expressed as vigiles marks (so the lint can't verify them), or a

package/dist/coverage-evidence.d.ts

@@ -197,4 +197,46 @@ export declare function formatEvidence(counts: EvidenceCounts): string;
  * (`basename` of the audited dir on disk, the repo name in the browser).
  */
 export declare function declaredSurfaceName(content: string): string | 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.
+ */
+export declare function outputStyleSurface(path: string, content: string): {
+    readonly kind: "output-style";
+    readonly path: string;
+    readonly name: string;
+    readonly tokens: readonly string[];
+    readonly ignored: boolean;
+};
+/**
+ * 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.
+ */
+export declare function outputStyleCount(layouts: readonly {
+    readonly outputStyles?: unknown;
+}[], tier: {
+    readonly covered: readonly {
+        readonly kind: string;
+    }[];
+    readonly untested: readonly {
+        readonly kind: string;
+    }[];
+}, exempt: readonly {
+    readonly kind: string;
+}[]): number | "not-supported";
+/** The inventory counts both scan engines report the same way. */
+export declare function inventoryCounts(files: Readonly<Record<string, string>>, isCommand: (path: string) => boolean, layouts: Parameters<typeof outputStyleCount>[0], coverage: {
+    readonly harness: Parameters<typeof outputStyleCount>[1];
+    readonly exemptSurfaces: Parameters<typeof outputStyleCount>[2];
+}): {
+    readonly commands: number;
+    readonly outputStyles: number | "not-supported";
+};
 //# sourceMappingURL=coverage-evidence.d.ts.map