vigiles 2.6.0 → 3.0.0

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

@@ -0,0 +1,20 @@
+import type { HarnessTestDriver, HarnessDriverContext, ParsedRun } from "../../core/harness-driver.js";
+/**
+ * The non-interactive `codex exec` argv. The mock-wiring `-c` flags
+ * (`ctx.mockArgs`, from `runtime.wireMock`) MUST follow `exec` — placed before
+ * `exec` they're parsed as global flags and ignored (codex falls back to the
+ * real OpenAI provider). `--ephemeral` +
+ * `--dangerously-bypass-approvals-and-sandbox` make it run unattended;
+ * `--skip-git-repo-check` lets it run in a bare temp dir; `--ignore-user-config`
+ * keeps the host's `~/.codex` out. The prompt is the trailing positional.
+ * Pure, so the arg shape is unit-tested.
+ */
+export declare function buildCodexArgs(ctx: HarnessDriverContext): string[];
+/**
+ * Extract the final assistant text from codex stdout. Codex `exec` prints the
+ * assistant message as plain text (no `--json` here); we return the trimmed
+ * stdout as the output. Pure, so it's unit-tested without spawning codex.
+ */
+export declare function parseCodexRun(stdout: string): ParsedRun;
+export declare const codexDriver: HarnessTestDriver;
+//# sourceMappingURL=driver.d.ts.map

package/dist/adapters/codex/driver.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codexDriver = void 0;
+exports.buildCodexArgs = buildCodexArgs;
+exports.parseCodexRun = parseCodexRun;
+/**
+ * codexDriver — the Codex `HarnessTestDriver`. Lets the adapter-driven
+ * `runHarnessTest` drive real `codex exec` against the proven OpenAI-Responses
+ * mock (`startCodexMock`), keylessly, via the `wireMock` flag recipe in
+ * `runtime.ts`. The Codex-side analogue of `claudeCodeDriver`.
+ *
+ * Scope: pillar-2 deterministic harness testing of the *output* turn — codex's
+ * non-interactive `exec` runs the scripted mock to completion and the final
+ * assistant text lands in `parseRun().output`. Tool-call / hook stream parsing
+ * is left empty (the JSONL schema isn't worth fully parsing for the output
+ * check); a test that needs those uses Claude Code today.
+ */
+const node_child_process_1 = require("node:child_process");
+const runtime_js_1 = require("./runtime.js");
+const mock_model_js_1 = require("./mock-model.js");
+/**
+ * The non-interactive `codex exec` argv. The mock-wiring `-c` flags
+ * (`ctx.mockArgs`, from `runtime.wireMock`) MUST follow `exec` — placed before
+ * `exec` they're parsed as global flags and ignored (codex falls back to the
+ * real OpenAI provider). `--ephemeral` +
+ * `--dangerously-bypass-approvals-and-sandbox` make it run unattended;
+ * `--skip-git-repo-check` lets it run in a bare temp dir; `--ignore-user-config`
+ * keeps the host's `~/.codex` out. The prompt is the trailing positional.
+ * Pure, so the arg shape is unit-tested.
+ */
+function buildCodexArgs(ctx) {
+    return [
+        "exec",
+        "--ignore-user-config",
+        "--skip-git-repo-check",
+        "--ephemeral",
+        "--dangerously-bypass-approvals-and-sandbox",
+        ...ctx.mockArgs,
+        "-c",
+        'model="gpt-5-codex"',
+        ctx.prompt,
+    ];
+}
+/**
+ * Extract the final assistant text from codex stdout. Codex `exec` prints the
+ * assistant message as plain text (no `--json` here); we return the trimmed
+ * stdout as the output. Pure, so it's unit-tested without spawning codex.
+ */
+function parseCodexRun(stdout) {
+    return { toolCalls: [], hooks: [], output: stdout.trim() };
+}
+/* v8 ignore start -- spawns the real codex CLI; exercised by the gated
+   codex-backed suite, the pure helpers above carry the testable logic. */
+function codexAvailable() {
+    try {
+        return ((0, node_child_process_1.spawnSync)(runtime_js_1.codexRuntime.agentBinary, ["--version"], {
+            stdio: "ignore",
+        }).status === 0);
+    }
+    catch {
+        return false;
+    }
+}
+async function startCodexMockHandle(script) {
+    const mock = await (0, mock_model_js_1.startCodexMock)(script.map((t) => ({ text: t.text ?? "" })));
+    return {
+        url: mock.url,
+        get requests() {
+            // Codex requests carry only the flattened prompt; adapt to ModelRequest.
+            return mock.requests.map((r) => ({
+                system: "",
+                messages: [{ role: "user", text: r.prompt }],
+            }));
+        },
+        get count() {
+            return mock.requests.length;
+        },
+        close: () => mock.close(),
+    };
+}
+exports.codexDriver = {
+    runtime: runtime_js_1.codexRuntime,
+    buildArgs: buildCodexArgs,
+    startMock: startCodexMockHandle,
+    parseRun: parseCodexRun,
+    available: codexAvailable,
+};
+/* v8 ignore stop */
+//# sourceMappingURL=driver.js.map

package/dist/adapters/codex/hook-protocol.d.ts

@@ -0,0 +1,10 @@
+/**
+ * codexHookProtocol — EXPERIMENTAL, internal-only. Codex's hook wire protocol.
+ * Finding: it is essentially IDENTICAL to Claude Code's (exit 2 / `decision:block`
+ * / `permissionDecision:deny`) — the thin `HookProtocol` port was the right call.
+ * The genuine deltas are the env vars a hook receives + the TOML config format
+ * (the latter lives in PluginLayout.settingsFormat, not here).
+ */
+import type { HookProtocol } from "../../core/hook-protocol.js";
+export declare const codexHookProtocol: HookProtocol;
+//# sourceMappingURL=hook-protocol.d.ts.map

package/dist/adapters/codex/hook-protocol.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codexHookProtocol = void 0;
+exports.codexHookProtocol = {
+    name: "codex",
+    blockExitCode: 2,
+    denyDecisionValues: ["block", "deny"],
+    eventEnvVars: [
+        "session_id",
+        "cwd",
+        "hook_event_name",
+        "model",
+        "turn_id",
+        "permission_mode",
+        "PLUGIN_ROOT",
+    ],
+};
+//# sourceMappingURL=hook-protocol.js.map

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

@@ -0,0 +1,16 @@
+/**
+ * codexLayout — EXPERIMENTAL, internal-only. A prototype `PluginLayout` for
+ * Codex: `.codex/` conventions, `config.toml` (TOML) hooks, `AGENTS.md`,
+ * `${PLUGIN_ROOT}`. Validates the layout port + the settings-format axis against
+ * real Codex shapes. NOT exported / NOT registered.
+ *
+ * Findings surfaced by writing it (see research/codex-prototype-findings.md):
+ * - Codex has no separate JSON *manifest* — `config.toml` carries everything; we
+ *   point `manifestPath` at it (its JSON parse simply fails → the loader falls
+ *   through to the TOML `settingsPath`). The manifest field is CC-JSON-shaped.
+ * - MCP detection (`mcpConfigFile`/`mcpManifestKey`) is JSON-shaped, so it won't
+ *   see Codex's `[mcp_servers]` TOML table — a known layout-port gap.
+ */
+import type { PluginLayout } from "../../core/layout.js";
+export declare const codexLayout: PluginLayout;
+//# sourceMappingURL=layout.d.ts.map

package/dist/adapters/codex/layout.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codexLayout = void 0;
+exports.codexLayout = {
+    name: "codex",
+    manifestPath: ".codex/config.toml",
+    hooksConventionPath: ".codex/hooks.json",
+    settingsPath: ".codex/config.toml",
+    settingsFormat: "toml",
+    instructionFile: "AGENTS.md",
+    surfaceDirs: ["skills", "prompts"],
+    materializeRoot: ".codex",
+    pluginRootToken: "${PLUGIN_ROOT}",
+    mcpConfigFile: ".mcp.json",
+    mcpManifestKey: "mcp_servers",
+    intraRefDirs: ["skills", "prompts", "hooks"],
+};
+//# sourceMappingURL=layout.js.map

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

@@ -0,0 +1,52 @@
+/** One scripted assistant turn: the final text answer codex should emit. */
+export interface CodexTurn {
+    /** Final text answer for this turn. */
+    readonly text: string;
+}
+/**
+ * One `/v1/responses` request the mock received, parsed for assertions: the
+ * user's prompt (last `input` item with `role:"user"`), the requested model,
+ * and the declared function-tool names.
+ */
+export interface CodexRequest {
+    readonly prompt: string;
+    readonly model: string;
+    readonly toolNames: readonly string[];
+}
+export interface CodexMockHandle {
+    readonly url: string;
+    readonly port: number;
+    /** Every `/v1/responses` request the mock received, in order. */
+    readonly requests: readonly CodexRequest[];
+    close(): Promise<void>;
+}
+/**
+ * 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.
+ */
+export declare function renderResponsesSSE(text: string, opts?: {
+    model?: string;
+}): string;
+/**
+ * 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.
+ */
+export declare function parseResponsesRequest(body: string): {
+    prompt: string;
+    model: string;
+    toolNames: string[];
+};
+/**
+ * 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()`.
+ */
+export declare function startCodexMock(script: readonly CodexTurn[], opts?: {
+    onRequest?: (req: CodexRequest) => void;
+}): Promise<CodexMockHandle>;
+//# sourceMappingURL=mock-model.d.ts.map

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