vigiles 33.1.0 → 33.3.0

package/dist/skill-links.js

@@ -0,0 +1,255 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VIGILES_PACKAGE = void 0;
+exports.decideSkillLink = decideSkillLink;
+exports.locatePackage = locatePackage;
+exports.isWithinProject = isWithinProject;
+exports.linkPrecondition = linkPrecondition;
+exports.portableTarget = portableTarget;
+exports.planSkillLinks = planSkillLinks;
+exports.relinkTempPath = relinkTempPath;
+exports.writeSkillLink = writeSkillLink;
+exports.linkFailureReason = linkFailureReason;
+exports.skillLinksUsable = skillLinksUsable;
+exports.formatSkillLinks = formatSkillLinks;
+/**
+ * The pure half of how `vigiles init` makes vigiles's skills visible to the
+ * agent in EVERY clone: one relative symlink per shipped skill,
+ * `<skills home>/<name> -> ../../node_modules/vigiles/skills/<name>`, committed
+ * with the repo. The IO half (lstat, readlink, symlink) is `linkVigilesSkills`
+ * in `cli-main.ts`; everything that decides something is here, so it is tested
+ * without a filesystem.
+ *
+ * 🔴 WHY LINKS AND NOT ONLY THE PLUGIN. `npm install vigiles` puts the skills at
+ * `node_modules/vigiles/skills/`, which no harness scans. The Claude Code plugin
+ * install carries them, but it lands in `~/.claude/plugins/` — a fact about ONE
+ * machine. A fresh clone or a fresh container has an empty home directory, and
+ * the project's `enabledPlugins` declaration only makes Claude Code PROMPT for
+ * an install (`./plugin-declaration.ts`); headless, nobody sees the prompt. The
+ * skills were on disk and silently absent. A link is part of the repository, so
+ * it arrives with `git clone` and resolves as soon as `npm install` has run —
+ * the same step every other dependency already needs.
+ *
+ * Both harnesses document following a symlinked skill folder:
+ *
+ * > Claude Code: "a `<skill-name>` entry in the enterprise, personal, or project
+ * > location can be a symlink to a directory elsewhere on disk. Claude Code
+ * > reads `SKILL.md` from the target" (code.claude.com/docs/en/skills, fetched
+ * > 2026-10-07).
+ *
+ * > Codex: "Codex supports symlinked skill folders and follows the symlink
+ * > target when scanning these locations" (learn.chatgpt.com/docs/build-skills,
+ * > fetched 2026-10-07).
+ *
+ * The layout is the one paperlint's `init` already ships (its `link-skills.ts`),
+ * kept on purpose: the links that work in a real consumer are the proven shape.
+ *
+ * ── THE RULES ──────────────────────────────────────────────────────────────
+ *   what to link     every skill the package ships: the installed package's
+ *                    `skills/` when it is installed, the running CLI's own
+ *                    otherwise (the version `init` just declared).
+ *   where it points  `node_modules/vigiles` as the PROJECT spells it, found by
+ *                    walking up no further than the repository root. A link that
+ *                    leaves the repository resolves on this machine only — the
+ *                    defect this module exists to remove. Under pnpm the real
+ *                    path is a version-stamped store directory; a link spelled
+ *                    through `node_modules/vigiles` survives the next upgrade.
+ *   what it touches  only what is missing. An entry that already leads to the
+ *                    shipped skill is kept; ANY other entry of the same name —
+ *                    the user's own skill directory, a file, a link elsewhere —
+ *                    is theirs, and is reported, never replaced.
+ *
+ * Names are not namespaced: a linked skill is `test-harness`, where the plugin's
+ * copy is `vigiles:test-harness`. A user's own skill of the same name therefore
+ * wins by construction (we never replace it) and the report names the skill
+ * they did not get.
+ */
+const node_path_1 = require("node:path");
+const skill_link_target_js_1 = require("./core/skill-link-target.js");
+/** The package whose skills are linked. */
+exports.VIGILES_PACKAGE = "vigiles";
+/**
+ * Decide one entry. A link with OUR target is ours even while it dangles — that
+ * is exactly how a committed link looks in a clone that has not run
+ * `npm install` yet, and calling it foreign would make re-running `init` noisy
+ * in precisely the place it is meant to help.
+ */
+function decideSkillLink(name, entry, want) {
+    switch (entry.kind) {
+        case "missing":
+            return { name, action: "create", target: want.target };
+        case "link":
+            if (entry.target === want.target ||
+                (entry.resolvesTo !== null && entry.resolvesTo === want.real))
+                return { name, action: "keep" };
+            // Provably ours (the shape `init` writes, same skill) but aimed elsewhere —
+            // e.g. linked before a workspace install hoisted the package. Rewrite it.
+            if ((0, skill_link_target_js_1.isVigilesSkillTarget)(entry.target, name))
+                return { name, action: "replace", target: want.target };
+            return {
+                name,
+                action: "refuse",
+                reason: entry.resolvesTo === null
+                    ? `a dangling link to ${entry.target}`
+                    : `a link to ${entry.target}`,
+            };
+        case "directory":
+            return { name, action: "refuse", reason: "a directory (your own skill)" };
+        case "file":
+            return { name, action: "refuse", reason: "a file" };
+    }
+}
+/** Is there a workspace root strictly above `project`, up to the repo root? */
+function insideWorkspace(project, probe) {
+    const walk = (dir) => {
+        if (dir !== project && probe.isWorkspaceRoot(dir))
+            return true;
+        if (probe.isRepoRoot(dir) || (0, node_path_1.dirname)(dir) === dir)
+            return false;
+        return walk((0, node_path_1.dirname)(dir));
+    };
+    return walk(project);
+}
+/**
+ * Node's own lookup — the first `node_modules/vigiles` up the tree — bounded by
+ * the repository root, because a committed link that leaves the repository is a
+ * link only this machine can follow.
+ */
+function locatePackage(project, probe) {
+    // The walk stops at the repository root; with no repository yet (before
+    // `git init`) the project itself is the boundary, or an unrelated ancestor's
+    // node_modules would be linked into it.
+    const repoRoot = (dir) => {
+        if (probe.isRepoRoot(dir))
+            return dir;
+        return (0, node_path_1.dirname)(dir) === dir ? null : repoRoot((0, node_path_1.dirname)(dir));
+    };
+    const boundary = repoRoot(project) ?? project;
+    const walk = (dir) => {
+        const candidate = (0, node_path_1.join)(dir, "node_modules", exports.VIGILES_PACKAGE);
+        if (probe.isPackage(candidate))
+            return { kind: "installed", dir: candidate };
+        if (dir === boundary || (0, node_path_1.dirname)(dir) === dir)
+            return null;
+        return walk((0, node_path_1.dirname)(dir));
+    };
+    const installed = walk(project);
+    if (installed !== null)
+        return installed;
+    return insideWorkspace(project, probe)
+        ? {
+            kind: "unsure",
+            reason: "vigiles isn't installed yet and this package is in a workspace, where the install decides whether it lands in this package's node_modules or the workspace root's — run npm install, then npx vigiles init",
+        }
+        : { kind: "expected", dir: (0, node_path_1.join)(project, "node_modules", exports.VIGILES_PACKAGE) };
+}
+/**
+ * Is the real path `path` the project's own real path or somewhere under it?
+ * Both must be physical (symlink-free), or a link could pass for a child.
+ */
+function isWithinProject(project, path) {
+    const rel = (0, node_path_1.relative)(project, path);
+    // A child can be NAMED `..cache`; only a whole `..` segment leaves the project.
+    return rel.split(node_path_1.sep)[0] !== ".." && !(0, node_path_1.isAbsolute)(rel);
+}
+/**
+ * Why NOT to link, or null to go ahead. A link into a `node_modules/vigiles`
+ * that no install will ever create is a dangling link committed to the repo — a
+ * worse state than no link, because it looks like the job was done.
+ */
+function linkPrecondition(facts) {
+    if (facts.isVigilesItself)
+        return "this is the vigiles repository itself; its skills are the plugin's own skills/";
+    if (!facts.installed && !facts.dependsOnVigiles)
+        return "this repo has no package.json dependency on vigiles, so no install will create node_modules/vigiles for a link to point at; the global install carries the skills here instead";
+    return null;
+}
+/**
+ * A link target as it is committed: `/` separators on every OS. `relative()` on
+ * Windows yields `..\\..\\node_modules\\…`, and a clone on Linux or macOS
+ * reads those backslashes as ordinary filename characters, so the link dangles.
+ */
+function portableTarget(target, separator = node_path_1.sep) {
+    return target.split(separator).join("/");
+}
+function planSkillLinks(input) {
+    const skillsDir = (0, node_path_1.join)(input.site.dir, "skills");
+    return {
+        pending: input.site.kind === "expected",
+        decisions: input.names.map((name) => decideSkillLink(name, input.entries(name), {
+            target: portableTarget((0, node_path_1.relative)(input.physicalHome, (0, node_path_1.join)(skillsDir, name))),
+            real: input.realOf(name),
+        })),
+    };
+}
+/** Where a replacement link is built before it takes the old one's place. */
+function relinkTempPath(entry) {
+    return (0, node_path_1.join)((0, node_path_1.dirname)(entry), `.${(0, node_path_1.basename)(entry)}.vigiles-new`);
+}
+/**
+ * Write the link `decision` asks for. A `replace` never leaves a gap: the new
+ * link is built under a temporary name beside the old one and renamed over it,
+ * which is atomic. Removing the old link first would lose it for good when the
+ * new one cannot be created (a Windows account without the symlink privilege,
+ * a full disk) — a skill that worked yesterday gone, and only a warning to show
+ * for it. Any failure leaves the old link in place and throws.
+ */
+function writeSkillLink(io, entry, target, action) {
+    if (action === "create") {
+        io.symlink(target, entry);
+        return;
+    }
+    const temp = relinkTempPath(entry);
+    // Whatever already sits at the temporary name is not ours to delete: the
+    // `symlink` then fails (EEXIST) and is reported, and both entries stay.
+    io.symlink(target, temp);
+    try {
+        io.rename(temp, entry);
+    }
+    catch (e) {
+        try {
+            // Only the link this call just created is removed.
+            io.unlink(temp);
+        }
+        catch {
+            // Already gone: the rename error is the news.
+        }
+        throw e;
+    }
+}
+/** Why a `symlink` call failed, with the fix when there is a known one. */
+function linkFailureReason(code, message) {
+    const base = `could not create the link: ${message}`;
+    return code === "EPERM"
+        ? `${base} — on Windows, creating a symlink needs Developer Mode (or an elevated shell), and git needs core.symlinks=true to check one out`
+        : base;
+}
+/** At least one shipped skill now reaches the agent through a link. */
+function skillLinksUsable(outcome) {
+    return (outcome.kind === "linked" &&
+        outcome.results.some((r) => r.status !== "skipped"));
+}
+/**
+ * The lines `init` prints. Skipped skills are named one by one: the user loses
+ * that skill, and the reason is theirs to act on.
+ */
+function formatSkillLinks(outcome) {
+    if (outcome.kind === "not-linked")
+        return [`⚠ vigiles's skills were NOT linked — ${outcome.reason}`];
+    const count = (s) => outcome.results.filter((r) => r.status === s).length;
+    const skipped = outcome.results.filter((r) => r.status === "skipped");
+    const mark = skipped.length > 0 ? "⚠" : "✓";
+    return [
+        `${mark} vigiles's ${String(outcome.results.length)} skills → ${outcome.home}/ (relative links into node_modules; commit them): ` +
+            `${String(count("created"))} linked now, ${String(count("present"))} already linked, ` +
+            (count("relinked") > 0 ? `${String(count("relinked"))} relinked, ` : "") +
+            `${String(skipped.length)} skipped`,
+        ...skipped.map((r) => `  ${outcome.home}/${r.name} left alone — it is ${r.reason}. Rename it to get vigiles's ${r.name}.`),
+        ...(outcome.pending
+            ? [
+                "  They resolve once vigiles is installed: run npm install (every clone and container needs it anyway).",
+            ]
+            : []),
+    ];
+}
+//# sourceMappingURL=skill-links.js.map

package/dist/test-coverage-files.d.ts

@@ -1,7 +1,7 @@
 import { type PluginLayout } from "./core/layout.js";
 import type { CoverageDecision, CoverageTier, Surface } from "./test-coverage.js";
 /**
- * The untested harness surfaces (skills / agents / hooks) in a file map — the
+ * The untested harness surfaces (skills / agents / hooks / output styles) in a file map — the
  * browser-safe twin of `findUntestedSurfaces`, returning the union `untested` list
  * plus the same per-tier split (`scanFiles` needs the counts). Same coverage rules
  * as the disk detector; the tier split is by suffix, exactly as on disk.
@@ -17,5 +17,7 @@ repoName: string): {
     decisions: readonly CoverageDecision[];
     harness: CoverageTier;
     evals: CoverageTier;
+    /** Surfaces opted out via `vigiles:ignore-test`; still part of the inventory. */
+    exemptSurfaces: readonly Surface[];
 };
 //# sourceMappingURL=test-coverage-files.d.ts.map

package/dist/test-coverage-files.js

@@ -34,6 +34,7 @@ exports.findUntestedSurfacesInFiles = findUntestedSurfacesInFiles;
 const posix_path_js_1 = require("./posix-path.js");
 const layout_js_1 = require("./core/layout.js");
 const coverage_evidence_js_1 = require("./coverage-evidence.js");
+const output_style_js_1 = require("./core/output-style.js");
 const source_kinds_js_1 = require("./source-kinds.js");
 const IGNORE_MARKER = "vigiles:ignore-test";
 /** Mirror of the DEFAULT_IGNORE globs (root-anchored), as a key predicate. */
@@ -136,6 +137,13 @@ function discoverAgents(files, layout) {
     }
     return out;
 }
+/** Twin of test-coverage.ts `discoverOutputStyles`: the harness decides, over the map. */
+function discoverOutputStyles(files, layout) {
+    const scan = (0, output_style_js_1.findOutputStyles)(layout, new Map(Object.entries(files).filter(([path]) => !isIgnored(path))));
+    return scan.kind === "not-supported"
+        ? []
+        : scan.styles.map((style) => (0, coverage_evidence_js_1.outputStyleSurface)(style.path, files[style.path] ?? ""));
+}
 /**
  * Hook-script paths referenced from a manifest's `hooks` block (file hooks only).
  *
@@ -226,8 +234,17 @@ function tierOf(considered, tests, globs) {
     }
     return { covered, untested, decisions };
 }
+/** Every surface kind in the map — twin of test-coverage.ts `discoverSurfaces`. */
+function discoverSurfaces(files, layout, repoName) {
+    return [
+        ...discoverSkills(files, layout, repoName),
+        ...discoverAgents(files, layout),
+        ...discoverHooks(files, layout),
+        ...discoverOutputStyles(files, layout),
+    ];
+}
 /**
- * The untested harness surfaces (skills / agents / hooks) in a file map — the
+ * The untested harness surfaces (skills / agents / hooks / output styles) in a file map — the
  * browser-safe twin of `findUntestedSurfaces`, returning the union `untested` list
  * plus the same per-tier split (`scanFiles` needs the counts). Same coverage rules
  * as the disk detector; the tier split is by suffix, exactly as on disk.
@@ -239,11 +256,7 @@ function findUntestedSurfacesInFiles(files, layout,
  * `name:`. Same value `scanFiles` already threads for the skill inventory.
  */
 repoName) {
-    const surfaces = [
-        ...discoverSkills(files, layout, repoName),
-        ...discoverAgents(files, layout),
-        ...discoverHooks(files, layout),
-    ];
+    const surfaces = discoverSurfaces(files, layout, repoName);
     const considered = surfaces.filter((s) => !s.ignored);
     const tests = discoverTests(files);
     // NO configured `{surface}` globs here, and that is a property of this twin
@@ -257,6 +270,7 @@ repoName) {
     return {
         untested: [...union.untested],
         decisions: union.decisions,
+        exemptSurfaces: surfaces.filter((s) => s.ignored),
         harness: tierOf(considered, tests.filter((t) => !(0, coverage_evidence_js_1.isEvalScript)((0, posix_path_js_1.basename)(t.path))), noConfiguredGlobs),
         evals: tierOf(considered, tests.filter((t) => (0, coverage_evidence_js_1.isEvalScript)((0, posix_path_js_1.basename)(t.path))), noConfiguredGlobs),
     };

package/dist/test-coverage.d.ts

@@ -64,7 +64,7 @@ import { type ExcludeSet } from "./exclude.js";
 import type { RepoPath } from "./core/frame.js";
 import { type PluginLayout } from "./core/layout.js";
 import { type CoverageEvidence, type EvidenceCounts } from "./coverage-evidence.js";
-export type SurfaceKind = "skill" | "agent" | "hook";
+export type SurfaceKind = "skill" | "agent" | "hook" | "output-style";
 export interface Surface {
     readonly kind: SurfaceKind;
     /** Repo-relative path to the surface file (SKILL.md / agent .md / hook script). */
@@ -119,6 +119,11 @@ export interface UntestedReport {
     readonly untested: readonly Surface[];
     /** Surfaces explicitly opted out via `vigiles:ignore-test`. */
     readonly exempt: number;
+    /**
+     * The exempt surfaces themselves. The marker waives a surface's test, not its
+     * existence, so an inventory counts them (an exempt style still ships).
+     */
+    readonly exemptSurfaces: readonly Surface[];
     /**
      * Test files still carrying the RETIRED `vigiles:covers` marker.
      *
@@ -201,6 +206,18 @@ export interface TestCoverageOptions {
     readonly agents?: boolean;
     /** Scan hook scripts referenced from plugin.json / settings.json. Default true. */
     readonly hooks?: boolean;
+    /**
+     * Scan output styles, in every folder the layout's `outputStyles` names.
+     * Default true; a layout with no output styles finds none either way.
+     */
+    readonly outputStyles?: boolean;
+    /**
+     * Every harness the repository declares, when it declares more than one.
+     * Surfaces are found in each of them, one per file: a repository can list a
+     * harness first and keep its skills, agents or styles in another's folder.
+     * Defaults to `[layout]`.
+     */
+    readonly harnessLayouts?: readonly PluginLayout[];
     /** Globs of test files that count as coverage. */
     readonly include?: readonly string[];
     /**

package/dist/test-coverage.js

@@ -78,6 +78,7 @@ const ts_runner_caps_js_1 = require("./ts-runner-caps.js");
 const glob_1 = require("glob");
 const glob_ignore_js_1 = require("./core/glob-ignore.js");
 const exclude_js_1 = require("./exclude.js");
+const output_style_js_1 = require("./core/output-style.js");
 const source_kinds_js_1 = require("./source-kinds.js");
 const layout_js_1 = require("./core/layout.js");
 const coverage_evidence_js_1 = require("./coverage-evidence.js");
@@ -146,6 +147,42 @@ function read(path) {
         return "";
     }
 }
+/**
+ * Is this skill directory a DEPENDENCY's — does it really live under a
+ * `node_modules` that is not the scanned base's own ancestor?
+ *
+ * The `node_modules/**` floor (`EXCLUDE_FLOOR`) is applied to the path as
+ * SPELLED, and `.claude/skills/<name>` spells no `node_modules` even when it is
+ * a link into one — which is exactly what `vigiles init` (and paperlint's)
+ * commits so the agent sees a package's skills in every clone. Those skills are
+ * the package's work, tested by the package; counting them here would report
+ * the repo's own `init` as six untested skills, and fail `--strict`.
+ *
+ * Both the link as written and its real target are asked (see the body).
+ * Measured on the path RELATIVE to the base's real path, so auditing a package
+ * that itself sits in `node_modules` still sees its own skills, and a pnpm
+ * store target (`node_modules/.pnpm/…`) or a hoisted workspace root
+ * (`../../node_modules/…`) both count as dependencies. A link elsewhere (one
+ * shared skills folder linked per skill) is the repo's own and stays graded.
+ * Unresolvable → not a dependency (the skill stays visible: silence is the
+ * worse error here).
+ */
+function isDependencySkill(basePath, skillDir) {
+    try {
+        const base = (0, node_fs_1.realpathSync)(basePath);
+        const inNodeModules = (p) => (0, node_path_1.relative)(base, p).split(node_path_1.sep).includes("node_modules");
+        // Both the link as WRITTEN and where it finally lands: under `npm link`, a
+        // `file:` dependency or a workspace, `node_modules/<pkg>` is itself a link
+        // to a source checkout, so the real path alone names no `node_modules`.
+        const spelled = (0, node_fs_1.lstatSync)(skillDir).isSymbolicLink()
+            ? (0, node_path_1.resolve)((0, node_fs_1.realpathSync)((0, node_path_1.dirname)(skillDir)), (0, node_fs_1.readlinkSync)(skillDir))
+            : skillDir;
+        return inNodeModules(spelled) || inNodeModules((0, node_fs_1.realpathSync)(skillDir));
+    }
+    catch {
+        return false;
+    }
+}
 function discoverSkills(basePath, ignore, layout) {
     const out = [];
     // 🔴 ONE GATE FOR THE WHOLE FUNCTION, and it is structural rather than
@@ -158,7 +195,7 @@ function discoverSkills(basePath, ignore, layout) {
     const skillDir = layout.surfaces.skill;
     if (skillDir === undefined)
         return out;
-    const found = (0, glob_1.globSync)(surfaceGlobs(skillDir, "*/SKILL.md", (0, layout_js_1.materializePrefix)(layout)), { cwd: basePath, ignore });
+    const found = (0, glob_1.globSync)(surfaceGlobs(skillDir, "*/SKILL.md", (0, layout_js_1.materializePrefix)(layout)), { cwd: basePath, ignore }).filter((path) => !isDependencySkill(basePath, (0, node_path_1.join)(basePath, (0, node_path_1.dirname)(path))));
     for (const path of found.sort()) {
         const name = (0, node_path_1.basename)((0, node_path_1.dirname)(path));
         const content = read((0, node_path_1.join)(basePath, path));
@@ -249,6 +286,46 @@ function discoverAgents(basePath, ignore, layout) {
     }
     return out;
 }
+/**
+ * Output styles, by the layout's own rules: every file in a style home that
+ * the harness would load. {@link findOutputStyles} decides; this only reads the
+ * candidates off the disk, so it and the browser twin cannot disagree on which
+ * files are styles.
+ */
+function discoverOutputStyles(basePath, ignore, layout) {
+    const candidates = new Map((0, output_style_js_1.outputStyleHomes)(layout).flatMap((home) => (0, glob_1.globSync)(`${home}/**/*`, {
+        cwd: basePath,
+        ignore: [...ignore],
+        dot: true,
+        nodir: true,
+    }).map((path) => [path.split(node_path_1.sep).join("/"), ""])));
+    const scan = (0, output_style_js_1.findOutputStyles)(layout, candidates);
+    return scan.kind === "not-supported"
+        ? []
+        : scan.styles.map((style) => (0, coverage_evidence_js_1.outputStyleSurface)(style.path, read((0, node_path_1.join)(basePath, style.path))));
+}
+/**
+ * Every kind the options switch on, found under the bundle. Discovery gets only
+ * the frame-free ignore floor; the rule's and the repo's excludes are applied
+ * later, from `root`, by the caller.
+ */
+function discoverSurfaces(basePath, layout, options) {
+    const on = (flag) => flag !== false;
+    const found = (options.harnessLayouts ?? [layout]).flatMap((each) => [
+        ...(on(options.skills)
+            ? discoverSkills(basePath, [...DEFAULT_IGNORE], each)
+            : []),
+        ...(on(options.agents)
+            ? discoverAgents(basePath, [...DEFAULT_IGNORE], each)
+            : []),
+        ...(on(options.hooks) ? discoverHooks(basePath, each) : []),
+        ...(on(options.outputStyles)
+            ? discoverOutputStyles(basePath, DEFAULT_IGNORE, each)
+            : []),
+    ]);
+    // Two declared harnesses can read the same file: one surface per file.
+    return [...new Map(found.map((s) => [`${s.kind}\0${s.path}`, s])).values()];
+}
 /**
  * Hook-script paths referenced from a manifest's `hooks` block (file hooks only).
  *
@@ -419,6 +496,11 @@ function tierOf(considered, tests, index, tier, globs) {
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
+/** The exempt surfaces and their count: waived from testing, still in the inventory. */
+function exemptOf(surfaces) {
+    const exemptSurfaces = surfaces.filter((s) => s.ignored);
+    return { exempt: exemptSurfaces.length, exemptSurfaces };
+}
 /**
  * Find harness surfaces (skills / agents / hooks) that no test or eval covers.
  * A surface is covered by a colocated `*.{harness,eval}.mjs` OR any discovered
@@ -449,24 +531,15 @@ function findUntestedSurfaces(options) {
     // Discovery globs from the BUNDLE, so it gets only the frame-free floor; the
     // rule's patterns are root-relative and the repo's carry their own root, so
     // both are applied below, to the root-relative path.
-    const floor = [...DEFAULT_IGNORE];
-    const found = [];
-    if (options.skills !== false)
-        found.push(...discoverSkills(basePath, floor, layout));
-    if (options.agents !== false)
-        found.push(...discoverAgents(basePath, floor, layout));
-    if (options.hooks !== false)
-        found.push(...discoverHooks(basePath, layout));
+    const found = discoverSurfaces(basePath, layout, options);
     // Hooks were never subject to `ignore` (a compiled hook lives under the
     // default-ignored `.vigiles/`); keep that, and re-apply exclude to the kinds
     // whose discovery glob used it — now from `root`, where the patterns live.
     const surfaces = found
         .map(toRoot)
         .filter((s) => s.kind === "hook" || !excluded(s.path));
-    // Every skill/agent/hook is held to the requirement — only an explicit
-    // `vigiles:ignore-test` marker exempts a surface (a visible, deliberate skip).
+    // Only an explicit `vigiles:ignore-test` marker exempts a surface.
     const considered = surfaces.filter((s) => !s.ignored);
-    const exempt = surfaces.length - considered.length;
     const tests = discoverTests(root, globs, ignore);
     const split = partitionTests(tests);
     // The run record, if there is one. NO artifact ⇒ an empty index ⇒ every
@@ -487,7 +560,7 @@ function findUntestedSurfaces(options) {
         total: considered.length,
         covered: union.covered,
         untested: union.untested,
-        exempt,
+        ...exemptOf(surfaces),
         staleRuns: staleRunsFor(considered, runIndex),
         testExt: (0, test_file_ext_js_1.testFileExt)({
             configured: options.testExtension,
@@ -683,6 +756,19 @@ function evalTierQuestion(kind) {
                 `the tool contract, \`assertAgentOk\` for the typed result. Those two ` +
                 `calls drive Claude Code and take no \`evalDriver\`, so on another ` +
                 `harness this tier has no public dispatch yet.`);
+        case "output-style":
+            // A style is not selected by the model, so there is no firing to
+            // measure; the real-model question is whether a model handed the style
+            // FOLLOWS it. The deterministic test that covers it drove a scripted
+            // model, which proves delivery and nothing about following.
+            return (`A deterministic test covers it, but that test drove a SCRIPTED model: ` +
+                `it can show the style reached the model, never that a real model ` +
+                `follows it.\n` +
+                `See the \`test-harness\` skill: compare runs with and without the style ` +
+                `(\`measureArms\`), check the output with deterministic checks where the ` +
+                `rule has a checkable shape and \`judged\` where it does not, and gate ` +
+                `with \`assertRates\`. NOT \`measureTriggerRate\`: a style is not ` +
+                `selected by the model, so there is no trigger to measure.`);
         case "hook":
             // Nothing. A hook is deterministic by construction: `runHook` answers
             // "does it block event X?" at the unit tier, free, for every event type —
@@ -859,8 +945,8 @@ function formatUntestedReport(report) {
     // model budget.
     lines.push(`  Two gaps, two costs: ${String(report.harness.untested.length)} with no ` +
         `deterministic harness (free, every push) · ` +
-        `${String(report.evals.untested.length)} whose firing was never measured ` +
-        `(needs a real model, run on a schedule).`);
+        `${String(report.evals.untested.length)} never measured with a real model ` +
+        `(paid, run on a schedule).`);
     // What the surfaces that DID pass are resting on.
     if (provenance)
         lines.push(`  ${provenance}`);

package/dist/test.d.ts

@@ -62,7 +62,7 @@ export { loadHook } from "./load-hook.js";
 export { experimental_hookState } from "./hook-state-store.js";
 export type { HookStateHandle, SeedStateOptions } from "./hook-state-store.js";
 export type { StateFact, Duration } from "./core/hook-state.js";
-export { evalChecks, assertChecks, tool, toolWith, notTool, onlyTools, skill, output, hookFired, received, turns, wrote, didNotWrite, subagent, blocked, allowed, mcp, cost, latency, tokens, inputTokens, outputTokens, cacheTokens, } from "./check.js";
+export { evalChecks, assertChecks, tool, toolWith, notTool, onlyTools, skill, output, experimental_eachReply, experimental_replyCount, hookFired, received, turns, wrote, didNotWrite, subagent, blocked, allowed, mcp, cost, latency, tokens, inputTokens, outputTokens, cacheTokens, } from "./check.js";
 export type { ArgMatcher, Check, CheckJSON, CheckResult, JudgeFn, } from "./check.js";
 export { DISASTER_CATALOG, verifyGuardrail, unblockedDisasters, assertBlocksDisasters, formatGuardrailReport, experimental_alternateSpellings, } from "./guardrail-check.js";
 export type { DisasterEvent, DisasterCategory, GuardrailResult, VerifyGuardrailOptions, } from "./guardrail-check.js";
@@ -70,6 +70,8 @@ export { experimental_verifyPluginGuards, experimental_formatPluginGuardReport,
 export type { PluginGuardReport, SweptHook, SweptHookOutcome, NonCommandHookAction, VerifyPluginGuardsOptions, } from "./verify-plugin-guards.js";
 export * from "./tool-stub.js";
 export { runHarnessTest, runHarness, parseToolCalls, parseSubagents, parseResultEvent, parseOutput, parseHooks, decideSandbox, specTrusted, sandboxAvailable, } from "./harness-test.js";
+export { experimental_outputStyleArms } from "./output-style-arms.js";
+export type { OutputStyleArms } from "./output-style-arms.js";
 export type { HarnessTestSpec, Trace, SubagentTrace, HarnessTestResult, RunHarnessTestOptions, ModelTurn, ModelRequest, ToolCall, HookFire, HarnessTestDriver, SandboxMode, } from "./harness-test.js";
 export { commandsIn, mustInclude, mustNotInclude } from "./doc-commands.js";
 export type { DocCommand } from "./doc-commands.js";

package/dist/test.js

@@ -71,8 +71,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseSubagents = exports.parseToolCalls = exports.runHarness = exports.runHarnessTest = exports.experimental_formatPluginGuardReport = exports.experimental_verifyPluginGuards = exports.experimental_alternateSpellings = exports.formatGuardrailReport = exports.assertBlocksDisasters = exports.unblockedDisasters = exports.verifyGuardrail = exports.DISASTER_CATALOG = exports.cacheTokens = exports.outputTokens = exports.inputTokens = exports.tokens = exports.latency = exports.cost = exports.mcp = exports.allowed = exports.blocked = exports.subagent = exports.didNotWrite = exports.wrote = exports.turns = exports.received = exports.hookFired = exports.output = exports.skill = exports.onlyTools = exports.notTool = exports.toolWith = exports.tool = exports.assertChecks = exports.evalChecks = exports.experimental_hookState = exports.loadHook = exports.experimental_assertEmittedOk = exports.experimental_parseEmitted = exports.experimental_emitTool = exports.egressRoutes = exports.fileToolEvents = exports.propertyHook = exports.decideHook = exports.parseHookOutput = exports.runHook = exports.runScript = exports.cleanupTmpDir = exports.makeTmpDir = exports.recordCheck = void 0;
-exports.experimental_makeDockerRuntime = exports.experimental_dockerRuntime = exports.experimental_withServices = exports.experimental_startServices = exports.stubSkillBody = exports.parseClaudeRun = exports.formatTriggerRateReport = exports.formatEvalReport = exports.formatCheckReport = exports.checkReportToJUnit = exports.checkPromptDiversity = exports.assertPromptDiversity = exports.assertRates = exports.defineEval = exports.formatContainment = exports.compareContainment = exports.skillContract = exports.mustNotInclude = exports.mustInclude = exports.commandsIn = exports.sandboxAvailable = exports.specTrusted = exports.decideSandbox = exports.parseHooks = exports.parseOutput = exports.parseResultEvent = void 0;
+exports.runHarness = exports.runHarnessTest = exports.experimental_formatPluginGuardReport = exports.experimental_verifyPluginGuards = exports.experimental_alternateSpellings = exports.formatGuardrailReport = exports.assertBlocksDisasters = exports.unblockedDisasters = exports.verifyGuardrail = exports.DISASTER_CATALOG = exports.cacheTokens = exports.outputTokens = exports.inputTokens = exports.tokens = exports.latency = exports.cost = exports.mcp = exports.allowed = exports.blocked = exports.subagent = exports.didNotWrite = exports.wrote = exports.turns = exports.received = exports.hookFired = exports.experimental_replyCount = exports.experimental_eachReply = exports.output = exports.skill = exports.onlyTools = exports.notTool = exports.toolWith = exports.tool = exports.assertChecks = exports.evalChecks = exports.experimental_hookState = exports.loadHook = exports.experimental_assertEmittedOk = exports.experimental_parseEmitted = exports.experimental_emitTool = exports.egressRoutes = exports.fileToolEvents = exports.propertyHook = exports.decideHook = exports.parseHookOutput = exports.runHook = exports.runScript = exports.cleanupTmpDir = exports.makeTmpDir = exports.recordCheck = void 0;
+exports.experimental_makeDockerRuntime = exports.experimental_dockerRuntime = exports.experimental_withServices = exports.experimental_startServices = exports.stubSkillBody = exports.parseClaudeRun = exports.formatTriggerRateReport = exports.formatEvalReport = exports.formatCheckReport = exports.checkReportToJUnit = exports.checkPromptDiversity = exports.assertPromptDiversity = exports.assertRates = exports.defineEval = exports.formatContainment = exports.compareContainment = exports.skillContract = exports.mustNotInclude = exports.mustInclude = exports.commandsIn = exports.experimental_outputStyleArms = exports.sandboxAvailable = exports.specTrusted = exports.decideSandbox = exports.parseHooks = exports.parseOutput = exports.parseResultEvent = exports.parseSubagents = exports.parseToolCalls = void 0;
 // --- reporting: how much did this script actually do? ---
 // `vigiles test` can otherwise see only an exit code, so a file that runs NOTHING
 // prints the same `✓` as one that ran and passed (measured 2026-08-08 on a file
@@ -159,6 +159,8 @@ Object.defineProperty(exports, "notTool", { enumerable: true, get: function () {
 Object.defineProperty(exports, "onlyTools", { enumerable: true, get: function () { return check_js_1.onlyTools; } });
 Object.defineProperty(exports, "skill", { enumerable: true, get: function () { return check_js_1.skill; } });
 Object.defineProperty(exports, "output", { enumerable: true, get: function () { return check_js_1.output; } });
+Object.defineProperty(exports, "experimental_eachReply", { enumerable: true, get: function () { return check_js_1.experimental_eachReply; } });
+Object.defineProperty(exports, "experimental_replyCount", { enumerable: true, get: function () { return check_js_1.experimental_replyCount; } });
 Object.defineProperty(exports, "hookFired", { enumerable: true, get: function () { return check_js_1.hookFired; } });
 Object.defineProperty(exports, "received", { enumerable: true, get: function () { return check_js_1.received; } });
 Object.defineProperty(exports, "turns", { enumerable: true, get: function () { return check_js_1.turns; } });
@@ -213,6 +215,10 @@ Object.defineProperty(exports, "parseHooks", { enumerable: true, get: function (
 Object.defineProperty(exports, "decideSandbox", { enumerable: true, get: function () { return harness_test_js_1.decideSandbox; } });
 Object.defineProperty(exports, "specTrusted", { enumerable: true, get: function () { return harness_test_js_1.specTrusted; } });
 Object.defineProperty(exports, "sandboxAvailable", { enumerable: true, get: function () { return harness_test_js_1.sandboxAvailable; } });
+// The two arms of an output-style eval, after one free run proves the style
+// reaches the model. Free: the run uses the scripted model.
+var output_style_arms_js_1 = require("./output-style-arms.js");
+Object.defineProperty(exports, "experimental_outputStyleArms", { enumerable: true, get: function () { return output_style_arms_js_1.experimental_outputStyleArms; } });
 // A document's own rule about its own COMMANDS, made checkable. vigiles cannot
 // infer "always pass -g" from prose; what was missing was a cheap way to declare
 // it — measured at ~95 lines of markdown parsing around ~5 lines of rule, which