skill-probe 0.8.0 → 0.10.0

package/dist/llm.js

@@ -3,8 +3,8 @@
  *   - otherwise              → fall back to the `claude` CLI (works on a Claude subscription,
  *                              no API key needed).
  * So the whole tool — audit, gen, fix — runs on just a logged-in `claude`. */
-import { spawn } from "node:child_process";
 import { tmpdir } from "node:os";
+import { runProcess } from "./proc.js";
 const ANTHROPIC_URL = "https://api.anthropic.com/v1/messages";
 /** Which backend complete() will use, given the environment. Exported for testing/diagnostics. */
 export function llmBackend() {
@@ -47,26 +47,26 @@ export function interpretClaudeJson(code, out, err, timedOut) {
     text = text.trim();
     return text ? { text } : { error: `claude CLI returned no text (${(err || out).slice(0, 200)})` };
 }
-function completeViaClaudeCli(system, user, opts) {
-    return new Promise((resolve, reject) => {
-        const args = ["-p", user, "--append-system-prompt", system, "--output-format", "json"];
-        if (opts.model)
-            args.push("--model", opts.model);
-        // run in a neutral cwd so the project's own skills/AGENTS.md don't bias the generation
-        const child = spawn("claude", args, { cwd: tmpdir(), stdio: ["ignore", "pipe", "pipe"] });
-        let out = "", err = "", settled = false, timedOut = false;
-        const timer = setTimeout(() => { timedOut = true; child.kill("SIGKILL"); }, 120_000);
-        const done = (fn) => { if (settled)
-            return; settled = true; clearTimeout(timer); fn(); };
-        child.stdout.on("data", (d) => { out += d.toString(); });
-        child.stderr.on("data", (d) => { err += d.toString(); });
-        child.on("error", (e) => done(() => reject(new Error(`claude CLI failed: ${e.message} — set ANTHROPIC_API_KEY or install/login 'claude'.`))));
-        child.on("close", (code) => done(() => {
-            const r = interpretClaudeJson(code, out, err, timedOut);
-            if (r.text)
-                resolve(r.text);
-            else
-                reject(new Error(r.error ?? "claude CLI failed"));
-        }));
-    });
+/** CLI arguments for one completion. Exported for testing. */
+export function claudeCliArgs(system, user, opts) {
+    // hermetic + no session transcript: diagnose calls this k times per case, and neither the user's
+    // plugins/MCP servers nor ~/.claude/projects clutter have any business in a plain completion
+    const args = [
+        "-p", user, "--append-system-prompt", system, "--output-format", "json",
+        "--no-session-persistence", "--setting-sources", "project", "--strict-mcp-config",
+    ];
+    if (opts.model)
+        args.push("--model", opts.model);
+    return args;
+}
+async function completeViaClaudeCli(system, user, opts) {
+    // run in a neutral cwd so the project's own skills/AGENTS.md don't bias the generation
+    const r = await runProcess("claude", claudeCliArgs(system, user, opts), { cwd: tmpdir(), timeoutMs: 120_000 });
+    if (r.spawnError) {
+        throw new Error(`claude CLI failed: ${r.spawnError} — set ANTHROPIC_API_KEY or install/login 'claude'.`);
+    }
+    const out = interpretClaudeJson(r.code, r.stdout, r.stderr, r.timedOut);
+    if (out.text)
+        return out.text;
+    throw new Error(out.error ?? "claude CLI failed");
 }

package/dist/manifest.d.ts

@@ -0,0 +1,40 @@
+import type { Config, ProbeEnv, RuntimeAdapter } from "./types.ts";
+/** What the runtime actually ran with — reported by the runtime itself, not assumed. */
+export interface RunEnvironment {
+    /** runtime CLI version (built-in skills and routing change between versions) */
+    runtimeVersion?: string;
+    /** the model the runtime actually used — resolves "(runtime default)" */
+    resolvedModel?: string;
+    /** skills the runtime loaded that are not in the library (e.g. Claude Code's built-ins) */
+    extraSkills?: string[];
+    /** the user's personal runtime config was requested in probes (--user-config) */
+    userConfig: boolean;
+    /** personal runtime config was actually kept out of probes (false when the runtime can't) */
+    hermetic?: boolean;
+    maxTurns: number;
+}
+export interface RunManifest {
+    tool: "skill-probe";
+    version: string;
+    command: "audit" | "context" | "diagnose";
+    /** ISO 8601 UTC */
+    date: string;
+    runtime: string;
+    model: string;
+    k: number;
+    threshold: number;
+    conf: number;
+    /** sha256 (first 16 hex chars) of the resolved config — cases + settings, NOT cwd */
+    configHash: string;
+    node: string;
+    environment?: RunEnvironment;
+}
+export declare function toolVersion(): string;
+/** Hash the parts of the config that change what was measured. `cwd` is deliberately EXCLUDED:
+ * the same library checked out at a different path (CI runner vs laptop) is the same experiment.
+ * Settings added later are hashed only when non-default, so existing baselines keep their hash. */
+export declare function configHash(cfg: Config): string;
+export declare function buildEnvironment(cfg: Config, env: ProbeEnv | undefined, extraSkills: string[] | undefined, adapter: RuntimeAdapter): RunEnvironment;
+/** Caveats when the config asks for something this runtime can't do. */
+export declare function capabilityWarnings(cfg: Config, adapter: RuntimeAdapter): string[];
+export declare function buildManifest(command: RunManifest["command"], cfg: Config, environment?: RunEnvironment): RunManifest;

package/dist/manifest.js

@@ -0,0 +1,73 @@
+/** Run manifest — stamps every probe-running result so two runs are comparable and a report is
+ * citable: tool version, command, when it ran, runtime/model, the statistical settings, and a
+ * hash of the resolved config. Same configHash = same cases + settings = apples to apples; the
+ * baseline comparison uses it to warn when a gate compares different experiments. */
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+let cachedVersion;
+export function toolVersion() {
+    if (cachedVersion === undefined) {
+        try {
+            const pkg = JSON.parse(readFileSync(join(import.meta.dirname, "..", "package.json"), "utf8"));
+            cachedVersion = pkg.version ?? "unknown";
+        }
+        catch {
+            cachedVersion = "unknown";
+        }
+    }
+    return cachedVersion;
+}
+/** Hash the parts of the config that change what was measured. `cwd` is deliberately EXCLUDED:
+ * the same library checked out at a different path (CI runner vs laptop) is the same experiment.
+ * Settings added later are hashed only when non-default, so existing baselines keep their hash. */
+export function configHash(cfg) {
+    const canonical = JSON.stringify({
+        runtime: cfg.runtime,
+        model: cfg.model ?? null,
+        k: cfg.k,
+        threshold: cfg.threshold,
+        conf: cfg.conf,
+        cases: cfg.cases.map((c) => ({ prompt: c.prompt, expected: c.expected })),
+        ...((cfg.maxTurns ?? 1) !== 1 ? { maxTurns: cfg.maxTurns } : {}),
+        ...(cfg.userConfig ? { userConfig: true } : {}),
+    });
+    return createHash("sha256").update(canonical).digest("hex").slice(0, 16);
+}
+export function buildEnvironment(cfg, env, extraSkills, adapter) {
+    return {
+        ...(env?.runtimeVersion ? { runtimeVersion: env.runtimeVersion } : {}),
+        ...(env?.model ? { resolvedModel: env.model } : {}),
+        ...(extraSkills ? { extraSkills } : {}),
+        userConfig: Boolean(cfg.userConfig),
+        hermetic: Boolean(adapter.isolatesUserConfig) && !cfg.userConfig,
+        maxTurns: cfg.maxTurns ?? 1,
+    };
+}
+/** Caveats when the config asks for something this runtime can't do. */
+export function capabilityWarnings(cfg, adapter) {
+    const w = [];
+    if (cfg.maxTurns !== undefined && cfg.maxTurns !== 1 && !adapter.supportsMaxTurns) {
+        w.push(`${adapter.name} has no turn limit — maxTurns (${cfg.maxTurns}) is ignored`);
+    }
+    if (!adapter.isolatesUserConfig && !cfg.userConfig) {
+        w.push(`${adapter.name} can't exclude your personal/global config from probes — results may differ between machines`);
+    }
+    return w;
+}
+export function buildManifest(command, cfg, environment) {
+    return {
+        tool: "skill-probe",
+        version: toolVersion(),
+        command,
+        date: new Date().toISOString(),
+        runtime: cfg.runtime,
+        model: cfg.model ?? "(runtime default)",
+        k: cfg.k,
+        threshold: cfg.threshold,
+        conf: cfg.conf,
+        configHash: configHash(cfg),
+        node: process.version,
+        ...(environment ? { environment } : {}),
+    };
+}

package/dist/orchestrator.d.ts

@@ -1,7 +1,9 @@
 /** Runs one prompt up to k VALID times with sequential early-stopping vs the threshold.
  * Infra errors (status="error") are retried up to a budget and never counted as a behavioral
- * outcome (finding #1) — they're tracked separately so the audit can flag untrustworthy cases. */
-import type { RuntimeAdapter } from "./types.ts";
+ * outcome (finding #1) — they're tracked separately so the audit can flag untrustworthy cases.
+ * Early stopping follows an exact group-sequential plan (stats.ts), so peeking after every probe
+ * doesn't inflate the verdict error rate. */
+import type { ProbeEnv, ProbeOpts, RuntimeAdapter } from "./types.ts";
 export interface RunStats {
     /** valid probes whose outcome matched the expected behavior */
     hits: number;
@@ -14,16 +16,56 @@ export interface RunStats {
     /** distribution of outcomes over valid probes: skill name (or "None") -> count */
     dist: Record<string, number>;
     totalCost: number;
+    /** valid probes where the model called some other tool and no skill fired — with a low
+     * --max-turns the skill may have been about to load, so activation can be under-counted */
+    preempted: number;
+    /** what the runtime reported loading (first probe that reported it) */
+    env?: ProbeEnv;
+    /** stopped because the shared --max-cost budget ran out (the measurement is incomplete) */
+    budgetExhausted?: boolean;
+}
+/** A shared spend cap across every probe of a run (`--max-cost`). Checked before each probe, so a
+ * run can overshoot by at most the probes already in flight. */
+export declare class Budget {
+    spent: number;
+    readonly maxUsd: number;
+    constructor(maxUsd: number);
+    get exhausted(): boolean;
+    add(usd: number): void;
 }
 /** A measurement is untrustworthy when infrastructure failures dominate — no valid probes, or
  * errors at least equal the valid count. Such a run must NOT read as a behavioral result (a runtime
  * outage is not a clean pass). Shared by the audit, context, and diagnose paths. */
 export declare function infraUntrustworthy(s: RunStats): boolean;
-export declare function measure(adapter: RuntimeAdapter, prompt: string, expected: string | null, opts: {
+export interface MeasureOpts extends Omit<ProbeOpts, "cwd"> {
     cwd: string;
     maxK: number;
     threshold: number;
     conf: number;
-    model?: string;
+    budget?: Budget;
     onProbe?: (validN: number, maxK: number) => void;
-}): Promise<RunStats>;
+}
+export declare function measure(adapter: RuntimeAdapter, prompt: string, expected: string | null, opts: MeasureOpts): Promise<RunStats>;
+/** Bounded-concurrency map preserving input order. concurrency 1 = strictly sequential. */
+export declare function mapPool<T, R>(items: readonly T[], concurrency: number, fn: (item: T, index: number) => Promise<R>): Promise<R[]>;
+/** Problems with what the runtime actually loaded for a condition that was meant to contain
+ * exactly `intended` out of `library`. Matches either folder names or frontmatter names. Skills in
+ * `ambiguous` (library skills sharing a name with a runtime built-in, which is "loaded" whether or
+ * not the library copy is) can't be judged from names alone and are skipped. */
+export declare function loadProblems(env: ProbeEnv | undefined, intended: readonly string[], library: ReadonlyArray<{
+    name: string;
+    frontmatterName?: string;
+}>, ambiguous?: ReadonlySet<string>): {
+    missing: string[];
+    unexpected: string[];
+};
+/** Library skills whose name (folder or frontmatter) is also a runtime built-in's name. */
+export declare function builtinClashes(builtins: readonly string[], library: ReadonlyArray<{
+    name: string;
+    frontmatterName?: string;
+}>): string[];
+/** Skills the runtime loaded that are NOT part of the library (runtime built-ins, user config…). */
+export declare function extraSkills(env: ProbeEnv | undefined, library: ReadonlyArray<{
+    name: string;
+    frontmatterName?: string;
+}>): string[] | undefined;

package/dist/orchestrator.js

@@ -1,4 +1,13 @@
-import { sequentialDecision } from "./stats.js";
+import { planDecision, sequentialPlan } from "./stats.js";
+/** A shared spend cap across every probe of a run (`--max-cost`). Checked before each probe, so a
+ * run can overshoot by at most the probes already in flight. */
+export class Budget {
+    spent = 0;
+    maxUsd;
+    constructor(maxUsd) { this.maxUsd = maxUsd; }
+    get exhausted() { return this.spent >= this.maxUsd; }
+    add(usd) { this.spent += usd; }
+}
 /** A measurement is untrustworthy when infrastructure failures dominate — no valid probes, or
  * errors at least equal the valid count. Such a run must NOT read as a behavioral result (a runtime
  * outage is not a clean pass). Shared by the audit, context, and diagnose paths. */
@@ -6,32 +15,92 @@ export function infraUntrustworthy(s) {
     return s.n === 0 || (s.errors > 0 && s.errors >= s.n);
 }
 export async function measure(adapter, prompt, expected, opts) {
+    const { maxK, threshold, conf, budget, onProbe, ...probeOpts } = opts;
     const want = expected ?? "None";
+    const plan = sequentialPlan(maxK, threshold, conf);
     const dist = {};
-    let hits = 0, n = 0, errors = 0, totalCost = 0;
+    let hits = 0, n = 0, errors = 0, totalCost = 0, preempted = 0;
     let lastError;
+    let env;
+    let budgetExhausted = false;
     // allow up to 50% extra attempts to absorb transient infra errors without inflating k
-    const maxAttempts = opts.maxK + Math.ceil(opts.maxK / 2);
-    for (let attempt = 0; attempt < maxAttempts && n < opts.maxK; attempt++) {
-        const r = await adapter.probe(prompt, { cwd: opts.cwd, ...(opts.model ? { model: opts.model } : {}) });
+    const maxAttempts = maxK + Math.ceil(maxK / 2);
+    for (let attempt = 0; attempt < maxAttempts && n < maxK; attempt++) {
+        if (budget?.exhausted) {
+            budgetExhausted = true;
+            lastError = `--max-cost budget ($${budget.maxUsd}) reached`;
+            break;
+        }
+        const r = await adapter.probe(prompt, probeOpts);
         totalCost += r.cost;
+        budget?.add(r.cost);
+        if (!env && r.env?.loadedSkills)
+            env = r.env;
         if (r.status === "error") {
             errors++;
             lastError = r.error;
-            opts.onProbe?.(n, opts.maxK);
+            onProbe?.(n, maxK);
             continue; // do NOT record as a behavioral outcome
         }
         const key = r.skillFired ?? "None";
         dist[key] = (dist[key] ?? 0) + 1;
         if (key === want)
             hits++;
+        if (r.skillFired === null && r.trajectory.length > 0)
+            preempted++;
         n++;
-        opts.onProbe?.(n, opts.maxK);
-        if (n >= 3) {
-            const d = sequentialDecision(hits, n, opts.threshold, opts.conf);
-            if (d !== "undecided")
-                break;
-        }
+        onProbe?.(n, maxK);
+        if (planDecision(plan, hits, n) !== "undecided")
+            break;
     }
-    return { hits, n, errors, dist, totalCost, ...(lastError ? { lastError } : {}) };
+    return {
+        hits, n, errors, dist, totalCost, preempted,
+        ...(lastError ? { lastError } : {}),
+        ...(env ? { env } : {}),
+        ...(budgetExhausted ? { budgetExhausted } : {}),
+    };
+}
+/** Bounded-concurrency map preserving input order. concurrency 1 = strictly sequential. */
+export async function mapPool(items, concurrency, fn) {
+    const out = new Array(items.length);
+    let next = 0;
+    const worker = async () => {
+        while (next < items.length) {
+            const i = next++;
+            out[i] = await fn(items[i], i);
+        }
+    };
+    const width = Math.max(1, Math.min(Math.floor(concurrency) || 1, items.length));
+    await Promise.all(Array.from({ length: width }, worker));
+    return out;
+}
+/** Problems with what the runtime actually loaded for a condition that was meant to contain
+ * exactly `intended` out of `library`. Matches either folder names or frontmatter names. Skills in
+ * `ambiguous` (library skills sharing a name with a runtime built-in, which is "loaded" whether or
+ * not the library copy is) can't be judged from names alone and are skipped. */
+export function loadProblems(env, intended, library, ambiguous = new Set()) {
+    if (!env?.loadedSkills)
+        return { missing: [], unexpected: [] };
+    const loaded = new Set(env.loadedSkills);
+    const isLoaded = (s) => loaded.has(s.name) || (s.frontmatterName !== undefined && loaded.has(s.frontmatterName));
+    const want = new Set(intended);
+    const judged = library.filter((s) => !ambiguous.has(s.name));
+    return {
+        missing: judged.filter((s) => want.has(s.name) && !isLoaded(s)).map((s) => s.name),
+        unexpected: judged.filter((s) => !want.has(s.name) && isLoaded(s)).map((s) => s.name),
+    };
+}
+/** Library skills whose name (folder or frontmatter) is also a runtime built-in's name. */
+export function builtinClashes(builtins, library) {
+    const b = new Set(builtins);
+    return library
+        .filter((s) => b.has(s.name) || (s.frontmatterName !== undefined && b.has(s.frontmatterName)))
+        .map((s) => s.name);
+}
+/** Skills the runtime loaded that are NOT part of the library (runtime built-ins, user config…). */
+export function extraSkills(env, library) {
+    if (!env?.loadedSkills)
+        return undefined;
+    const mine = new Set(library.flatMap((s) => [s.name, ...(s.frontmatterName ? [s.frontmatterName] : [])]));
+    return env.loadedSkills.filter((s) => !mine.has(s)).sort();
 }

package/dist/proc.d.ts

@@ -0,0 +1,24 @@
+export interface ProcResult {
+    /** exit code; null when killed by a signal or when the spawn itself failed */
+    code: number | null;
+    stdout: string;
+    stderr: string;
+    timedOut: boolean;
+    /** set when the binary couldn't be started at all (e.g. ENOENT: not on PATH) */
+    spawnError?: string;
+}
+/** Run `cmd args` in `cwd` with stdin closed (some CLIs hang waiting on an open stdin). Never
+ * rejects: failures come back as data so callers can classify them as infrastructure errors.
+ * Resolves within timeoutMs + PIPE_GRACE_MS no matter what the child's descendants do. */
+export declare function runProcess(cmd: string, args: string[], opts: {
+    cwd: string;
+    timeoutMs: number;
+    env?: NodeJS.ProcessEnv;
+}): Promise<ProcResult>;
+/** Track a temp dir so it's removed (plus `also`) even if the run is interrupted. */
+export declare function trackTempDir(dir: string, also?: () => void): void;
+export declare function untrackTempDir(dir: string): void;
+/** Kill live children and remove tracked temp dirs. Synchronous: safe inside an 'exit' handler. */
+export declare function cleanupAll(): void;
+/** For the CLI entry point only (library callers keep default signal behavior). */
+export declare function installSignalHandlers(): void;

package/dist/proc.js

@@ -0,0 +1,101 @@
+/** Child-process plumbing shared by the runtime adapters and the LLM CLI backend: one spawn with a
+ * hard timeout, plus a registry of live children and temp dirs so Ctrl-C / SIGTERM never leaves
+ * orphaned `claude` processes or sandbox directories behind. */
+import { spawn } from "node:child_process";
+import { rmSync } from "node:fs";
+const liveChildren = new Set();
+/** temp dir -> extra cleanup to run alongside removing it */
+const liveDirs = new Map();
+/** How long to wait for stdout/stderr to close after the child exits or is killed. A descendant
+ * that inherited our pipes can hold them open forever; the timeout must still bound wall time. */
+const PIPE_GRACE_MS = 1500;
+const OWN_GROUP = process.platform !== "win32";
+/** Kill the child and everything it spawned. Each child leads its own process group (detached),
+ * so one signal to -pid reaches grandchildren too. Only while the leader is alive — once it has
+ * exited, its group id could in principle be recycled, and we never signal a group we don't own. */
+function killTree(child) {
+    if (child.pid === undefined || child.exitCode !== null || child.signalCode !== null)
+        return;
+    try {
+        if (OWN_GROUP)
+            process.kill(-child.pid, "SIGKILL");
+        else
+            child.kill("SIGKILL");
+    }
+    catch {
+        try {
+            child.kill("SIGKILL");
+        }
+        catch { /* already gone */ }
+    }
+}
+/** Run `cmd args` in `cwd` with stdin closed (some CLIs hang waiting on an open stdin). Never
+ * rejects: failures come back as data so callers can classify them as infrastructure errors.
+ * Resolves within timeoutMs + PIPE_GRACE_MS no matter what the child's descendants do. */
+export function runProcess(cmd, args, opts) {
+    return new Promise((resolve) => {
+        let stdout = "", stderr = "", timedOut = false, settled = false;
+        let exitCode = null;
+        let grace;
+        const child = spawn(cmd, args, {
+            cwd: opts.cwd, stdio: ["ignore", "pipe", "pipe"], detached: OWN_GROUP,
+            ...(opts.env ? { env: opts.env } : {}),
+        });
+        liveChildren.add(child);
+        const finish = (r) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            clearTimeout(grace);
+            liveChildren.delete(child);
+            child.stdout?.destroy();
+            child.stderr?.destroy();
+            resolve(r);
+        };
+        const finishSoon = () => {
+            grace ??= setTimeout(() => finish({ code: exitCode, stdout, stderr, timedOut }), PIPE_GRACE_MS);
+        };
+        const timer = setTimeout(() => { timedOut = true; killTree(child); finishSoon(); }, opts.timeoutMs);
+        child.stdout.on("data", (d) => { stdout += d.toString(); });
+        child.stderr.on("data", (d) => { stderr += d.toString(); });
+        child.on("error", (e) => finish({ code: null, stdout, stderr, timedOut, spawnError: e.message }));
+        child.on("exit", (code) => { exitCode = code; finishSoon(); });
+        child.on("close", (code) => finish({ code, stdout, stderr, timedOut }));
+    });
+}
+/** Track a temp dir so it's removed (plus `also`) even if the run is interrupted. */
+export function trackTempDir(dir, also) { liveDirs.set(dir, also); }
+export function untrackTempDir(dir) { liveDirs.delete(dir); }
+/** Kill live children and remove tracked temp dirs. Synchronous: safe inside an 'exit' handler. */
+export function cleanupAll() {
+    for (const c of liveChildren)
+        killTree(c);
+    liveChildren.clear();
+    for (const [d, also] of liveDirs) {
+        try {
+            rmSync(d, { recursive: true, force: true });
+        }
+        catch { /* best effort */ }
+        try {
+            also?.();
+        }
+        catch { /* best effort */ }
+    }
+    liveDirs.clear();
+}
+let installed = false;
+/** For the CLI entry point only (library callers keep default signal behavior). */
+export function installSignalHandlers() {
+    if (installed)
+        return;
+    installed = true;
+    process.on("exit", cleanupAll);
+    for (const [sig, code] of [["SIGINT", 130], ["SIGTERM", 143]]) {
+        process.on(sig, () => {
+            process.stderr.write(`\nskill-probe: interrupted (${sig}) — stopping probes and cleaning up\n`);
+            cleanupAll();
+            process.exit(code);
+        });
+    }
+}

package/dist/report.d.ts

@@ -1,10 +1,13 @@
+/** Human table + machine JSON rendering. Every number ships with its CI and k; infrastructure
+ * errors are shown distinctly from behavioral results. */
+import { kToCertify } from "./stats.ts";
 import type { AuditResult } from "./eval.ts";
 import type { FixResult } from "./fix.ts";
 import type { ContextAuditResult } from "./context.ts";
 import type { DoctorResult } from "./doctor.ts";
 import type { DiagnoseResult } from "./diagnose.ts";
-/** Smallest k at which an all-success run could certify reliability >= threshold. */
-export declare function kToCertify(threshold: number, conf: number): number;
+import type { BaselineComparison } from "./baseline.ts";
+export { kToCertify };
 export interface RenderOpts {
     showCost?: boolean;
 }
@@ -17,4 +20,6 @@ export declare function renderDiagnose(d: DiagnoseResult, opts?: RenderOpts): st
 export declare function renderDoctor(d: DoctorResult): string;
 /** activation-rate-by-context: isolation vs co-loaded, with a Fisher's-exact p on the drop. */
 export declare function renderContext(a: ContextAuditResult, opts?: RenderOpts): string;
+/** regression gate vs a saved baseline: only significant (BH-corrected) drops fail the build. */
+export declare function renderBaseline(cmp: BaselineComparison): string;
 export declare function renderFix(f: FixResult): string;