vigiles 29.0.0 → 30.0.0

package/dist/scan-behavioral.js

@@ -40,38 +40,72 @@ const scan_js_1 = require("./scan.js");
 const audit_prompts_js_1 = require("./audit-prompts.js");
 const judge_js_1 = require("./judge.js");
 const eval_js_1 = require("./eval.js");
-const harness_assert_js_1 = require("./harness-assert.js");
-const harness_test_js_1 = require("./harness-test.js");
+// eslint-disable-next-line local/no-harness-names -- IMPORT PATH, not a decision: this module is the application layer that drives a real harness binary, and Claude Code is the documented DEFAULT for candidate discovery. The rule flags the module path the way it flags `scan.ts`'s (rule header, "three are the import specifiers"); what it is guarding against — a name-driven BRANCH — is gone from this file.
 const plugin_loader_js_1 = require("./adapters/claude-code/plugin-loader.js");
-const eval_js_2 = require("./adapters/codex/eval.js");
-const driver_js_1 = require("./adapters/codex/driver.js");
+// The Claude Code default for candidate DISCOVERY. This module is the
+// application layer (it drives a real harness binary and already imports the
+// Claude Code loader above), which is where a default belongs — `src/scan.ts`
+// and `src/test-coverage.ts` are the harness-agnostic detectors, and they no
+// longer carry one.
+// eslint-disable-next-line local/no-harness-names -- IMPORT PATH, not a decision: this module is the application layer that drives a real harness binary, and Claude Code is the documented DEFAULT for candidate discovery. The rule flags the module path the way it flags `scan.ts`'s (rule header, "three are the import specifiers"); what it is guarding against — a name-driven BRANCH — is gone from this file.
+const layout_js_1 = require("./adapters/claude-code/layout.js");
+// eslint-disable-next-line local/no-harness-names -- IMPORT PATH, not a decision: this module is the application layer that drives a real harness binary, and Claude Code is the documented DEFAULT for candidate discovery. The rule flags the module path the way it flags `scan.ts`'s (rule header, "three are the import specifiers"); what it is guarding against — a name-driven BRANCH — is gone from this file.
+const dialect_js_1 = require("./adapters/claude-code/dialect.js");
+const live_driver_js_1 = require("./core/live-driver.js");
+const adapter_registry_js_1 = require("./adapter-registry.js");
 const tmp_root_js_1 = require("./core/tmp-root.js");
-function buildProbe(dir, harness) {
-    if (harness === "codex") {
-        return {
-            evalDriver: eval_js_2.codexEvalDriver,
-            firedFor: (name) => (t) => (0, eval_js_2.codexSkillFired)(t, name),
-            // Codex stubbing of a non-Claude plugin isn't validated; install the real
-            // skills (firing is the SKILL.md read, detected regardless of body).
-            stub: false,
-            available: () => driver_js_1.codexDriver.available(),
-        };
-    }
-    const ns = pluginName(dir);
-    return {
-        evalDriver: eval_js_1.claudeEvalDriver,
-        firedFor: (name) => (t) => (0, harness_assert_js_1.skillResolved)(t, ns ? `${ns}:${name}` : name),
-        stub: true,
-        available: harness_test_js_1.claudeAvailable,
-    };
+/**
+ * Resolve the adapter driving a behavioral measurement.
+ *
+ * 🔴 THE ONE SANCTIONED STRING→ADAPTER CONVERSION. `opts.adapter` is the way in;
+ * the deprecated `harness` NAME is accepted for one release because
+ * `SelectionOptions` is public API (`vigiles/claude-code`), and it is resolved
+ * HERE, through the registry, rather than compared to a literal anywhere.
+ */
+function adapterFor(opts) {
+    return (opts.adapter ??
+        (opts.harness ? (0, adapter_registry_js_1.getAdapter)(opts.harness) : undefined) ??
+        adapter_registry_js_1.defaultAdapter);
+}
+/**
+ * The executing-tier wiring for one adapter: its live driver plus the CLI-presence
+ * gate. This is what `buildProbe(dir, harness)` used to switch on a NAME to build;
+ * both halves now come off the adapter, so adding a harness adds no branch here.
+ *
+ * ⚠️ `available` IS THE BINARY PROBE, NOT `liveDriver.access(env)`, and the
+ * difference is load-bearing. `access` answers "is a model reachable and on whose
+ * bill" — for Claude Code that is an env-only read by design (deciding whether to
+ * OFFER a measurement must not spend a token), which is NOT the same question as
+ * "is the CLI installed". Routing this gate through `access` would make the
+ * behavioral column go dark for anyone driving a logged-in `claude` from a plain
+ * shell with none of the env vars set, and light up for anyone with a key but no
+ * binary. The CLI-presence fact already has exactly one home — `available` on the
+ * MOCK-tier driver, which is the same binary and the same probe both tiers need
+ * (`claudeAvailable` / `codexDriver.available`, the two functions `buildProbe`
+ * itself called) — so it is read from there rather than copied onto a second port.
+ */
+async function probeFor(adapter) {
+    if (!adapter.harnessTesting)
+        return null;
+    const [live, test] = await Promise.all([
+        adapter.liveDriver(),
+        adapter.harnessTestDriver(),
+    ]);
+    // Wrapped rather than handed over bare: an extracted method loses its `this`.
+    return { live, available: () => test.available() };
 }
-/** Plugin name from `.claude-plugin/plugin.json` (the skill id's namespace). */
-function pluginName(dir) {
-    const p = (0, node_path_1.join)(dir, ".claude-plugin", "plugin.json");
+/**
+ * The plugin manifest's `name` — the namespace a harness may prefix onto a skill
+ * id. Read through the LAYOUT's path and codec, never a `.claude-plugin` literal,
+ * so a TOML-manifest harness is read with its own parser.
+ */
+function manifestName(dir, layout) {
+    const p = (0, node_path_1.join)(dir, layout.manifestPath);
     if (!(0, node_fs_1.existsSync)(p))
         return null;
     try {
-        return (JSON.parse((0, node_fs_1.readFileSync)(p, "utf-8")).name ?? null);
+        const parsed = layout.settings.parse((0, node_fs_1.readFileSync)(p, "utf-8"));
+        return typeof parsed.name === "string" ? parsed.name : null;
     }
     catch {
         return null;
@@ -115,15 +149,15 @@ async function probeSkill(ctx, name, ps) {
     try {
         const r = await (0, eval_js_1.measureTriggerRate)({
             pluginDir: ctx.dir,
-            stubSkillBodies: ctx.probe.stub,
+            stubSkillBodies: ctx.live.installsStubs,
             prompts: ps.prompts,
             irrelevantPrompts: ps.irrelevant,
             minPrompts: ctx.opts.minPrompts,
             minDistance: ctx.opts.minDistance,
             model: ctx.opts.model,
             concurrency: ctx.opts.concurrency,
-            fired: ctx.probe.firedFor(name),
-        }, { evalDriver: ctx.probe.evalDriver });
+            fired: ctx.live.firedFor(name, ctx.plugin),
+        }, { evalDriver: ctx.live.evalDriver });
         return {
             skill: name,
             measured: true,
@@ -144,13 +178,19 @@ async function probeSkill(ctx, name, ps) {
     }
 }
 /** The injectable core (for tests): probe every model-invocable skill that has prompts. */
-async function probePluginTriggersWith(dir, promptSet, probe, opts = {}) {
-    const ctx = { dir, opts, probe };
+async function probePluginTriggersWith(dir, promptSet, live, opts = {}) {
+    const layout = opts.layout ?? layout_js_1.claudeCodeLayout;
+    const ctx = {
+        dir,
+        opts,
+        live,
+        plugin: { name: manifestName(dir, layout) },
+    };
     // Only model-invocable, describable skills can auto-trigger; user-invoked and
     // description-less ones can't, so they're not behavioral candidates. Discover
     // them with the resolved layout/dialect (default CC) so a Codex repo's skills
     // aren't missed by the wrong layout.
-    const candidates = (0, scan_js_1.scanPlugin)(dir, opts.layout, opts.dialect).skills.filter((s) => !s.userInvoked && s.hasDescription);
+    const candidates = (0, scan_js_1.scanPlugin)(dir, layout, opts.dialect ?? dialect_js_1.claudeCodeDialect).skills.filter((s) => !s.userInvoked && s.hasDescription);
     const results = [];
     for (const s of candidates) {
         const ps = promptSet[s.name];
@@ -166,14 +206,14 @@ async function probePluginTriggersWith(dir, promptSet, probe, opts = {}) {
     }
     return {
         available: true,
-        results: relabelTriggerArtifact(dir, probe, results),
-        experimental: probe.evalDriver.experimental,
+        results: relabelTriggerArtifact(dir, live, results),
+        experimental: live.evalDriver.experimental,
     };
 }
 /** Relabel an all-zero-recall stubbed run on a hooked plugin as unmeasured (Layer 1). */
-function relabelTriggerArtifact(dir, probe, results) {
+function relabelTriggerArtifact(dir, live, results) {
     const recalls = results.filter((r) => r.measured).map((r) => r.recall ?? 0);
-    if (!isStubbedHookArtifact(dir, probe.stub, recalls))
+    if (!isStubbedHookArtifact(dir, live.installsStubs, recalls))
         return [...results];
     return results.map((r) => r.measured && (r.recall ?? 0) === 0
         ? { skill: r.skill, measured: false, note: HOOK_PRIMED_NOTE }
@@ -185,10 +225,10 @@ function relabelTriggerArtifact(dir, probe, results) {
  * `available: false` otherwise.
  */
 async function probePluginTriggers(dir, promptSet, opts = {}) {
-    const probe = buildProbe(dir, opts.harness ?? "claude-code");
-    if (!probe.available())
+    const probe = await probeFor(adapterFor(opts));
+    if (!probe?.available())
         return { available: false, results: [] };
-    return probePluginTriggersWith(dir, promptSet, probe, opts);
+    return probePluginTriggersWith(dir, promptSet, probe.live, opts);
 }
 const pct = (x) => `${(x * 100).toFixed(0)}%`;
 /** Format the behavioral column as a scan-report section. */
@@ -307,9 +347,17 @@ function selectionJobs(candidates, promptSet, trials) {
         return ps.prompts.flatMap((prompt) => Array.from({ length: trials }, () => ({ intended: c.name, prompt })));
     });
 }
-/** The injectable core (for tests): drive the matrix via a fake/real probe. */
+/**
+ * The injectable core (for tests): drive the matrix via a fake/real driver.
+ *
+ * 🔴 IT TAKES AN {@link EventFiringDriver}, NOT ANY LIVE DRIVER, AND THAT IS THE
+ * RATCHET. The matrix asks WHICH of the plugin's skills fired on each prompt; a
+ * harness that only INFERS firing cannot answer that, and the old guard was a
+ * name check in the wrapper below — invisible to anyone calling this core
+ * directly. Now an inferred driver is a compile error at every call site.
+ */
 async function measurePluginSelectionWith(dir, promptSet, probe, opts = {}) {
-    const candidates = (0, scan_js_1.scanPlugin)(dir).skills.filter((s) => !s.userInvoked && s.hasDescription);
+    const candidates = (0, scan_js_1.scanPlugin)(dir, opts.layout ?? layout_js_1.claudeCodeLayout, opts.dialect ?? dialect_js_1.claudeCodeDialect).skills.filter((s) => !s.userInvoked && s.hasDescription);
     const skills = candidates.map((c) => c.name);
     if (skills.length < 2) {
         return {
@@ -328,7 +376,7 @@ async function measurePluginSelectionWith(dir, promptSet, probe, opts = {}) {
     // Selection is decided at the frontmatter (the selector picks BEFORE the body
     // loads), so stub each body to a no-op: the run stops AT selection instead of
     // executing the whole workflow — the same affordability trick trigger-rate uses.
-    const pluginDir = probe.stub ? (0, eval_js_1.stubbedPluginDir)(dir) : dir;
+    const pluginDir = probe.installsStubs ? (0, eval_js_1.stubbedPluginDir)(dir) : dir;
     try {
         const d = probe.evalDriver;
         const outcomes = await (0, eval_js_1.runPool)(jobs, Math.max(1, opts.concurrency ?? 1), (job) => (0, eval_js_1.runSkillSelectionTrial)({
@@ -356,38 +404,50 @@ async function measurePluginSelectionWith(dir, promptSet, probe, opts = {}) {
         // dropped-hook artifact — flag it instead of presenting a 0%-collision result
         // computed from a plugin that never fired.
         const recalls = report.perSkill.filter((s) => s.n > 0).map((s) => s.recall);
-        return isStubbedHookArtifact(dir, probe.stub, recalls)
+        return isStubbedHookArtifact(dir, probe.installsStubs, recalls)
             ? { ...report, note: HOOK_PRIMED_NOTE }
             : report;
     }
     finally {
-        if (probe.stub)
+        if (probe.installsStubs)
             (0, node_fs_1.rmSync)(pluginDir, { recursive: true, force: true });
     }
 }
+/**
+ * Why the matrix cannot run on this harness — the DRIVER's own reason, carried
+ * verbatim, rather than a sentence written at the call site next to a name check.
+ */
+function selectionUnavailableNote(name, live) {
+    if (!live)
+        return `selection-collision needs an executing-tier driver, which ${name} does not have`;
+    const why = live.firing.kind === "inferred" ? live.firing.caveat : "no firing event";
+    return `selection-collision needs a discrete skill-selection event, which ${name} does not emit (${why})`;
+}
 /**
  * Measure a plugin's cross-skill selection-collision matrix against the real
  * harness (Claude Code only — Codex has no skill-selection event). Needs the
  * `claude` CLI + model auth; degrades to `available: false` otherwise.
  */
 async function measurePluginSelection(dir, promptSet, opts = {}) {
-    const harness = opts.harness ?? "claude-code";
-    if (harness !== "claude-code") {
+    const adapter = adapterFor(opts);
+    const probe = await probeFor(adapter);
+    // The n/a reason now comes from the DRIVER's own firing signal and carries the
+    // driver's own caveat, instead of being a name check with the reason inlined.
+    if (!probe || !(0, live_driver_js_1.isEventFiring)(probe.live)) {
         return {
             ...emptySelection([]),
             available: false,
-            note: `selection-collision is Claude Code only (no skill-selection event on ${harness})`,
+            note: selectionUnavailableNote(adapter.name, probe?.live),
         };
     }
-    const probe = buildProbe(dir, harness);
     if (!probe.available()) {
         return {
             ...emptySelection([]),
             available: false,
-            note: "needs the claude CLI + model auth",
+            note: `needs the ${adapter.name} CLI + model auth`,
         };
     }
-    return measurePluginSelectionWith(dir, promptSet, probe, opts);
+    return measurePluginSelectionWith(dir, promptSet, probe.live, opts);
 }
 /** Format the selection-collision matrix as a scan-report section. */
 function formatSelectionReport(r) {
@@ -437,7 +497,7 @@ async function measureSelectionMatrixWith(dir, probe, opts = {}) {
  * model-invocable skills' descriptions (the zero-setup path). */
 function resolveSelectionPrompts(dir, opts) {
     return (opts.prompts ??
-        (0, audit_prompts_js_1.autoTriggerPrompts)((0, scan_js_1.scanPlugin)(dir)
+        (0, audit_prompts_js_1.autoTriggerPrompts)((0, scan_js_1.scanPlugin)(dir, opts.layout ?? layout_js_1.claudeCodeLayout, opts.dialect ?? dialect_js_1.claudeCodeDialect)
             .skills.filter((s) => !s.userInvoked && s.hasDescription)
             .map((s) => ({ name: s.name, description: s.description ?? "" }))));
 }
@@ -637,29 +697,33 @@ function judgeGateReal(a) {
  * hold vs cave. Claude Code only; degrades to `available: false` without the CLI/auth.
  */
 async function measureGateAdversarial(dir, opts = {}) {
-    const harness = opts.harness ?? "claude-code";
-    if (harness !== "claude-code") {
+    const adapter = adapterFor(opts);
+    const probe = await probeFor(adapter);
+    // Same gate as the collision matrix and for the same reason: the attack is only
+    // meaningful once the gate skill has actually been SELECTED, which an inferred
+    // firing signal cannot establish. Read off the driver, not off a name.
+    if (!probe || !(0, live_driver_js_1.isEventFiring)(probe.live)) {
         return {
             available: false,
             results: [],
-            note: `adversarial-gate is Claude Code only (no Skill selection on ${harness})`,
+            note: `adversarial-gate needs a discrete skill-selection event, which ${adapter.name} does not emit`,
         };
     }
-    const probe = buildProbe(dir, harness);
     if (!probe.available()) {
         return {
             available: false,
             results: [],
-            note: "needs the claude CLI + model auth",
+            note: `needs the ${adapter.name} CLI + model auth`,
         };
     }
-    const skills = (0, scan_js_1.scanPlugin)(dir, opts.layout, opts.dialect).skills;
+    const skills = (0, scan_js_1.scanPlugin)(dir, opts.layout ?? layout_js_1.claudeCodeLayout, opts.dialect ?? dialect_js_1.claudeCodeDialect).skills;
     const gateNames = new Set(detectGateSkills(skills));
     const gates = skills
         .filter((s) => gateNames.has(s.name))
         .map((s) => ({ name: s.name, description: s.description ?? "" }));
     const deps = {
-        driver: eval_js_1.claudeEvalDriver,
+        // The driving adapter's own eval transport, not a hard-wired Claude one.
+        driver: probe.live.evalDriver,
         judge: judgeGateReal,
         derive: deriveAttackReal,
     };

package/dist/scan-core.js

@@ -142,18 +142,35 @@ function escapeRe(s) {
     return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function makeClassifier(layout) {
-    // An empty dir means "this harness has no such surface" → never matches.
+    // An ABSENT dir means "this harness has no such surface" → never matches.
+    // (`""` used to mean the same thing; a `Partial<Record<SurfaceKind, string>>`
+    // has one spelling for it, so this takes `string | undefined` and the empty
+    // string is no longer a value any layout can supply.)
     const at = (dir) => dir ? `(?:^|/)${escapeRe(dir)}/` : null;
-    const skill = at(layout.skillDir);
-    const agent = at(layout.agentDir);
-    const command = at(layout.commandDir);
-    const rules = at(layout.rulesDir ?? "");
+    const skillDir = layout.surfaces.skill;
+    const agentDir = layout.surfaces.agent;
+    const commandDir = layout.surfaces.command;
+    const skill = at(skillDir);
+    const agent = at(agentDir);
+    const command = at(commandDir);
     const skillRe = skill ? new RegExp(`${skill}[^/]+/SKILL\\.md$`) : null;
     const agentRe = agent ? new RegExp(`${agent}${layout_js_1.AGENT_FILE_LEAF_RE}$`) : null;
     const commandRe = command ? new RegExp(`${command}.+\\.md$`) : null;
-    // Flat `<rulesDir>/<name>.md`, like commands. A layout without a rules dir
-    // yields null and every path below answers false — the additive default.
-    const ruleRe = rules ? new RegExp(`${rules}[^/]+\\.md$`) : null;
+    // 🔴 RECURSIVE, AND IT USED TO BE FLAT (`[^/]+\\.md$`) WHILE THE LOADER WALKED
+    // THE DIRECTORY RECURSIVELY. A rule in a subdirectory was therefore READ and
+    // never CLASSIFIED: it never became a rule entry, so it was never
+    // frontmatter-checked, never counted and never weighed — zernie/vigiles#262
+    // §3. The depth rule is quoted from `RULE_FILE_LEAF_RE` rather than spelled
+    // here, because the instruction chain has to ask the same question and two
+    // readers that each spell it disagree silently (the agent constant beside it
+    // records the measurement where that happened).
+    // 🔴 THE PREFIX COMES FROM `ruleFileRe` NOW, not from `at()`. `at()` is
+    // deliberately loose — `(?:^|/)skills/` has to match a published plugin's
+    // root AND `.claude/skills` — and rules have exactly ONE home, so the same
+    // looseness let `.github/rules/policy.md` be classified as a Claude Code
+    // rule here just as it was weighed as one by the chain. Sharing the leaf and
+    // not the prefix is what let the two readers named above disagree.
+    const ruleRe = (0, layout_js_1.ruleFileRe)(layout);
     // A subagent lives under the plugin's `agents/` dir AT ANY DEPTH (the harness
     // reads it recursively — see AGENT_FILE_LEAF_RE for the vendor's wording and
     // the measurement), but never under ANOTHER surface dir. Two real-world
@@ -167,13 +184,13 @@ function makeClassifier(layout) {
     // (adapter-agnostic), and both patterns already tolerate depth on BOTH sides of
     // the `agents/` segment, so the recursion above does not leak through them.
     // See scan.test.ts for the regressions.
-    const nestedUnder = [
-        layout.skillDir &&
-            `${escapeRe(layout.skillDir)}/.+/${escapeRe(layout.agentDir)}/`,
-        layout.commandDir &&
-            `${escapeRe(layout.commandDir)}/(?:.+/)?${escapeRe(layout.agentDir)}/`,
-    ].filter((x) => Boolean(x));
-    const nestedAgentRe = layout.agentDir && nestedUnder.length
+    const nestedUnder = agentDir
+        ? [
+            skillDir && `${escapeRe(skillDir)}/.+/${escapeRe(agentDir)}/`,
+            commandDir && `${escapeRe(commandDir)}/(?:.+/)?${escapeRe(agentDir)}/`,
+        ].filter((x) => Boolean(x))
+        : [];
+    const nestedAgentRe = agentDir && nestedUnder.length
         ? new RegExp(`(?:^|/)(?:${nestedUnder.join("|")})`)
         : null;
     const isAgent = (f) => (agentRe?.test(f) ?? false) &&
@@ -188,8 +205,8 @@ function makeClassifier(layout) {
     // `.md` under `agents/` recursively — so this file is a subagent, and is not a
     // skill. Excluding it here (rather than excluding it from agents) is what keeps
     // the two classifiers disjoint AND agreeing with the harness.
-    const nestedSkillRe = layout.skillDir && layout.agentDir
-        ? new RegExp(`(?:^|/)${escapeRe(layout.agentDir)}/(?:.+/)?${escapeRe(layout.skillDir)}/`)
+    const nestedSkillRe = skillDir && agentDir
+        ? new RegExp(`(?:^|/)${escapeRe(agentDir)}/(?:.+/)?${escapeRe(skillDir)}/`)
         : null;
     const isSkill = (f) => (skillRe?.test(f) ?? false) && !(nestedSkillRe?.test(f) ?? false);
     return {
@@ -197,7 +214,9 @@ function makeClassifier(layout) {
         isAgent,
         isCommand: (f) => commandRe?.test(f) ?? false,
         isRule: (f) => ruleRe?.test(f) ?? false,
-        agentName: (f) => isAgent(f) ? (0, layout_js_1.agentSurfaceName)(f, layout.agentDir) : null,
+        agentName: (f) => isAgent(f) && agentDir !== undefined
+            ? (0, layout_js_1.agentSurfaceName)(f, agentDir)
+            : null,
     };
 }
 /**

package/dist/scan-files.d.ts

@@ -1,4 +1,4 @@
-import type { PluginLayout } from "./core/layout.js";
+import { type PluginLayout } from "./core/layout.js";
 import type { HarnessDialect } from "./core/dialect.js";
 import type { LoadedPlugin } from "./plugin-loader.js";
 import type { ScanReport } from "./scan.js";

package/dist/scan-files.js

@@ -39,10 +39,11 @@ exports.scanFiles = scanFiles;
  * is excluded. See research/report-view-and-browser-demo.md.
  */
 const posix_path_js_1 = require("./posix-path.js");
-const toml_1 = require("@iarna/toml");
 const layout_js_1 = require("./adapters/claude-code/layout.js");
 const dialect_js_1 = require("./adapters/claude-code/dialect.js");
+const layout_js_2 = require("./core/layout.js");
 const instruction_weight_js_1 = require("./core/instruction-weight.js");
+const instruction_chain_js_1 = require("./core/instruction-chain.js");
 const hook_normalize_js_1 = require("./core/hook-normalize.js");
 const hook_events_js_1 = require("./core/hook-events.js");
 const mcp_config_js_1 = require("./core/mcp-config.js");
@@ -159,31 +160,26 @@ function safeParseJson(text) {
         return null;
     }
 }
-/** Parse the layout's manifest (JSON or TOML) from the map, or null. */
+/** Parse the layout's manifest from the map through its CODEC, or null. */
 function readManifest(files, layout) {
     const text = files[layout.manifestPath];
     if (text === undefined)
         return null;
-    if (layout.settingsFormat === "toml") {
-        try {
-            return (0, toml_1.parse)(text);
-        }
-        catch {
-            return null;
-        }
+    try {
+        return layout.settings.parse(text);
+    }
+    catch {
+        return null;
     }
-    return safeParseJson(text);
 }
 /** The `.hooks` field of a JSON file in the map, or undefined. */
 function readHooksJsonFile(files, rel) {
     return safeParseJson(files[rel])?.hooks;
 }
-/** The `.hooks` of a settings file in the map, in the layout's format. */
-function readSettingsHooks(text, format) {
-    if (format === "json")
-        return safeParseJson(text)?.hooks;
+/** The `.hooks` of a settings file in the map, through the layout's codec. */
+function readSettingsHooks(text, codec) {
     try {
-        return (0, toml_1.parse)(text).hooks;
+        return codec.parse(text).hooks;
     }
     catch {
         return undefined;
@@ -199,12 +195,15 @@ function readHooks(files, layout) {
         if (m.hooks !== undefined)
             return m.hooks;
     }
-    if (hasFile(files, layout.hooksConventionPath)) {
+    // Optional: a harness whose hooks are in-process code modules has no
+    // standalone hooks FILE. Mirrors the disk loader.
+    if (layout.hooksConventionPath !== undefined &&
+        hasFile(files, layout.hooksConventionPath)) {
         return readHooksJsonFile(files, layout.hooksConventionPath);
     }
     const settings = files[layout.settingsPath];
     if (settings !== undefined) {
-        return readSettingsHooks(settings, layout.settingsFormat);
+        return readSettingsHooks(settings, layout.settings);
     }
     return undefined;
 }
@@ -225,7 +224,7 @@ function hasMcp(files, layout) {
  */
 function surfaceHasLoadable(layout, surface, tree) {
     const keys = Object.keys(tree);
-    return surface === layout.skillDir
+    return surface === layout.surfaces.skill
         ? keys.some((k) => (0, posix_path_js_1.basename)(k) === "SKILL.md")
         : keys.some((k) => k.endsWith(".md"));
 }
@@ -236,13 +235,13 @@ function materializeSurfaces(files, layout, acc, repoName) {
     const harnessCounts = {};
     const scopeTrees = (base) => {
         const trees = new Map();
-        for (const surface of layout.surfaceDirs) {
+        for (const surface of (0, layout_js_2.surfaceDirs)(layout)) {
             const dirRel = base === "" ? surface : `${base}/${surface}`;
             trees.set(surface, isDirRel(files, dirRel) ? readTreeUnder(files, dirRel, dirRel) : {});
         }
         return trees;
     };
-    const hasLoadable = (trees) => layout.surfaceDirs.some((s) => surfaceHasLoadable(layout, s, trees.get(s) ?? {}));
+    const hasLoadable = (trees) => (0, layout_js_2.surfaceDirs)(layout).some((s) => surfaceHasLoadable(layout, s, trees.get(s) ?? {}));
     const add = (key, content, onDisk) => {
         out[key] = content;
         sources[key] = onDisk;
@@ -253,7 +252,7 @@ function materializeSurfaces(files, layout, acc, repoName) {
         : new Map();
     /** Mirror of the disk loader's `materializeScope`. */
     const materializeScope = (scope, trees) => {
-        for (const surface of layout.surfaceDirs) {
+        for (const surface of (0, layout_js_2.surfaceDirs)(layout)) {
             const tree = trees.get(surface) ?? {};
             const dirRel = scope.base === "" ? surface : `${scope.base}/${surface}`;
             for (const [rel, content] of Object.entries(tree))
@@ -265,24 +264,29 @@ function materializeSurfaces(files, layout, acc, repoName) {
         }
     };
     const source = (0, surface_scopes_js_1.surfaceSource)(layout, {
-        hasRootSkillFile: Boolean(layout.skillDir) && hasFile(files, "SKILL.md"),
+        hasRootSkillFile: layout.surfaces.skill !== undefined && hasFile(files, "SKILL.md"),
         // Disk mirrors the CLI: a nameless root SKILL.md takes the audited dir's
         // basename. In-browser there's no real dir, so use the repo name when the
         // caller (runAudit) supplies it, else the synthetic BROWSER_ROOT basename.
         skillName: repoName ?? (0, posix_path_js_1.basename)(exports.BROWSER_ROOT),
         rootHasLoadable: hasLoadable(rootTrees),
         isPluginShaped: hasFile(files, layout.manifestPath) ||
-            hasFile(files, layout.hooksConventionPath),
+            (layout.hooksConventionPath !== undefined &&
+                hasFile(files, layout.hooksConventionPath)),
         userHasLoadable: hasLoadable(userTrees),
     });
     switch (source.kind) {
         case "single-skill": {
             const tree = readTreeUnder(files, "", "");
+            // Mirrors the disk loader: the skill dir is carried on the variant, so
+            // there is no `undefined` case to guard and no dead branch to keep in
+            // sync across the two engines.
+            const { skillDir } = source;
             for (const [rel, content] of Object.entries(tree)) {
-                add((0, posix_path_js_1.join)(layout.materializeRoot, layout.skillDir, source.skillName, rel), content, (0, posix_path_js_1.join)(exports.BROWSER_ROOT, rel));
+                add((0, posix_path_js_1.join)((0, layout_js_2.materializePrefix)(layout), skillDir, source.skillName, rel), content, (0, posix_path_js_1.join)(exports.BROWSER_ROOT, rel));
             }
-            counts[layout.skillDir] = Object.keys(tree).length;
-            harnessCounts[layout.skillDir] = counts[layout.skillDir];
+            counts[skillDir] = Object.keys(tree).length;
+            harnessCounts[skillDir] = counts[skillDir];
             return { counts, harnessCounts, scopes: [] };
         }
         case "scopes": {
@@ -299,7 +303,7 @@ function materializeSurfaces(files, layout, acc, repoName) {
 // Extensions + BOTH token boundaries live in core/source-refs.ts, so this and
 // its disk twin (plugin-loader.ts) cannot disagree and neither can omit one.
 function intraRefRe(layout) {
-    return (0, source_refs_js_1.intraRefPattern)(layout.intraRefDirs);
+    return (0, source_refs_js_1.intraRefPattern)((0, layout_js_2.executableSourceDirs)(layout));
 }
 const NON_PLUGIN_VARS = new Set([
     "CLAUDE_PROJECT_DIR",
@@ -326,7 +330,7 @@ const DOC_SOURCE_RE = /\.(?:md|markdown|mdx|txt|rst)$/i;
 /** The plugin's executable (non-prose) source-file CONTENTS under the surface dirs. */
 function executableContents(files, layout) {
     const out = [];
-    for (const surface of layout.intraRefDirs) {
+    for (const surface of (0, layout_js_2.executableSourceDirs)(layout)) {
         if (!isDirRel(files, surface))
             continue;
         for (const [k, content] of Object.entries(files)) {
@@ -491,6 +495,14 @@ function scanFiles(files, layout = layout_js_1.claudeCodeLayout, dialect = diale
             hasSpec: hasFile(files, `${lay.instructionFile}.spec.ts`),
         }
         : null;
+    // The BOUNDED candidate set over the map, then the same one-level import pass
+    // the disk walk runs — `resolveImports` lives in the core precisely so these
+    // two cannot drift. An import the fetcher never fetched simply stays unread,
+    // and the weight says so (`unreadImports`) instead of quietly omitting it.
+    const instructionFiles = (0, instruction_chain_js_1.resolveImports)(lay, Object.fromEntries((0, instruction_chain_js_1.instructionCandidatePaths)(Object.keys(files), lay).map((p) => [
+        p,
+        files[p] ?? "",
+    ])), (p) => files[p]);
     const mcpServers = collectMcpServers(files, lay);
     const declaredServers = Object.keys(mcpServers);
     // The repo's own test signal — same shared detector as the disk path, over the
@@ -505,7 +517,7 @@ function scanFiles(files, layout = layout_js_1.claudeCodeLayout, dialect = diale
     });
     const skills = (0, scan_core_js_1.scanSkills)(loaded.files, cls, {
         root: exports.BROWSER_ROOT,
-        materializeRoot: lay.materializeRoot,
+        materializeRoot: (0, layout_js_2.materializePrefix)(lay),
         dialect,
         sources: loaded.sources,
         existsSync: exists,
@@ -560,7 +572,10 @@ function scanFiles(files, layout = layout_js_1.claudeCodeLayout, dialect = diale
         // The browser twin has the WHOLE fetched key set in hand, so discovery needs
         // no walk here — the pure classifier re-applies the same bounded-root rule.
         unclaimedSurfaces: (0, surface_discovery_js_1.unclaimedSurfaceFindings)(Object.keys(files), layout_registry_js_1.REGISTERED_LAYOUTS),
-        pluginLayoutIssues: (0, plugin_dir_layout_js_1.pluginDirLayoutIssues)((0, posix_path_js_1.join)(exports.BROWSER_ROOT, (0, posix_path_js_1.dirname)(lay.manifestPath)), [...new Set([...lay.surfaceDirs, lay.hooksConventionPath.split("/")[0]])], { existsSync: exists, isDirectory: mapIsDirectory(files) }),
+        pluginLayoutIssues: (0, plugin_dir_layout_js_1.pluginDirLayoutIssues)((0, posix_path_js_1.join)(exports.BROWSER_ROOT, (0, posix_path_js_1.dirname)(lay.manifestPath)), 
+        // See the note in scan.ts: the scripts dir is NAMED by the layout, not
+        // derived from the registration file's first segment.
+        (0, layout_js_2.executableSourceDirs)(lay), { existsSync: exists, isDirectory: mapIsDirectory(files) }),
         delegationTrifecta: (0, scan_core_js_1.collectDelegationTrifecta)(agents, dialect),
         hookBlockFindings: (0, event_capability_js_1.blockIneffectiveEventsOf)(dialect).length > 0
             ? (0, hook_block_ineffective_js_1.hookBlockIssues)((0, scan_core_js_1.collectHookBlockEntries)(hookRegs, exports.BROWSER_ROOT, lay.pluginRootToken, exists), {
@@ -578,10 +593,15 @@ function scanFiles(files, layout = layout_js_1.claudeCodeLayout, dialect = diale
             ...loaded.warnings,
             ...(0, merge_conflict_js_1.conflictedHarnessConfigs)((f) => files[f]).map(merge_conflict_js_1.mergeConflictWarning),
         ],
-        // The browser side needs no directory walk — the file map IS the repo, so
-        // the glob filter inside weighInstructions does the whole job.
+        // 🔴 THE TWIN APPLIES THE SAME BOUND AS THE DISK WALK, and until now it
+        // applied none. The comment here used to read "the file map IS the repo, so
+        // the glob filter does the whole job" — which was true of a glob and is not
+        // true of a bound: `boundedInstructionFiles` enumerates the repo root plus
+        // depth-1 dot-directories and nothing else, so handing the whole fetched map
+        // over would make the browser weigh files the CLI never opens. Same filter,
+        // same import pass, same chain; only the storage differs.
         instructionWeight: dialect.instructionBudget
-            ? (0, instruction_weight_js_1.weighInstructions)(files, dialect.instructionBudget)
+            ? (0, instruction_weight_js_1.weighInstructions)(lay.instructionChain(instructionFiles), instructionFiles, dialect.instructionBudget)
             : null,
         untested: coverage.untested.length,
         untestedHarness: coverage.harness.untested.length,