vigiles 2.5.0 → 3.0.0

package/dist/adapters/codex/mock-model.js

@@ -0,0 +1,210 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderResponsesSSE = renderResponsesSSE;
+exports.parseResponsesRequest = parseResponsesRequest;
+exports.startCodexMock = startCodexMock;
+/**
+ * codex mock-model — EXPERIMENTAL, internal-only. A scripted, deterministic
+ * OpenAI **Responses API** mock that real `codex` completes a turn against.
+ *
+ * Codex speaks the Responses API: a turn-consuming request hits
+ * `POST /v1/responses` with `Accept: text/event-stream`, and the mock answers
+ * with the proven `response.created → … → response.completed` SSE sequence that
+ * makes codex emit one assistant text message. There is no count-tokens
+ * endpoint. This is the Codex-side analogue of the Anthropic Messages mock in
+ * `src/adapters/claude-code/mock-model.ts` (`startMock`).
+ *
+ * The wire format here is NOT guessed — it is PROVEN end-to-end against real
+ * `codex` (codex-cli 0.139.0) via the `-c model_providers.mock.*` recipe in
+ * `src/adapters/codex/runtime.ts` (`codexMockArgs`/`codexMockEnv`).
+ */
+const node_http_1 = __importDefault(require("node:http"));
+const MSG_ID = "msg_mock_1";
+const RESP_ID = "resp_mock_1";
+/**
+ * Render the PROVEN OpenAI-Responses SSE event sequence for a single assistant
+ * text message — `response.created` through `response.completed`. This exact
+ * sequence is confirmed to make real `codex` complete a turn. Pure and exported
+ * so the renderer is testable without the HTTP server.
+ */
+function renderResponsesSSE(text, opts = {}) {
+    const model = opts.model ?? "gpt-5-codex";
+    const response = (status, output) => ({
+        id: RESP_ID,
+        object: "response",
+        status,
+        model,
+        output,
+        usage: null,
+    });
+    const completedItem = {
+        type: "message",
+        id: MSG_ID,
+        status: "completed",
+        role: "assistant",
+        content: [{ type: "output_text", text }],
+    };
+    const events = [
+        {
+            type: "response.created",
+            data: { response: response("in_progress", []) },
+        },
+        {
+            type: "response.in_progress",
+            data: { response: response("in_progress", []) },
+        },
+        {
+            type: "response.output_item.added",
+            data: {
+                output_index: 0,
+                item: {
+                    type: "message",
+                    id: MSG_ID,
+                    status: "in_progress",
+                    role: "assistant",
+                    content: [],
+                },
+            },
+        },
+        {
+            type: "response.content_part.added",
+            data: {
+                item_id: MSG_ID,
+                output_index: 0,
+                content_index: 0,
+                part: { type: "output_text", text: "" },
+            },
+        },
+        {
+            type: "response.output_text.delta",
+            data: { item_id: MSG_ID, output_index: 0, content_index: 0, delta: text },
+        },
+        {
+            type: "response.output_text.done",
+            data: { item_id: MSG_ID, output_index: 0, content_index: 0, text },
+        },
+        {
+            type: "response.content_part.done",
+            data: {
+                item_id: MSG_ID,
+                output_index: 0,
+                content_index: 0,
+                part: { type: "output_text", text },
+            },
+        },
+        {
+            type: "response.output_item.done",
+            data: { output_index: 0, item: completedItem },
+        },
+        {
+            type: "response.completed",
+            data: { response: response("completed", [completedItem]) },
+        },
+    ];
+    return events
+        .map((e) => `event: ${e.type}\n` +
+        `data: ${JSON.stringify({ type: e.type, ...e.data })}\n\n`)
+        .join("");
+}
+function joinInputText(content) {
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((c) => {
+        const t = c.text;
+        return typeof t === "string" ? t : "";
+    })
+        .join("");
+}
+/**
+ * Parse a Responses request body — the user's prompt (the LAST `input` item
+ * with `role:"user"`, joining its `content[].text`), the requested `model`, and
+ * the declared function-tool names. Tolerates malformed JSON (returns an empty
+ * prompt). Pure and exported so request capture is testable without the server.
+ */
+function parseResponsesRequest(body) {
+    let parsed = {};
+    try {
+        parsed = JSON.parse(body);
+    }
+    catch {
+        return { prompt: "", model: "", toolNames: [] };
+    }
+    const input = Array.isArray(parsed.input)
+        ? parsed.input
+        : [];
+    const lastUser = [...input]
+        .reverse()
+        .find((item) => item.role === "user" && item.type === "message");
+    const prompt = lastUser ? joinInputText(lastUser.content) : "";
+    const model = typeof parsed.model === "string" ? parsed.model : "";
+    const toolNames = Array.isArray(parsed.tools)
+        ? parsed.tools
+            .map((t) => {
+            const tool = t;
+            if (typeof tool.name === "string")
+                return tool.name;
+            const fnName = tool.function?.name;
+            return typeof fnName === "string" ? fnName : "";
+        })
+            .filter((n) => n.length > 0)
+        : [];
+    return { prompt, model, toolNames };
+}
+/**
+ * Start the scripted Codex Responses mock on a free port. Each
+ * `POST /v1/responses` consumes the next scripted turn (the last turn repeats if
+ * codex asks for more); HEAD and any other path get `{}`. Resolves to a handle
+ * with the base `url`, the `port`, the recorded `requests`, and `close()`.
+ */
+function startCodexMock(script, opts = {}) {
+    let i = 0;
+    const requests = [];
+    const server = node_http_1.default.createServer((req, res) => {
+        let body = "";
+        req.on("data", (c) => (body += c));
+        req.on("end", () => {
+            const url = req.url ?? "";
+            const isResponses = req.method === "POST" && url.includes("/v1/responses");
+            if (!isResponses) {
+                res.writeHead(200, { "content-type": "application/json" });
+                res.end("{}");
+                return;
+            }
+            const parsed = parseResponsesRequest(body);
+            requests.push(parsed);
+            opts.onRequest?.(parsed);
+            const turn = script[Math.min(i, script.length - 1)] ?? { text: "" };
+            i++;
+            const model = parsed.model || "gpt-5-codex";
+            res.writeHead(200, {
+                "content-type": "text/event-stream",
+                "cache-control": "no-cache",
+                connection: "keep-alive",
+            });
+            res.write(renderResponsesSSE(turn.text, { model }));
+            res.end();
+        });
+    });
+    return new Promise((resolve) => {
+        server.listen(0, "127.0.0.1", () => {
+            const { port } = server.address();
+            resolve({
+                url: `http://127.0.0.1:${String(port)}`,
+                port,
+                get requests() {
+                    return requests;
+                },
+                close: () => new Promise((r) => {
+                    server.close(() => {
+                        r();
+                    });
+                }),
+            });
+        });
+    });
+}
+//# sourceMappingURL=mock-model.js.map

package/dist/adapters/codex/model-mock.d.ts

@@ -0,0 +1,11 @@
+/**
+ * codexModelMock — EXPERIMENTAL, internal-only. Codex speaks the OpenAI
+ * **Responses** API: a turn-consuming request hits `/v1/responses`, and there is
+ * no count-tokens endpoint. Finding: the `ModelMock` *descriptor* captures the
+ * wire facts cleanly; the SSE *renderer* (the `response.created → … →
+ * response.completed` event sequence + a Responses request-parser) is the
+ * deferred piece — built with the Codex transport tier, not declared here.
+ */
+import type { ModelMock } from "../../core/model-mock.js";
+export declare const codexModelMock: ModelMock;
+//# sourceMappingURL=model-mock.d.ts.map

package/dist/adapters/codex/model-mock.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codexModelMock = void 0;
+exports.codexModelMock = {
+    name: "codex",
+    wireApi: "openai-responses",
+    modelEndpoint: "/v1/responses",
+    // No count-tokens endpoint (countTokensEndpoint omitted).
+};
+//# sourceMappingURL=model-mock.js.map

package/dist/adapters/codex/runtime.d.ts

@@ -0,0 +1,38 @@
+/**
+ * codexRuntime — EXPERIMENTAL, internal-only. A prototype `HarnessRuntime` for
+ * Codex: spawn `codex`, and point it at a no-key mock.
+ *
+ * PROVEN wiring (validated against real codex-cli 0.139.0): the clean keyless
+ * route is NOT the built-in `OPENAI_BASE_URL` override the prototype guessed
+ * (the docs called that "messy") — it is a `[model_providers.mock]` provider
+ * defined inline via `-c` flags on `codex exec`. `codexMockArgs(baseUrl)`
+ * returns that flag array (the `wireMock` recipe as data) and `codexMockEnv()`
+ * returns the dummy-key env codex reads through it. So "point at the mock" is a
+ * flag-based *operation* here, not a single env var.
+ *
+ * The `HarnessRuntime` port still requires `modelBaseUrlEnv`/`modelApiKeyEnv`
+ * (the env-var transport axis), so we keep valid values for conformance — but
+ * codex's real wiring is the flag-based recipe below, not those env vars. The
+ * port's `wireMock(baseUrl)` surfaces that recipe as `{ args, env }` so the
+ * generalized `runHarnessTest` runner drives codex the same way it drives
+ * Claude Code; `codexMockArgs`/`codexMockEnv` remain exported (used by
+ * `wireMock` and by `mock-model.test.ts`).
+ */
+import type { HarnessRuntime } from "../../core/runtime.js";
+export declare const codexRuntime: HarnessRuntime;
+/**
+ * The PROVEN `-c` flag array that points `codex exec` at a mock served at
+ * `baseUrl` (e.g. `http://127.0.0.1:PORT`) over the Responses wire API, keyless.
+ * Defines a `[model_providers.mock]` provider inline and selects it as the
+ * active model provider. `baseUrl` is suffixed with `/v1` (codex appends
+ * `/responses`). Combine with `codexMockEnv()` and the `codex exec` flags
+ * `--ignore-user-config --skip-git-repo-check --ephemeral
+ * --dangerously-bypass-approvals-and-sandbox -c model="gpt-5-codex"`.
+ */
+export declare function codexMockArgs(baseUrl: string): string[];
+/**
+ * The dummy-key env codex reads `model_providers.mock.env_key` through. Codex
+ * sends `Authorization: Bearer dummy-key`; the mock ignores it.
+ */
+export declare function codexMockEnv(): Record<string, string>;
+//# sourceMappingURL=runtime.d.ts.map

package/dist/adapters/codex/runtime.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codexRuntime = void 0;
+exports.codexMockArgs = codexMockArgs;
+exports.codexMockEnv = codexMockEnv;
+exports.codexRuntime = {
+    name: "codex",
+    agentBinary: "codex",
+    // Kept non-empty for HarnessRuntime conformance (the env-var transport axis).
+    // Codex's PROVEN keyless wiring is the flag-based codexMockArgs recipe, not
+    // this built-in-provider override.
+    modelBaseUrlEnv: "OPENAI_BASE_URL",
+    modelApiKeyEnv: "MOCK_KEY",
+    mockApiKey: "dummy-key",
+    /**
+     * Codex reaches the mock through the PROVEN keyless flag recipe (the
+     * `-c model_providers.mock.*` array), NOT a single base-URL env var. So
+     * `wireMock` carries args (the flags) AND env (the dummy key codex reads
+     * `model_providers.mock.env_key` through). The `wireMock` method unifies both
+     * transport axes (CC's env-only, Codex's flags) behind one call.
+     */
+    wireMock(baseUrl) {
+        return { args: codexMockArgs(baseUrl), env: codexMockEnv() };
+    },
+};
+/**
+ * The PROVEN `-c` flag array that points `codex exec` at a mock served at
+ * `baseUrl` (e.g. `http://127.0.0.1:PORT`) over the Responses wire API, keyless.
+ * Defines a `[model_providers.mock]` provider inline and selects it as the
+ * active model provider. `baseUrl` is suffixed with `/v1` (codex appends
+ * `/responses`). Combine with `codexMockEnv()` and the `codex exec` flags
+ * `--ignore-user-config --skip-git-repo-check --ephemeral
+ * --dangerously-bypass-approvals-and-sandbox -c model="gpt-5-codex"`.
+ */
+function codexMockArgs(baseUrl) {
+    return [
+        "-c",
+        "model_provider=mock",
+        "-c",
+        'model_providers.mock.name="mock"',
+        "-c",
+        `model_providers.mock.base_url="${baseUrl}/v1"`,
+        "-c",
+        'model_providers.mock.wire_api="responses"',
+        "-c",
+        'model_providers.mock.env_key="MOCK_KEY"',
+        "-c",
+        "model_providers.mock.requires_openai_auth=false",
+        "-c",
+        "model_providers.mock.request_max_retries=0",
+        "-c",
+        "model_providers.mock.stream_max_retries=0",
+    ];
+}
+/**
+ * The dummy-key env codex reads `model_providers.mock.env_key` through. Codex
+ * sends `Authorization: Bearer dummy-key`; the mock ignores it.
+ */
+function codexMockEnv() {
+    return { MOCK_KEY: "dummy-key" };
+}
+//# sourceMappingURL=runtime.js.map

package/dist/adapters/opencode/adapter.d.ts

@@ -0,0 +1,3 @@
+import type { HarnessAdapter } from "../../core/adapter.js";
+export declare const opencodeAdapter: HarnessAdapter;
+//# sourceMappingURL=adapter.d.ts.map

package/dist/adapters/opencode/adapter.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.opencodeAdapter = void 0;
+/**
+ * opencodeAdapter — EXPERIMENTAL, internal-only prototype `HarnessAdapter`. It
+ * exists to PROVE the kit generalizes to the optional-transport-port shape: a
+ * harness that does pillar 1 AND is mockable (openai-compatible) BUT whose hooks
+ * are in-process JS/TS plugin modules, not shell processes. So it declares
+ * `shellHooks: false`, ships NO `hookProtocol`, and the conformance kit must
+ * accept it without demanding a fake one. This is the pillar-1-+-mockable-but-
+ * no-shell-hooks shape the capability gating was built for.
+ *
+ * It is deliberately NOT registered in `src/adapter-registry.ts` and NOT exported
+ * from any `vigiles/*` subpath, so the CLI never auto-detects OpenCode and
+ * consumers can't import it. Promote it (register + `vigiles/opencode` export +
+ * the deferred transport renderers) only when OpenCode support actually ships.
+ */
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const dialect_js_1 = require("./dialect.js");
+const layout_js_1 = require("./layout.js");
+const runtime_js_1 = require("./runtime.js");
+const model_mock_js_1 = require("./model-mock.js");
+exports.opencodeAdapter = {
+    name: "opencode",
+    // Pillar 1 + mockable (openai-chat SSE), but hooks are in-process JS/TS plugin
+    // modules — no shell-hook tier, hence shellHooks:false and NO hookProtocol.
+    capabilities: {
+        referenceVerification: true,
+        harnessTesting: true,
+        shellHooks: false,
+    },
+    dialect: dialect_js_1.opencodeDialect,
+    layout: layout_js_1.opencodeLayout,
+    runtime: runtime_js_1.opencodeRuntime,
+    modelMock: model_mock_js_1.opencodeModelMock,
+    // No hookProtocol: OpenCode hooks are code modules, not shell processes.
+    detect(root) {
+        // An `opencode.json` is a strong signal; a bare AGENTS.md is weak (many
+        // harnesses read it). (Unused while unregistered — kept for symmetry.)
+        if ((0, node_fs_1.existsSync)((0, node_path_1.join)(root, "opencode.json")))
+            return 3;
+        if ((0, node_fs_1.existsSync)((0, node_path_1.join)(root, layout_js_1.opencodeLayout.instructionFile)))
+            return 1;
+        return 0;
+    },
+};
+//# sourceMappingURL=adapter.js.map

package/dist/adapters/opencode/dialect.d.ts

@@ -0,0 +1,10 @@
+/**
+ * opencodeDialect — EXPERIMENTAL, internal-only. A prototype `HarnessDialect` for
+ * OpenCode, built to validate that the format axis generalizes to a harness whose
+ * hooks are in-process JS/TS plugin modules rather than shell processes. NOT
+ * exported from `vigiles/*` and NOT registered in the adapter registry — it exists
+ * to be run through the conformance kit + real OpenCode-shaped fixtures.
+ */
+import type { HarnessDialect } from "../../core/dialect.js";
+export declare const opencodeDialect: HarnessDialect;
+//# sourceMappingURL=dialect.d.ts.map

package/dist/adapters/opencode/dialect.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.opencodeDialect = void 0;
+exports.opencodeDialect = {
+    name: "opencode",
+    // OpenCode's lowercase built-in tool catalog (file/shell/search + task).
+    builtinAgentTools: [
+        "bash",
+        "edit",
+        "read",
+        "write",
+        "grep",
+        "glob",
+        "list",
+        "webfetch",
+        "task",
+    ],
+    // No documented "never available to a subagent" set — left empty.
+    neverAvailableTools: [],
+    mcpToolPattern: /^mcp__[a-z0-9_-]+__[a-z0-9_-]+$/i,
+    // OpenCode's event-bus names, NOT shell hook events: a plugin module subscribes
+    // to these in-process (no exit-code/env wire protocol → shellHooks:false).
+    hookEvents: [
+        "session.start",
+        "tool.execute.before",
+        "tool.execute.after",
+        "session.idle",
+    ],
+    // AGENTS.md native + CLAUDE.md fallback.
+    instructionTargets: ["AGENTS.md", "CLAUDE.md"],
+    pluginRootToken: "${OPENCODE_PLUGIN_ROOT}",
+    // OpenCode reads the minimal cross-tool SKILL.md frontmatter (name +
+    // description); the CC-only keys are not part of its format.
+    skillFrontmatter: "minimal",
+};
+//# sourceMappingURL=dialect.js.map

package/dist/adapters/opencode/layout.d.ts

@@ -0,0 +1,9 @@
+/**
+ * opencodeLayout — EXPERIMENTAL, internal-only. A prototype `PluginLayout` for
+ * OpenCode: `opencode.json` manifest/settings, `AGENTS.md`, `.opencode/`
+ * surfaces, `${OPENCODE_PLUGIN_ROOT}`. Validates the layout port against real
+ * OpenCode shapes. NOT exported / NOT registered.
+ */
+import type { PluginLayout } from "../../core/layout.js";
+export declare const opencodeLayout: PluginLayout;
+//# sourceMappingURL=layout.d.ts.map

package/dist/adapters/opencode/layout.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.opencodeLayout = void 0;
+exports.opencodeLayout = {
+    name: "opencode",
+    manifestPath: "opencode.json",
+    // Vestigial: OpenCode hooks are JS plugin modules under `.opencode/plugin`, not
+    // shell-hook settings, so the shell-hook settings round-trip does NOT apply here
+    // (the adapter declares shellHooks:false; assertAdapterLoadsHooks is skipped).
+    hooksConventionPath: ".opencode/plugin",
+    settingsPath: "opencode.json",
+    settingsFormat: "json",
+    instructionFile: "AGENTS.md",
+    // OpenCode's surfaces already live UNDER `.opencode/` at the source, so they
+    // are NOT relocated — materializeRoot is "" (no prefix) to avoid doubling the
+    // `.opencode/` segment. (Contrast Claude Code: root-level `skills/` surfaces
+    // relocated under `.claude`.)
+    surfaceDirs: [".opencode/agent", ".opencode/command"],
+    materializeRoot: "",
+    pluginRootToken: "${OPENCODE_PLUGIN_ROOT}",
+    mcpConfigFile: "opencode.json",
+    mcpManifestKey: "mcp",
+    intraRefDirs: [".opencode/agent", ".opencode/command"],
+};
+//# sourceMappingURL=layout.js.map

package/dist/adapters/opencode/model-mock.d.ts

@@ -0,0 +1,10 @@
+/**
+ * opencodeModelMock — EXPERIMENTAL, internal-only. OpenCode is OpenAI-compatible
+ * and speaks the OpenAI **Chat Completions** API: a turn-consuming request hits
+ * `/v1/chat/completions`, with no separate count-tokens endpoint. The descriptor
+ * captures the wire facts; the SSE renderer is the deferred piece (built with the
+ * OpenCode transport tier, not declared here). NOT exported / NOT registered.
+ */
+import type { ModelMock } from "../../core/model-mock.js";
+export declare const opencodeModelMock: ModelMock;
+//# sourceMappingURL=model-mock.d.ts.map

package/dist/adapters/opencode/model-mock.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.opencodeModelMock = void 0;
+exports.opencodeModelMock = {
+    name: "opencode",
+    wireApi: "openai-chat",
+    modelEndpoint: "/v1/chat/completions",
+    // No count-tokens endpoint (countTokensEndpoint omitted).
+};
+//# sourceMappingURL=model-mock.js.map

package/dist/adapters/opencode/runtime.d.ts

@@ -0,0 +1,9 @@
+/**
+ * opencodeRuntime — EXPERIMENTAL, internal-only. A prototype `HarnessRuntime` for
+ * OpenCode: spawn `opencode`, reach a mock via the OpenAI-compatible base-URL env.
+ * OpenCode is BYOM/openai-compatible, so the env-var "point at the mock" route
+ * fits cleanly. NOT exported / NOT registered.
+ */
+import type { HarnessRuntime } from "../../core/runtime.js";
+export declare const opencodeRuntime: HarnessRuntime;
+//# sourceMappingURL=runtime.d.ts.map

package/dist/adapters/opencode/runtime.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.opencodeRuntime = void 0;
+exports.opencodeRuntime = {
+    name: "opencode",
+    agentBinary: "opencode",
+    modelBaseUrlEnv: "OPENAI_BASE_URL",
+    modelApiKeyEnv: "OPENAI_API_KEY",
+    mockApiKey: "sk-mock-opencode",
+    /** Env-only (OpenAI-compatible base-URL override), like Claude Code. */
+    wireMock(baseUrl) {
+        return {
+            args: [],
+            env: {
+                [exports.opencodeRuntime.modelBaseUrlEnv]: baseUrl,
+                [exports.opencodeRuntime.modelApiKeyEnv]: exports.opencodeRuntime.mockApiKey,
+            },
+        };
+    },
+};
+//# sourceMappingURL=runtime.js.map

package/dist/claude-code.d.ts

@@ -0,0 +1,16 @@
+/**
+ * `vigiles/claude-code` — the Claude Code-specific harness pieces a *different*
+ * harness would swap out: the plugin/repo loader (reads real Claude Code plugin
+ * layouts) and the scriptable Anthropic Messages mock. Split from
+ * `vigiles/testing` on purpose — the test API above is the stable surface; this
+ * is the adapter, so a future `vigiles/<other-harness>` can sit beside it.
+ */
+export * from "./adapters/claude-code/plugin-loader.js";
+export * from "./adapters/claude-code/mock-model.js";
+export * from "./adapters/claude-code/dialect.js";
+export * from "./adapters/claude-code/layout.js";
+export * from "./adapters/claude-code/runtime.js";
+export * from "./adapters/claude-code/hook-protocol.js";
+export * from "./adapters/claude-code/model-mock.js";
+export * from "./adapters/claude-code/adapter.js";
+//# sourceMappingURL=claude-code.d.ts.map

package/dist/claude-code.js

@@ -0,0 +1,32 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * `vigiles/claude-code` — the Claude Code-specific harness pieces a *different*
+ * harness would swap out: the plugin/repo loader (reads real Claude Code plugin
+ * layouts) and the scriptable Anthropic Messages mock. Split from
+ * `vigiles/testing` on purpose — the test API above is the stable surface; this
+ * is the adapter, so a future `vigiles/<other-harness>` can sit beside it.
+ */
+__exportStar(require("./adapters/claude-code/plugin-loader.js"), exports);
+__exportStar(require("./adapters/claude-code/mock-model.js"), exports);
+__exportStar(require("./adapters/claude-code/dialect.js"), exports);
+__exportStar(require("./adapters/claude-code/layout.js"), exports);
+__exportStar(require("./adapters/claude-code/runtime.js"), exports);
+__exportStar(require("./adapters/claude-code/hook-protocol.js"), exports);
+__exportStar(require("./adapters/claude-code/model-mock.js"), exports);
+__exportStar(require("./adapters/claude-code/adapter.js"), exports);
+//# sourceMappingURL=claude-code.js.map

package/dist/cli-flags.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Command-line config overrides.
+ *
+ * The GitHub Action is a thin composite over this CLI, so every Action
+ * input must map to a real CLI flag (no config-file-only knobs the Action
+ * can't reach — see the `prod-grade-gha-cli` rule). This module turns the
+ * shared flags into `VigilesConfig` overrides on top of the loaded config.
+ *
+ * Pure and exported for unit testing.
+ */
+import type { VigilesConfig } from "./core/types.js";
+/**
+ * Apply shared command-line overrides to a loaded config.
+ *
+ *   --max-rules=<n>   → config.maxRules   (positive integer; ignored otherwise)
+ *   --catalog-only    → config.catalogOnly = true
+ *
+ * Unknown flags are left untouched (each command parses its own besides
+ * these). Returns a new object; the input is not mutated.
+ */
+export declare function applyConfigFlags(config: VigilesConfig, args: readonly string[]): VigilesConfig;
+//# sourceMappingURL=cli-flags.d.ts.map

package/dist/cli-flags.js

@@ -0,0 +1,38 @@
+"use strict";
+/**
+ * Command-line config overrides.
+ *
+ * The GitHub Action is a thin composite over this CLI, so every Action
+ * input must map to a real CLI flag (no config-file-only knobs the Action
+ * can't reach — see the `prod-grade-gha-cli` rule). This module turns the
+ * shared flags into `VigilesConfig` overrides on top of the loaded config.
+ *
+ * Pure and exported for unit testing.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyConfigFlags = applyConfigFlags;
+const MAX_RULES = "--max-rules=";
+/**
+ * Apply shared command-line overrides to a loaded config.
+ *
+ *   --max-rules=<n>   → config.maxRules   (positive integer; ignored otherwise)
+ *   --catalog-only    → config.catalogOnly = true
+ *
+ * Unknown flags are left untouched (each command parses its own besides
+ * these). Returns a new object; the input is not mutated.
+ */
+function applyConfigFlags(config, args) {
+    const next = { ...config };
+    const maxRulesFlag = args.find((a) => a.startsWith(MAX_RULES));
+    if (maxRulesFlag) {
+        const n = Number(maxRulesFlag.slice(MAX_RULES.length));
+        if (Number.isInteger(n) && n > 0) {
+            next.maxRules = n;
+        }
+    }
+    if (args.includes("--catalog-only")) {
+        next.catalogOnly = true;
+    }
+    return next;
+}
+//# sourceMappingURL=cli-flags.js.map