vigiles 33.1.0 → 33.3.0

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/install-reader.js

@@ -30,6 +30,18 @@ function readOrNull(absolute) {
         return null;
     }
 }
+/** A symlink's stored target, or null when it is not a link. Never throws. */
+function linkOrNull(absolute) {
+    try {
+        return (0, node_fs_1.lstatSync)(absolute, { throwIfNoEntry: false })?.isSymbolicLink() ===
+            true
+            ? (0, node_fs_1.readlinkSync)(absolute)
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
 /** Directory names directly under `dir`, or [] when it is not readable. */
 function dirNames(dir) {
     try {
@@ -80,6 +92,9 @@ function buildInstallReader(adapter, root, opts = {}) {
         repo: (repoRelative) => adapter.claims(repoRelative)
             ? readOrNull((0, node_path_1.resolve)(root, repoRelative))
             : null,
+        repoLink: (repoRelative) => adapter.claims(repoRelative)
+            ? linkOrNull((0, node_path_1.resolve)(root, repoRelative))
+            : null,
         home: (homeRelative) => readOrNull((0, node_path_1.join)(home, homeRelative)),
         repoDependsOnVigiles: pkgJson !== null && declaresVigilesDependency(pkgJson),
         vendoredSkillNames: dirNames((0, node_path_1.join)(root, "node_modules", "vigiles", "skills")),

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
@@ -234,6 +241,16 @@ export declare function executableSourceDirs(layout: PluginLayout): readonly str
  * written a layout where they differed.
  */
 export declare function materializePrefix(layout: PluginLayout): string;
+/**
+ * Where a REPOSITORY keeps its skills for this harness, repo-relative — the
+ * skill surface under {@link materializePrefix}: `.claude/skills` on Claude
+ * Code, `.agents/skills` on Codex. `null` when the layout has no skill surface.
+ *
+ * `vigiles init` links the package's shipped skills here, so it must be the
+ * directory the harness actually scans for a project; deriving it from the two
+ * fields that already say so keeps a third spelling from appearing.
+ */
+export declare function skillsHome(layout: Pick<PluginLayout, "surfaces" | "userSurfaceRoot">): string | null;
 /**
  * How DEEP a harness reads its {@link PluginLayout.agentDir} — the one statement
  * of that rule, as a RegExp source fragment matching the part of a path AFTER

package/dist/core/layout.js

@@ -4,6 +4,7 @@ exports.RULE_FILE_LEAF_RE = exports.AGENT_FILE_LEAF_RE = exports.SURFACE_KINDS =
 exports.surfaceDirs = surfaceDirs;
 exports.executableSourceDirs = executableSourceDirs;
 exports.materializePrefix = materializePrefix;
+exports.skillsHome = skillsHome;
 exports.rulesHome = rulesHome;
 exports.ruleFileRe = ruleFileRe;
 exports.agentSurfaceName = agentSurfaceName;
@@ -46,6 +47,22 @@ function executableSourceDirs(layout) {
 function materializePrefix(layout) {
     return layout.userSurfaceRoot ?? "";
 }
+/**
+ * Where a REPOSITORY keeps its skills for this harness, repo-relative — the
+ * skill surface under {@link materializePrefix}: `.claude/skills` on Claude
+ * Code, `.agents/skills` on Codex. `null` when the layout has no skill surface.
+ *
+ * `vigiles init` links the package's shipped skills here, so it must be the
+ * directory the harness actually scans for a project; deriving it from the two
+ * fields that already say so keeps a third spelling from appearing.
+ */
+function skillsHome(layout) {
+    const skill = layout.surfaces.skill;
+    if (skill === undefined || skill === "")
+        return null;
+    const root = layout.userSurfaceRoot;
+    return root === undefined || root === "" ? skill : `${root}/${skill}`;
+}
 /**
  * How DEEP a harness reads its {@link PluginLayout.agentDir} — the one statement
  * of that rule, as a RegExp source fragment matching the part of a path AFTER

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/run-env.d.ts

@@ -0,0 +1,50 @@
+/**
+ * The environment a child agent run inherits — the one place the runners turn
+ * a caller's `process.env` into a spawn env.
+ *
+ * Two shapes, both driven by the harness's declared {@link RunEnvPolicy}:
+ *
+ * - SCRUBBED (`scrubbedRunEnv`): a throwaway HOME/TMPDIR, the OS essentials, the
+ *   harness's declared auth, and the caller's own named extras. Everything else
+ *   is dropped. The eval tier's `ephemeralEnv` and the harness-tier preflight of
+ *   `experimental_outputStyleArms` use it.
+ * - INHERITED (`withoutSessionIdentity`): the caller's env as-is, minus the
+ *   harness's declared session identity. The default spawn of both tiers.
+ *
+ * In both, the parent session's identity never reaches the child. The core
+ * names no harness: which variables are auth and which are identity is the
+ * adapter's declaration.
+ *
+ * Pure — no fs, no spawn.
+ */
+import type { RunEnvPolicy } from "./runtime.js";
+type EnvLike = Readonly<Record<string, string | undefined>>;
+/**
+ * What ANY spawned process needs to function, whatever the harness: resolve
+ * binaries (`PATH`) and keep the locale and terminal (`LANG`, `LC_*`, `TERM`).
+ * Mirrors what `bwrapArgs` sets back after `--clearenv` in `src/sandbox.ts`.
+ */
+export declare const OS_ESSENTIAL_ENV: readonly string[];
+/**
+ * Build a SCRUBBED run environment: a NEW env with `HOME`/`TMPDIR` set to the
+ * throwaway `opts.home`, the {@link OS_ESSENTIAL_ENV}, the harness's
+ * `policy.keep`, and the caller's `opts.allow`, taken from `base`. Everything
+ * else is dropped, and `policy.sessionIdentity` is dropped even when listed in
+ * `keep` or `allow`.
+ *
+ * Without a policy only the essentials pass: right for a run against a scripted
+ * mock, which needs no auth.
+ */
+export declare function scrubbedRunEnv(base: EnvLike, opts: {
+    readonly home: string;
+    readonly policy?: RunEnvPolicy;
+    readonly allow?: readonly string[];
+}): Readonly<Record<string, string>>;
+/**
+ * The caller's env with the harness's declared session identity removed — the
+ * INHERITED shape. Unset (`undefined`) values are dropped too, so the result is
+ * a plain spawn env. Without a policy nothing is removed.
+ */
+export declare function withoutSessionIdentity(base: EnvLike, policy?: RunEnvPolicy): Readonly<Record<string, string>>;
+export {};
+//# sourceMappingURL=run-env.d.ts.map

package/dist/core/run-env.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OS_ESSENTIAL_ENV = void 0;
+exports.scrubbedRunEnv = scrubbedRunEnv;
+exports.withoutSessionIdentity = withoutSessionIdentity;
+/**
+ * What ANY spawned process needs to function, whatever the harness: resolve
+ * binaries (`PATH`) and keep the locale and terminal (`LANG`, `LC_*`, `TERM`).
+ * Mirrors what `bwrapArgs` sets back after `--clearenv` in `src/sandbox.ts`.
+ */
+exports.OS_ESSENTIAL_ENV = ["PATH", "LANG", "TERM"];
+const OS_ESSENTIAL_PREFIXES = ["LC_"];
+/**
+ * Build a SCRUBBED run environment: a NEW env with `HOME`/`TMPDIR` set to the
+ * throwaway `opts.home`, the {@link OS_ESSENTIAL_ENV}, the harness's
+ * `policy.keep`, and the caller's `opts.allow`, taken from `base`. Everything
+ * else is dropped, and `policy.sessionIdentity` is dropped even when listed in
+ * `keep` or `allow`.
+ *
+ * Without a policy only the essentials pass: right for a run against a scripted
+ * mock, which needs no auth.
+ */
+function scrubbedRunEnv(base, opts) {
+    const identity = new Set(opts.policy?.sessionIdentity ?? []);
+    const exact = new Set([
+        ...exports.OS_ESSENTIAL_ENV,
+        ...(opts.policy?.keep ?? []),
+        ...(opts.allow ?? []),
+    ]);
+    const passes = (k) => !identity.has(k) &&
+        (exact.has(k) || OS_ESSENTIAL_PREFIXES.some((p) => k.startsWith(p)));
+    return {
+        ...defined(base, passes),
+        // Last, so they win over anything passed through.
+        HOME: opts.home,
+        TMPDIR: opts.home,
+    };
+}
+/**
+ * The caller's env with the harness's declared session identity removed — the
+ * INHERITED shape. Unset (`undefined`) values are dropped too, so the result is
+ * a plain spawn env. Without a policy nothing is removed.
+ */
+function withoutSessionIdentity(base, policy) {
+    const identity = new Set(policy?.sessionIdentity ?? []);
+    return defined(base, (k) => !identity.has(k));
+}
+function defined(base, keep) {
+    return Object.fromEntries(Object.entries(base).filter((e) => e[1] !== undefined && keep(e[0])));
+}
+//# sourceMappingURL=run-env.js.map

package/dist/core/runtime.d.ts

@@ -54,5 +54,49 @@ export interface HarnessRuntime {
      * caller resolves the raw string via `agentBinary --version`); unit-testable.
      */
     versionKey(raw: string): string;
+    /**
+     * Which of the caller's environment a child run may inherit — see
+     * {@link RunEnvPolicy}. Absent: a scrubbed run inherits no harness variable,
+     * and nothing is removed from an inherited env.
+     */
+    readonly runEnv?: RunEnvPolicy;
+}
+/**
+ * Which of the caller's environment a CHILD run of this harness may inherit.
+ *
+ * A run spawned from inside a live session of the same harness (an eval started
+ * by an agent, a harness test run from a hook) inherits that session's process
+ * environment, and a harness marks its own session there. Measured on Claude
+ * Code 2.1.292 (2026-10-07): a child `claude -p` started with the parent's
+ * session variables ran AS the parent session — a task it created landed in the
+ * parent's live task list. Which variables are identity and which are auth is a
+ * fact about one harness, so the adapter declares it and the runners apply it
+ * (`src/core/run-env.ts`) without spelling a single name.
+ *
+ * Optional, so an adapter written before this field still type-checks. An
+ * adapter without one gets the strict reading: a scrubbed run inherits no
+ * harness variable at all, and an inherited one has nothing removed.
+ */
+export interface RunEnvPolicy {
+    /**
+     * Exact names a SCRUBBED run (fresh HOME, cleared env) inherits: the
+     * harness's auth and backend selection, nothing else. An allowlist on purpose —
+     * a harness's session variables are open-ended (the Claude Code 2.1.292
+     * binary references several dozen `*SESSION*` / `*SOCKET*` / `*TOKEN*` names),
+     * so a prefix with a few exceptions would keep passing whichever ones nobody
+     * listed.
+     */
+    readonly keep: readonly string[];
+    /**
+     * Auth FILES under HOME (relative paths) that a scrubbed run's throwaway HOME
+     * is seeded with, by copy. The file half of `keep`.
+     */
+    readonly keepHomeFiles: readonly string[];
+    /**
+     * The PARENT session's identity: names no child run ever inherits — not a
+     * scrubbed run, and not a run that otherwise inherits the whole caller env.
+     * Wins over `keep` and over any name a caller allows.
+     */
+    readonly sessionIdentity: readonly string[];
 }
 //# sourceMappingURL=runtime.d.ts.map

package/dist/core/skill-link-target.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Is a symlink's stored target one that `vigiles init` writes — a path ending
+ * in `node_modules/vigiles/skills/<name>`, for the SAME skill name?
+ *
+ * Two readers ask, and must agree, so the answer lives here once:
+ *
+ * - `init` (`../skill-links.ts`): an existing link of this shape that points
+ *   somewhere other than where `init` would link now was made by an earlier
+ *   `init` (for example before a workspace install hoisted the package), so it
+ *   is replaced instead of being refused as the user's;
+ * - `audit` (`../adapters/claude-code/skill-reachability.ts`): only a dangling
+ *   link of this shape is "vigiles's link, run npm install". A dangling link
+ *   that merely shares a skill's NAME is the user's, and the advice would send
+ *   them to fix the wrong thing.
+ *
+ * The test is on path SEGMENTS (either separator, so a link written on Windows
+ * reads the same), not on a substring: `my-node_modules/vigiles/...` is not it.
+ */
+export declare function isVigilesSkillTarget(target: string, name: string): boolean;
+//# sourceMappingURL=skill-link-target.d.ts.map

package/dist/core/skill-link-target.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isVigilesSkillTarget = isVigilesSkillTarget;
+/**
+ * Is a symlink's stored target one that `vigiles init` writes — a path ending
+ * in `node_modules/vigiles/skills/<name>`, for the SAME skill name?
+ *
+ * Two readers ask, and must agree, so the answer lives here once:
+ *
+ * - `init` (`../skill-links.ts`): an existing link of this shape that points
+ *   somewhere other than where `init` would link now was made by an earlier
+ *   `init` (for example before a workspace install hoisted the package), so it
+ *   is replaced instead of being refused as the user's;
+ * - `audit` (`../adapters/claude-code/skill-reachability.ts`): only a dangling
+ *   link of this shape is "vigiles's link, run npm install". A dangling link
+ *   that merely shares a skill's NAME is the user's, and the advice would send
+ *   them to fix the wrong thing.
+ *
+ * The test is on path SEGMENTS (either separator, so a link written on Windows
+ * reads the same), not on a substring: `my-node_modules/vigiles/...` is not it.
+ */
+function isVigilesSkillTarget(target, name) {
+    const tail = target
+        .split(/[\\/]+/)
+        .filter((s) => s !== "")
+        .slice(-4);
+    return (tail.length === 4 &&
+        tail[0] === "node_modules" &&
+        tail[1] === "vigiles" &&
+        tail[2] === "skills" &&
+        tail[3] === name);
+}
+//# sourceMappingURL=skill-link-target.js.map

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

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