vigiles 5.0.1 → 5.1.0

package/dist/eval.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EPHEMERAL_HOME_KEEP = void 0;
+exports.claudeEvalDriver = exports.EPHEMERAL_HOME_KEEP = void 0;
 exports.resolveSpawnEnv = resolveSpawnEnv;
+exports.spawnAgent = spawnAgent;
 exports.runEval = runEval;
 exports.measureWith = measureWith;
 exports.measure = measure;
@@ -12,6 +13,7 @@ exports.formatCheckReport = formatCheckReport;
 exports.assertRates = assertRates;
 exports.checkReportToJUnit = checkReportToJUnit;
 exports.parseUsage = parseUsage;
+exports.parseClaudeRun = parseClaudeRun;
 exports.aggregate = aggregate;
 exports.aggregateStats = aggregateStats;
 exports.aggregateUsage = aggregateUsage;
@@ -91,6 +93,8 @@ function resolveSpawnEnv(a, base = process.env) {
     return a.replaceEnv ? (a.env ?? {}) : { ...base, ...a.env };
 }
 /* v8 ignore start -- real claude subprocess; exercised by bench/, not the unit gate */
+/** The real `claude`-spawning runner (composition root). Exported so other
+ *  real-model entries (e.g. `scan --trigger`) bind the same runner. */
 function spawnAgent(a) {
     return new Promise((resolvePromise) => {
         const args = [
@@ -392,21 +396,31 @@ function usageFrom(result) {
 function parseUsage(stdout) {
     return usageFrom((0, harness_test_js_1.parseResultEvent)(stdout));
 }
-function makeContext(cwd, out) {
+/** Parse Claude Code's stream-json stdout into the common trace fields. */
+function parseClaudeRun(out) {
     const result = (0, harness_test_js_1.parseResultEvent)(out.stdout);
-    const turns = typeof result?.num_turns === "number" ? result.num_turns : 0;
-    const output = typeof result?.result === "string" ? result.result : "";
     return {
-        cwd,
-        exitCode: out.code,
-        stdout: out.stdout,
-        turns,
+        turns: typeof result?.num_turns === "number" ? result.num_turns : 0,
+        output: typeof result?.result === "string" ? result.result : "",
         toolCalls: (0, harness_test_js_1.parseToolCalls)(out.stdout),
         hooks: (0, harness_test_js_1.parseHooks)(out.stdout),
-        output,
         subagents: (0, harness_test_js_1.parseSubagents)(out.stdout),
         usage: usageFrom(result),
-        // The eval tier drives the real API (no mock between claude and the model),
+    };
+}
+function makeContext(cwd, out, parse = parseClaudeRun) {
+    const p = parse(out);
+    return {
+        cwd,
+        exitCode: out.code,
+        stdout: out.stdout,
+        turns: p.turns,
+        toolCalls: p.toolCalls,
+        hooks: p.hooks,
+        output: p.output,
+        subagents: p.subagents,
+        usage: p.usage,
+        // The eval tier drives the real API (no mock between the agent and the model),
         // so the requests can't be captured here — modelRequests is harness-tier only.
         modelRequests: [],
         file: (p) => {
@@ -993,6 +1007,11 @@ function formatEvalReport(report) {
     }
     return lines.join("\n");
 }
+/** The default (Claude Code) eval driver: real `claude` + stream-json parsing. */
+exports.claudeEvalDriver = {
+    runner: spawnAgent,
+    parse: parseClaudeRun,
+};
 /**
  * Package loose `<skillsDir>/<name>/SKILL.md` skills into a throwaway plugin dir
  * that `claude --plugin-dir` accepts — so repo-local skills (e.g. `.claude/skills`)
@@ -1284,42 +1303,65 @@ function resolveTriggerPluginDir(spec) {
     };
 }
 /** Run one prompt set × trials through `runner`, aggregating fired counts. */
-async function runTriggerSet(prompts, cfg, runner) {
-    const perPrompt = [];
-    let firedTotal = 0;
-    let n = 0;
-    for (const prompt of prompts) {
-        let fired = 0;
-        for (let t = 0; t < cfg.trials; t++) {
-            const cwd = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "vigiles-trigger-"));
-            try {
-                const out = await runner({
-                    task: prompt,
-                    cwd,
-                    model: cfg.model,
-                    tools: cfg.tools,
-                    hasSettings: false,
-                    pluginDir: cfg.pluginDir,
-                    timeoutMs: cfg.timeoutMs,
-                });
-                if (cfg.fired(makeContext(cwd, out)))
-                    fired++;
-            }
-            finally {
-                (0, node_fs_1.rmSync)(cwd, { recursive: true, force: true });
-                await sleep(cfg.spacing);
-            }
-        }
-        perPrompt.push({
-            prompt,
-            fired,
-            trials: cfg.trials,
-            rate: cfg.trials > 0 ? fired / cfg.trials : 0,
+/** Run one trigger trial in a throwaway cwd (fixture seeded) → fired 0/1. */
+async function runTriggerTrial(prompt, cfg, runner) {
+    const cwd = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "vigiles-trigger-"));
+    try {
+        if (cfg.fixture)
+            writeFiles(cwd, cfg.fixture);
+        const out = await runner({
+            task: prompt,
+            cwd,
+            model: cfg.model,
+            tools: cfg.tools,
+            hasSettings: false,
+            pluginDir: cfg.pluginDir,
+            timeoutMs: cfg.timeoutMs,
         });
-        firedTotal += fired;
-        n += cfg.trials;
+        // An errored/rate-limited turn is NOT a "skill didn't fire" miss — it's
+        // excluded from the rate, so e.g. a Codex usage limit can't read as recall 0.
+        if (cfg.runError?.(out))
+            return { fired: 0, errored: true };
+        return {
+            fired: cfg.fired(makeContext(cwd, out, cfg.parse)) ? 1 : 0,
+            errored: false,
+        };
+    }
+    finally {
+        (0, node_fs_1.rmSync)(cwd, { recursive: true, force: true });
+        await sleep(cfg.spacing);
     }
-    return { perPrompt, fired: firedTotal, n };
+}
+/** A count for reporting: the number if positive, else undefined (omit zero). */
+const positiveOrUndefined = (n) => n > 0 ? n : undefined;
+async function runTriggerSet(prompts, cfg, runner) {
+    // Flatten prompts × trials into one work list so concurrency spans both.
+    const jobs = prompts.flatMap((prompt, promptIndex) => Array.from({ length: cfg.trials }, () => ({ prompt, promptIndex })));
+    const outcomes = await runPool(jobs, cfg.concurrency, (job) => runTriggerTrial(job.prompt, cfg, runner));
+    // Re-aggregate per prompt, preserving input order; errored runs don't count.
+    const firedBy = new Array(prompts.length).fill(0);
+    const trialsBy = new Array(prompts.length).fill(0);
+    let errored = 0;
+    jobs.forEach((job, i) => {
+        if (outcomes[i].errored) {
+            errored += 1;
+            return;
+        }
+        firedBy[job.promptIndex] += outcomes[i].fired;
+        trialsBy[job.promptIndex] += 1;
+    });
+    const perPrompt = prompts.map((prompt, i) => ({
+        prompt,
+        fired: firedBy[i],
+        trials: trialsBy[i],
+        rate: trialsBy[i] > 0 ? firedBy[i] / trialsBy[i] : 0,
+    }));
+    return {
+        perPrompt,
+        fired: firedBy.reduce((a, b) => a + b, 0),
+        n: trialsBy.reduce((a, b) => a + b, 0),
+        errored,
+    };
 }
 /**
  * Trigger-rate orchestration — every prompt × trial via `runner`, the `fired`
@@ -1329,9 +1371,8 @@ async function runTriggerSet(prompts, cfg, runner) {
  * injectable `runner` so the loop is unit-testable without a model;
  * `measureTriggerRate` is this with the real agent runner.
  */
-async function measureTriggerRateWith(spec, runner) {
-    // Deterministic gate FIRST — reject a too-small / near-duplicate prompt set
-    // before spending a token (and before packaging a skillsDir).
+/** Diversity pre-flight: reject a too-small / near-duplicate prompt set (both sides). */
+function assertTriggerDiversity(spec) {
     const diversity = {
         minPrompts: spec.minPrompts,
         minDistance: spec.minDistance,
@@ -1343,6 +1384,10 @@ async function measureTriggerRateWith(spec, runner) {
             label: "irrelevantPrompts",
         });
     }
+}
+async function measureTriggerRateWith(spec, runner, parse = parseClaudeRun, runError) {
+    // Deterministic gate FIRST — before spending a token (or packaging a skillsDir).
+    assertTriggerDiversity(spec);
     // Model floor (default Sonnet): trigger-rate under-measures selection on a
     // weaker model, so FAIL before spending a token rather than report a
     // false-negative recall. The floor lives in the spec (`minModel`), not an env
@@ -1365,6 +1410,10 @@ async function measureTriggerRateWith(spec, runner) {
         spacing: (spec.spacingSec ?? 4) * 1000,
         pluginDir,
         fired: spec.fired,
+        fixture: spec.fixture,
+        concurrency: Math.max(1, spec.concurrency ?? 1),
+        parse,
+        runError,
     };
     try {
         const relevant = await runTriggerSet(spec.prompts, cfg, runner);
@@ -1373,6 +1422,7 @@ async function measureTriggerRateWith(spec, runner) {
             n: relevant.n,
             perPrompt: relevant.perPrompt,
             competitors,
+            errored: positiveOrUndefined(relevant.errored),
         };
         if ((spec.irrelevantPrompts?.length ?? 0) === 0)
             return base;
@@ -1380,6 +1430,7 @@ async function measureTriggerRateWith(spec, runner) {
         const fires = relevant.fired + irrelevant.fired;
         return {
             ...base,
+            errored: positiveOrUndefined(relevant.errored + irrelevant.errored),
             falsePositiveRate: irrelevant.n > 0 ? irrelevant.fired / irrelevant.n : 0,
             precision: fires > 0 ? relevant.fired / fires : undefined,
             perIrrelevant: irrelevant.perPrompt,
@@ -1393,11 +1444,15 @@ async function measureTriggerRateWith(spec, runner) {
 }
 /* v8 ignore start -- real claude subprocess; thin wrapper over measureTriggerRateWith */
 /**
- * Measure a skill/behaviour's real trigger rate across prompts × trials against
- * the real `claude` CLI. Requires `claude` + model auth.
+ * Measure a skill/behaviour's real trigger rate across prompts × trials. Defaults
+ * to the real `claude` CLI (`claudeEvalDriver`); pass `{ evalDriver }` to drive a
+ * second harness — e.g. `measureTriggerRate(spec, { evalDriver: codexEvalDriver })`
+ * from `vigiles/codex` (the eval-tier analog of `runHarnessTest`'s `{ adapter }`).
+ * Requires that harness's binary + auth.
  */
-async function measureTriggerRate(spec) {
-    return measureTriggerRateWith(spec, spawnAgent);
+async function measureTriggerRate(spec, opts = {}) {
+    const d = opts.evalDriver ?? exports.claudeEvalDriver;
+    return measureTriggerRateWith(spec, d.runner, d.parse, d.runError);
 }
 /* v8 ignore stop */
 /** Format a trigger-rate report: overall %, then each prompt's rate. */

package/dist/leaderboard.js

@@ -20,6 +20,7 @@ const scan_js_1 = require("./scan.js");
 // Penalty weights — broken-at-runtime costs most, footguns less, nudges least.
 const W_MISSING_HOOK = 15; // a hook script that doesn't exist → never runs
 const W_NO_DESCRIPTION = 10; // a skill with no usable description → can't trigger
+const W_DANGLING_REF = 8; // a referenced intra-plugin file that's missing → broken path
 const W_NO_CONTRACT = 5; // an agent with no `tools:` line → inherits everything
 const W_UNTESTED = 3; // a surface with no test/eval → warning-tier
 function gradeFor(score) {
@@ -35,29 +36,86 @@ function gradeFor(score) {
 }
 /** Deterministic structural-health score for one scanned plugin. */
 function scoreReport(r) {
-    // An empty/unloadable machine isn't healthy — it's a non-plugin or a broken load.
-    if (r.skills.length + r.agents.length + r.hooks.length === 0) {
+    // An empty/unloadable machine isn't healthy — it's a non-plugin or a broken
+    // load. A command-only or MCP-only plugin (commands/*.md or .mcp.json with no
+    // skills/agents/hooks) IS a legitimate plugin, though — Anthropic ships
+    // command-only plugins in its own marketplace — so it must NOT score 0.
+    const surfaces = r.skills.length + r.agents.length + r.hooks.length + r.commands;
+    if (surfaces === 0 && !r.mcp) {
         return { score: 0, issues: ["no loadable plugin surface"] };
     }
     const missingHooks = r.hooks.filter((h) => h.status === "missing").length;
     const noDesc = r.skills.filter((s) => !s.hasDescription).length;
     const noContract = r.agents.filter((a) => a.tools === null).length;
+    const deadTools = r.agents.reduce((n, a) => n + a.toolIssues.length, 0);
+    const deadMcpTools = r.agents.reduce((n, a) => n + a.mcpToolIssues.length, 0);
+    const deadDisallowed = r.agents.reduce((n, a) => n + a.disallowedToolIssues.length, 0);
+    const deadHookEvents = r.hookEventIssues.length;
+    const badFrontmatter = r.frontmatterIssues.length;
+    const badFrontmatterValues = r.frontmatterValueIssues.length;
+    const badMcp = r.mcpIssues.length;
+    const badMcpHooks = r.mcpHookIssues.length;
     const deductions = [
         {
             n: missingHooks,
             weight: W_MISSING_HOOK,
             label: "hook script(s) MISSING",
         },
+        {
+            n: deadHookEvents,
+            weight: W_MISSING_HOOK,
+            label: "hook(s) on an unknown event (never fire)",
+        },
         {
             n: noDesc,
             weight: W_NO_DESCRIPTION,
             label: "skill(s) with no usable description",
         },
+        {
+            n: r.danglingRefs.length,
+            weight: W_DANGLING_REF,
+            label: "broken intra-plugin reference(s)",
+        },
+        {
+            n: deadTools,
+            weight: W_DANGLING_REF,
+            label: "agent tool(s) that don't exist (typo / never-available)",
+        },
+        {
+            n: deadMcpTools,
+            weight: W_DANGLING_REF,
+            label: "agent MCP tool(s) whose server isn't declared (can't resolve)",
+        },
+        {
+            n: deadDisallowed,
+            weight: W_NO_CONTRACT,
+            label: "agent disallowedTools typo(s) that block nothing",
+        },
         {
             n: noContract,
             weight: W_NO_CONTRACT,
             label: "agent(s) inherit all tools (no contract)",
         },
+        {
+            n: badFrontmatter,
+            weight: W_NO_DESCRIPTION,
+            label: "surface(s) missing required frontmatter (name/description)",
+        },
+        {
+            n: badFrontmatterValues,
+            weight: W_NO_CONTRACT,
+            label: "agent(s) with an invalid model/color (typo → silent fallback)",
+        },
+        {
+            n: badMcp,
+            weight: W_DANGLING_REF,
+            label: "MCP server(s) that can't start (no command/url)",
+        },
+        {
+            n: badMcpHooks,
+            weight: W_DANGLING_REF,
+            label: "mcp_tool hook(s) incomplete / targeting an undeclared server",
+        },
         { n: r.untested, weight: W_UNTESTED, label: "untested surface(s)" },
     ];
     let penalty = 0;
@@ -101,7 +159,7 @@ function formatLeaderboard(scores) {
         const issue = s.issues.length > 0 ? ` — ${s.issues.join("; ")}` : "";
         out.push(`  ${rank}  ${score}    ${s.grade}      ${s.name}${issue}`);
     });
-    out.push("", "Structural health only (no model). Weights: missing hook -15, no-description", "skill -10, agent-without-tool-contract -5, untested surface -3.");
+    out.push("", "Structural health only (no model). Weights: missing hook -15, no-description", "skill -10, broken intra-plugin ref -8, agent-without-tool-contract -5,", "untested surface -3.");
     return out.join("\n");
 }
 //# sourceMappingURL=leaderboard.js.map

package/dist/plugin-loader.d.ts

@@ -22,6 +22,7 @@ export interface LoadedPlugin {
  * `settings` with any inline settings and spread `files` into the fixture.
  */
 export declare function loadPlugin(pluginPath: string, layout: PluginLayout): LoadedPlugin;
+export declare function danglingRefs(root: string, layout: PluginLayout): string[];
 /**
  * Resolve the effective harness for a test/eval (arm): load the plugin if given,
  * then layer inline settings + files on top. Shared by `runHarnessTest` and

package/dist/plugin-loader.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadPlugin = loadPlugin;
+exports.danglingRefs = danglingRefs;
 exports.resolveHarness = resolveHarness;
 /**
  * vigiles — harness-agnostic plugin/repo harness loader (composition root).
@@ -208,34 +209,86 @@ const INTRA_REF_EXTS = "md|sh|cmd|mjs|cjs|js|ts|py|rb|txt|json";
 function intraRefRe(layout) {
     return new RegExp(`(?:${layout.intraRefDirs.join("|")})/[A-Za-z0-9._/-]+\\.(?:${INTRA_REF_EXTS})`, "g");
 }
+// Shell vars that root a path OUTSIDE the plugin (the user's project / home), so
+// a `surface/…` after one is NOT a plugin-root ref. Anything else ($ROOT,
+// $PLUGIN_ROOT, ${CLAUDE_PLUGIN_ROOT}, …) is taken as the plugin root.
+const NON_PLUGIN_VARS = new Set([
+    "CLAUDE_PROJECT_DIR",
+    "CLAUDE_PROJECT",
+    "HOME",
+    "PWD",
+    "OLDPWD",
+]);
+/**
+ * Is a surface-dir match at `idx` actually rooted at the PLUGIN (so checkable
+ * under `root`), vs nested under a literal dir or a project/home var? A match
+ * preceded by a literal segment (`.claude/hooks/…` — a PROJECT path, the
+ * gmickel/flow-next false positive) or a project var (`$CLAUDE_PROJECT_DIR/…`)
+ * is NOT a plugin ref. A bare ref (`cat skills/…`) or one after a plugin-root
+ * var (`${PLUGIN_ROOT}/skills/…`, obra/superpowers) IS.
+ */
+function isPluginRooted(content, idx) {
+    if (idx === 0 || content[idx - 1] !== "/")
+        return true; // bare / after quote-space
+    // The path component immediately before the separating slash.
+    const seg = /([^\s"'`(=:/]*)$/.exec(content.slice(0, idx - 1))?.[1] ?? "";
+    const varName = /^\$\{?(\w+)\}?$/.exec(seg)?.[1];
+    if (varName !== undefined)
+        return !NON_PLUGIN_VARS.has(varName); // a var root
+    return false; // a literal dir segment → nested, not a plugin-root ref
+}
+// Documentation files (skill bodies, command docs, reference notes) are PROSE —
+// a `skills/foo/SKILL.md` path inside them is almost always an example, a
+// template placeholder (`wc -w skills/path/SKILL.md`), or a "❌ Bad" sample, not
+// a real file operation. Scanning them produced near-100% false positives across
+// real plugins (wshobson/agents, obra/superpowers), so we skip them as SOURCES.
+// A path in an executable hook/helper script (incl. extensionless ones like
+// obra/superpowers' `hooks/session-start`) IS a real file op — those we scan.
+const DOC_SOURCE_RE = /\.(?:md|markdown|mdx|txt|rst)$/i;
 /**
  * Intra-plugin file references that don't resolve — the partial-vendor / broken-
- * path class (e.g. obra/superpowers' `SessionStart` reads
+ * path class (e.g. obra/superpowers' `hooks/session-start` reads
  * `skills/using-superpowers/SKILL.md`, which a sliced vendor snapshot omits). We
- * scan the plugin's own text files under the surface dirs (hooks scripts
- * included — those aren't materialized into `files`) for root-relative path refs
- * and report the ones missing on disk. A static check that would have caught a
- * bug the dogfood hit twice. Best-effort: a warning, not an error.
+ * scan the plugin's own EXECUTABLE files under the surface dirs (hook/helper
+ * scripts — those aren't materialized into `files`) for root-relative path refs
+ * and report the ones missing on disk. Documentation sources are deliberately
+ * excluded (see `DOC_SOURCE_RE`) — a path in prose is undecidably ref-or-example,
+ * the same heuristic-scanning anti-pattern reference verification rejects. A
+ * static check that would have caught a bug the dogfood hit twice. Best-effort:
+ * a warning, not an error.
  */
-function danglingRefs(root, layout) {
-    const missing = new Set();
-    const seen = new Set();
-    const re = intraRefRe(layout);
+/** Path refs in `content` (matched by `re`) that don't resolve under `root`. */
+function missingRefsIn(content, re, root) {
+    const out = [];
+    for (const m of content.matchAll(re)) {
+        if (m.index !== undefined && !isPluginRooted(content, m.index))
+            continue;
+        if (!(0, node_fs_1.existsSync)((0, node_path_1.join)(root, m[0])))
+            out.push(m[0]);
+    }
+    return out;
+}
+/** The plugin's executable (non-prose) source files under the surface dirs. */
+function executableSources(root, layout) {
+    const sources = {};
     for (const surface of layout.intraRefDirs) {
         const dir = (0, node_path_1.join)(root, surface);
         if (!(0, node_fs_1.existsSync)(dir) || !(0, node_fs_1.statSync)(dir).isDirectory())
             continue;
-        for (const content of Object.values(readTree(dir, root))) {
-            for (const m of content.matchAll(re)) {
-                const ref = m[0];
-                if (seen.has(ref))
-                    continue;
-                seen.add(ref);
-                if (!(0, node_fs_1.existsSync)((0, node_path_1.join)(root, ref)))
-                    missing.add(ref);
-            }
+        for (const [path, content] of Object.entries(readTree(dir, root))) {
+            if (!DOC_SOURCE_RE.test(path))
+                sources[path] = content; // skip prose
         }
     }
+    return sources;
+}
+function danglingRefs(root, layout) {
+    const re = intraRefRe(layout);
+    const missing = new Set();
+    for (const content of Object.values(executableSources(root, layout))) {
+        for (const ref of missingRefsIn(content, re, root))
+            missing.add(ref);
+    }
     return [...missing];
 }
 /**

package/dist/scan-behavioral.d.ts

@@ -0,0 +1,73 @@
+/**
+ * `vigiles scan --trigger` — the BEHAVIORAL column of the scan report.
+ *
+ * Structural `scan`/`scanPlugin` is deterministic, no-model, CI-free — and stays
+ * that way. This is the opt-in, model-gated column that stacks on top: for each
+ * model-invocable skill in a plugin, it measures how reliably the description
+ * actually FIRES (recall, + precision when irrelevant prompts are supplied),
+ * reusing `measureTriggerRate`. It degrades honestly when the `claude` CLI / auth
+ * is absent rather than faking a pass — exactly like the egress column.
+ *
+ * Prompts are AUTHOR-SUPPLIED (a per-skill JSON map), not model-generated — a
+ * path in prose is undecidable, and the deterministic-input discipline is what
+ * makes the column trustworthy. See `research/plugin-behavioral-findings.md`.
+ */
+import { type EvalDriver } from "./eval.js";
+import { type Trace } from "./harness-test.js";
+/** Which harness drives the behavioral column (default Claude Code). */
+export type ProbeHarness = "claude-code" | "codex";
+/** Author-supplied prompt sets for one skill (bare skill name → these). */
+export interface SkillPrompts {
+    readonly prompts: readonly string[];
+    readonly irrelevant?: readonly string[];
+}
+/** The `--prompts <file>` shape: bare skill name → its prompt sets. */
+export type TriggerPromptSet = Record<string, SkillPrompts>;
+export interface SkillTriggerResult {
+    readonly skill: string;
+    /** Whether a model probe actually ran (false = skipped, see `note`). */
+    readonly measured: boolean;
+    readonly recall?: number;
+    readonly precision?: number;
+    readonly falsePositiveRate?: number;
+    readonly n?: number;
+    /** Why it was skipped, or a measurement error. */
+    readonly note?: string;
+}
+export interface BehavioralReport {
+    /** False when the `claude` CLI / auth is absent — the column couldn't run. */
+    readonly available: boolean;
+    readonly results: readonly SkillTriggerResult[];
+}
+export interface ProbeOptions {
+    readonly concurrency?: number;
+    readonly model?: string;
+    readonly minPrompts?: number;
+    readonly minDistance?: number;
+    /** Which harness to drive (default `"claude-code"`). */
+    readonly harness?: ProbeHarness;
+}
+/**
+ * Per-harness probe wiring: the eval driver (runner+parse), how to build the
+ * `fired` predicate for a skill, whether to stub bodies, and an availability
+ * gate. Claude detects firing via the `Skill` tool_use (namespaced by the
+ * plugin name); Codex has no skill event, so firing is the SKILL.md read
+ * (`codexSkillFired`, bare name) — see `research/codex-prototype-findings.md`.
+ */
+export interface HarnessProbe {
+    readonly evalDriver: EvalDriver;
+    readonly firedFor: (name: string) => (t: Trace) => boolean;
+    readonly stub: boolean;
+    readonly available: () => boolean;
+}
+/** The injectable core (for tests): probe every model-invocable skill that has prompts. */
+export declare function probePluginTriggersWith(dir: string, promptSet: TriggerPromptSet, probe: HarnessProbe, opts?: ProbeOptions): Promise<BehavioralReport>;
+/**
+ * Probe a plugin's skills against the real harness (default Claude Code; Codex via
+ * `opts.harness`). Needs that harness's binary + auth; degrades to
+ * `available: false` otherwise.
+ */
+export declare function probePluginTriggers(dir: string, promptSet: TriggerPromptSet, opts?: ProbeOptions): Promise<BehavioralReport>;
+/** Format the behavioral column as a scan-report section. */
+export declare function formatBehavioralReport(b: BehavioralReport): string;
+//# sourceMappingURL=scan-behavioral.d.ts.map