vigiles 11.0.0 → 12.0.0

package/.claude-plugin/plugin.json

@@ -39,6 +39,15 @@
             "command": "bash ${CLAUDE_PLUGIN_ROOT}/hooks/refs-nudge.sh"
           }
         ]
+      },
+      {
+        "matcher": "Edit|Write",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash ${CLAUDE_PLUGIN_ROOT}/hooks/eval-lock-nudge.sh"
+          }
+        ]
       }
     ],
     "SessionStart": [

package/README.md

@@ -197,7 +197,8 @@ stray `git push` is caught before it happens. No model, no key, on every commit.
 _"65% fewer tokens." Says who?_ vigiles[^name] A/Bs the claim on real coding tasks and reports
 the token bill, whether it hit its target, and whether the code still works. promptfoo
 and DeepEval bill **per token, every run**; vigiles runs on your own Claude Pro/Max
-subscription. **[Measure a skill →](docs/measuring-skills.md)**
+subscription. Evals run locally — a committed lock then lets **CI catch stale results with no
+model call**. **[Measure a skill →](docs/measuring-skills.md)**
 
 ## Quick start
 
@@ -225,13 +226,17 @@ npx vigiles init   # adopts your files (non-destructive — eject reverses), add
 
 Interactive in a terminal, non-interactive for agents/CI (or `--yes`).
 
-**You don't hand-write any of this — your agent does.** `init` installs
-model-invocable skills, so a plain-English ask does the work:
+**Adoption is smooth: one command, then your agent does the rest.** `init` installs
+the **skills and hooks**, so a plain-English ask does the work — no specs to
+hand-write, no hooks to wire:
 
-- _"test my skills"_ → scaffolds **and runs** a trigger/behaviour test (`test-harness`)
+- _"test my skills"_ → scaffolds **and runs** a trigger/behaviour test, then commits its result so CI can check it (`test-harness`)
 - _"harden my rules"_ → upgrades prose guidance into enforced linter rules (`strengthen`)
 - _"add a rule to my CLAUDE.md"_ → edits the source and recompiles (`edit-spec`)
 
+The **hooks** keep it honest in-loop — nudging the agent to mark a reference or
+refresh a stale eval — so there are no chores to remember.
+
 <details>
 <summary>What <code>init</code> sets up</summary>
 

package/action.yml

@@ -7,7 +7,11 @@ branding:
 
 inputs:
   command:
-    description: "Which vigiles command to run: 'lint' (verify references + integrity + coverage) or 'compile' (specs → markdown)."
+    description: >
+      Which vigiles command to run: 'lint' (verify references + integrity +
+      coverage), 'compile' (specs → markdown), or 'eval-check' (verify committed
+      eval locks against current inputs — the staleness gate; runs NO model, so
+      it is the CI-safe half of evals you produce locally with `vigiles eval --update`).
     required: false
     default: "lint"
   paths:
@@ -65,7 +69,14 @@ runs:
         set -euo pipefail
 
         cmd="${VIGILES_COMMAND:-lint}"
-        args=("$cmd")
+        # 'eval-check' is the CI staleness gate — it maps to the real verb
+        # `eval --check` (verify committed locks vs current inputs, NO model).
+        # Real evals run locally on a subscription (`eval --update`), never in CI.
+        if [[ "$cmd" == "eval-check" ]]; then
+          args=("eval" "--check")
+        else
+          args=("$cmd")
+        fi
 
         # paths: split on commas and whitespace into positional args.
         paths="${VIGILES_PATHS:-}"

package/dist/adapter-conformance.js

@@ -67,6 +67,12 @@ function checkAdapterConformance(adapter) {
         need(adapter.hookProtocol !== undefined, "capabilities.shellHooks is true but hookProtocol is missing");
         if (adapter.hookProtocol) {
             need(Number.isInteger(adapter.hookProtocol.blockExitCode), "hookProtocol.blockExitCode is not an integer");
+            // A shell-hook harness must declare WHICH events can inject developer
+            // context (`additionalContext`). Encoding it makes "can this harness
+            // deliver an inject hook?" a tested contract — the gap that let Codex's
+            // inject support sit unverified in prose. Empty would mean the harness
+            // can't inject context from a hook at all; every harness we support can.
+            need(adapter.hookProtocol.injectableEvents.length > 0, "hookProtocol.injectableEvents is empty — a shell-hook harness must declare the events that honor additionalContext injection (or it can't deliver an inject/nudge hook)");
             portNames.push(["hookProtocol", adapter.hookProtocol.name]);
         }
     }

package/dist/adapter-registry.d.ts

@@ -83,4 +83,24 @@ export declare function resolveHarnessSelection(opts: {
     flag?: string;
     configHarness?: string | readonly string[];
 }): HarnessSelection;
+/**
+ * The FULL adapter set a compile-time INSTALL should fan out to. Unlike
+ * `resolveHarnessSelection` (which picks ONE dialect for a single-output compile,
+ * since you emit a markdown file in one harness's format), an install writes the
+ * SAME artifact into EVERY enabled harness's native config — so a repo targeting
+ * both harnesses gets a compiled hook in `.claude/settings.json` AND
+ * `.codex/config.toml`, not just the first. Precedence mirrors the single picker:
+ *
+ *   1. `--harness=` flag → just that one (an explicit override is singular).
+ *   2. config `harness` list → ALL of them (the multi-harness fan-out).
+ *   3. no config → auto-detect → the one detected.
+ *
+ * Returns ≥1 adapter, de-duplicated by name (a config that lists a harness twice,
+ * or an alias + its canonical, collapses to one install).
+ */
+export declare function resolveHarnessAdapters(opts: {
+    root: string;
+    flag?: string;
+    configHarness?: string | readonly string[];
+}): HarnessAdapter[];
 //# sourceMappingURL=adapter-registry.d.ts.map

package/dist/adapter-registry.js

@@ -9,6 +9,7 @@ exports.adapterForInstructionFile = adapterForInstructionFile;
 exports.resolveAdapter = resolveAdapter;
 exports.normalizeHarnessList = normalizeHarnessList;
 exports.resolveHarnessSelection = resolveHarnessSelection;
+exports.resolveHarnessAdapters = resolveHarnessAdapters;
 const adapter_js_1 = require("./adapters/claude-code/adapter.js");
 const adapter_js_2 = require("./adapters/codex/adapter.js");
 /** The default adapter when detection finds no harness markers. */
@@ -127,4 +128,30 @@ function resolveHarnessSelection(opts) {
     }
     return { kind: "ok", adapter: det.adapter };
 }
+/**
+ * The FULL adapter set a compile-time INSTALL should fan out to. Unlike
+ * `resolveHarnessSelection` (which picks ONE dialect for a single-output compile,
+ * since you emit a markdown file in one harness's format), an install writes the
+ * SAME artifact into EVERY enabled harness's native config — so a repo targeting
+ * both harnesses gets a compiled hook in `.claude/settings.json` AND
+ * `.codex/config.toml`, not just the first. Precedence mirrors the single picker:
+ *
+ *   1. `--harness=` flag → just that one (an explicit override is singular).
+ *   2. config `harness` list → ALL of them (the multi-harness fan-out).
+ *   3. no config → auto-detect → the one detected.
+ *
+ * Returns ≥1 adapter, de-duplicated by name (a config that lists a harness twice,
+ * or an alias + its canonical, collapses to one install).
+ */
+function resolveHarnessAdapters(opts) {
+    const { root, flag, configHarness } = opts;
+    if (flag !== undefined && flag !== "")
+        return [resolveAdapter(root, flag)];
+    const list = normalizeHarnessList(configHarness);
+    const adapters = list.length > 0
+        ? list.map((h) => resolveAdapter(root, h))
+        : [detectAdapterResult(root).adapter];
+    const seen = new Set();
+    return adapters.filter((a) => !seen.has(a.name) && seen.add(a.name));
+}
 //# sourceMappingURL=adapter-registry.js.map

package/dist/adapters/claude-code/hook-protocol.js

@@ -6,5 +6,9 @@ exports.claudeCodeHookProtocol = {
     blockExitCode: 2,
     denyDecisionValues: ["block", "deny"],
     eventEnvVars: [],
+    // Events that honor `hookSpecificOutput.additionalContext` (developer-context
+    // injection). Covers vigiles's shipped inject hooks: the SessionStart lint
+    // summary and the PostToolUse refs / eval-lock nudges.
+    injectableEvents: ["SessionStart", "UserPromptSubmit", "PostToolUse"],
 };
 //# sourceMappingURL=hook-protocol.js.map

package/dist/adapters/claude-code/runtime.js

@@ -22,6 +22,18 @@ exports.claudeCodeRuntime = {
             },
         };
     },
+    /**
+     * Claude Code keys on **major.minor**: a minor/major bump is where the system
+     * prompt + tool defs actually move (0.2 → 1.0 → 2.0 → 2.1, ~quarterly), while
+     * the daily patch stream rarely changes behavior — so keying patches would
+     * churn the cache for no signal. Falls back to the trimmed raw string when no
+     * semver is found. (If a specific patch is known to matter, clear the cache or
+     * bump `CACHE_FORMAT_VERSION`.)
+     */
+    versionKey(raw) {
+        const m = /(\d+)\.(\d+)\.\d+/.exec(raw);
+        return m ? `${m[1]}.${m[2]}` : raw.trim();
+    },
 };
 /**
  * Build the spawn env that points the agent CLI at the mock model: the caller's

package/dist/adapters/codex/eval.js

@@ -195,6 +195,9 @@ exports.codexEvalDriver = {
     runner: codexEvalAgentRunner,
     parse: parseCodexEvalRun,
     runError: codexRunError,
+    // The harness identity → folded into the trigger-rate lock hash, so a report
+    // recorded on Claude Code is STALE if the eval is switched to Codex (and v.v.).
+    harness: "codex",
 };
 /**
  * Spawn real `codex exec --json` for the eval tier (real model, the user's codex

package/dist/adapters/codex/hook-protocol.d.ts

@@ -1,9 +1,17 @@
 /**
- * codexHookProtocol — EXPERIMENTAL, internal-only. Codex's hook wire protocol.
+ * codexHookProtocol — Codex's hook wire protocol.
  * Finding: it is essentially IDENTICAL to Claude Code's (exit 2 / `decision:block`
  * / `permissionDecision:deny`) — the thin `HookProtocol` port was the right call.
  * The genuine deltas are the env vars a hook receives + the TOML config format
  * (the latter lives in PluginLayout.settingsFormat, not here).
+ *
+ * Context injection (`hookSpecificOutput.additionalContext`) is ALSO shared — same
+ * shape, confirmed against the official Codex hooks docs
+ * (developers.openai.com/codex/hooks): supported on SessionStart, UserPromptSubmit,
+ * PreToolUse, PostToolUse, SubagentStart. (Earlier docs called this "deferred" —
+ * it is not.) So vigiles's PostToolUse nudges + SessionStart summary deliver on
+ * Codex unchanged. Caveats: Stop/SubagentStop/PreCompact carry no context, and
+ * Codex marks a hook run failed if it emits an unsupported field for the event.
  */
 import type { HookProtocol } from "../../core/hook-protocol.js";
 export declare const codexHookProtocol: HookProtocol;

package/dist/adapters/codex/hook-protocol.js

@@ -8,6 +8,16 @@ exports.codexHookProtocol = {
     // Codex matchers are anchored regexes (`matcher = "^Bash$"`), unlike Claude
     // Code's exact tool name / `A|B` alternation.
     matcherStyle: "regex",
+    // Events that honor `hookSpecificOutput.additionalContext` on Codex, per the
+    // official hooks docs. Includes the events vigiles's shipped hooks use
+    // (PostToolUse, SessionStart), so those nudges reach the Codex agent too.
+    injectableEvents: [
+        "SessionStart",
+        "UserPromptSubmit",
+        "PreToolUse",
+        "PostToolUse",
+        "SubagentStart",
+    ],
     eventEnvVars: [
         "session_id",
         "cwd",

package/dist/adapters/codex/runtime.js

@@ -22,6 +22,16 @@ exports.codexRuntime = {
     wireMock(baseUrl) {
         return { args: codexMockArgs(baseUrl), env: codexMockEnv() };
     },
+    /**
+     * Codex opts OUT of version partitioning (`""`). It is perpetual `0.x` where
+     * the *minor* is the patch cadence (~2 bumps/week, 134 minors in 14 months), so
+     * keying `major.minor` like Claude Code would churn the cache/lock weekly. With
+     * no stable behavior boundary in the version string, Codex relies on the dated
+     * model id + `evalApiVersion` for staleness instead. See research/cache-invalidation.md.
+     */
+    versionKey(_raw) {
+        return "";
+    },
 };
 /**
  * The PROVEN `-c` flag array that points `codex exec` at a mock served at

package/dist/adapters/opencode/runtime.js

@@ -17,5 +17,9 @@ exports.opencodeRuntime = {
             },
         };
     },
+    /** Prototype: opts out of version partitioning (like Codex). */
+    versionKey(_raw) {
+        return "";
+    },
 };
 //# sourceMappingURL=runtime.js.map

package/dist/cli-commands.d.ts

@@ -13,7 +13,7 @@
 /** Human-facing verbs (printed in help; typed by a human/agent/CI). */
 export declare const VERBS: readonly ["init", "compile", "eject", "lint", "test", "eval", "audit", "scaffold-test", "generate", "hook-runtime"];
 /** Runtime entrypoint kinds under `vigiles hook-runtime <kind>` (emitted, not typed). */
-export declare const HOOK_RUNTIME_KINDS: readonly ["run-program", "agent", "agent-start", "agent-done", "skill", "skill-tool", "skill-start", "skill-done", "run-skill", "intercept-tool", "guard", "action", "refs", "effect-enter", "effect-exit"];
+export declare const HOOK_RUNTIME_KINDS: readonly ["run-program", "agent", "agent-start", "agent-done", "skill", "skill-tool", "skill-start", "skill-done", "run-skill", "intercept-tool", "guard", "action", "refs", "eval-lock-nudge", "effect-enter", "effect-exit"];
 export type Verb = (typeof VERBS)[number];
 export type HookRuntimeKind = (typeof HOOK_RUNTIME_KINDS)[number];
 //# sourceMappingURL=cli-commands.d.ts.map

package/dist/cli-commands.js

@@ -41,6 +41,7 @@ exports.HOOK_RUNTIME_KINDS = [
     "guard",
     "action",
     "refs",
+    "eval-lock-nudge",
     "effect-enter",
     "effect-exit",
 ];

package/dist/cli.js

@@ -17,6 +17,7 @@ const generate_types_js_1 = require("./core/generate-types.js");
 const generate_harness_js_1 = require("./core/generate-harness.js");
 const capability_diff_js_1 = require("./core/capability-diff.js");
 const validate_js_1 = require("./core/validate.js");
+const eval_lock_js_1 = require("./eval-lock.js");
 const cli_flags_js_1 = require("./cli-flags.js");
 const setup_plan_js_1 = require("./setup-plan.js");
 const types_js_1 = require("./core/types.js");
@@ -1601,7 +1602,19 @@ function specReferencedElsewhere(specFile, ejectedFile) {
 /** Full GitHub Actions workflow that wires the production `zernie/vigiles@v1`
  * Action (lint pillar) and, when the test pillar is set up, a deterministic
  * harness job. */
-function vigilesWorkflow(plan) {
+/** The npm package(s) that provide each harness's CLI binary — the deterministic
+ * harness tier spawns the real agent CLI against a mock model (no API key). A repo
+ * targeting both harnesses installs both. */
+function harnessTestBinaries(harnesses) {
+    const pkgs = [];
+    if (harnesses.includes("claude"))
+        pkgs.push("@anthropic-ai/claude-code");
+    if (harnesses.includes("codex"))
+        pkgs.push("@openai/codex");
+    // Fall back to Claude Code if the set is somehow empty (back-compatible default).
+    return (pkgs.length > 0 ? pkgs : ["@anthropic-ai/claude-code"]).join(" ");
+}
+function vigilesWorkflow(plan, harnesses) {
     const harness = plan.test
         ? `
   harness:
@@ -1615,8 +1628,23 @@ function vigilesWorkflow(plan) {
         with:
           node-version: "20"
       - run: npm install
-      - run: npm i -g @anthropic-ai/claude-code # mock tier needs the binary, no API key
+      - run: npm i -g ${harnessTestBinaries(harnesses)} # mock tier needs the binary, no API key
       - run: npx vigiles test
+
+  eval-check:
+    # Eval staleness gate — real-model evals run LOCALLY on your subscription
+    # (\`npx vigiles eval --update\`, which commits a lock); this job VERIFIES those
+    # committed results against the current inputs with NO model call. It stays a
+    # green no-op until you commit your first lock. See docs/harness-testing.md.
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: "20"
+      - uses: zernie/vigiles@v1
+        with:
+          command: eval-check
 `
         : "";
     return `name: vigiles
@@ -1687,7 +1715,7 @@ function rewriteRemovedSubcommands(content) {
  * commit hint). An existing workflow is never clobbered unless `--force`, but a
  * STALE one (old bare-`npx vigiles` API, or a removed subcommand) is reported
  * loudly instead of silently skipped — and rewritten in place with `--force`. */
-function wireGha(plan) {
+function wireGha(plan, harnesses) {
     const dir = (0, node_path_1.resolve)(process.cwd(), ".github", "workflows");
     const path = (0, node_path_1.resolve)(dir, "vigiles.yml");
     const rel = ".github/workflows/vigiles.yml";
@@ -1708,7 +1736,7 @@ function wireGha(plan) {
         }
         else if (workflowUsesStaleApi(content)) {
             if (plan.force) {
-                (0, node_fs_1.writeFileSync)(path, vigilesWorkflow(plan));
+                (0, node_fs_1.writeFileSync)(path, vigilesWorkflow(plan, harnesses));
                 console.log(`✓ Regenerated ${rel} (was a stale bare \`npx vigiles\`)`);
                 return [rel];
             }
@@ -1724,7 +1752,7 @@ function wireGha(plan) {
     }
     if (!(0, node_fs_1.existsSync)(dir))
         (0, node_fs_1.mkdirSync)(dir, { recursive: true });
-    (0, node_fs_1.writeFileSync)(path, vigilesWorkflow(plan));
+    (0, node_fs_1.writeFileSync)(path, vigilesWorkflow(plan, harnesses));
     console.log("✓ Created .github/workflows/vigiles.yml (uses zernie/vigiles@v1)");
     return [".github/workflows/vigiles.yml"];
 }
@@ -2130,6 +2158,36 @@ function installPlugins(harnesses) {
         console.log("");
         reportInstall(plan, runInstall(plan, exec));
     }
+    // Claude Code gets its hooks from the global marketplace plugin; Codex has no
+    // global store, so wire vigiles's proactive nudge hooks into the repo's
+    // .codex/config.toml directly (the idiomatic, repo-committed place).
+    if (harnesses.includes("codex"))
+        wireCodexHooks();
+}
+/**
+ * Wire vigiles's proactive nudge hooks into `.codex/config.toml` (idempotently).
+ * Codex honors `additionalContext` on `PostToolUse`, and these run as direct
+ * `npx vigiles hook-runtime …` commands (no plugin root / vendored script), so a
+ * Codex user gets the same eval-lock + refs nudges a Claude Code user gets from
+ * the marketplace plugin. The pure merge is `applyCodexPluginHooks` (unit-tested
+ * in setup-plan.test.ts) — this only does the read/parse/write IO.
+ */
+function wireCodexHooks() {
+    const path = (0, node_path_1.resolve)(process.cwd(), ".codex", "config.toml");
+    let config = {};
+    if ((0, node_fs_1.existsSync)(path)) {
+        try {
+            config = (0, toml_1.parse)((0, node_fs_1.readFileSync)(path, "utf-8"));
+        }
+        catch {
+            console.log("⚠ .codex/config.toml is not valid TOML — skipping Codex hook wiring (fix it, then re-run `vigiles init`).");
+            return;
+        }
+    }
+    const merged = (0, setup_plan_js_1.applyCodexPluginHooks)(config);
+    (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(path), { recursive: true });
+    (0, node_fs_1.writeFileSync)(path, (0, hook_install_js_1.serializeConfig)(merged, "toml"));
+    console.log("✓ Wired the eval-lock + refs nudge hooks into .codex/config.toml (commit it)");
 }
 /** Add/upgrade `vigiles` in the project's `devDependencies` (and move it out of
  * `dependencies` if it's there). Returns the files it wrote (for the commit
@@ -2293,7 +2351,7 @@ async function setup(args) {
     // CI — the production Action (+ a harness job when Pillar 2 is on).
     if (plan.gha) {
         console.log("");
-        written.push(...wireGha(plan));
+        written.push(...wireGha(plan, harnesses));
     }
     // Plugin/skill install — per-harness (Claude marketplace / Codex direct).
     if (plan.plugin) {
@@ -3406,10 +3464,55 @@ async function handleGenerateHarness(args, restArgs) {
  * tier needs it, just like the node:test suite). `--trials=N` is forwarded to
  * eval scripts via the `VIGILES_TRIALS` env var.
  */
+/**
+ * Resolve the eval LOCK env from the `eval` flags. `--update` records each named
+ * eval's report to a committed `.vigiles/eval-locks/<name>.lock.json` (run locally
+ * on your subscription); `--check` (CI) verifies the committed result against the
+ * current inputs WITHOUT a model call. `--check` is a green NO-OP until the first
+ * lock is committed (smooth adoption). Returns the env to thread, or `"skip"` to
+ * exit green now. `--check`+`--update` together is a usage error (exit 2). The
+ * behavior epoch comes from `.vigilesrc.json` `eval.apiVersion` (committed).
+ */
+function resolveEvalLockEnv(args) {
+    const wantCheck = args.includes("--check");
+    const wantUpdate = args.includes("--update");
+    if (wantCheck && wantUpdate) {
+        console.error("vigiles eval: --check and --update are mutually exclusive (one verifies, one records).");
+        process.exit(2);
+    }
+    if (wantCheck &&
+        !(0, eval_lock_js_1.anyLocksCommitted)((0, node_path_1.resolve)(process.cwd(), eval_lock_js_1.DEFAULT_LOCK_DIR))) {
+        console.log("ℹ vigiles eval --check: no committed eval locks found — nothing to verify.\n" +
+            "  Run `vigiles eval --update` locally (on your subscription) and commit the\n" +
+            "  lock to enable the CI staleness gate.");
+        return "skip";
+    }
+    const env = {};
+    if (wantCheck)
+        env.VIGILES_EVAL_LOCK = "check";
+    if (wantUpdate)
+        env.VIGILES_EVAL_LOCK = "update";
+    if (wantCheck || wantUpdate) {
+        const apiVersion = (0, validate_js_1.loadConfig)().eval?.apiVersion;
+        if (apiVersion !== undefined)
+            env.VIGILES_EVAL_API_VERSION = String(apiVersion);
+    }
+    return env;
+}
 function handleRunScripts(kind, args, restArgs) {
     const cwd = process.cwd();
     // Harness/eval scripts may be authored in JS or TS (see run-scripts.ts).
     const defaultGlob = (0, run_scripts_js_1.scriptGlob)(kind === "test" ? "harness" : "eval");
+    // The eval LOCK flags (`--check`/`--update`) are resolved BEFORE file discovery
+    // so mutual-exclusion + the cold-start no-op are honored regardless of file
+    // count. Returns the env to thread to scripts, or `"skip"` to exit green now.
+    let lockEnv = {};
+    if (kind === "eval") {
+        const r = resolveEvalLockEnv(args);
+        if (r === "skip")
+            return;
+        lockEnv = r;
+    }
     const files = (0, run_scripts_js_1.discoverScripts)(restArgs, defaultGlob, cwd);
     // `--min=N`: a CI gate asserts at least N scripts actually RAN — so a bad path,
     // a renamed file, or a glob that matched nothing fails LOUD instead of passing
@@ -3438,7 +3541,7 @@ function handleRunScripts(kind, args, restArgs) {
     // it's part of the measurement definition, so it belongs in the spec
     // (`model` / `minModel`), version-controlled, not a hidden override.
     const trialsFlag = args.find((a) => a.startsWith("--trials="));
-    const env = {};
+    const env = { ...lockEnv };
     if (trialsFlag)
         env.VIGILES_TRIALS = trialsFlag.split("=")[1];
     console.log(`Running ${String(files.length)} ${kind} file(s):\n`);
@@ -3617,6 +3720,8 @@ function printUsage(command) {
     console.log("                                 --serve opens a LIVE local report whose buttons create specs in one click (own repo only; loopback + token-guarded) · --no-serve to skip the prompt");
     console.log("  vigiles test [files...]        Run *.harness.mjs deterministic harness tests");
     console.log("  vigiles eval [files...]        Run *.eval.mjs real-model harness evals (--trials=N, --min=N, --no-skip)");
+    console.log("                                 --update records each named eval's result to a committed lock (run locally on your subscription)");
+    console.log("                                 --check verifies committed eval results against current inputs WITHOUT a model — the CI staleness gate");
     console.log("  vigiles scaffold-test [dir]    Generate a starter test for each untested skill/agent/hook (--write, --json)");
     console.log("");
     console.log("Examples:");
@@ -3932,6 +4037,9 @@ async function handleHookRuntime(kind, restArgs) {
         case "refs":
             refsHookCommand();
             return;
+        case "eval-lock-nudge":
+            evalLockNudgeHookCommand();
+            return;
         case "effect-enter":
             (0, effect_region_js_1.setEffectActive)(process.cwd());
             console.log("Effect boundary entered.");
@@ -3978,6 +4086,45 @@ const INSTRUCTION_FILE = /^(SKILL|CLAUDE|AGENTS)\.md$/;
 function isInstructionFile(file) {
     return INSTRUCTION_FILE.test((0, node_path_1.basename)(file));
 }
+/**
+ * PostToolUse-hook entrypoint: when the agent edits an eval input (a `SKILL.md`
+ * trigger surface or an `*.eval.*` script), and committed eval locks exist, inject
+ * a NON-BLOCKING reminder to re-run `vigiles eval --update`. Self-gating (silent
+ * until a lock is committed), never blocks, never runs an eval — a reminder, not a
+ * gate (the gate is `eval --check` in CI). The harness-neutral nudge lives in
+ * `evalLockNudge`; both CC and Codex deliver it as `additionalContext` on
+ * `PostToolUse` (confirmed — see docs/harness-testing-codex.md).
+ */
+function evalLockNudgeHookCommand() {
+    let raw = "";
+    try {
+        raw = (0, node_fs_1.readFileSync)(0, "utf-8");
+    }
+    catch {
+        /* no stdin → nothing to do */
+    }
+    let file = "";
+    try {
+        const j = JSON.parse(raw);
+        file = j.tool_input?.file_path ?? "";
+    }
+    catch {
+        /* malformed → nothing to do */
+    }
+    if (!file)
+        return;
+    const cwd = process.cwd();
+    const target = (0, node_path_1.relative)(cwd, (0, node_path_1.resolve)(cwd, file)) || file;
+    const msg = (0, eval_lock_js_1.evalLockNudge)(target, (0, node_path_1.resolve)(cwd, eval_lock_js_1.DEFAULT_LOCK_DIR));
+    if (!msg)
+        return;
+    process.stdout.write(JSON.stringify({
+        hookSpecificOutput: {
+            hookEventName: "PostToolUse",
+            additionalContext: msg,
+        },
+    }) + "\n");
+}
 /**
  * PostToolUse-hook entrypoint: when the agent edits an instruction file, force
  * every code reference to carry a file-qualified mark (`path.ext#symbol`) and
@@ -4153,31 +4300,63 @@ async function installHookFile(file, adapter, registeredProviders = []) {
         : (0, hook_install_js_1.mergeHooksJson)(existing, compiled.hooks, file);
     (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(settingsAbs), { recursive: true });
     (0, node_fs_1.writeFileSync)(settingsAbs, (0, hook_install_js_1.serializeConfig)(merged, format));
-    // Honest gap (no silent skips): the gate/deny path is exit-2 and cross-harness,
-    // but an inject/react hook's OUTPUT shape is confirmed only for Claude Code. On
-    // another harness it would emit CC-shaped output that may not be read — exactly
-    // the silent failure this feature exists to prevent. Flag it, loudly.
+    // No silent skips: warn loudly only where a hook's OUTPUT genuinely may not
+    // apply on this harness. INJECT's `additionalContext` shape is now CONFIRMED
+    // shared with Codex (per the official hooks docs), so an inject hook only
+    // warns when its event isn't in the harness's `injectableEvents`. REACT's
+    // output is still Claude-Code-confirmed only. The gate (deny→exit 2) path is
+    // cross-harness and never warns.
     const role = (0, hook_program_js_1.dispatchKind)(program);
-    const warning = adapter.name !== "claude-code" && (role === "inject" || role === "react")
-        ? `${role} output is only confirmed for Claude Code. On ${adapter.name}, ` +
-            `the gate (deny→exit 2) path works, but this hook's ${role} output is ` +
-            `CC-shaped and unverified — it may silently not apply. Use a gate hook on ` +
-            `${adapter.name} for now, or confirm against the real binary first ` +
-            `(research/compiled-hooks-codex.md §Deferred).`
-        : undefined;
+    const event = typeof program.on === "string" ? program.on : "";
+    const injectable = adapter.hookProtocol?.injectableEvents ?? [];
+    const matcher = (0, hook_program_js_1.hookRouting)(program).matcher;
+    let warning;
+    if (adapter.name !== "claude-code") {
+        if (role === "inject" && !injectable.includes(event)) {
+            warning =
+                `this inject hook targets "${event}", which ${adapter.name} does not ` +
+                    `honor for additionalContext — the injected text won't reach the agent. ` +
+                    `Use an event ${adapter.name} supports: ${injectable.join(", ")}.`;
+        }
+        else if (role === "react") {
+            warning =
+                `react output is confirmed only for Claude Code; on ${adapter.name} this ` +
+                    `hook's react output is unverified (the gate deny→exit 2 path IS ` +
+                    `cross-harness). Confirm against the real binary first.`;
+        }
+        else if (matcher !== undefined) {
+            // A tool-matched gate carries TOOL NAMES in its matcher. vigiles does not
+            // yet translate tool vocabularies across dialects, so a matcher authored
+            // with Claude Code names (`Edit`/`Write`/`Bash`) won't fire on a harness
+            // that names the same tools differently (Codex: `apply_patch`/`shell`).
+            // Warn LOUDLY rather than report a silently-non-firing success.
+            warning =
+                `this hook matches tool(s) "${matcher}" — if those are Claude Code tool ` +
+                    `names, they may not match ${adapter.name}'s vocabulary (e.g. ` +
+                    `apply_patch/shell), so the hook may not fire. Verify the matcher uses ` +
+                    `${adapter.name}'s tool names (cross-dialect matcher translation is not ` +
+                    `yet automatic).`;
+        }
+    }
     return { role, settingsPath: adapter.layout.settingsPath, warning };
 }
 /**
  * Compile + install every hook (explicit paths, else discovered under
- * `.vigiles/hooks/`) into the active harness's config. Returns false if any
- * hook failed to compile.
+ * `.vigiles/hooks/`) into EVERY enabled harness's config. A typed hook is
+ * harness-neutral, so when a repo targets both harnesses the SAME hook is merged
+ * into `.claude/settings.json` AND `.codex/config.toml` (each in its native
+ * format, with per-harness warnings) — never just the first. The harness set is
+ * resolved from the `--harness=` flag, else `config.harness`, else auto-detect.
+ * Returns false if any hook failed to compile for any harness.
  */
-async function installHooks(hookFiles, harnessFlag) {
+async function installHooks(hookFiles, harnessFlag, configHarness) {
     if (hookFiles.length === 0)
         return true;
-    const adapter = harnessFlag
-        ? (0, adapter_registry_js_1.resolveAdapter)(process.cwd(), harnessFlag)
-        : (0, adapter_registry_js_1.detectAdapterResult)(process.cwd()).adapter;
+    const adapters = (0, adapter_registry_js_1.resolveHarnessAdapters)({
+        root: process.cwd(),
+        flag: harnessFlag,
+        configHarness,
+    });
     // Validate registered providers first → the names a hook's provider() ref may
     // resolve to (an unsafe provider fails the whole compile, like a bad hook).
     let registeredProviders;
@@ -4194,10 +4373,13 @@ async function installHooks(hookFiles, harnessFlag) {
     let ok = true;
     for (const file of hookFiles) {
         try {
-            const r = await installHookFile(file, adapter, registeredProviders);
-            console.log(`✓ ${file} → ${r.settingsPath} (role: ${r.role}, harness: ${adapter.name})`);
-            if (r.warning)
-                console.warn(`⚠ ${r.warning}`);
+            // Fan out: the same compiled hook lands in each enabled harness's config.
+            for (const adapter of adapters) {
+                const r = await installHookFile(file, adapter, registeredProviders);
+                console.log(`✓ ${file} → ${r.settingsPath} (role: ${r.role}, harness: ${adapter.name})`);
+                if (r.warning)
+                    console.warn(`⚠ ${r.warning}`);
+            }
         }
         catch (e) {
             if (e instanceof hook_program_js_1.HookCompileError) {
@@ -4781,7 +4963,7 @@ async function main() {
             let valid = true;
             if (specs.length > 0)
                 valid = (await compile(specs, config, { harnessFlag })) && valid;
-            valid = (await installHooks(hooks, harnessFlag)) && valid;
+            valid = (await installHooks(hooks, harnessFlag, config.harness)) && valid;
             // Keep an existing whole-harness registry in sync (cheap, opt-in) so the
             // user never hand-runs `generate-harness`. Skipped when no harness.gen.ts.
             if (specs.length > 0)