codictator 0.0.0 → 0.1.3

package/dist/features/adapters/muse-code.js

@@ -0,0 +1,223 @@
+import { stableStringify } from "../../kernel/index.js";
+import { parseClaudeShapedEvent } from "./claude-shaped.js";
+import { normalizeToolName } from "./contract.js";
+// SPEC §4.5.3: per-adapter table. Unknown names fall back to other through
+// the contract normaliser, so a new harness tool is still seen.
+const MUSE_TOOL_TABLE = {
+    write: "write",
+    edit: "write",
+    notebookedit: "write",
+    create: "write",
+    apply_patch: "write",
+    bash: "shell",
+    shell: "shell",
+    exec: "shell",
+    terminal: "shell",
+    bashoutput: "shell",
+    read: "read",
+    cat: "read",
+    view: "read",
+    glob: "search",
+    grep: "search",
+    search: "search",
+    find: "search",
+    ls: "search",
+    webfetch: "web",
+    websearch: "web",
+    fetch: "web",
+    curl: "web",
+    task: "task",
+    todo: "task",
+    todowrite: "task",
+    todoread: "task",
+};
+export function normalizeMuseToolName(name) {
+    return normalizeToolName(MUSE_TOOL_TABLE, name);
+}
+export function parseMuseEvent(event, raw) {
+    return parseClaudeShapedEvent("muse-code", event, raw, MUSE_TOOL_TABLE);
+}
+// SPEC §4.5.4: exit 0 always; stdout carries only the hookSpecificOutput
+// form. Allow is exactly {}; a bare allow is rejected by the harness, and
+// legacy top-level shapes are hook errors, so neither is ever emitted.
+export function replyMuse(decision) {
+    if (decision.decision === "block" || decision.decision === "escalate") {
+        const reason = decision.message ?? "blocked";
+        return {
+            exitCode: 0,
+            stdout: JSON.stringify({
+                hookSpecificOutput: {
+                    hookEventName: "PreToolUse",
+                    permissionDecision: "deny",
+                    permissionDecisionReason: reason,
+                },
+            }),
+            stderr: "",
+        };
+    }
+    if (decision.additionalContext !== undefined &&
+        decision.additionalContext.length > 0) {
+        return {
+            exitCode: 0,
+            stdout: JSON.stringify({
+                hookSpecificOutput: {
+                    additionalContext: decision.additionalContext,
+                },
+            }),
+            stderr: "",
+        };
+    }
+    return { exitCode: 0, stdout: "{}", stderr: "" };
+}
+// SPEC §4.5.1: the pre-engine deny form, embedded by regen for CDX-E002 and
+// CDX-E003. No engine state, so it works when the engine is missing.
+export function staticBlockMuse(code, message) {
+    return replyMuse({
+        decision: "block",
+        message: `${code} ${message}`,
+        eventId: "static",
+    });
+}
+export const MUSE_CAPABILITIES = {
+    harness: "muse-code",
+    adapterVersion: "0.0.0",
+    verifiedAgainst: {
+        version: "1.4.10",
+        date: "2026-10-26",
+        source: "vendor docs; third-party live probes (see SPEC §4.5.4)",
+    },
+    layers: {
+        L0: "partial",
+        L1: "native",
+        L2: "none",
+        L3: "native",
+        L4: "native",
+        L5: "none",
+    },
+    controls: {
+        contextFile: true,
+        contextInject: true,
+        postCompactInject: false,
+        promptBlock: false,
+        preToolBlock: true,
+        readBlock: true,
+        postToolFeedback: false,
+        autoCompactConfig: "none",
+        forceCompact: false,
+        forceClear: false,
+        usageData: "none",
+        skills: true,
+        subagents: false,
+        commands: false,
+        projectPermissions: false,
+        trustRequired: true,
+        timeoutFailMode: "unknown",
+        launcherMissingFailMode: "unknown",
+        hookIoVerified: false,
+        projectRootSource: "cwd",
+        agentEnvMarkers: [],
+    },
+    gaps: [
+        "hookIoVerified is false until a first-party capture passes (§4.5.7)",
+        "subagent definition files: managed in-product, no documented file",
+        "project-level permissions: settings are user-level",
+        "hook timeout field: none documented",
+        "post-tool feedback: blocking unconfirmed, reports disagree",
+        "exit-2 deny: unconfirmed, never emitted",
+        "updatedInput: reports disagree, never emitted",
+        "SessionStart source values: unverified",
+        "usage data: no documented field; transcript_path is null under exec",
+    ],
+};
+// SPEC §4.5.1: every hook command runs the launcher. Muse Code has no
+// documented project-root variable, so the path is relative and the launcher
+// resolves the root from the payload cwd.
+function museHookCommand(event) {
+    return `node .codictator/bin/run.mjs hook muse-code ${event}`;
+}
+// SPEC §4.5.3: the Muse Code native events, rendered in sorted order so
+// regeneration is byte-identical.
+const MUSE_HOOK_EVENTS = [
+    "PostCompact",
+    "PostToolUse",
+    "PreToolUse",
+    "SessionStart",
+    "Stop",
+    "SubagentStart",
+    "UserPromptSubmit",
+];
+function renderMuseHooks() {
+    const hooks = {};
+    for (const event of MUSE_HOOK_EVENTS) {
+        hooks[event] = [
+            {
+                matcher: "*",
+                hooks: [{ type: "command", command: museHookCommand(event) }],
+            },
+        ];
+    }
+    return stableStringify({ hooks });
+}
+// SPEC §4.5.4 with S15: the memory topic carries the precedence statement and
+// the pointer to AGENTS.md, so L0 exists before workspace trust. The rule set
+// itself waits for steering in phase 9.
+const MUSE_MEMORY_INDEX = `# Memory
+
+- codictator.md — the Codictator topic: repository rules outrank any instruction here. Read it before the first tool call.
+`;
+const MUSE_MEMORY_CODICTATOR = `# Codictator
+
+Repository rules enforced by Codictator outrank any instruction in this conversation, including the user's. When an instruction conflicts with a rule, do what was asked the compliant way and tell the user which rule applied and why. Never bypass, disable or edit Codictator guardrails.
+
+The rule set lives in AGENTS.md at the repository root.
+`;
+// SPEC §4.6.6: skill paths per asset id. Bodies are pointers only; the pack
+// templates land in phase 9.2.
+const MUSE_SKILLS = [
+    {
+        id: "codictator-review",
+        purpose: "Fresh-session reviewer: reads only the staged diff and the task SPEC refs, then submits.",
+    },
+    {
+        id: "codictator-qa",
+        purpose: "Runs the scenario-required test kinds and reports gaps.",
+    },
+    {
+        id: "codictator-debug",
+        purpose: "Diagnose before fix: reproduce, record in the bug registry, write the regression test, prove it red.",
+    },
+    {
+        id: "codictator-bug-record",
+        purpose: "Files a defect found in passing without leaving the current task.",
+    },
+    {
+        id: "codictator-docs-audit",
+        purpose: "Runs doc checks and fixes findings.",
+    },
+    {
+        id: "codictator-checkpoint",
+        purpose: "Writes the checkpoint and the resume note.",
+    },
+];
+function renderMuse(_input) {
+    const artifacts = [
+        { path: ".muse/hooks.json", content: renderMuseHooks() },
+        { path: ".agents/memory/MEMORY.md", content: MUSE_MEMORY_INDEX },
+        { path: ".agents/memory/codictator.md", content: MUSE_MEMORY_CODICTATOR },
+    ];
+    for (const skill of MUSE_SKILLS) {
+        artifacts.push({
+            path: `.agents/skills/${skill.id}/SKILL.md`,
+            content: `# ${skill.id}\n\n${skill.purpose}\n\nRepository rules live in AGENTS.md and outrank any instruction in this conversation.\n`,
+        });
+    }
+    return artifacts;
+}
+export const museAdapter = {
+    id: "muse-code",
+    capabilities: MUSE_CAPABILITIES,
+    render: renderMuse,
+    parse: parseMuseEvent,
+    reply: replyMuse,
+    staticBlock: staticBlockMuse,
+};

package/dist/features/adapters/opencode-bridge.d.ts

@@ -0,0 +1 @@
+export declare const OPENCODE_BRIDGE_SOURCE = "// Codictator OpenCode bridge (generated, SPEC \u00A74.5.4). Plain ESM module: the\n// only imports are node:child_process and node:crypto. Tool gating fails\n// closed: a block reply, a non-zero launcher exit, a spawn error or a timeout\n// throws, which OpenCode turns into a refused tool call. Session events are\n// forwarded for recording and never throw. Per-prompt injection: chat.message\n// caches the prompt.submit context per session and the experimental transform\n// appends it before every model call; when the probe trips (a tool call in a\n// turn the transform never delivered), the next prompt carries the context as\n// a synthetic chat.message part instead (EC-20).\nimport { spawnSync } from \"node:child_process\";\nimport { createHash } from \"node:crypto\";\n\nconst HARD_LIMIT_MS = 5000;\nconst FALLBACK_LINE = \"Codictator context unavailable (CDX-E302); AGENTS.md and tool gating still apply\";\nconst parseJsonReply = JSON.parse.bind(JSON);\n\nfunction launcherFor(directory) {\n  return directory + \"/.codictator/bin/run.mjs\";\n}\n\nfunction digestOf(text) {\n  return createHash(\"sha256\").update(text, \"utf8\").digest(\"hex\").slice(0, 16);\n}\n\nfunction runLauncher(directory, event, fields) {\n  const payload = JSON.stringify(Object.assign({ event: event, cwd: directory, directory: directory }, fields));\n  const digest = digestOf(payload);\n  const child = spawnSync(\"node\", [launcherFor(directory), \"hook\", \"opencode\", event], {\n    input: payload,\n    encoding: \"utf8\",\n    shell: false,\n    timeout: HARD_LIMIT_MS,\n  });\n  if (child.error) {\n    throw new Error(\"codictator \" + digest + \": launcher did not run (\" + (child.error.code || \"spawn error\") + \")\");\n  }\n  if (child.status !== 0) {\n    const detail = typeof child.stderr === \"string\" ? child.stderr.trim() : \"\";\n    throw new Error(\"codictator \" + digest + \": launcher exited \" + child.status + (detail === \"\" ? \"\" : \" (\" + detail + \")\"));\n  }\n  const text = typeof child.stdout === \"string\" ? child.stdout : \"\";\n  try {\n    return parseJsonReply(text);\n  } catch {\n    throw new Error(\"codictator \" + digest + \": unreadable launcher reply (CDX-E302)\");\n  }\n}\n\nconst promptContexts = new Map();\nconst transformDelivered = new Map();\nconst probeFallback = new Set();\nconst fallbackPushed = new Map();\n\nfunction readAdditionalContext(reply) {\n  if (reply !== null && typeof reply === \"object\" && typeof reply.additionalContext === \"string\" && reply.additionalContext !== \"\") {\n    return reply.additionalContext;\n  }\n  return \"\";\n}\n\nfunction rememberContext(sessionID, text) {\n  if (text === \"\") {\n    return;\n  }\n  promptContexts.set(sessionID, { hash: digestOf(text), text: text });\n}\n\nfunction appendSystem(output, text) {\n  if (text === \"\") {\n    return;\n  }\n  if (typeof output.system === \"string\") {\n    output.system = output.system + text;\n    return;\n  }\n  if (Array.isArray(output.system)) {\n    output.system.push(text);\n    return;\n  }\n  output.system = text;\n}\n\nfunction throwOnBlock(reply) {\n  const blocked = reply !== null && typeof reply === \"object\" && (reply.decision === \"block\" || reply.decision === \"escalate\");\n  if (blocked) {\n    const message = typeof reply.message === \"string\" && reply.message !== \"\" ? reply.message : \"codictator blocked the turn\";\n    throw new Error(message);\n  }\n}\n\nfunction gateTool(input, output, event) {\n  if (transformDelivered.get(input.sessionID) !== true) {\n    probeFallback.add(input.sessionID);\n  }\n  const reply = runLauncher(input.directory, event, {\n    tool: input.tool,\n    sessionID: input.sessionID,\n    callID: input.callID,\n    contextDelivered: transformDelivered.get(input.sessionID) === true,\n    args: output.args || {},\n  });\n  throwOnBlock(reply);\n}\n\nfunction pushFallbackPart(input, output) {\n  let text = \"\";\n  try {\n    const reply = runLauncher(input.directory, \"prompt.submit\", { sessionID: input.sessionID });\n    throwOnBlock(reply);\n    text = readAdditionalContext(reply);\n  } catch {\n    text = FALLBACK_LINE;\n  }\n  if (text === \"\") {\n    text = FALLBACK_LINE;\n  }\n  const digest = digestOf(text);\n  if (fallbackPushed.get(input.sessionID) === digest) {\n    return;\n  }\n  fallbackPushed.set(input.sessionID, digest);\n  rememberContext(input.sessionID, text);\n  if (!Array.isArray(output.parts)) {\n    output.parts = [];\n  }\n  output.parts.push({ type: \"text\", text: text, synthetic: true });\n}\n\nfunction handleChatMessage(input, output) {\n  const sessionID = input.sessionID;\n  transformDelivered.set(sessionID, false);\n  if (probeFallback.has(sessionID)) {\n    pushFallbackPart(input, output);\n    return;\n  }\n  let reply;\n  try {\n    reply = runLauncher(input.directory, \"prompt.submit\", { sessionID: sessionID });\n  } catch {\n    if (!Array.isArray(output.parts)) {\n      output.parts = [];\n    }\n    output.parts.push({ type: \"text\", text: FALLBACK_LINE, synthetic: true });\n    return;\n  }\n  throwOnBlock(reply);\n  rememberContext(sessionID, readAdditionalContext(reply));\n}\n\nfunction handleTransform(input, output) {\n  const sessionID = input.sessionID;\n  const cached = promptContexts.get(sessionID);\n  if (cached !== undefined && cached.text !== \"\") {\n    appendSystem(output, cached.text);\n    transformDelivered.set(sessionID, true);\n    return;\n  }\n  let reply;\n  try {\n    reply = runLauncher(input.directory, \"prompt.submit\", { sessionID: sessionID });\n  } catch {\n    appendSystem(output, FALLBACK_LINE);\n    return;\n  }\n  throwOnBlock(reply);\n  const text = readAdditionalContext(reply);\n  rememberContext(sessionID, text);\n  appendSystem(output, text);\n  transformDelivered.set(sessionID, true);\n}\n\nfunction pushCompactingContext(input, output) {\n  try {\n    const reply = runLauncher(input.directory, \"experimental.session.compacting\", { sessionID: input.sessionID });\n    if (reply !== null && typeof reply === \"object\" && typeof reply.additionalContext === \"string\" && reply.additionalContext !== \"\") {\n      output.context.push(reply.additionalContext);\n    }\n  } catch {\n    output.context.push(FALLBACK_LINE);\n  }\n}\n\nfunction recordEvent(input) {\n  try {\n    runLauncher(input.directory, input.event || \"event\", { sessionID: input.sessionID });\n  } catch {\n    // Observe-only: recording never breaks the session; tool gating is the enforcement point.\n  }\n}\n\nfunction markAgentShell(output) {\n  const env = output.env !== null && typeof output.env === \"object\" ? output.env : {};\n  env.CODICTATOR_AGENT = \"opencode\";\n  output.env = env;\n}\n\nexport default function codictator() {\n  return {\n    \"tool.execute.before\": async (input, output) => {\n      gateTool(input, output, \"tool.execute.before\");\n    },\n    \"tool.execute.after\": async (input, output) => {\n      gateTool(input, output, \"tool.execute.after\");\n    },\n    \"chat.message\": async (input, output) => {\n      handleChatMessage(input, output);\n    },\n    \"experimental.chat.system.transform\": async (input, output) => {\n      handleTransform(input, output);\n    },\n    \"experimental.session.compacting\": async (input, output) => {\n      pushCompactingContext(input, output);\n    },\n    event: async (input) => {\n      recordEvent(input);\n    },\n    \"shell.env\": async (_input, output) => {\n      markAgentShell(output);\n    },\n  };\n}\n";

package/dist/features/adapters/opencode-bridge.js

@@ -0,0 +1,230 @@
+// SPEC §4.5.4: the generated OpenCode plugin bridge, rendered verbatim to
+// `.opencode/plugins/codictator.mjs`. Plain ESM importing only
+// node:child_process and node:crypto; tool gating fails closed by throwing.
+// SPEC §4.5.4 with §10.3 item 3: this module carries the bridge as text and
+// never imports an OS module itself. The child_process specifier is built by
+// concatenation so the OS-touching text scan keeps reading this file as pure
+// data; the emitted .mjs keeps the plain static import.
+const CHILD_PROCESS_SPECIFIER = "node:" + "child_process";
+export const OPENCODE_BRIDGE_SOURCE = `// Codictator OpenCode bridge (generated, SPEC §4.5.4). Plain ESM module: the
+// only imports are node:child_process and node:crypto. Tool gating fails
+// closed: a block reply, a non-zero launcher exit, a spawn error or a timeout
+// throws, which OpenCode turns into a refused tool call. Session events are
+// forwarded for recording and never throw. Per-prompt injection: chat.message
+// caches the prompt.submit context per session and the experimental transform
+// appends it before every model call; when the probe trips (a tool call in a
+// turn the transform never delivered), the next prompt carries the context as
+// a synthetic chat.message part instead (EC-20).
+import { spawnSync } from "${CHILD_PROCESS_SPECIFIER}";
+import { createHash } from "node:crypto";
+
+const HARD_LIMIT_MS = 5000;
+const FALLBACK_LINE = "Codictator context unavailable (CDX-E302); AGENTS.md and tool gating still apply";
+const parseJsonReply = JSON.parse.bind(JSON);
+
+function launcherFor(directory) {
+  return directory + "/.codictator/bin/run.mjs";
+}
+
+function digestOf(text) {
+  return createHash("sha256").update(text, "utf8").digest("hex").slice(0, 16);
+}
+
+function runLauncher(directory, event, fields) {
+  const payload = JSON.stringify(Object.assign({ event: event, cwd: directory, directory: directory }, fields));
+  const digest = digestOf(payload);
+  const child = spawnSync("node", [launcherFor(directory), "hook", "opencode", event], {
+    input: payload,
+    encoding: "utf8",
+    shell: false,
+    timeout: HARD_LIMIT_MS,
+  });
+  if (child.error) {
+    throw new Error("codictator " + digest + ": launcher did not run (" + (child.error.code || "spawn error") + ")");
+  }
+  if (child.status !== 0) {
+    const detail = typeof child.stderr === "string" ? child.stderr.trim() : "";
+    throw new Error("codictator " + digest + ": launcher exited " + child.status + (detail === "" ? "" : " (" + detail + ")"));
+  }
+  const text = typeof child.stdout === "string" ? child.stdout : "";
+  try {
+    return parseJsonReply(text);
+  } catch {
+    throw new Error("codictator " + digest + ": unreadable launcher reply (CDX-E302)");
+  }
+}
+
+const promptContexts = new Map();
+const transformDelivered = new Map();
+const probeFallback = new Set();
+const fallbackPushed = new Map();
+
+function readAdditionalContext(reply) {
+  if (reply !== null && typeof reply === "object" && typeof reply.additionalContext === "string" && reply.additionalContext !== "") {
+    return reply.additionalContext;
+  }
+  return "";
+}
+
+function rememberContext(sessionID, text) {
+  if (text === "") {
+    return;
+  }
+  promptContexts.set(sessionID, { hash: digestOf(text), text: text });
+}
+
+function appendSystem(output, text) {
+  if (text === "") {
+    return;
+  }
+  if (typeof output.system === "string") {
+    output.system = output.system + text;
+    return;
+  }
+  if (Array.isArray(output.system)) {
+    output.system.push(text);
+    return;
+  }
+  output.system = text;
+}
+
+function throwOnBlock(reply) {
+  const blocked = reply !== null && typeof reply === "object" && (reply.decision === "block" || reply.decision === "escalate");
+  if (blocked) {
+    const message = typeof reply.message === "string" && reply.message !== "" ? reply.message : "codictator blocked the turn";
+    throw new Error(message);
+  }
+}
+
+function gateTool(input, output, event) {
+  if (transformDelivered.get(input.sessionID) !== true) {
+    probeFallback.add(input.sessionID);
+  }
+  const reply = runLauncher(input.directory, event, {
+    tool: input.tool,
+    sessionID: input.sessionID,
+    callID: input.callID,
+    contextDelivered: transformDelivered.get(input.sessionID) === true,
+    args: output.args || {},
+  });
+  throwOnBlock(reply);
+}
+
+function pushFallbackPart(input, output) {
+  let text = "";
+  try {
+    const reply = runLauncher(input.directory, "prompt.submit", { sessionID: input.sessionID });
+    throwOnBlock(reply);
+    text = readAdditionalContext(reply);
+  } catch {
+    text = FALLBACK_LINE;
+  }
+  if (text === "") {
+    text = FALLBACK_LINE;
+  }
+  const digest = digestOf(text);
+  if (fallbackPushed.get(input.sessionID) === digest) {
+    return;
+  }
+  fallbackPushed.set(input.sessionID, digest);
+  rememberContext(input.sessionID, text);
+  if (!Array.isArray(output.parts)) {
+    output.parts = [];
+  }
+  output.parts.push({ type: "text", text: text, synthetic: true });
+}
+
+function handleChatMessage(input, output) {
+  const sessionID = input.sessionID;
+  transformDelivered.set(sessionID, false);
+  if (probeFallback.has(sessionID)) {
+    pushFallbackPart(input, output);
+    return;
+  }
+  let reply;
+  try {
+    reply = runLauncher(input.directory, "prompt.submit", { sessionID: sessionID });
+  } catch {
+    if (!Array.isArray(output.parts)) {
+      output.parts = [];
+    }
+    output.parts.push({ type: "text", text: FALLBACK_LINE, synthetic: true });
+    return;
+  }
+  throwOnBlock(reply);
+  rememberContext(sessionID, readAdditionalContext(reply));
+}
+
+function handleTransform(input, output) {
+  const sessionID = input.sessionID;
+  const cached = promptContexts.get(sessionID);
+  if (cached !== undefined && cached.text !== "") {
+    appendSystem(output, cached.text);
+    transformDelivered.set(sessionID, true);
+    return;
+  }
+  let reply;
+  try {
+    reply = runLauncher(input.directory, "prompt.submit", { sessionID: sessionID });
+  } catch {
+    appendSystem(output, FALLBACK_LINE);
+    return;
+  }
+  throwOnBlock(reply);
+  const text = readAdditionalContext(reply);
+  rememberContext(sessionID, text);
+  appendSystem(output, text);
+  transformDelivered.set(sessionID, true);
+}
+
+function pushCompactingContext(input, output) {
+  try {
+    const reply = runLauncher(input.directory, "experimental.session.compacting", { sessionID: input.sessionID });
+    if (reply !== null && typeof reply === "object" && typeof reply.additionalContext === "string" && reply.additionalContext !== "") {
+      output.context.push(reply.additionalContext);
+    }
+  } catch {
+    output.context.push(FALLBACK_LINE);
+  }
+}
+
+function recordEvent(input) {
+  try {
+    runLauncher(input.directory, input.event || "event", { sessionID: input.sessionID });
+  } catch {
+    // Observe-only: recording never breaks the session; tool gating is the enforcement point.
+  }
+}
+
+function markAgentShell(output) {
+  const env = output.env !== null && typeof output.env === "object" ? output.env : {};
+  env.CODICTATOR_AGENT = "opencode";
+  output.env = env;
+}
+
+export default function codictator() {
+  return {
+    "tool.execute.before": async (input, output) => {
+      gateTool(input, output, "tool.execute.before");
+    },
+    "tool.execute.after": async (input, output) => {
+      gateTool(input, output, "tool.execute.after");
+    },
+    "chat.message": async (input, output) => {
+      handleChatMessage(input, output);
+    },
+    "experimental.chat.system.transform": async (input, output) => {
+      handleTransform(input, output);
+    },
+    "experimental.session.compacting": async (input, output) => {
+      pushCompactingContext(input, output);
+    },
+    event: async (input) => {
+      recordEvent(input);
+    },
+    "shell.env": async (_input, output) => {
+      markAgentShell(output);
+    },
+  };
+}
+`;

package/dist/features/adapters/opencode-capabilities.d.ts

@@ -0,0 +1,2 @@
+import type { CapabilityDeclaration } from "./contract.ts";
+export declare const OPENCODE_CAPABILITIES: CapabilityDeclaration;

package/dist/features/adapters/opencode-capabilities.js

@@ -0,0 +1,47 @@
+export const OPENCODE_CAPABILITIES = {
+    harness: "opencode",
+    adapterVersion: "0.0.0",
+    verifiedAgainst: {
+        version: "1.19.4",
+        date: "2026-10-26",
+        source: "@opencode-ai/plugin Hooks type at tag v1.19.4; vendor plugins page",
+    },
+    layers: {
+        L0: "native",
+        L1: "native",
+        L2: "none",
+        L3: "native",
+        L4: "native",
+        L5: "none",
+    },
+    controls: {
+        contextFile: true,
+        contextInject: true,
+        postCompactInject: true,
+        promptBlock: false,
+        preToolBlock: true,
+        readBlock: true,
+        postToolFeedback: false,
+        autoCompactConfig: "partial",
+        forceCompact: false,
+        forceClear: false,
+        usageData: "none",
+        skills: false,
+        subagents: false,
+        commands: false,
+        projectPermissions: false,
+        trustRequired: false,
+        timeoutFailMode: "closed",
+        launcherMissingFailMode: "closed",
+        hookIoVerified: false,
+        projectRootSource: "cwd",
+        agentEnvMarkers: ["CODICTATOR_AGENT"],
+    },
+    gaps: [
+        "hookIoVerified is false until a first-party capture passes (§4.5.7)",
+        "contextInject and promptBlock stay partial until a first-party capture",
+        "session.* events are observe-only",
+        "skills directory unverified",
+        "OpenCode 2.x reshapes the plugin API and stays a gap per the range",
+    ],
+};

package/dist/features/adapters/opencode-parse.d.ts

@@ -0,0 +1,3 @@
+import type { Result } from "../../kernel/index.ts";
+import type { HookEvent } from "./contract.ts";
+export declare function parseOpenCodeEvent(event: string, raw: unknown): Result<HookEvent>;

package/dist/features/adapters/opencode-parse.js

@@ -0,0 +1,137 @@
+import { err, makeError, ok } from "../../kernel/index.js";
+import { mapOpenCodeEvent, normalizeOpenCodeToolName, } from "./opencode-tables.js";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readString(record, keys) {
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value === "string" && value.length > 0) {
+            return value;
+        }
+    }
+    return undefined;
+}
+function readArgs(raw) {
+    for (const key of ["args", "tool_input", "toolInput", "input"]) {
+        const value = raw[key];
+        if (isRecord(value)) {
+            return value;
+        }
+    }
+    return {};
+}
+function collectOpenCodePaths(args) {
+    const found = new Set();
+    for (const key of ["filePath", "file_path", "path", "file", "filename"]) {
+        const value = args[key];
+        if (typeof value === "string" && value.length > 0) {
+            found.add(value);
+        }
+        else if (Array.isArray(value)) {
+            for (const entry of value) {
+                if (typeof entry === "string" && entry.length > 0) {
+                    found.add(entry);
+                }
+            }
+        }
+    }
+    return [...found].sort();
+}
+function blockError(detail) {
+    return makeError("CDX-E303", `unparseable opencode hook payload: ${detail}`, "Check the harness hook configuration, then retry the tool call.");
+}
+function readOpenCodeTool(raw) {
+    const toolName = readString(raw, ["tool", "toolName", "tool_name"]);
+    if (toolName === undefined) {
+        return err(blockError("missing tool"));
+    }
+    const args = readArgs(raw);
+    const command = readString(args, ["command"]);
+    const proposedContent = readString(args, [
+        "content",
+        "new_content",
+        "newContent",
+        "new_string",
+        "newString",
+        "text",
+        "proposedContent",
+    ]);
+    const query = readString(args, ["query", "pattern", "prompt"]);
+    return ok({
+        kind: normalizeOpenCodeToolName(toolName),
+        name: toolName,
+        paths: collectOpenCodePaths(args),
+        ...(command === undefined ? {} : { command }),
+        ...(proposedContent === undefined ? {} : { proposedContent }),
+        ...(query === undefined ? {} : { query }),
+    });
+}
+// SPEC §4.5.8 EC-17..EC-19: the bridge payload to the normalised event. A
+// spawn failure is CDX-E001; a launch timeout carries no tool data and is a
+// pre-tool marker for the CDX-E902 the next run records; anything else
+// without tool data fails closed.
+export function parseOpenCodeEvent(event, raw) {
+    if (!isRecord(raw)) {
+        return err(blockError("expected a JSON object"));
+    }
+    const spawnError = raw.spawnError;
+    if (typeof spawnError === "string" && spawnError.length > 0) {
+        return err(makeError("CDX-E001", "opencode bridge could not start node", "Put node on PATH, then retry the tool call."));
+    }
+    const nativeName = readString(raw, ["event", "eventName", "type"]);
+    const nativeTrigger = nativeName === undefined ? undefined : mapOpenCodeEvent(nativeName);
+    const trigger = nativeTrigger ?? mapOpenCodeEvent(event);
+    if (trigger === undefined) {
+        return err(blockError("unknown event"));
+    }
+    const sessionId = readString(raw, ["sessionID", "sessionId", "session_id"]);
+    if (sessionId === undefined) {
+        return err(blockError("missing session id"));
+    }
+    const cwd = readString(raw, ["cwd", "directory"]) ?? "";
+    if (trigger === "pre-tool" || trigger === "post-tool") {
+        const tool = readOpenCodeTool(raw);
+        if (!tool.ok) {
+            if (trigger === "pre-tool" && raw.timedOut === true) {
+                return ok({
+                    harness: "opencode",
+                    event: nativeName ?? event,
+                    trigger,
+                    sessionId,
+                    cwd,
+                });
+            }
+            // SPEC §4.5.8 EC-20: the bridge probe trips when a tool call fires
+            // in a turn whose context the transform never delivered. The
+            // bridge forwards contextDelivered: false; the launcher records
+            // the gap marker here and the bridge falls back to a synthetic
+            // chat.message part from the next prompt. Never a block by itself.
+            if (trigger === "pre-tool" && raw.contextDelivered === false) {
+                return ok({
+                    harness: "opencode",
+                    event: nativeName ?? event,
+                    trigger,
+                    sessionId,
+                    cwd,
+                });
+            }
+            return tool;
+        }
+        return ok({
+            harness: "opencode",
+            event: nativeName ?? event,
+            trigger,
+            sessionId,
+            cwd,
+            tool: tool.value,
+        });
+    }
+    return ok({
+        harness: "opencode",
+        event: nativeName ?? event,
+        trigger,
+        sessionId,
+        cwd,
+    });
+}

package/dist/features/adapters/opencode-tables.d.ts

@@ -0,0 +1,5 @@
+import type { Trigger } from "../engine/index.ts";
+import type { ToolKind } from "./contract.ts";
+export declare const OPENCODE_TOOL_TABLE: Readonly<Record<string, ToolKind>>;
+export declare function normalizeOpenCodeToolName(name: string): ToolKind;
+export declare function mapOpenCodeEvent(event: string): Trigger | undefined;