vigiles 2.2.0 → 2.4.0

package/dist/harness-test.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.scriptModel = void 0;
+exports.resolveHarness = exports.loadPlugin = exports.scriptModel = void 0;
+exports.parseToolCalls = parseToolCalls;
 exports.claudeAvailable = claudeAvailable;
 exports.runHarnessTest = runHarnessTest;
 /**
@@ -37,8 +38,69 @@ const node_fs_1 = require("node:fs");
 const node_os_1 = require("node:os");
 const node_path_1 = require("node:path");
 const mock_model_js_1 = require("./mock-model.js");
+const plugin_loader_js_1 = require("./plugin-loader.js");
 var mock_model_js_2 = require("./mock-model.js");
 Object.defineProperty(exports, "scriptModel", { enumerable: true, get: function () { return mock_model_js_2.scriptModel; } });
+var plugin_loader_js_2 = require("./plugin-loader.js");
+Object.defineProperty(exports, "loadPlugin", { enumerable: true, get: function () { return plugin_loader_js_2.loadPlugin; } });
+Object.defineProperty(exports, "resolveHarness", { enumerable: true, get: function () { return plugin_loader_js_2.resolveHarness; } });
+function contentText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((b) => {
+        if (typeof b === "string")
+            return b;
+        const t = b.text;
+        return typeof t === "string" ? t : "";
+    })
+        .join("");
+}
+/**
+ * Parse `--output-format stream-json` (the `transcript: true` output) into the
+ * tools the agent invoked, each joined to its result by id. Returns [] for the
+ * non-stream `json` output. The seam that lets a test assert on the agent's
+ * actions, not a brittle stdout substring.
+ */
+function parseToolCalls(streamJson) {
+    const uses = [];
+    const results = new Map();
+    for (const line of streamJson.split("\n")) {
+        if (!line.trim())
+            continue;
+        let evt;
+        try {
+            evt = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const content = evt.message?.content;
+        if (!Array.isArray(content))
+            continue;
+        for (const b of content) {
+            if (b.type === "tool_use" && typeof b.name === "string") {
+                const id = typeof b.id === "string" ? b.id : "";
+                uses.push({ id, name: b.name, input: b.input });
+            }
+            else if (b.type === "tool_result") {
+                const id = typeof b.tool_use_id === "string" ? b.tool_use_id : "";
+                results.set(id, {
+                    text: contentText(b.content),
+                    isError: b.is_error === true,
+                });
+            }
+        }
+    }
+    return uses.map((u) => ({
+        name: u.name,
+        input: u.input,
+        resultText: results.get(u.id)?.text ?? "",
+        isError: results.get(u.id)?.isError ?? false,
+    }));
+}
 /** Whether the `claude` CLI is available — harness tests need it. */
 function claudeAvailable() {
     try {
@@ -48,17 +110,17 @@ function claudeAvailable() {
         return false;
     }
 }
-function writeFixture(cwd, spec) {
-    for (const [p, content] of Object.entries(spec.files ?? {})) {
+function writeFixture(cwd, files, settings) {
+    for (const [p, content] of Object.entries(files)) {
         const full = (0, node_path_1.resolve)(cwd, p);
         (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(full), { recursive: true });
         (0, node_fs_1.writeFileSync)(full, content);
     }
-    if (spec.settings !== undefined) {
+    if (settings !== undefined) {
         // `{cwd}` in any hook command is substituted with the working dir, so a
         // hook can reference an absolute path inside it (hooks don't run with the
         // project dir as cwd).
-        const json = JSON.stringify(spec.settings, null, 2).replaceAll("{cwd}", cwd);
+        const json = JSON.stringify(settings, null, 2).replaceAll("{cwd}", cwd);
         (0, node_fs_1.writeFileSync)((0, node_path_1.join)(cwd, "settings.json"), json);
     }
 }
@@ -91,18 +153,27 @@ function spawnClaude(args, cwd, baseUrl, timeoutMs) {
  */
 async function runHarnessTest(spec) {
     const cwd = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "vigiles-harness-"));
-    writeFixture(cwd, spec);
+    const { files, settings } = (0, plugin_loader_js_1.resolveHarness)({
+        plugin: spec.plugin,
+        settings: spec.settings,
+        files: spec.files,
+    });
+    writeFixture(cwd, files, settings);
     const mock = await (0, mock_model_js_1.startMock)(spec.model);
     try {
         const tools = spec.allowedTools ?? ["Read", "Edit", "Write", "Bash"];
         const args = [
             "-p",
             spec.prompt ?? "go",
-            "--output-format",
-            "json",
+            ...(spec.transcript
+                ? ["--output-format", "stream-json", "--verbose"]
+                : ["--output-format", "json"]),
             "--model",
             "claude-sonnet-4-5",
-            ...(spec.settings !== undefined ? ["--settings", "settings.json"] : []),
+            ...(spec.pluginDir !== undefined
+                ? ["--plugin-dir", (0, node_path_1.resolve)(spec.pluginDir)]
+                : []),
+            ...(settings !== undefined ? ["--settings", "settings.json"] : []),
             "--allowedTools",
             ...tools,
         ];
@@ -113,6 +184,7 @@ async function runHarnessTest(spec) {
             stderr: out.stderr,
             cwd,
             turns: mock.count,
+            toolCalls: parseToolCalls(out.stdout),
             file: (p) => {
                 const f = (0, node_path_1.resolve)(cwd, p);
                 return (0, node_fs_1.existsSync)(f) ? (0, node_fs_1.readFileSync)(f, "utf-8") : null;

package/dist/jest.d.ts

@@ -0,0 +1,9 @@
+declare module "@jest/expect" {
+    interface Matchers<R> {
+        toHaveCreated(path: string): R;
+        toBlock(): R;
+        toBeatBaseline(baseline: string, arm: string, metric: string, by?: number): R;
+    }
+}
+export {};
+//# sourceMappingURL=jest.d.ts.map

package/dist/jest.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable max-params --
+   The matcher signatures mirror the runtime vigilesMatchers (positional args). */
+/**
+ * vigiles — jest integration (opt-in).
+ *
+ * Importing this entry registers the vigiles matchers AND augments jest's types
+ * so `toHaveCreated` / `toBeatBaseline` type-check.
+ *
+ *   // jest.config.js →  setupFilesAfterEnv: ["vigiles/jest"]
+ *   // …or at the top of a test file:
+ *   import "vigiles/jest";
+ *
+ *   expect(result).toHaveCreated("DONE");
+ *   expect(report).toBeatBaseline("vanilla", "gated", "caught");
+ *
+ * jest is an optional peer dependency — only jest users load this entry.
+ */
+const globals_1 = require("@jest/globals");
+const harness_assert_js_1 = require("./harness-assert.js");
+globals_1.expect.extend(harness_assert_js_1.vigilesMatchers);
+//# sourceMappingURL=jest.js.map

package/dist/judge.d.ts

@@ -0,0 +1,29 @@
+export interface JudgeResult {
+    /** Score in [0, 1] (clamped). 0 on any failure to obtain a verdict. */
+    readonly score: number;
+    /** score ≥ threshold (default 0.5). */
+    readonly pass: boolean;
+    /** The model's one-line rationale, or an error string. */
+    readonly reason: string;
+}
+export interface JudgeOptions {
+    /** The text to grade. */
+    readonly output: string;
+    /** The grading rubric — describe what earns a high vs low score. */
+    readonly rubric: string;
+    /** Model alias. Default "haiku" (cheap; judging is a simple call). */
+    readonly model?: string;
+    /** pass = score ≥ threshold. Default 0.5. */
+    readonly threshold?: number;
+    /** Per-call timeout ms. Default 60000. */
+    readonly timeoutMs?: number;
+}
+/** Grade `output` against `rubric` with a model. Synchronous (for `measure`). */
+export declare function judge(opts: JudgeOptions): JudgeResult;
+/**
+ * Parse a verdict out of the grader's stdout — pure, so the parsing is testable
+ * without a model. Handles `claude --output-format json` (text wrapped in a
+ * `result` field), bare/prose-wrapped JSON, clamping, and the pass threshold.
+ */
+export declare function parseJudgeOutput(stdout: string, threshold?: number): JudgeResult;
+//# sourceMappingURL=judge.d.ts.map

package/dist/judge.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.judge = judge;
+exports.parseJudgeOutput = parseJudgeOutput;
+/**
+ * vigiles — a thin LLM-as-judge for the eval tier.
+ *
+ * Some outcomes aren't a regex: "is this commit message clear?", "did the SKILL
+ * produce a sensible plan?". `judge` grades an output against a rubric with a
+ * model and returns a numeric score + pass/fail, for use *inside* an eval's
+ * `measure` (which is synchronous — so this shells out via the `claude` CLI
+ * synchronously, no extra deps):
+ *
+ *   measure: (ctx) => {
+ *     const v = judge({ output: ctx.file("PLAN.md") ?? "", rubric:
+ *       "1 if the plan lists concrete, ordered steps; else 0." });
+ *     return { quality: v.score, ok: v.pass };
+ *   }
+ *
+ * This is deliberately minimal — for datasets, tracing, and dashboards use a
+ * dedicated eval platform (Braintrust, DeepEval). vigiles owns the harness A/B,
+ * not the judging platform. Needs the `claude` CLI + model auth.
+ */
+const node_child_process_1 = require("node:child_process");
+const clamp01 = (n) => Math.max(0, Math.min(1, n));
+/** Extract the first JSON object from a string (models often wrap it in prose). */
+function firstJsonObject(s) {
+    const start = s.indexOf("{");
+    const end = s.lastIndexOf("}");
+    if (start === -1 || end <= start)
+        return null;
+    try {
+        return JSON.parse(s.slice(start, end + 1));
+    }
+    catch {
+        return null;
+    }
+}
+/** Grade `output` against `rubric` with a model. Synchronous (for `measure`). */
+function judge(opts) {
+    const threshold = opts.threshold ?? 0.5;
+    const prompt = "You are a strict grader. Score the OUTPUT against the RUBRIC. " +
+        'Respond with ONLY a JSON object: {"score": <number 0..1>, "reason": "<one line>"}.\n\n' +
+        `RUBRIC:\n${opts.rubric}\n\nOUTPUT:\n${opts.output}`;
+    let res;
+    try {
+        res = (0, node_child_process_1.spawnSync)("claude", [
+            "-p",
+            prompt,
+            "--model",
+            opts.model ?? "haiku",
+            "--output-format",
+            "json",
+        ], { encoding: "utf-8", timeout: opts.timeoutMs ?? 60000 });
+    }
+    catch (e) {
+        return {
+            score: 0,
+            pass: false,
+            reason: `judge spawn failed: ${String(e)}`,
+        };
+    }
+    if (res.status !== 0) {
+        return { score: 0, pass: false, reason: "judge: no model output" };
+    }
+    return parseJudgeOutput(res.stdout ?? "", threshold);
+}
+/**
+ * Parse a verdict out of the grader's stdout — pure, so the parsing is testable
+ * without a model. Handles `claude --output-format json` (text wrapped in a
+ * `result` field), bare/prose-wrapped JSON, clamping, and the pass threshold.
+ */
+function parseJudgeOutput(stdout, threshold = 0.5) {
+    if (!stdout)
+        return { score: 0, pass: false, reason: "judge: no model output" };
+    // claude --output-format json wraps the model text in a `result` field.
+    let text = stdout;
+    const wrapper = firstJsonObject(stdout);
+    if (wrapper && typeof wrapper.result === "string")
+        text = wrapper.result;
+    const verdict = firstJsonObject(text);
+    if (!verdict || typeof verdict.score !== "number") {
+        return { score: 0, pass: false, reason: "judge: unparseable verdict" };
+    }
+    const score = clamp01(verdict.score);
+    return { score, pass: score >= threshold, reason: verdict.reason ?? "" };
+}
+//# sourceMappingURL=judge.js.map

package/dist/mcp.d.ts

@@ -0,0 +1,48 @@
+export interface McpServerConfig {
+    readonly command: string;
+    readonly args?: readonly string[];
+    readonly env?: Record<string, string>;
+    readonly cwd?: string;
+}
+export interface McpToolInfo {
+    readonly name: string;
+    readonly description?: string;
+}
+/**
+ * Start an MCP server over stdio, complete the handshake, and return its tools.
+ * Kills the server when done. Throws on spawn/timeout/exit/protocol error.
+ */
+export declare function listMcpTools(server: McpServerConfig, timeoutMs?: number): Promise<McpToolInfo[]>;
+export interface McpRefResult {
+    readonly exists: boolean;
+    readonly available: string[];
+    readonly suggestions: string[];
+}
+/**
+ * Verify `toolName` exists on `server`; on a miss, suggest the closest tool names
+ * (edit distance) — "did you mean issue_write?".
+ */
+export declare function verifyMcpTool(server: McpServerConfig, toolName: string, timeoutMs?: number): Promise<McpRefResult>;
+export interface McpRef {
+    readonly server: string;
+    readonly tool: string;
+    readonly line: number;
+}
+export type McpRefReason = "server-undeclared" | "server-unreachable" | "tool-missing";
+export interface McpRefError extends McpRef {
+    readonly reason: McpRefReason;
+    readonly suggestions: string[];
+}
+/** Parse `vigiles:mcp server#tool` marks from a markdown file's inline spans. */
+export declare function parseMcpRefs(markdown: string): McpRef[];
+/** Read `mcpServers` from `.mcp.json` (the stdio-server config map), or `{}`. */
+export declare function loadMcpServers(cwd: string): Record<string, McpServerConfig>;
+/**
+ * Verify every `vigiles:mcp server#tool` mark in `markdown` against the live
+ * servers in `mcpServers` (each referenced server is started once). A reference
+ * to an undeclared server, an unreachable server, or a missing tool is an error.
+ */
+export declare function verifyMcpRefs(markdown: string, mcpServers: Record<string, McpServerConfig>, timeoutMs?: number): Promise<McpRefError[]>;
+/** Human-readable message for an MCP reference error (with "did you mean"). */
+export declare function mcpRefMessage(e: McpRefError): string;
+//# sourceMappingURL=mcp.d.ts.map

package/dist/mcp.js

@@ -0,0 +1,247 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listMcpTools = listMcpTools;
+exports.verifyMcpTool = verifyMcpTool;
+exports.parseMcpRefs = parseMcpRefs;
+exports.loadMcpServers = loadMcpServers;
+exports.verifyMcpRefs = verifyMcpRefs;
+exports.mcpRefMessage = mcpRefMessage;
+/**
+ * Minimal MCP client over stdio — start a server, do the JSON-RPC handshake, and
+ * list its tools. This lets vigiles VERIFY a referenced `mcp__server__tool`
+ * resolves against the real server (the way `enforce()` resolves a linter rule
+ * against its catalog), catching a skill/CLAUDE.md that cites an MCP tool that was
+ * renamed or removed — e.g. the GitHub MCP server renaming `create_issue` →
+ * `issue_write`, which otherwise fails silently at runtime.
+ *
+ * MCP stdio transport = newline-delimited JSON-RPC 2.0.
+ */
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const refs_js_1 = require("./refs.js");
+const hash_js_1 = require("./hash.js");
+function dispatch(line, pending) {
+    let msg;
+    try {
+        msg = JSON.parse(line);
+    }
+    catch {
+        return;
+    }
+    if (typeof msg.id !== "number")
+        return;
+    const p = pending.get(msg.id);
+    if (p) {
+        pending.delete(msg.id);
+        p.resolve(msg);
+    }
+}
+/**
+ * Start an MCP server over stdio, complete the handshake, and return its tools.
+ * Kills the server when done. Throws on spawn/timeout/exit/protocol error.
+ */
+async function listMcpTools(server, timeoutMs = 10000) {
+    const child = (0, node_child_process_1.spawn)(server.command, [...(server.args ?? [])], {
+        env: server.env ? { ...process.env, ...server.env } : process.env,
+        cwd: server.cwd,
+        stdio: ["pipe", "pipe", "ignore"],
+    });
+    const { stdin, stdout } = child;
+    if (!stdin || !stdout) {
+        child.kill("SIGKILL");
+        throw new Error("failed to open MCP server stdio");
+    }
+    const pending = new Map();
+    const failAll = (err) => {
+        for (const [, p] of pending)
+            p.reject(err);
+        pending.clear();
+    };
+    let buffer = "";
+    stdout.setEncoding("utf-8");
+    stdout.on("data", (chunk) => {
+        buffer += chunk;
+        let nl = buffer.indexOf("\n");
+        while (nl >= 0) {
+            const line = buffer.slice(0, nl).trim();
+            buffer = buffer.slice(nl + 1);
+            if (line)
+                dispatch(line, pending);
+            nl = buffer.indexOf("\n");
+        }
+    });
+    child.on("error", (e) => {
+        failAll(e);
+    });
+    child.on("close", () => {
+        failAll(new Error("MCP server exited before responding"));
+    });
+    const send = (obj) => {
+        stdin.write(`${JSON.stringify(obj)}\n`);
+    };
+    const request = (id, method, params) => new Promise((resolve, reject) => {
+        pending.set(id, { resolve, reject });
+        send({ jsonrpc: "2.0", id, method, params });
+    });
+    const timer = setTimeout(() => {
+        failAll(new Error(`MCP server timed out after ${String(timeoutMs)}ms`));
+        child.kill("SIGKILL");
+    }, timeoutMs);
+    try {
+        await request(1, "initialize", {
+            protocolVersion: "2024-11-05",
+            capabilities: {},
+            clientInfo: { name: "vigiles", version: "0" },
+        });
+        send({ jsonrpc: "2.0", method: "notifications/initialized" });
+        const res = await request(2, "tools/list", {});
+        if (res.error) {
+            throw new Error(`tools/list failed: ${res.error.message ?? "unknown"}`);
+        }
+        return (res.result?.tools ?? []).map((t) => ({
+            name: t.name,
+            description: t.description,
+        }));
+    }
+    finally {
+        clearTimeout(timer);
+        child.kill("SIGKILL");
+    }
+}
+/**
+ * Verify `toolName` exists on `server`; on a miss, suggest the closest tool names
+ * (edit distance) — "did you mean issue_write?".
+ */
+async function verifyMcpTool(server, toolName, timeoutMs = 10000) {
+    const available = (await listMcpTools(server, timeoutMs)).map((t) => t.name);
+    const exists = available.includes(toolName);
+    return {
+        exists,
+        available,
+        suggestions: exists ? [] : closest(toolName, available),
+    };
+}
+function editDistance(a, b) {
+    if (a === b)
+        return 0;
+    const m = a.length;
+    const n = b.length;
+    if (m === 0)
+        return n;
+    if (n === 0)
+        return m;
+    const dp = Array.from({ length: n + 1 }, (_, i) => i);
+    for (let i = 1; i <= m; i++) {
+        let prev = dp[0];
+        dp[0] = i;
+        for (let j = 1; j <= n; j++) {
+            const tmp = dp[j];
+            dp[j] =
+                a[i - 1] === b[j - 1] ? prev : 1 + Math.min(prev, dp[j], dp[j - 1]);
+            prev = tmp;
+        }
+    }
+    return dp[n];
+}
+function closest(target, candidates, max = 4) {
+    return candidates
+        .map((c) => ({ c, d: editDistance(target, c) }))
+        .filter((x) => x.d <= max)
+        .sort((a, b) => a.d - b.d)
+        .slice(0, 3)
+        .map((x) => x.c);
+}
+// --- MCP tool references in instruction files ------------------------------
+// `vigiles:mcp <server>#<tool>` inside an inline code span — the MCP analogue of
+// the `vigiles:symbol path#name` mark. Self-contained (server + tool in one
+// token) so it binds unambiguously.
+const MCP_MARK = /^vigiles:mcp\s+([\w-]+)#([\w.-]+)$/;
+/** Parse `vigiles:mcp server#tool` marks from a markdown file's inline spans. */
+function parseMcpRefs(markdown) {
+    const refs = [];
+    for (const span of (0, refs_js_1.inlineSpans)(markdown)) {
+        const m = MCP_MARK.exec(span.text);
+        if (m)
+            refs.push({ server: m[1], tool: m[2], line: span.line });
+    }
+    return refs;
+}
+/** Read `mcpServers` from `.mcp.json` (the stdio-server config map), or `{}`. */
+function loadMcpServers(cwd) {
+    const p = (0, node_path_1.join)(cwd, ".mcp.json");
+    if (!(0, node_fs_1.existsSync)(p))
+        return {};
+    try {
+        const json = JSON.parse((0, node_fs_1.readFileSync)(p, "utf-8"));
+        return json.mcpServers ?? {};
+    }
+    catch {
+        return {};
+    }
+}
+async function verifyOneServer(group, cfg, timeoutMs) {
+    if (!cfg) {
+        return group.map((r) => ({
+            ...r,
+            reason: "server-undeclared",
+            suggestions: [],
+        }));
+    }
+    let available;
+    try {
+        available = (await listMcpTools(cfg, timeoutMs)).map((t) => t.name);
+    }
+    catch {
+        return group.map((r) => ({
+            ...r,
+            reason: "server-unreachable",
+            suggestions: [],
+        }));
+    }
+    const errs = [];
+    for (const r of group) {
+        if (!available.includes(r.tool)) {
+            errs.push({
+                ...r,
+                reason: "tool-missing",
+                suggestions: closest(r.tool, available),
+            });
+        }
+    }
+    return errs;
+}
+/**
+ * Verify every `vigiles:mcp server#tool` mark in `markdown` against the live
+ * servers in `mcpServers` (each referenced server is started once). A reference
+ * to an undeclared server, an unreachable server, or a missing tool is an error.
+ */
+async function verifyMcpRefs(markdown, mcpServers, timeoutMs = 10000) {
+    const byServer = new Map();
+    for (const r of parseMcpRefs(markdown)) {
+        const arr = byServer.get(r.server) ?? [];
+        arr.push(r);
+        byServer.set(r.server, arr);
+    }
+    const all = [];
+    for (const [server, group] of byServer) {
+        all.push(...(await verifyOneServer(group, mcpServers[server], timeoutMs)));
+    }
+    return all;
+}
+/** Human-readable message for an MCP reference error (with "did you mean"). */
+function mcpRefMessage(e) {
+    switch (e.reason) {
+        case "server-undeclared":
+            return `MCP server "${e.server}" is not declared in .mcp.json`;
+        case "server-unreachable":
+            return `MCP server "${e.server}" failed to start`;
+        case "tool-missing":
+            return `MCP tool "${e.server}#${e.tool}" not found${e.suggestions.length > 0
+                ? ` — did you mean ${e.suggestions.map((s) => `"${s}"`).join(", ")}?`
+                : ""}`;
+        default:
+            return (0, hash_js_1.assertNever)(e.reason);
+    }
+}
+//# sourceMappingURL=mcp.js.map

package/dist/plugin-loader.d.ts

@@ -0,0 +1,37 @@
+export interface LoadedPlugin {
+    /** A `.claude/settings.json`-shaped object with hooks resolved. */
+    readonly settings: {
+        hooks?: unknown;
+    };
+    /** Files to materialize in the sandbox (CLAUDE.md, skills, agents, commands). */
+    readonly files: Record<string, string>;
+    /**
+     * Surfaces that are present in the plugin but cannot be exercised at the
+     * deterministic tier (subagents and slash commands need a real model; MCP
+     * servers aren't wired by the loader). Empty when the plugin is fully
+     * covered. Surfaced so "load the whole plugin" never silently tests nothing —
+     * read it in a test, or just to know what the deterministic run won't reach.
+     */
+    readonly warnings: readonly string[];
+}
+/**
+ * Load the real harness at `pluginPath`. Returns the resolved settings (hooks),
+ * the files (CLAUDE.md + skills + agents + commands) to write into the test
+ * sandbox, and `warnings` for surfaces the deterministic tier can't drive. Merge
+ * `settings` with any inline settings and spread `files` into the fixture.
+ */
+export declare function loadPlugin(pluginPath: string): LoadedPlugin;
+/**
+ * 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
+ * `runEval` so both test the assembled machine the same way.
+ */
+export declare function resolveHarness(opts: {
+    plugin?: string;
+    settings?: unknown;
+    files?: Record<string, string>;
+}): {
+    settings: unknown;
+    files: Record<string, string>;
+};
+//# sourceMappingURL=plugin-loader.d.ts.map