vigiles 33.1.0 → 33.3.0

package/dist/harness-test.d.ts

@@ -2,10 +2,15 @@ import type { HarnessAdapter } from "./core/adapter.js";
 import type { HarnessTestDriver, ToolCall, HookFire, ParsedRun, ModelTurn } from "./core/harness-driver.js";
 import type { Trace, SubagentTrace } from "./core/eval-driver.js";
 export type { Trace, SubagentTrace } from "./core/eval-driver.js";
+import { parseReplies, reachedModel } from "./adapters/claude-code/replies.js";
+/** Re-exported for the eval tier's parser, which reads the same stream. */
+export { parseReplies, reachedModel };
+import type { HarnessRuntime } from "./core/runtime.js";
 import { type SandboxMode } from "./sandbox.js";
 export { scriptModel } from "./mock-model.js";
 export type { ModelTurn, ModelRequest, ToolCall, HookFire, HarnessTestDriver, } from "./core/harness-driver.js";
-export { loadPlugin, resolveHarness, } from "./adapters/claude-code/plugin-loader.js";
+import { loadPlugin, resolveHarness } from "./adapters/claude-code/plugin-loader.js";
+export { loadPlugin, resolveHarness };
 export { decideSandbox, specTrusted, sandboxAvailable, type SandboxMode, } from "./sandbox.js";
 export interface HarnessTestSpec {
     /** Fixture files to write in a fresh temp working dir (path → contents). */
@@ -28,6 +33,21 @@ export interface HarnessTestSpec {
      * `plugin` still layer on top. Resolved to an absolute path.
      */
     readonly pluginDir?: string;
+    /**
+     * Path to an OUTPUT STYLE file to switch on for this run. The style is
+     * written where the harness keeps styles, and selected by the name the
+     * harness reads from the file — never by a name you type, because a setting
+     * that misses the name loads no style and raises no error.
+     *
+     * The run is then checked: if no model request carried the style,
+     * `runHarnessTest` THROWS instead of returning a trace, so a style that never
+     * loaded cannot pass a test. Refused up front on a harness without output
+     * styles, or when the fixture's files or settings already decide.
+     *
+     * What it proves is delivery. A scripted model does not read the style, so
+     * nothing in this tier shows that a model FOLLOWS it.
+     */
+    readonly outputStyle?: string;
     /** The scripted model turns the agent will take. */
     readonly model: readonly ModelTurn[];
     /** The user prompt. Default: "go". */
@@ -107,6 +127,31 @@ export declare function parseHooks(stdout: string): HookFire[];
 export declare function buildClaudeArgs(spec: HarnessTestSpec, hasSettings: boolean): string[];
 /** Parse the `claude` stdout/stream into the unified trace fields. */
 export declare function parseClaudeRun(stdout: string): ParsedRun;
+/**
+ * Where a harness-tier run's agent gets HOME and the rest of its environment.
+ *
+ * - `inherit` — the caller's env (real HOME), minus the harness's declared
+ *   session identity. The default of `runHarnessTest`: a test that reads the
+ *   machine's config keeps doing so, but no run executes AS the caller's live
+ *   session.
+ * - `throwaway` — a fresh HOME/TMPDIR at `dir`, the OS essentials, and nothing
+ *   else from the caller: no harness auth (the scripted mock needs none, and a
+ *   config-dir variable would point the run back at the real config), no
+ *   identity, no secrets. The same scrubbed shape as the eval tier's
+ *   `ephemeralEnv` (`scrubbedRunEnv`), without the auth.
+ */
+export type HarnessRunHome = {
+    readonly home: "inherit";
+} | {
+    readonly home: "throwaway";
+    readonly dir: string;
+};
+/**
+ * The spawn env of one harness-tier run: {@link HarnessRunHome} applied to
+ * `base`, with the runtime's mock wiring on top. Pure — the testable seam of
+ * the un-coverable spawn.
+ */
+export declare function harnessSpawnEnv(runtime: HarnessRuntime, wiredEnv: Readonly<Record<string, string>>, home: HarnessRunHome, base?: NodeJS.ProcessEnv): Readonly<Record<string, string>>;
 /** Whether the agent CLI is available — harness tests need it. */
 export declare function claudeAvailable(): boolean;
 /**
@@ -138,6 +183,15 @@ export interface RunHarnessTestOptions {
  * only — requesting confinement for another harness throws.
  */
 export declare function runHarnessTest(spec: HarnessTestSpec, opts?: RunHarnessTestOptions): Promise<HarnessTestResult>;
+/**
+ * {@link runHarnessTest} with the run's HOME chosen by the caller — see
+ * {@link HarnessRunHome}. Not on a public entry point: the one caller that needs
+ * a throwaway HOME is vigiles's own preflight (`output-style-arms.ts`), whose
+ * run must not depend on, or act as, the machine it happens to run on. The
+ * confined (bubblewrap) path ignores `home`: it already runs with its own HOME
+ * and a cleared env.
+ */
+export declare function runHarnessTestIn(spec: HarnessTestSpec, opts: RunHarnessTestOptions, home: HarnessRunHome["home"]): Promise<HarnessTestResult>;
 /**
  * `runHarness` — the harness-scope entry of the revamped API (Phase 2 of
  * `research/testing-api-design.md`). The harness has two execution scopes, `hook`
@@ -156,4 +210,14 @@ export declare function runHarnessTest(spec: HarnessTestSpec, opts?: RunHarnessT
 export declare function runHarness(spec: HarnessTestSpec, opts?: RunHarnessTestOptions & {
     model?: "mock" | "real";
 }): Promise<HarnessTestResult>;
+/**
+ * The files and settings a run with `outputStyle` writes — the style at its
+ * place, selected by the name the harness reads from it. The same fixture
+ * `runHarnessTest({ outputStyle })` runs, so an eval arm built from it gets
+ * exactly what that run proved reaches the model.
+ */
+export declare function outputStyleFixture(outputStyle: string, adapter?: HarnessAdapter): {
+    readonly files: Readonly<Record<string, string>>;
+    readonly settings: unknown;
+};
 //# sourceMappingURL=harness-test.d.ts.map

package/dist/harness-test.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.claudeCodeDriver = exports.sandboxAvailable = exports.specTrusted = exports.decideSandbox = exports.resolveHarness = exports.loadPlugin = exports.scriptModel = void 0;
+exports.claudeCodeDriver = exports.sandboxAvailable = exports.specTrusted = exports.decideSandbox = exports.resolveHarness = exports.loadPlugin = exports.scriptModel = exports.reachedModel = exports.parseReplies = void 0;
 exports.parseToolCalls = parseToolCalls;
 exports.parseSubagents = parseSubagents;
 exports.parseResultEvent = parseResultEvent;
@@ -8,9 +8,12 @@ exports.parseOutput = parseOutput;
 exports.parseHooks = parseHooks;
 exports.buildClaudeArgs = buildClaudeArgs;
 exports.parseClaudeRun = parseClaudeRun;
+exports.harnessSpawnEnv = harnessSpawnEnv;
 exports.claudeAvailable = claudeAvailable;
 exports.runHarnessTest = runHarnessTest;
+exports.runHarnessTestIn = runHarnessTestIn;
 exports.runHarness = runHarness;
+exports.outputStyleFixture = outputStyleFixture;
 /**
  * vigiles — deterministic Claude Code harness testing.
  *
@@ -49,13 +52,18 @@ const check_count_js_1 = require("./check-count.js");
 const coverage_probe_js_1 = require("./coverage-probe.js");
 const runtime_js_1 = require("./adapters/claude-code/runtime.js");
 const mock_model_js_1 = require("./mock-model.js");
-const plugin_loader_js_1 = require("./adapters/claude-code/plugin-loader.js");
+const replies_js_1 = require("./adapters/claude-code/replies.js");
+Object.defineProperty(exports, "parseReplies", { enumerable: true, get: function () { return replies_js_1.parseReplies; } });
+Object.defineProperty(exports, "reachedModel", { enumerable: true, get: function () { return replies_js_1.reachedModel; } });
+const adapter_registry_js_1 = require("./adapter-registry.js");
+const output_style_js_1 = require("./core/output-style.js");
+const run_env_js_1 = require("./core/run-env.js");
 const sandbox_js_1 = require("./sandbox.js");
 var mock_model_js_2 = require("./mock-model.js");
 Object.defineProperty(exports, "scriptModel", { enumerable: true, get: function () { return mock_model_js_2.scriptModel; } });
-var plugin_loader_js_2 = require("./adapters/claude-code/plugin-loader.js");
-Object.defineProperty(exports, "loadPlugin", { enumerable: true, get: function () { return plugin_loader_js_2.loadPlugin; } });
-Object.defineProperty(exports, "resolveHarness", { enumerable: true, get: function () { return plugin_loader_js_2.resolveHarness; } });
+const plugin_loader_js_1 = require("./adapters/claude-code/plugin-loader.js");
+Object.defineProperty(exports, "loadPlugin", { enumerable: true, get: function () { return plugin_loader_js_1.loadPlugin; } });
+Object.defineProperty(exports, "resolveHarness", { enumerable: true, get: function () { return plugin_loader_js_1.resolveHarness; } });
 var sandbox_js_2 = require("./sandbox.js");
 Object.defineProperty(exports, "decideSandbox", { enumerable: true, get: function () { return sandbox_js_2.decideSandbox; } });
 Object.defineProperty(exports, "specTrusted", { enumerable: true, get: function () { return sandbox_js_2.specTrusted; } });
@@ -285,8 +293,9 @@ function buildClaudeArgs(spec, hasSettings) {
             ? ["--plugin-dir", (0, node_path_1.resolve)(spec.pluginDir)]
             : []),
         ...(hasSettings ? ["--settings", "settings.json"] : []),
-        "--allowedTools",
-        ...tools,
+        // A permission allowlist: an empty one approves nothing, so the flag is
+        // left out (a bare `--allowedTools` exits before any model turn).
+        ...(tools.length === 0 ? [] : ["--allowedTools", ...tools]),
     ];
 }
 /** Build the `claude` argv from the driver context — wraps `buildClaudeArgs`. */
@@ -305,8 +314,22 @@ function parseClaudeRun(stdout) {
         toolCalls: parseToolCalls(stdout),
         hooks: parseHooks(stdout),
         output: parseOutput(stdout),
+        replies: (0, replies_js_1.parseReplies)(stdout),
     };
 }
+/**
+ * The spawn env of one harness-tier run: {@link HarnessRunHome} applied to
+ * `base`, with the runtime's mock wiring on top. Pure — the testable seam of
+ * the un-coverable spawn.
+ */
+function harnessSpawnEnv(runtime, wiredEnv, home, base = process.env) {
+    switch (home.home) {
+        case "inherit":
+            return { ...(0, run_env_js_1.withoutSessionIdentity)(base, runtime.runEnv), ...wiredEnv };
+        case "throwaway":
+            return { ...(0, run_env_js_1.scrubbedRunEnv)(base, { home: home.dir }), ...wiredEnv };
+    }
+}
 /* v8 ignore start -- spawns the real claude CLI + filesystem; exercised by the
    claude-backed suite, excluded from the deterministic coverage gate (the parse
    helpers above carry the testable logic). */
@@ -338,13 +361,24 @@ function writeFixture(cwd, files, settings) {
         (0, node_fs_1.writeFileSync)((0, node_path_1.join)(cwd, "settings.json"), json);
     }
 }
+/**
+ * The {@link HarnessRunHome} for a run in `cwd`. A throwaway HOME lives under
+ * the run's own temp dir, as the eval tier's does, so `cleanup()` removes it
+ * with everything else.
+ */
+function runHomeIn(cwd, home) {
+    return home === "throwaway"
+        ? { home, dir: (0, node_fs_1.mkdtempSync)((0, node_path_1.join)(cwd, "home-")) }
+        : { home };
+}
 /**
  * Spawn the agent binary against the mock. The mock-wiring *args* are already in
  * `args` (the driver placed `wireMock(url).args` at the correct argv position
- * via `ctx.mockArgs`); here we only layer `wireMock(url).env` over the caller's
- * env. Driver-agnostic at the transport seam.
+ * via `ctx.mockArgs`); here the env is {@link harnessSpawnEnv} of the caller's,
+ * with `wireMock(url).env` on top. Driver-agnostic at the transport seam.
  */
-function spawnAgent(runtime, args, cwd, baseUrl, timeoutMs) {
+function spawnAgent(runtime, args, run) {
+    const { cwd, baseUrl, timeoutMs, home } = run;
     const wired = runtime.wireMock(baseUrl);
     return new Promise((resolvePromise) => {
         // vigiles:free-tier — the deterministic harness tier. `runtime.wireMock`
@@ -354,9 +388,8 @@ function spawnAgent(runtime, args, cwd, baseUrl, timeoutMs) {
         const child = (0, node_child_process_1.spawn)(runtime.agentBinary, [...args], {
             cwd,
             // Any key works — the mock ignores auth. wireMock supplies the overlay
-            // env (base-URL var + dummy key for CC; the dummy key for Codex); layer it
-            // over the caller's env.
-            env: { ...process.env, ...wired.env },
+            // env (base-URL var + dummy key for CC; the dummy key for Codex).
+            env: harnessSpawnEnv(runtime, wired.env, home),
             stdio: ["ignore", "pipe", "pipe"],
         });
         let stdout = "";
@@ -399,6 +432,7 @@ function makeResult(cwd, out, parsed, turns, modelRequests) {
         toolCalls: parsed.toolCalls,
         hooks: parsed.hooks,
         output: parsed.output,
+        ...(parsed.replies === undefined ? {} : { replies: parsed.replies }),
         modelRequests,
         subagents: parseSubagents(out.stdout),
         file: (p) => {
@@ -423,6 +457,17 @@ function makeResult(cwd, out, parsed, turns, modelRequests) {
  * only — requesting confinement for another harness throws.
  */
 async function runHarnessTest(spec, opts = {}) {
+    return runHarnessTestIn(spec, opts, "inherit");
+}
+/**
+ * {@link runHarnessTest} with the run's HOME chosen by the caller — see
+ * {@link HarnessRunHome}. Not on a public entry point: the one caller that needs
+ * a throwaway HOME is vigiles's own preflight (`output-style-arms.ts`), whose
+ * run must not depend on, or act as, the machine it happens to run on. The
+ * confined (bubblewrap) path ignores `home`: it already runs with its own HOME
+ * and a cleared env.
+ */
+async function runHarnessTestIn(spec, opts, home) {
     // Tell the CLI runner this script exercised the harness, so a file that runs
     // NOTHING can be told apart from one that ran and passed. See check-count.ts.
     (0, check_count_js_1.recordCheck)();
@@ -443,12 +488,8 @@ async function runHarnessTest(spec, opts = {}) {
     if (decision.action === "sandbox" && !isClaudeCode) {
         throw new Error(`sandbox not supported for ${driver.runtime.name}: confined execution is Claude Code only. Pass sandbox: false to run ${driver.runtime.name} unconfined (you audited the code, or trust the outer container).`);
     }
+    const { files, settings, check } = fixtureFor(spec, opts.adapter);
     const cwd = (0, tmp_root_js_1.makeTmpDir)("harness");
-    const { files, settings } = (0, plugin_loader_js_1.resolveHarness)({
-        plugin: spec.plugin,
-        settings: spec.settings,
-        files: spec.files,
-    });
     writeFixture(cwd, files, settings);
     const tools = spec.allowedTools ?? ["Read", "Edit", "Write", "Bash"];
     const timeoutMs = spec.timeoutMs ?? 60000;
@@ -481,14 +522,19 @@ async function runHarnessTest(spec, opts = {}) {
         const unconsumed = (0, mock_model_js_1.scriptUnconsumedWarning)(count, sideChannelCount);
         if (unconsumed !== undefined)
             console.error(unconsumed);
-        return makeResult(cwd, out, parseClaudeRun(out.stdout), count, out.requests);
+        return check(makeResult(cwd, out, parseClaudeRun(out.stdout), count, out.requests));
     }
     // Direct path: mock runs in this process; the agent reaches it over localhost.
     // Start the mock first so its URL feeds the driver's mock-wiring args.
     const mock = await driver.startMock(spec.model);
     try {
         const args = buildArgs(driver.runtime.wireMock(mock.url).args);
-        const out = await spawnAgent(driver.runtime, args, cwd, mock.url, timeoutMs);
+        const out = await spawnAgent(driver.runtime, args, {
+            cwd,
+            baseUrl: mock.url,
+            timeoutMs,
+            home: runHomeIn(cwd, home),
+        });
         // A script that was never consumed is otherwise invisible — the run just
         // looks empty. `scriptUnconsumedWarning` names the one shape that produces
         // it (every request arriving without tool declarations, so nothing looked
@@ -496,9 +542,9 @@ async function runHarnessTest(spec, opts = {}) {
         const unconsumed = (0, mock_model_js_1.scriptUnconsumedWarning)(mock.count, mock.sideChannelCount ?? 0);
         if (unconsumed !== undefined)
             console.error(unconsumed);
-        return makeResult(cwd, out, driver.parseRun(out.stdout), mock.count, [
+        return check(makeResult(cwd, out, driver.parseRun(out.stdout), mock.count, [
             ...mock.requests,
-        ]);
+        ]));
     }
     finally {
         await mock.close();
@@ -527,6 +573,52 @@ async function runHarness(spec, opts = {}) {
     }
     return runHarnessTest(spec, opts);
 }
+/**
+ * The fixture to write, and the check its result must pass. Without
+ * `outputStyle` the check returns the result as it is.
+ */
+function fixtureFor(spec, adapter) {
+    // One layout for both phases: the plugin is loaded the way the selected
+    // harness lays it out, the same layout the style is then planned against.
+    const { layout } = adapter ?? adapter_registry_js_1.defaultAdapter;
+    const resolved = (0, plugin_loader_js_1.resolveHarness)({ plugin: spec.plugin, settings: spec.settings, files: spec.files }, layout);
+    if (spec.outputStyle === undefined)
+        return { ...resolved, check: (result) => result };
+    const rules = layout.outputStyles;
+    if (rules === undefined)
+        throw new Error("outputStyle: this harness has no output styles");
+    const plan = (0, output_style_js_1.planStyleRun)(layout, { path: spec.outputStyle, text: readStyleFile(spec.outputStyle) }, resolved);
+    if (plan.kind === "refused")
+        throw new Error(`outputStyle: ${plan.reason}`);
+    return {
+        files: plan.files,
+        settings: plan.settings,
+        check: (result) => {
+            if ((0, output_style_js_1.styleReached)(rules, plan.style, result.modelRequests))
+                return result;
+            throw new Error(`outputStyle: "${plan.style.name ?? ""}" never reached the model — ` +
+                `no request carried it, so the harness did not load it. ` +
+                `Work dir kept for inspection: ${result.cwd}`);
+        },
+    };
+}
+/**
+ * The files and settings a run with `outputStyle` writes — the style at its
+ * place, selected by the name the harness reads from it. The same fixture
+ * `runHarnessTest({ outputStyle })` runs, so an eval arm built from it gets
+ * exactly what that run proved reaches the model.
+ */
+function outputStyleFixture(outputStyle, adapter) {
+    const { files, settings } = fixtureFor({ outputStyle, model: [] }, adapter);
+    return { files, settings };
+}
+/** The style file's text, or a clear error naming the path. */
+function readStyleFile(path) {
+    const abs = (0, node_path_1.resolve)(path);
+    if (!(0, node_fs_1.existsSync)(abs))
+        throw new Error(`outputStyle: no such file: ${path}`);
+    return (0, node_fs_1.readFileSync)(abs, "utf-8");
+}
 /** Pull the pillar-2 driver off an adapter, asserting it supports testing. */
 async function requireDriver(adapter) {
     (0, adapter_conformance_js_1.assertHarnessTestable)(adapter);

package/dist/optimize.js

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

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

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

package/dist/output-style-arms.js

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

package/dist/plugin-declaration.d.ts

@@ -17,12 +17,12 @@
  * boundary is deliberate: plugins "can execute arbitrary code on your machine
  * with your user privileges", so a repo is not allowed to install one for you.
  *
- * The declaration buys exactly one thing, and it is worth having: a collaborator
- * who clones the repo and never runs `vigiles init` currently gets **silence** —
- * the package is in `node_modules`, its six skills are unreachable, and nothing
- * says so. With the declaration, Claude Code tells them the project wants this
- * plugin and prints the command that installs it. **Silent absence becomes a
- * prompt.** It does not become a working install.
+ * The declaration buys exactly one thing: a collaborator who clones the repo is
+ * told the project wants this plugin, with the command that installs it.
+ * **Silent absence becomes a prompt.** It does not become a working install. What
+ * the plugin adds on their machine is the HOOKS; the SKILLS do not depend on it
+ * any more — `init` links them into `.claude/skills/` (`./skill-links.ts`), and
+ * the links travel with the clone.
  *
  * Nothing is vendored: what lands in the repo is a *reference* (a marketplace
  * source plus an enabled flag). The plugin content still lives in the global

package/dist/plugin-declaration.js

@@ -18,12 +18,12 @@
  * boundary is deliberate: plugins "can execute arbitrary code on your machine
  * with your user privileges", so a repo is not allowed to install one for you.
  *
- * The declaration buys exactly one thing, and it is worth having: a collaborator
- * who clones the repo and never runs `vigiles init` currently gets **silence** —
- * the package is in `node_modules`, its six skills are unreachable, and nothing
- * says so. With the declaration, Claude Code tells them the project wants this
- * plugin and prints the command that installs it. **Silent absence becomes a
- * prompt.** It does not become a working install.
+ * The declaration buys exactly one thing: a collaborator who clones the repo is
+ * told the project wants this plugin, with the command that installs it.
+ * **Silent absence becomes a prompt.** It does not become a working install. What
+ * the plugin adds on their machine is the HOOKS; the SKILLS do not depend on it
+ * any more — `init` links them into `.claude/skills/` (`./skill-links.ts`), and
+ * the links travel with the clone.
  *
  * Nothing is vendored: what lands in the repo is a *reference* (a marketplace
  * source plus an enabled flag). The plugin content still lives in the global

package/dist/scan-files.js

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

package/dist/scan.d.ts

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

package/dist/scan.js

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

package/dist/score-core.d.ts

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

package/dist/score-core.js

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