vigiles 2.5.0 → 3.0.0

package/dist/setup-plan.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Pure decision logic for `vigiles init`.
+ *
+ * Turns CLI args + whether a human's at a TTY into a concrete setup PLAN, so the
+ * IO-heavy `setup()` in cli.ts stays a thin shell and every choice is unit-tested.
+ * Best-practice onboarding: **interactive** when a human runs it in a terminal,
+ * **non-interactive** (sensible defaults) for agents / CI / piped input — so
+ * "set up vigiles" from a Claude Code or Codex prompt Just Works without hanging
+ * on a prompt. See docs/agent-setup.md.
+ */
+/** What `vigiles init` will set up. */
+export interface SetupPlan {
+    /** Pillar 1 — verify instruction files (specs, types, compile, audit, hooks). */
+    verify: boolean;
+    /** Pillar 2 — test the harness (scaffold a starter harness test + CI job). */
+    test: boolean;
+    /** Wire CI (the `zernie/vigiles@v1` Action; creates a workflow if none). */
+    gha: boolean;
+    /** Install the Claude Code plugin (hooks + skills). */
+    plugin: boolean;
+    /** Strict rule severities in `.vigilesrc.json`. */
+    strict: boolean;
+}
+/** The explicit choices a user pinned via flags (undefined = "not specified"). */
+export interface ParsedSetupArgs {
+    target?: string;
+    strict: boolean;
+    yes: boolean;
+    pillars?: "verify" | "test" | "both";
+    gha?: boolean;
+    plugin?: boolean;
+}
+/** Parse `init` args into the choices the user pinned. */
+export declare function parseSetupArgs(args: readonly string[]): ParsedSetupArgs;
+/** The non-interactive defaults: both pillars, CI, and the plugin. */
+export declare function defaultPlan(strict?: boolean): SetupPlan;
+/**
+ * Whether to drop into interactive prompts: a human at a TTY who passed neither
+ * `--yes` nor an explicit `--target`, and who hasn't already pinned every choice
+ * via flags. Agents / CI / piped input (no TTY) never prompt.
+ */
+export declare function shouldPrompt(parsed: ParsedSetupArgs, isTTY: boolean): boolean;
+/** Interactive answers (only the fields the prompts cover). */
+export type SetupAnswers = Partial<Pick<SetupPlan, "verify" | "test" | "gha" | "plugin">>;
+/**
+ * Resolve the final plan: defaults, then flags, then interactive answers (each
+ * layer overrides the previous only where it has an opinion). `--target` pins a
+ * bare Pillar-1 spec (no harness scaffold).
+ */
+export declare function resolvePlan(parsed: ParsedSetupArgs, answers?: SetupAnswers): SetupPlan;
+//# sourceMappingURL=setup-plan.d.ts.map

package/dist/setup-plan.js

@@ -0,0 +1,85 @@
+"use strict";
+/**
+ * Pure decision logic for `vigiles init`.
+ *
+ * Turns CLI args + whether a human's at a TTY into a concrete setup PLAN, so the
+ * IO-heavy `setup()` in cli.ts stays a thin shell and every choice is unit-tested.
+ * Best-practice onboarding: **interactive** when a human runs it in a terminal,
+ * **non-interactive** (sensible defaults) for agents / CI / piped input — so
+ * "set up vigiles" from a Claude Code or Codex prompt Just Works without hanging
+ * on a prompt. See docs/agent-setup.md.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSetupArgs = parseSetupArgs;
+exports.defaultPlan = defaultPlan;
+exports.shouldPrompt = shouldPrompt;
+exports.resolvePlan = resolvePlan;
+function flagValue(args, prefix) {
+    return args.find((a) => a.startsWith(prefix))?.slice(prefix.length);
+}
+/** Parse `init` args into the choices the user pinned. */
+function parseSetupArgs(args) {
+    const pillarsRaw = flagValue(args, "--pillars=");
+    const pillars = pillarsRaw === "verify" || pillarsRaw === "test" || pillarsRaw === "both"
+        ? pillarsRaw
+        : undefined;
+    return {
+        target: flagValue(args, "--target="),
+        strict: args.includes("--strict"),
+        yes: args.includes("--yes") || args.includes("-y"),
+        pillars,
+        gha: args.includes("--no-gha") ? false : undefined,
+        plugin: args.includes("--no-plugin") ? false : undefined,
+    };
+}
+/** The non-interactive defaults: both pillars, CI, and the plugin. */
+function defaultPlan(strict = false) {
+    return { verify: true, test: true, gha: true, plugin: true, strict };
+}
+/**
+ * Whether to drop into interactive prompts: a human at a TTY who passed neither
+ * `--yes` nor an explicit `--target`, and who hasn't already pinned every choice
+ * via flags. Agents / CI / piped input (no TTY) never prompt.
+ */
+function shouldPrompt(parsed, isTTY) {
+    if (!isTTY || parsed.yes || parsed.target)
+        return false;
+    const allPinned = parsed.pillars !== undefined &&
+        parsed.gha !== undefined &&
+        parsed.plugin !== undefined;
+    return !allPinned;
+}
+/**
+ * Resolve the final plan: defaults, then flags, then interactive answers (each
+ * layer overrides the previous only where it has an opinion). `--target` pins a
+ * bare Pillar-1 spec (no harness scaffold).
+ */
+function resolvePlan(parsed, answers) {
+    const plan = defaultPlan(parsed.strict);
+    if (parsed.pillars === "verify") {
+        plan.verify = true;
+        plan.test = false;
+    }
+    else if (parsed.pillars === "test") {
+        plan.verify = false;
+        plan.test = true;
+    }
+    if (parsed.gha === false)
+        plan.gha = false;
+    if (parsed.plugin === false)
+        plan.plugin = false;
+    if (parsed.target)
+        plan.test = false;
+    if (answers) {
+        if (answers.verify !== undefined)
+            plan.verify = answers.verify;
+        if (answers.test !== undefined)
+            plan.test = answers.test;
+        if (answers.gha !== undefined)
+            plan.gha = answers.gha;
+        if (answers.plugin !== undefined)
+            plan.plugin = answers.plugin;
+    }
+    return plan;
+}
+//# sourceMappingURL=setup-plan.js.map

package/dist/skill-test.d.ts

@@ -8,7 +8,7 @@
  * gate blocked. The model's prose quality is never asserted — that's the
  * probabilistic boundary; everything else is deterministic and checkable.
  */
-import { type SkillProgram, type GeneratorSkill } from "./skill-driver.js";
+import { type SkillProgram, type GeneratorSkill } from "./adapters/claude-code/skill-driver.js";
 export type ModelFn = (prose: string) => string;
 /**
  * Script the mocked model. Pass:

package/dist/skill-test.js

@@ -12,7 +12,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.scriptModel = scriptModel;
 exports.runSkill = runSkill;
-const skill_driver_js_1 = require("./skill-driver.js");
+const skill_driver_js_1 = require("./adapters/claude-code/skill-driver.js");
 function gateLabel(g) {
     if (g._ref === "cmd")
         return g.command;

package/dist/test-coverage.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Untested-surface detection: the third gap detector, alongside orphan-docs.
+ *
+ * Stale-ref detection catches specs pointing at files that vanished.
+ * Orphan-docs catches docs nothing references. This catches harness *surfaces*
+ * — skills, subagents, and hooks — that ship without a test or eval. A surface
+ * with no test is a probabilistic-compliance gap hiding in the deterministic
+ * layer: nothing measures whether it still does what it claims.
+ *
+ * Two detectors decide "tested", OR'd, so a test placed ANYWHERE counts:
+ *   1. colocation — a `*.{harness,eval}.mjs` next to the surface (the zero-config
+ *      convention the warning suggests): `skills/foo/*.eval.mjs`,
+ *      `agents/bar.harness.mjs`, `hooks/pre-edit.harness.mjs`.
+ *   2. content-reference — any discovered test (incl. `*.test.ts`) that names the
+ *      surface by PATH (`skills/foo`, `hooks/pre-edit.sh`) or NAMESPACE
+ *      (`vigiles:foo`). Not bare-name — too fuzzy.
+ *
+ * Warning-by-default (a nudge, not a gate). User-invoked skills
+ * (`disable-model-invocation: true`) can't auto-trigger, so they're exempt by
+ * default; flip `includeUserInvokedSkills` to demand an outcome test for them.
+ * Per-surface opt-out: a `vigiles:ignore-test` marker in the surface file.
+ */
+export type SurfaceKind = "skill" | "agent" | "hook";
+export interface Surface {
+    readonly kind: SurfaceKind;
+    /** Repo-relative path to the surface file (SKILL.md / agent .md / hook script). */
+    readonly path: string;
+    /** Stable name: skill dir, agent basename, or hook script basename. */
+    readonly name: string;
+    /** Substrings a test may reference to "cover" this surface (path / namespace). */
+    readonly tokens: readonly string[];
+    /** True for skills with `disable-model-invocation: true`. */
+    readonly userInvoked: boolean;
+}
+export interface UntestedReport {
+    /** Total surfaces considered (after exemptions). */
+    readonly total: number;
+    readonly covered: readonly Surface[];
+    readonly untested: readonly Surface[];
+    /** Surfaces skipped (user-invoked skills, `vigiles:ignore-test`). */
+    readonly exempt: number;
+}
+export interface TestCoverageOptions {
+    /** Repository root. Defaults to `process.cwd()`. */
+    readonly basePath?: string;
+    /** Scan skills under `skills/` and `.claude/skills/`. Default true. */
+    readonly skills?: boolean;
+    /** Scan subagents under `agents/` and `.claude/agents/`. Default true. */
+    readonly agents?: boolean;
+    /** Scan hook scripts referenced from plugin.json / settings.json. Default true. */
+    readonly hooks?: boolean;
+    /** Require a test for user-invoked (disable-model-invocation) skills. Default false. */
+    readonly includeUserInvokedSkills?: boolean;
+    /** Globs of test files that count as coverage. */
+    readonly testGlobs?: readonly string[];
+    /** Extra ignore globs (added to node_modules/dist/.git/.vigiles). */
+    readonly exclude?: readonly string[];
+}
+/**
+ * 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
+ * test that references its path/namespace. User-invoked skills are exempt unless
+ * `includeUserInvokedSkills` is set; any surface with a `vigiles:ignore-test`
+ * marker is exempt.
+ */
+export declare function findUntestedSurfaces(options?: TestCoverageOptions): UntestedReport;
+/** Suggested colocated test path for an untested surface (shown in the warning). */
+export declare function suggestedTestPath(surface: Surface): string;
+/** Format an untested-surface report as human-readable text. */
+export declare function formatUntestedReport(report: UntestedReport): string;
+//# sourceMappingURL=test-coverage.d.ts.map

package/dist/test-coverage.js

@@ -0,0 +1,228 @@
+"use strict";
+/**
+ * Untested-surface detection: the third gap detector, alongside orphan-docs.
+ *
+ * Stale-ref detection catches specs pointing at files that vanished.
+ * Orphan-docs catches docs nothing references. This catches harness *surfaces*
+ * — skills, subagents, and hooks — that ship without a test or eval. A surface
+ * with no test is a probabilistic-compliance gap hiding in the deterministic
+ * layer: nothing measures whether it still does what it claims.
+ *
+ * Two detectors decide "tested", OR'd, so a test placed ANYWHERE counts:
+ *   1. colocation — a `*.{harness,eval}.mjs` next to the surface (the zero-config
+ *      convention the warning suggests): `skills/foo/*.eval.mjs`,
+ *      `agents/bar.harness.mjs`, `hooks/pre-edit.harness.mjs`.
+ *   2. content-reference — any discovered test (incl. `*.test.ts`) that names the
+ *      surface by PATH (`skills/foo`, `hooks/pre-edit.sh`) or NAMESPACE
+ *      (`vigiles:foo`). Not bare-name — too fuzzy.
+ *
+ * Warning-by-default (a nudge, not a gate). User-invoked skills
+ * (`disable-model-invocation: true`) can't auto-trigger, so they're exempt by
+ * default; flip `includeUserInvokedSkills` to demand an outcome test for them.
+ * Per-surface opt-out: a `vigiles:ignore-test` marker in the surface file.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findUntestedSurfaces = findUntestedSurfaces;
+exports.suggestedTestPath = suggestedTestPath;
+exports.formatUntestedReport = formatUntestedReport;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const glob_1 = require("glob");
+// ---------------------------------------------------------------------------
+// Internals
+// ---------------------------------------------------------------------------
+const DEFAULT_TEST_GLOBS = [
+    "**/*.harness.mjs",
+    "**/*.eval.mjs",
+    "**/*.test.ts",
+    "**/*.test.mts",
+    "**/*.test.cts",
+    "**/*.test.js",
+    "**/*.test.mjs",
+    "**/*.test.cjs",
+];
+const DEFAULT_IGNORE = [
+    "node_modules/**",
+    "dist/**",
+    ".vigiles/**",
+    ".git/**",
+];
+const IGNORE_MARKER = "vigiles:ignore-test";
+const SCRIPT_RE = /[\w./${}@-]+\.(?:sh|mjs|cjs|js|ts|py|rb)/g;
+function read(path) {
+    try {
+        return (0, node_fs_1.readFileSync)(path, "utf-8");
+    }
+    catch {
+        return "";
+    }
+}
+/** A SKILL.md is user-invoked when its frontmatter sets disable-model-invocation. */
+function isUserInvoked(content) {
+    return /^\s*disable-model-invocation:\s*true\s*$/m.test(content);
+}
+function discoverSkills(basePath, ignore) {
+    const out = [];
+    const found = (0, glob_1.globSync)(["skills/*/SKILL.md", ".claude/skills/*/SKILL.md"], {
+        cwd: basePath,
+        ignore,
+    });
+    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));
+        if (content.includes(IGNORE_MARKER))
+            continue;
+        out.push({
+            kind: "skill",
+            path,
+            name,
+            tokens: [`skills/${name}`, `:${name}`],
+            userInvoked: isUserInvoked(content),
+        });
+    }
+    return out;
+}
+function discoverAgents(basePath, ignore) {
+    const out = [];
+    const found = (0, glob_1.globSync)(["agents/*.md", ".claude/agents/*.md"], {
+        cwd: basePath,
+        ignore,
+    });
+    for (const path of found.sort()) {
+        if (path.endsWith(".spec.ts"))
+            continue;
+        const content = read((0, node_path_1.join)(basePath, path));
+        if (content.includes(IGNORE_MARKER))
+            continue;
+        const name = (0, node_path_1.basename)(path, ".md");
+        const dir = (0, node_path_1.dirname)(path);
+        out.push({
+            kind: "agent",
+            path,
+            name,
+            tokens: [`${dir}/${name}`],
+            userInvoked: false,
+        });
+    }
+    return out;
+}
+/** Hook-script paths referenced from a manifest's `hooks` block (file hooks only). */
+function hookScripts(basePath, manifest) {
+    if (!(0, node_fs_1.existsSync)((0, node_path_1.join)(basePath, manifest)))
+        return [];
+    let hooks;
+    try {
+        hooks = JSON.parse(read((0, node_path_1.join)(basePath, manifest)))
+            .hooks;
+    }
+    catch {
+        return [];
+    }
+    if (hooks === undefined)
+        return [];
+    const text = JSON.stringify(hooks);
+    const scripts = new Set();
+    for (const m of text.matchAll(SCRIPT_RE)) {
+        const rel = m[0]
+            .replace("${CLAUDE_PLUGIN_ROOT}/", "")
+            .replace(/^\$\{CLAUDE_PLUGIN_ROOT\}/, "")
+            .replace(/^\.\//, "");
+        if ((0, node_fs_1.existsSync)((0, node_path_1.join)(basePath, rel)))
+            scripts.add(rel);
+    }
+    return [...scripts];
+}
+function discoverHooks(basePath) {
+    const scripts = new Set();
+    for (const m of [
+        ".claude-plugin/plugin.json",
+        ".claude/settings.json",
+        ".claude/settings.local.json",
+    ]) {
+        for (const s of hookScripts(basePath, m))
+            scripts.add(s);
+    }
+    return [...scripts].sort().map((path) => ({
+        kind: "hook",
+        path,
+        name: (0, node_path_1.basename)(path).replace(/\.[^.]+$/, ""),
+        tokens: [path],
+        userInvoked: false,
+    }));
+}
+function discoverTests(basePath, globs, ignore) {
+    const found = (0, glob_1.globSync)([...globs], { cwd: basePath, ignore });
+    return found.map((path) => ({ path, content: read((0, node_path_1.join)(basePath, path)) }));
+}
+/** Colocated: a test inside a skill dir, or a name-prefixed sibling of an agent/hook. */
+function isColocated(surface, testPath) {
+    if (surface.kind === "skill") {
+        return testPath.startsWith(`${(0, node_path_1.dirname)(surface.path)}/`);
+    }
+    return ((0, node_path_1.dirname)(testPath) === (0, node_path_1.dirname)(surface.path) &&
+        (0, node_path_1.basename)(testPath).startsWith(`${surface.name}.`));
+}
+function isCovered(surface, tests) {
+    for (const t of tests) {
+        if (t.path === surface.path)
+            continue;
+        if (isColocated(surface, t.path))
+            return true;
+        if (surface.tokens.some((tok) => t.content.includes(tok)))
+            return true;
+    }
+    return false;
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * 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
+ * test that references its path/namespace. User-invoked skills are exempt unless
+ * `includeUserInvokedSkills` is set; any surface with a `vigiles:ignore-test`
+ * marker is exempt.
+ */
+function findUntestedSurfaces(options = {}) {
+    const basePath = options.basePath ?? process.cwd();
+    const ignore = [...DEFAULT_IGNORE, ...(options.exclude ?? [])];
+    const globs = options.testGlobs ?? DEFAULT_TEST_GLOBS;
+    const surfaces = [];
+    if (options.skills !== false)
+        surfaces.push(...discoverSkills(basePath, ignore));
+    if (options.agents !== false)
+        surfaces.push(...discoverAgents(basePath, ignore));
+    if (options.hooks !== false)
+        surfaces.push(...discoverHooks(basePath));
+    const considered = surfaces.filter((s) => !s.userInvoked || s.kind !== "skill" || options.includeUserInvokedSkills);
+    const exempt = surfaces.length - considered.length;
+    const tests = discoverTests(basePath, globs, ignore);
+    const covered = [];
+    const untested = [];
+    for (const s of considered) {
+        (isCovered(s, tests) ? covered : untested).push(s);
+    }
+    return { total: considered.length, covered, untested, exempt };
+}
+/** Suggested colocated test path for an untested surface (shown in the warning). */
+function suggestedTestPath(surface) {
+    if (surface.kind === "skill") {
+        return `${(0, node_path_1.dirname)(surface.path)}/${surface.name}.eval.mjs`;
+    }
+    return `${(0, node_path_1.dirname)(surface.path)}/${surface.name}.harness.mjs`;
+}
+/** Format an untested-surface report as human-readable text. */
+function formatUntestedReport(report) {
+    if (report.untested.length === 0) {
+        const tail = report.exempt > 0 ? ` (${String(report.exempt)} exempt)` : "";
+        return `✓ all ${String(report.total)} surface(s) have a test or eval${tail}`;
+    }
+    const lines = [
+        `⚠ ${String(report.untested.length)} surface(s) with no test or eval:`,
+    ];
+    for (const s of report.untested) {
+        lines.push(`    ${s.kind} ${s.path} — add e.g. ${suggestedTestPath(s)}`);
+    }
+    return lines.join("\n");
+}
+//# sourceMappingURL=test-coverage.js.map

package/dist/testing.d.ts

@@ -0,0 +1,12 @@
+/**
+ * `vigiles/testing` — Pillar 2 entry point: the **harness-testing** API. Re-exports
+ * the three tiers — `runHook` (unit), `runHarnessTest` (deterministic), `runEval`
+ * (eval) — plus the runner-agnostic predicates/assertions. Kept deliberately
+ * separate from `vigiles/claude-code` so this surface can stay harness-agnostic as
+ * more harnesses are added. Granular paths (`vigiles/run-hook`, etc.) still work.
+ */
+export * from "./adapters/claude-code/run-hook.js";
+export * from "./adapters/claude-code/harness-test.js";
+export * from "./adapters/claude-code/eval.js";
+export * from "./harness-assert.js";
+//# sourceMappingURL=testing.d.ts.map

package/dist/testing.js

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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 });
+/**
+ * `vigiles/testing` — Pillar 2 entry point: the **harness-testing** API. Re-exports
+ * the three tiers — `runHook` (unit), `runHarnessTest` (deterministic), `runEval`
+ * (eval) — plus the runner-agnostic predicates/assertions. Kept deliberately
+ * separate from `vigiles/claude-code` so this surface can stay harness-agnostic as
+ * more harnesses are added. Granular paths (`vigiles/run-hook`, etc.) still work.
+ */
+__exportStar(require("./adapters/claude-code/run-hook.js"), exports);
+__exportStar(require("./adapters/claude-code/harness-test.js"), exports);
+__exportStar(require("./adapters/claude-code/eval.js"), exports);
+__exportStar(require("./harness-assert.js"), exports);
+//# sourceMappingURL=testing.js.map

package/dist/unit.d.ts

@@ -0,0 +1,17 @@
+/**
+ * `vigiles/unit` — the **no-capability** harness-testing surface.
+ *
+ * Importing from here is a contract: this test needs **no `claude`, no model, no
+ * bubblewrap, no network** — only a process. It is the cheap base of the pyramid:
+ * `runHook` (pipe a synthesized event to a hook and read the block/allow
+ * decision), the bare `Trace` predicates, the `assert*` helpers, and the pure
+ * parsers. A `*.test.ts` should import **only** from here (enforced by lint).
+ *
+ * Higher tiers re-export this one — dependencies point downward only
+ * (e2e → integration → unit), never up. See `vigiles/integration` and
+ * `vigiles/e2e`.
+ */
+export * from "./harness-assert.js";
+export { runHook, parseHookOutput, decideHook, } from "./adapters/claude-code/run-hook.js";
+export type { HookInput, HookOutput, HookRunResult, RunHookOptions, } from "./adapters/claude-code/run-hook.js";
+//# sourceMappingURL=unit.d.ts.map

package/dist/unit.js

@@ -0,0 +1,36 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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.decideHook = exports.parseHookOutput = exports.runHook = void 0;
+/**
+ * `vigiles/unit` — the **no-capability** harness-testing surface.
+ *
+ * Importing from here is a contract: this test needs **no `claude`, no model, no
+ * bubblewrap, no network** — only a process. It is the cheap base of the pyramid:
+ * `runHook` (pipe a synthesized event to a hook and read the block/allow
+ * decision), the bare `Trace` predicates, the `assert*` helpers, and the pure
+ * parsers. A `*.test.ts` should import **only** from here (enforced by lint).
+ *
+ * Higher tiers re-export this one — dependencies point downward only
+ * (e2e → integration → unit), never up. See `vigiles/integration` and
+ * `vigiles/e2e`.
+ */
+__exportStar(require("./harness-assert.js"), exports);
+var run_hook_js_1 = require("./adapters/claude-code/run-hook.js");
+Object.defineProperty(exports, "runHook", { enumerable: true, get: function () { return run_hook_js_1.runHook; } });
+Object.defineProperty(exports, "parseHookOutput", { enumerable: true, get: function () { return run_hook_js_1.parseHookOutput; } });
+Object.defineProperty(exports, "decideHook", { enumerable: true, get: function () { return run_hook_js_1.decideHook; } });
+//# sourceMappingURL=unit.js.map

package/hooks/refs-nudge.sh

@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+# PostToolUse hook — nudge the agent to express references in instruction files
+# (CLAUDE.md / AGENTS.md / SKILL.md) as vigiles marks, so `vigiles audit` can
+# actually verify them. Non-blocking by default; set the `unmarked-refs` rule to
+# "error" in .vigilesrc.json to turn the nudge into a hard block, or to false to
+# disable it. Runs as its OWN PostToolUse entry so its stdout stays clean JSON.
+
+set -uo pipefail
+
+INPUT=$(cat)
+
+# No npx / not a Node project → nothing to do, never disrupt the edit.
+command -v npx >/dev/null 2>&1 || exit 0
+[ -f package.json ] || exit 0
+
+printf '%s' "$INPUT" | npx vigiles refs-hook
+status=${PIPESTATUS[1]}
+
+# Propagate ONLY an explicit block (exit 2). Swallow tool/setup errors so a
+# missing dep or transient failure never blocks the agent's edit.
+if [ "$status" -eq 2 ]; then
+  exit 2
+fi
+exit 0