vigiles 29.1.0 → 30.0.0

package/dist/cli-main.js

@@ -36,8 +36,7 @@ const test_coverage_js_1 = require("./test-coverage.js");
 const scan_js_1 = require("./scan.js");
 const surface_discovery_js_1 = require("./core/surface-discovery.js");
 const scan_trigger_suggest_js_1 = require("./scan-trigger-suggest.js");
-const dialect_drift_js_1 = require("./dialect-drift.js");
-const skill_reachability_js_1 = require("./skill-reachability.js");
+const install_reader_js_1 = require("./core/install-reader.js");
 const plugin_declaration_js_1 = require("./plugin-declaration.js");
 const scan_behavioral_js_1 = require("./scan-behavioral.js");
 const adapter_registry_js_1 = require("./adapter-registry.js");
@@ -1500,7 +1499,7 @@ async function runLint(restArgs, flags, excludes, config) {
     // hand-edit of a compiled subagent slipped past `lint`. A hand-written agent
     // (no hash header) stays a no-op, and require-instructions-spec is filename-
     // scoped to CLAUDE/AGENTS so agents are never falsely flagged as spec-less.
-    const files = findInstructionFiles(restArgs, excludes, adapter.layout.agentDir);
+    const files = findInstructionFiles(restArgs, excludes, adapter.layout.surfaces.agent ?? "");
     // 1. Verify hashes and structure
     if (!silent) {
         if (files.length > 0) {
@@ -2822,7 +2821,26 @@ async function promptSetup() {
         rl.close();
     }
 }
-const KNOWN_INSTRUCTION_FILES = ["CLAUDE.md", "AGENTS.md"];
+/**
+ * The instruction filenames `init` probes for on disk — DERIVED from the
+ * registered adapters, never listed.
+ *
+ * 🔴 THIS IS THE SAME DEFECT CLASS THE PORT REDESIGN REMOVES: a fact restated
+ * by hand beside the registry that owns it. The literal read `["CLAUDE.md",
+ * "AGENTS.md"]` and was correct only because the adapters happen to say that
+ * today — it could not have noticed a third adapter, and it did not notice when
+ * Claude Code's `instructionTargets` GAINED `AGENTS.md` (it was already there
+ * by coincidence).
+ *
+ * `instructionTargets` rather than `layout.instructionFile`, because the
+ * question here is "which files might exist and want a spec", which is every
+ * name a registered harness READS — a repository with only an `AGENTS.md` is
+ * one `init` must still see. Verified identical before and after over the
+ * registry as it stands: union = `["CLAUDE.md", "AGENTS.md"]`.
+ */
+const KNOWN_INSTRUCTION_FILES = [
+    ...new Set(adapter_registry_js_1.ADAPTERS.flatMap((a) => a.dialect.instructionTargets)),
+];
 const KNOWN_OTHER_CONFIGS = {
     ".cursorrules": "Cursor",
     ".github/copilot-instructions.md": "GitHub Copilot",
@@ -2903,13 +2921,20 @@ function detectProject() {
 function determineTargets(detected, targetValue, harnesses) {
     if (targetValue)
         return [targetValue];
-    const targets = [];
-    if (harnesses.includes("claude"))
-        targets.push("CLAUDE.md");
-    if (harnesses.includes("codex"))
-        targets.push("AGENTS.md");
+    // 🔴 WHICH FILE A HARNESS COMPILES INTO IS THE LAYOUT'S ANSWER, not a pair of
+    // name literals here. This read `harnesses.includes("claude") -> "CLAUDE.md"`
+    // and `includes("codex") -> "AGENTS.md"` — the registry restated, in the one
+    // place a third adapter would be forgotten. `getAdapter` is alias-aware, so
+    // the short `"claude"` that `init` uses resolves exactly as it did.
+    //
+    // ITERATING THE REGISTRY, NOT `harnesses`, KEEPS THE ORDER FIXED: the old
+    // code always produced CLAUDE.md before AGENTS.md whatever order the config
+    // listed, and that order reaches the printed spec targets. Verified over all
+    // five inputs (each harness alone, both orders, and none): identical.
+    const selected = new Set(harnesses.map((h) => (0, adapter_registry_js_1.getAdapter)(h)?.name).filter((n) => n !== undefined));
+    const targets = adapter_registry_js_1.ADAPTERS.filter((a) => selected.has(a.name)).map((a) => a.layout.instructionFile);
     if (targets.length === 0)
-        targets.push("CLAUDE.md");
+        targets.push(adapter_registry_js_1.defaultAdapter.layout.instructionFile);
     // Any existing instruction file without a spec also gets one.
     for (const f of detected.instructionFiles) {
         if (!f.hasSpec && !targets.includes(f.path))
@@ -3257,6 +3282,7 @@ function ensureVigilesDevDep() {
  * (`claude`). Everything else passes through trimmed + lowercased. */
 function shortHarness(name) {
     const n = name.trim().toLowerCase();
+    // eslint-disable-next-line no-restricted-syntax -- COMPOSITION ROOT'S OWN UI, not a harness decision: `init` keys its install/plan path on a short form, and this is the one place the two spellings are related. Nothing about the harness is read from the answer.
     return n === "claude-code" ? "claude" : n;
 }
 /** Which harnesses to set up, in precedence order: an explicit `--harness=`
@@ -3631,7 +3657,7 @@ function checkSubagentToolContracts(config, silent, adapter, scanRoot) {
     const sev = (0, types_js_1.ruleSeverity)(config?.rules?.["subagent-tool-contract"]);
     if (!sev)
         return { issues: 0, errors: 0 };
-    if (!adapter.capabilities.subagents) {
+    if (!adapter.subagents) {
         reportNotApplicable("Subagent tool-contract check", "subagents", adapter, silent);
         return { issues: 0, errors: 0 };
     }
@@ -3674,7 +3700,7 @@ function checkHookEvents(config, silent, adapter, scanRoot) {
     const sev = (0, types_js_1.ruleSeverity)(config?.rules?.["hook-events"]);
     if (!sev)
         return { issues: 0, errors: 0 };
-    if (!adapter.capabilities.shellHooks) {
+    if (!adapter.shellHooks) {
         reportNotApplicable("Hook-event check", "shell hooks", adapter, silent);
         return { issues: 0, errors: 0 };
     }
@@ -3705,7 +3731,7 @@ function checkFrontmatterSchema(config, silent, adapter, scanRoot) {
     const sev = (0, types_js_1.ruleSeverity)(config?.rules?.["subagent-frontmatter"]);
     if (!sev)
         return { issues: 0, errors: 0 };
-    if (!adapter.capabilities.subagents) {
+    if (!adapter.subagents) {
         reportNotApplicable("Subagent-frontmatter check", "subagents", adapter, silent);
         return { issues: 0, errors: 0 };
     }
@@ -3818,7 +3844,7 @@ function checkDisallowedTools(config, silent, adapter, scanRoot) {
     const sev = (0, types_js_1.ruleSeverity)(config?.rules?.["disallowed-tools-contract"]);
     if (!sev)
         return { issues: 0, errors: 0 };
-    if (!adapter.capabilities.subagents) {
+    if (!adapter.subagents) {
         reportNotApplicable("Disallowed-tools check", "subagents", adapter, silent);
         return { issues: 0, errors: 0 };
     }
@@ -4102,7 +4128,7 @@ function checkHookBlockIneffective(config, silent, adapter, scanRoot) {
     const sev = (0, types_js_1.ruleSeverity)(config?.rules?.["hook-block-ineffective"]);
     if (!sev)
         return { issues: 0, errors: 0 };
-    if (!adapter.capabilities.shellHooks) {
+    if (!adapter.shellHooks) {
         reportNotApplicable("Hook-block check", "shell hooks", adapter, silent);
         return { issues: 0, errors: 0 };
     }
@@ -4136,7 +4162,7 @@ function checkHookMatcher(config, silent, adapter, scanRoot) {
     const sev = (0, types_js_1.ruleSeverity)(config?.rules?.["hook-matcher"]);
     if (!sev)
         return { issues: 0, errors: 0 };
-    if (!adapter.capabilities.shellHooks) {
+    if (!adapter.shellHooks) {
         reportNotApplicable("Hook-matcher check", "shell hooks", adapter, silent);
         return { issues: 0, errors: 0 };
     }
@@ -4167,7 +4193,7 @@ function checkMcpHookTargets(config, silent, adapter, scanRoot) {
     const sev = (0, types_js_1.ruleSeverity)(config?.rules?.["mcp-hook-target-resolves"]);
     if (!sev)
         return { issues: 0, errors: 0 };
-    if (!adapter.capabilities.shellHooks) {
+    if (!adapter.shellHooks) {
         reportNotApplicable("MCP hook-target check", "shell hooks", adapter, silent);
         return { issues: 0, errors: 0 };
     }
@@ -4199,7 +4225,7 @@ function checkHookScriptExists(config, silent, adapter, scanRoot) {
     const sev = (0, types_js_1.ruleSeverity)(config?.rules?.["hook-script-exists"]);
     if (!sev)
         return { issues: 0, errors: 0 };
-    if (!adapter.capabilities.shellHooks) {
+    if (!adapter.shellHooks) {
         reportNotApplicable("Hook-script existence check", "shell hooks", adapter, silent);
         return { issues: 0, errors: 0 };
     }
@@ -4234,7 +4260,7 @@ function checkMcpToolResolves(config, silent, adapter, scanRoot) {
     const sev = (0, types_js_1.ruleSeverity)(config?.rules?.["mcp-tool-resolves"]);
     if (!sev)
         return { issues: 0, errors: 0 };
-    if (!adapter.capabilities.subagents) {
+    if (!adapter.subagents) {
         reportNotApplicable("MCP tool-resolution check", "subagents", adapter, silent);
         return { issues: 0, errors: 0 };
     }
@@ -4408,7 +4434,6 @@ async function handleMeasure(restArgs, args) {
     const json = args.includes("--json");
     const harnessFlag = harnessFlagFrom(args);
     const adapter = resolveCommandHarness(dir, harnessFlag).adapter;
-    const harness = adapter.name === "codex" ? "codex" : "claude-code";
     const promptsPath = flagValue(args, "--prompts");
     if (!promptsPath) {
         console.error("measure needs --prompts=<file.json> (a map of skill name → { prompts, irrelevant }).");
@@ -4437,13 +4462,13 @@ async function handleMeasure(restArgs, args) {
         concurrency,
         minPrompts: num("--min-prompts"),
         model,
-        harness,
+        adapter,
     });
     const collisions = await (0, scan_behavioral_js_1.measurePluginSelection)(dir, promptSet, {
         concurrency,
         trials: num("--trials"),
         model,
-        harness,
+        adapter,
     });
     if (json) {
         console.log(JSON.stringify({ trigger, collisions }, null, 2));
@@ -5857,25 +5882,34 @@ async function installHookFile(file, adapter, registeredProviders = []) {
             `${(0, hook_install_js_1.hookGateRef)(ref, adapter.layout.projectRootTokens)} || exit ${(0, hook_install_js_1.hookRuntimeMissingExit)((0, hook_program_js_1.dispatchKind)(program))}`,
         dialect: adapter.dialect,
         hookProtocol: adapter.hookProtocol,
-        settingsFormat: adapter.layout.settingsFormat,
+        settings: adapter.layout.settings,
         registeredProviders,
     });
     // Tamper-evident stamp beside the source (one dir → basename is unique).
     (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)((0, hook_runtime_js_1.hookStampPath)(file)), { recursive: true });
     (0, node_fs_1.writeFileSync)((0, hook_runtime_js_1.hookStampPath)(file), JSON.stringify({ file, stamp: compiled.stamp }, null, 2) + "\n");
     // Merge into the harness's native config, idempotently.
-    const format = adapter.layout.settingsFormat;
+    //
+    // 🔴 THREE FORMAT BRANCHES BECAME ZERO, and they were three because the ONE
+    // enum they all read was standing in for two different questions. Reading
+    // and writing the file is the ENCODING (`layout.settings`, a codec); folding
+    // our registrations into what is already there is the entry SHAPE
+    // (`hookProtocol.mergeRegistrations` — CC nests several commands under one
+    // matcher, Codex carries one command per entry). A TOML harness with
+    // CC-shaped entries was expressible under the enum and would have been
+    // merged wrong; neither port can be wrong about its own half.
     const settingsAbs = (0, node_path_1.resolve)(process.cwd(), adapter.layout.settingsPath);
     const existing = (0, node_fs_1.existsSync)(settingsAbs)
-        ? format === "toml"
-            ? (0, toml_1.parse)((0, node_fs_1.readFileSync)(settingsAbs, "utf-8"))
-            : JSON.parse((0, node_fs_1.readFileSync)(settingsAbs, "utf-8"))
+        ? adapter.layout.settings.parse((0, node_fs_1.readFileSync)(settingsAbs, "utf-8"))
         : {};
-    const merged = format === "toml"
-        ? (0, hook_install_js_1.mergeHooksToml)(existing, compiled.hooks, ref)
-        : (0, hook_install_js_1.mergeHooksJson)(existing, compiled.hooks, ref);
+    // `shellHooks` narrows the adapter union: a harness whose hooks are code
+    // modules has no settings block to install into, and the type says so.
+    if (!adapter.shellHooks) {
+        throw new Error(`Harness "${adapter.name}" has no shell-hook settings to install into (hooks are code modules).`);
+    }
+    const merged = adapter.hookProtocol.mergeRegistrations(existing, compiled.hooks, ref);
     (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));
+    (0, node_fs_1.writeFileSync)(settingsAbs, adapter.layout.settings.render(merged));
     // 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
@@ -5900,6 +5934,7 @@ async function installHookFile(file, adapter, registeredProviders = []) {
                 `(stderr at exit 0 goes to the debug log, not the transcript, and the model ` +
                 `never sees it). Injectable here: ${injectable.join(", ") || "(none)"}. ` +
                 `Move the hook to one of those events, or use run() if you meant an action.`;
+        // eslint-disable-next-line no-restricted-syntax -- KEPT ON PURPOSE (design §2 "the eighth site" / §6). This is a per-channel MEASUREMENT STATUS — react output is CONFIRMED only on Claude Code — and there is no port to read it from: `EventCapability` carries `carries`/`honours`/`matcher`/`denyShape` and no verified-status column. The fix is that column, owned by the capability table, not by this port. Until it exists, a name check that says so is honest and a fabricated capability field would not be.
     }
     else if (adapter.name !== "claude-code") {
         if (role === "inject" && !injectable.includes(event)) {
@@ -6191,7 +6226,6 @@ async function runAuditServe(report, adoptable, cliErr) {
  */
 async function runAutoTrigger(dir, report, adapter, args) {
     const json = args.includes("--json");
-    const harness = adapter.name === "codex" ? "codex" : "claude-code";
     const skills = report.skills
         .filter((s) => s.hasDescription && !s.userInvoked && s.description)
         .map((s) => ({ name: s.name, description: s.description ?? "" }));
@@ -6210,7 +6244,7 @@ async function runAutoTrigger(dir, report, adapter, args) {
         minPrompts: audit_prompts_js_1.AUTO_RECALL_COUNT,
         minDistance: audit_prompts_js_1.AUTO_MIN_DISTANCE,
         model,
-        harness,
+        adapter,
         // Discover candidates with the resolved adapter's layout/dialect — a Codex
         // repo's skills live under the Codex layout, not the default CC one.
         layout: adapter.layout,
@@ -6222,14 +6256,14 @@ async function runAutoTrigger(dir, report, adapter, args) {
     // this proves the wrong one actually fires). Only meaningful with ≥2 model-
     // invocable skills (a lone skill can't collide); reuses the same auto prompts.
     const collisions = skills.length >= 2
-        ? await (0, scan_behavioral_js_1.measurePluginSelection)(dir, promptSet, { model, harness })
+        ? await (0, scan_behavioral_js_1.measurePluginSelection)(dir, promptSet, { model, adapter })
         : null;
     // Third behavioral eval (same consent): adversarial-gate — do enforcement-gate
     // skills HOLD when the agent is told to violate them? Auto-derives its own
     // attacks; a no-op (no model calls) when the plugin declares no gate skills.
     const gates = await (0, scan_behavioral_js_1.measureGateAdversarial)(dir, {
         model,
-        harness,
+        adapter,
         layout: adapter.layout,
         dialect: adapter.dialect,
     });
@@ -6264,7 +6298,7 @@ async function runAutoTrigger(dir, report, adapter, args) {
  *
  * Returns `execute` (run the executing checks?) + a `note` to print at the end.
  */
-async function resolveExecution(s, decision, json, harness) {
+async function resolveExecution(s, decision, json, access) {
     if (decision.kind === "run")
         return { execute: true, note: null };
     if (decision.kind === "skip")
@@ -6273,7 +6307,7 @@ async function resolveExecution(s, decision, json, harness) {
             note: json ? null : (0, scan_trigger_suggest_js_1.formatExecuteSkip)(decision.reason),
         };
     // ask — prompt once, then remember the answer.
-    const answer = await askOnce(buildExecuteDisclosure(s, harness));
+    const answer = await askOnce(buildExecuteDisclosure(s, access));
     const yes = /^y(es)?$/i.test(answer); // default NO (executes your hooks / servers)
     rememberAuditMeasure(yes);
     return {
@@ -6284,10 +6318,11 @@ async function resolveExecution(s, decision, json, harness) {
     };
 }
 /** The bundled consent prompt — discloses exactly what will execute (and what it
- *  costs) so the yes is informed. Default NO. Harness-aware: a Codex repo measures
- *  via the codex CLI (not a Claude env var), so the cost wording must not falsely
- *  read "no model access" in exactly the case the prompt is meant to disclose. */
-function buildExecuteDisclosure(s, harness) {
+ *  costs) so the yes is informed. Default NO. Harness-aware WITHOUT knowing which
+ *  harness: the cost wording comes from the driving adapter's own `access`, so a
+ *  repo on any harness is disclosed in that harness's terms — the old version had
+ *  to name Codex to stop the prompt falsely reading "no model access". */
+function buildExecuteDisclosure(s, access) {
     const lines = ["\nRun the executing checks against your harness?"];
     if (s.hasMcp)
         lines.push("  · start your MCP servers — connects to their backends");
@@ -6297,29 +6332,51 @@ function buildExecuteDisclosure(s, harness) {
         const what = s.triggerableSkills >= 2
             ? "measure whether skills fire and collide"
             : "measure whether skills fire";
-        lines.push(`  · ${what} (${triggerCostWording(harness)})`);
+        lines.push(`  · ${what} (${triggerCostWording(access)})`);
     }
     if (s.gateSkills > 0) {
         // The adversarial-gate eval runs the FULL (unstubbed) skill — the most
         // expensive check — so disclose it separately when gate skills are present.
-        lines.push(`  · test whether ${String(s.gateSkills)} enforcement-gate skill${s.gateSkills === 1 ? "" : "s"} hold under pressure — runs the full skill (${triggerCostWording(harness)})`);
+        lines.push(`  · test whether ${String(s.gateSkills)} enforcement-gate skill${s.gateSkills === 1 ? "" : "s"} hold under pressure — runs the full skill (${triggerCostWording(access)})`);
     }
     if (s.adoptableRefs) {
-        lines.push(`  · draft + verify your instruction file's references (${triggerCostWording(harness)})`);
+        lines.push(`  · draft + verify your instruction file's references (${triggerCostWording(access)})`);
     }
     lines.push("Asked once — remembered in .vigilesrc.json. [y/N] ");
     return lines.join("\n");
 }
-/** Cost/availability wording for the trigger tier, per harness. Codex runs on the
- *  codex CLI (its own auth/plan), so it's never gated on a Claude env var. */
-function triggerCostWording(harness) {
-    if (harness === "codex")
-        return "your Codex CLI, $0 metered — skips if `codex` isn't on PATH";
-    return !(0, scan_trigger_suggest_js_1.hasModelAccess)(process.env)
-        ? "needs model access — none detected, will skip"
-        : (0, scan_trigger_suggest_js_1.isMeteredAccess)(process.env)
-            ? "⚠ spends API credits"
-            : "your subscription, $0 metered";
+/**
+ * Cost/availability wording for the trigger tier, read off the DRIVING HARNESS's
+ * own answer instead of branching on its name.
+ *
+ * 🔴 IT REPLACES THREE THINGS AT ONCE: `harness === "codex"`, and the pair of
+ * Claude-env predicates that ran for every other harness. The old Codex arm was a
+ * guess ("skips if `codex` isn't on PATH") because nothing had asked; `access`
+ * asks, so the prompt now discloses what will actually happen.
+ */
+function triggerCostWording(access) {
+    switch (access.kind) {
+        case "none":
+            return `needs model access — none detected, will skip (${access.fix})`;
+        case "metered":
+            return "⚠ spends API credits";
+        case "subscription":
+            return "your subscription, $0 metered";
+    }
+}
+/**
+ * This adapter's answer to "is a real model reachable, and on whose bill".
+ *
+ * A reference-only harness has no executing tier at all, which is a `none` whose
+ * `fix` says so rather than a Claude-shaped credential hint.
+ */
+async function modelAccessFor(adapter) {
+    if (!adapter.harnessTesting)
+        return {
+            kind: "none",
+            fix: `${adapter.name} has no executing-tier driver in this build`,
+        };
+    return (await adapter.liveDriver()).access(process.env);
 }
 /** Run the trigger tier: a curated `--prompts` file, else auto-generated probes. */
 async function runTriggerTier(dir, report, adapter, args) {
@@ -6509,7 +6566,14 @@ async function main() {
             const json = args.includes("--json");
             // A single dir that's a marketplace (e.g. wshobson/agents' 80+ plugins
             // under one marketplace.json) expands into its members and ranks them.
-            const market = dirs.length === 1 ? (0, scan_js_1.inspectMarketplace)((0, node_path_1.resolve)(dirs[0])) : null;
+            // The layout is passed rather than defaulted: `inspectMarketplace` reads
+            // `dirname(layout.manifestPath)`, which is a different directory per
+            // harness, and it used to fall back to the Claude Code layout inside the
+            // harness-agnostic detector. `harnessLayoutFor` is the same resolution
+            // the audit itself uses a few lines down.
+            const market = dirs.length === 1
+                ? (0, scan_js_1.inspectMarketplace)((0, node_path_1.resolve)(dirs[0]), harnessLayoutFor((0, node_path_1.resolve)(dirs[0]), config, harnessFlagFrom(args)))
+                : null;
             // A marketplace whose members are all EXTERNAL expands to nothing, and the
             // fallback below already says what to do about that: the target is the
             // directory itself.
@@ -6659,21 +6723,13 @@ async function main() {
                     if (selection.kind === "notice") {
                         console.log(`⚠ ${selection.notice}`);
                     }
-                    // Freshness: warn if our hand-maintained CC catalog drifted from the
-                    // user's INSTALLED claude-code (read-local, best-effort, never throws).
-                    if (adapter.name === "claude-code") {
-                        const drift = (0, dialect_drift_js_1.formatDialectDrift)((0, dialect_drift_js_1.checkDialectDrift)());
-                        if (drift)
-                            console.log(drift);
-                        // Adoption: this repo depends on vigiles, but can the agent SEE the
-                        // skills it ships? `npm install` drops them in node_modules, which
-                        // Claude Code never scans — the plugin install is what wires them,
-                        // and until it runs the whole teaching surface is silently absent.
-                        // Advisory only (machine state, not repo state) — never scored.
-                        const reach = (0, skill_reachability_js_1.formatSkillReachability)((0, skill_reachability_js_1.checkSkillReachability)(root));
-                        if (reach)
-                            console.log(reach);
-                    }
+                    // Install diagnostics from the DRIVING harness — "is what vigiles
+                    // assumes about this harness's install true on this machine". Advisory
+                    // only (machine state, not repo state), never scored, printed as-is.
+                    // This used to be `if (adapter.name === "claude-code") { …two Claude
+                    // Code checks… }`; the checks were right and the gate was the defect.
+                    for (const line of adapter.advisories((0, install_reader_js_1.buildInstallReader)(adapter, root)))
+                        console.log(line);
                     console.log("");
                 }
                 // The versioned AuditReport is the product boundary — the same JSON the
@@ -6693,12 +6749,19 @@ async function main() {
                 // `Evaluated` ring needs to know whether this run will ever ask the
                 // skill-firing question — see `firingMeasured` below.
                 const isForeign = root !== process.cwd();
+                // ONE read of "can we reach a model, and on whose bill", from the driving
+                // adapter. It replaces a name check OR-ed with one harness's env vars at
+                // four sites below, and the two hard-coded "authenticate the `claude` CLI"
+                // strings that printed whatever harness was driving.
+                const modelAccess = await modelAccessFor(adapter);
                 const surfaces = {
                     hasMcp: report.mcp && !isForeign,
                     triggerableSkills: report.skills.filter((s) => s.hasDescription && !s.userInvoked).length,
                     gateSkills: (0, scan_behavioral_js_1.detectGateSkills)(report.skills).length,
-                    adoptableRefs: adapter.name === "claude-code" &&
-                        (0, node_fs_1.existsSync)((0, node_path_1.resolve)(root, adapter.layout.instructionFile)),
+                    // NOT gated on a harness name any more. The drafter is the adapter's
+                    // own eval driver and the verifier is deterministic and harness-free,
+                    // so an instruction file is an instruction file: prose, on any harness.
+                    adoptableRefs: (0, node_fs_1.existsSync)((0, node_path_1.resolve)(root, adapter.layout.instructionFile)),
                 };
                 // `decideExecute` is PURE and prompt-free, so the read-vs-run outcome can
                 // be known before anything prints. Only a settled `run` (a remembered yes)
@@ -6718,7 +6781,7 @@ async function main() {
                 });
                 const firingMeasured = execDecision.kind === "run" &&
                     surfaces.triggerableSkills > 0 &&
-                    (adapter.name === "codex" || (0, scan_trigger_suggest_js_1.hasModelAccess)(process.env));
+                    modelAccess.kind !== "none";
                 // The report scaffold WITHOUT the rule map — the map's catalog
                 // enrichment (enabled-state / "documented but OFF") enumerates the repo's
                 // linter, which is gated on the SAME audit.measure consent as the
@@ -6814,7 +6877,7 @@ async function main() {
                 // that isn't shipped, so it lives in the vigiles testing API.)
                 // `surfaces` + `execDecision` were resolved above (the ring needed them);
                 // this only turns an `ask` into a prompt and remembers the answer.
-                const { execute, note: execNote } = await resolveExecution(surfaces, execDecision, json, adapter.name);
+                const { execute, note: execNote } = await resolveExecution(surfaces, execDecision, json, modelAccess);
                 // Consent is now settled (and remembered via .vigilesrc.json, which
                 // computeRuleRouting re-reads) — route the prose rules, enumerating the
                 // live catalog when consented + own-repo. Feeds the JSON report, the
@@ -6881,17 +6944,14 @@ async function main() {
                 // of the same consent (`execute`), and only when a model is reachable;
                 // otherwise it's a one-line note (never a hang).
                 if (execute && surfaces.triggerableSkills > 0) {
-                    // Model-access detection is per-harness: `hasModelAccess` reads Claude
-                    // env (claude CLI / ANTHROPIC_API_KEY). A Codex repo authenticates the
-                    // codex CLI instead, so we DON'T gate it on a Claude var — the Codex
-                    // probe checks `codexDriver.available()` internally and self-reports
-                    // unavailable. (harness-parity: never block Codex behind a CC check.)
-                    const modelReachable = adapter.name === "codex" || (0, scan_trigger_suggest_js_1.hasModelAccess)(process.env);
-                    if (modelReachable) {
+                    // The adapter answered this once, above. `fix` is THIS harness's own
+                    // sentence: the string here used to say "authenticate the `claude` CLI
+                    // or set ANTHROPIC_API_KEY" whatever harness the repo was on.
+                    if (modelAccess.kind !== "none") {
                         await runTriggerTier(targets[0], report, adapter, args);
                     }
                     else if (!json) {
-                        console.log("\nℹ skill firing not measured — no model access (authenticate the `claude` CLI or set ANTHROPIC_API_KEY).");
+                        console.log(`\nℹ skill firing not measured — no model access (${modelAccess.fix}).`);
                     }
                 }
                 // The adoption preview — "what would vigiles catch in YOUR repo?" The model
@@ -6899,34 +6959,52 @@ async function main() {
                 // VERIFIES each, so "M broken right now" is trustworthy though the extraction
                 // is probabilistic. Same consent as the trigger tier (`surfaces.adoptableRefs`
                 // makes a bare instruction-file repo consent-eligible — the prime adoption
-                // target). v1: instruction-file only; drafting drives the `claude` CLI, so
-                // `adoptableRefs` is Claude Code only (the Codex deferral note is printed
-                // below as a LOUD harness-parity deferral, never a silent CC-only path).
+                // target).
+                //
+                // 🔴 NO LONGER CLAUDE CODE ONLY, and the feature gate that said so is
+                // gone rather than widened. The drafter is the driving adapter's own eval
+                // driver (`draftWith`); the verifier was always deterministic and
+                // harness-free. What made this CC-only was that `defaultDraft` defaulted
+                // to the Claude runner and parser and nobody had passed anything else —
+                // a TODO, which the old `adapter.name === "claude-code"` froze into the
+                // report as if it were a vendor fact.
                 let adoptabilityResult;
                 if (execute && surfaces.adoptableRefs) {
-                    if ((0, scan_trigger_suggest_js_1.hasModelAccess)(process.env)) {
+                    if (modelAccess.kind !== "none" && adapter.harnessTesting) {
                         const instrPath = (0, node_path_1.resolve)(root, adapter.layout.instructionFile);
-                        adoptabilityResult = await (0, adoptability_js_1.runAdoptabilityTier)({
-                            instructionContent: (0, node_fs_1.readFileSync)(instrPath, "utf-8"),
-                            basePath: root,
-                        });
-                        if (!json)
-                            console.log("\n" +
-                                (0, adoptability_js_1.formatAdoptability)(adoptabilityResult, adapter.layout.instructionFile));
+                        // 🔴 CAUGHT, because a FAILED RUN and an EMPTY RESULT are different
+                        // answers and this tier used to print the second for both. It
+                        // reaches the harness binary directly — no behavioral probe in
+                        // front of it to self-report unavailability — so on a machine
+                        // without that CLI the drafter would exit non-zero with no output
+                        // and the report would say "no machine-verifiable references
+                        // found". `DraftRunFailed` is thrown for exactly that; anything
+                        // else is a real bug and is left to propagate.
+                        try {
+                            adoptabilityResult = await (0, adoptability_js_1.runAdoptabilityTier)({
+                                instructionContent: (0, node_fs_1.readFileSync)(instrPath, "utf-8"),
+                                basePath: root,
+                                draft: (0, adoptability_js_1.draftWith)((await adapter.liveDriver()).evalDriver),
+                            });
+                            if (!json)
+                                console.log("\n" +
+                                    (0, adoptability_js_1.formatAdoptability)(adoptabilityResult, adapter.layout.instructionFile));
+                        }
+                        catch (e) {
+                            if (!(e instanceof adoptability_js_1.DraftRunFailed))
+                                throw e;
+                            if (!json)
+                                console.log(`\nℹ adoptability not measured — ${e.message}.`);
+                        }
                     }
                     else if (!json && surfaces.triggerableSkills === 0) {
                         // Only when the trigger tier didn't already print the same note.
-                        console.log("\nℹ adoptability not measured — no model access (authenticate the `claude` CLI or set ANTHROPIC_API_KEY).");
+                        console.log(`\nℹ adoptability not measured — no model access (${modelAccess.kind === "none" ? modelAccess.fix : `${adapter.name} has no executing-tier driver`}).`);
                     }
                 }
-                // LOUD harness-parity deferral: adoptability drafting drives the `claude`
-                // CLI, so a Codex repo with an instruction file is told it's a follow-up,
-                // never silently skipped (research/adoption-gateway-preview.md, increment 4).
-                if (!json &&
-                    adapter.name === "codex" &&
-                    (0, node_fs_1.existsSync)((0, node_path_1.resolve)(root, adapter.layout.instructionFile))) {
-                    console.log("\nℹ adoptability preview (what vigiles would catch in your repo) is Claude Code only for now — Codex support is a follow-up.");
-                }
+                // The "adoptability preview is Claude Code only for now — Codex support
+                // is a follow-up" note used to print here. It is DELETED, not reworded:
+                // Codex is not a follow-up, so there is nothing to defer.
                 // The loud read-vs-run nudge for a headless / remembered-no skip — printed
                 // AFTER the report so the deterministic read leads.
                 if (execNote)