@kylecheng3146/agent-ops 0.1.3 → 0.1.5

package/dist/packages/cli/src/wizard.js

@@ -1,7 +1,32 @@
 import { CliArgumentError } from "./args.js";
+import { HARNESS_IDS, resolveHarnessSelection } from "../../../runtime/src/install/harness.js";
+import { selectOption, selectOptions } from "./ui.js";
 const SCOPES = new Set(["project", "user"]);
-const HARNESSES = new Set(["both", "claude", "codex"]);
 const PROFILES = new Set(["advisory", "core", "guardrails"]);
+const DEFAULT_HARNESS = [];
+const SCOPE_CHOICES = [
+    { label: "project", value: "project" },
+    { label: "user", value: "user" }
+];
+const HARNESS_CHOICES = HARNESS_IDS.map((id) => ({ label: id, value: id }));
+const PROFILE_CHOICES = [
+    {
+        label: "core",
+        value: "core",
+        description: "Base rules, task tracking, verification, and review guidance."
+    },
+    {
+        label: "advisory",
+        value: "advisory",
+        description: "Adds informational SessionStart summaries and local logs; never blocks."
+    },
+    {
+        label: "guardrails",
+        value: "guardrails",
+        description: "Blocks high-confidence unsafe commands; Stop verification is a separate opt-in feature."
+    }
+];
+const WIZARD_SUBTITLE = "Safe setup for Codex, Claude Code, and opencode with profile-driven rules, verification, and hooks.";
 async function createPromptSession(io) {
     if (!io.isTTY) {
         throw new CliArgumentError("CLI_INTERACTIVE_REQUIRED", "Missing init choices require an interactive terminal.");
@@ -32,6 +57,16 @@ function selectValue(raw, fallback, allowed, label) {
     }
     return value;
 }
+function selectHarness(raw) {
+    if (raw.trim() === "") {
+        throw new CliArgumentError("CLI_INVALID_VALUE", "Choose at least one harness.");
+    }
+    const selection = resolveHarnessSelection(raw);
+    if (selection === null) {
+        throw new CliArgumentError("CLI_INVALID_VALUE", `Harness must be a unique comma-separated list of ${HARNESS_IDS.join(", ")}.`);
+    }
+    return selection;
+}
 function selectProfiles(raw) {
     const values = raw.trim() === ""
         ? ["core"]
@@ -53,12 +88,43 @@ export async function completeInitChoices(args, io) {
     if (!io.isTTY) {
         throw new CliArgumentError("CLI_INTERACTIVE_REQUIRED", "Non-interactive init requires --scope, --harness, and at least one --profile.");
     }
+    const canUseRawSelectors = io.input !== undefined &&
+        io.output !== undefined &&
+        typeof io.input.setRawMode === "function" &&
+        io.input.isTTY === true;
+    if (canUseRawSelectors) {
+        const selectorIo = {
+            input: io.input,
+            output: io.output
+        };
+        selectorIo.output.write(`${WIZARD_SUBTITLE}\n\n`);
+        const scope = args.scope ?? await selectOption("Scope", SCOPE_CHOICES, selectorIo);
+        const harness = args.harness ??
+            await selectOptions("Harness (multi-select: ↑↓ move, Space toggle, Enter confirm)", HARNESS_CHOICES, selectorIo, [...DEFAULT_HARNESS], {
+                selectAll: true,
+                selectAllLabel: "Select all",
+                selectAllDescription: "Install for every supported harness."
+            });
+        const profiles = args.profiles.length > 0
+            ? args.profiles
+            : await selectOptions("Profiles (multi-select: ↑↓ move, Space toggle, Enter confirm)", PROFILE_CHOICES, selectorIo, [], {
+                selectAll: true,
+                selectAllLabel: "Select all",
+                selectAllDescription: "Enable core, advisory, and guardrails together."
+            });
+        return {
+            ...args,
+            scope,
+            harness,
+            profiles
+        };
+    }
     const session = await createPromptSession(io);
     try {
         const scope = args.scope ??
             selectValue(await session.question("Scope (project/user) [project]: "), "project", SCOPES, "scope");
         const harness = args.harness ??
-            selectValue(await session.question("Harness (both/claude/codex) [both]: "), "both", HARNESSES, "harness");
+            selectHarness(await session.question(`Harness (${HARNESS_IDS.join(",")}): `));
         const profiles = args.profiles.length > 0
             ? args.profiles
             : selectProfiles(await session.question("Profiles (core,advisory,guardrails) [core]: "));

package/dist/runtime/src/adapters/claude/config.js

@@ -10,14 +10,6 @@ export function claudeSettingsTarget(scope) {
             requiresWorkspaceTrust: false
         };
 }
-export function claudeRoutingBlock() {
-    return [
-        "## Loop Engineering",
-        "",
-        "Load `.agent-ops/CLAUDE.md` as concise project context.",
-        ""
-    ].join("\n");
-}
 function commandHook(event, runtimePath) {
     return {
         type: "command",

package/dist/runtime/src/adapters/claude/events.js

@@ -6,3 +6,29 @@ export const CLAUDE_SUPPORTED_EVENTS = [
 export function claudeNonInteractiveTrust(printMode) {
     return printMode ? "dialog-skipped" : "interactive-dialog";
 }
+export const CLAUDE_CAPABILITY_REGISTRATIONS = [
+    {
+        capability: "lifecycle-summary",
+        normalizedEvent: "session-start",
+        nativeEvent: "SessionStart",
+        surfaceId: "claude-settings",
+        support: "supported",
+        runtimeFailure: "fail-open"
+    },
+    {
+        capability: "command-policy",
+        normalizedEvent: "command",
+        nativeEvent: "PreToolUse",
+        surfaceId: "claude-settings",
+        support: "supported",
+        runtimeFailure: "fail-closed"
+    },
+    {
+        capability: "optional-stop-verify",
+        normalizedEvent: "stop",
+        nativeEvent: "Stop",
+        surfaceId: "claude-settings",
+        support: "supported",
+        runtimeFailure: "fail-open"
+    }
+];

package/dist/runtime/src/adapters/claude/output.js

@@ -6,6 +6,12 @@ function json(value) {
     };
 }
 export function claudeHookOutput(event, result) {
+    if (event === "Stop" && result.evidence !== undefined) {
+        return json({
+            systemMessage: `agent-ops: ${result.code}`,
+            evidence: result.evidence
+        });
+    }
     if (result.action === "continue" && result.status === "PASS") {
         return { exitCode: 0, stdout: "", stderr: "" };
     }
@@ -18,12 +24,6 @@ export function claudeHookOutput(event, result) {
             }
         });
     }
-    if (event === "Stop" && result.action === "block") {
-        return json({
-            decision: "block",
-            reason: result.code
-        });
-    }
     return json({
         systemMessage: `agent-ops: ${result.code}`
     });

package/dist/runtime/src/adapters/claude/surfaces.js

@@ -0,0 +1,70 @@
+export const CLAUDE_SURFACE_IDS = {
+    settings: "claude-settings",
+    projectLocal: "project-local",
+    userSettings: "user-settings",
+    plugin: "plugin"
+};
+export function claudeSurfaces(scope) {
+    if (scope === "project") {
+        return [
+            {
+                id: CLAUDE_SURFACE_IDS.settings,
+                path: ".claude/settings.json",
+                scope: "project",
+                access: "managed-default",
+                representation: "json"
+            },
+            {
+                id: CLAUDE_SURFACE_IDS.projectLocal,
+                path: ".claude/settings.local.json",
+                scope: "project",
+                access: "managed-opt-in",
+                representation: "json"
+            },
+            {
+                id: CLAUDE_SURFACE_IDS.userSettings,
+                path: "~/.claude/settings.json",
+                scope: "external",
+                access: "inspect-only",
+                representation: "json"
+            },
+            {
+                id: CLAUDE_SURFACE_IDS.plugin,
+                path: "~/.claude/plugins",
+                scope: "external",
+                access: "inspect-only",
+                representation: "javascript"
+            }
+        ];
+    }
+    return [
+        {
+            id: CLAUDE_SURFACE_IDS.settings,
+            path: ".claude/settings.json",
+            scope: "user",
+            access: "managed-default",
+            representation: "json"
+        },
+        {
+            id: CLAUDE_SURFACE_IDS.projectLocal,
+            path: "project/.claude/settings.local.json",
+            scope: "external",
+            access: "inspect-only",
+            representation: "json"
+        },
+        {
+            id: CLAUDE_SURFACE_IDS.userSettings,
+            path: "project/.claude/settings.json",
+            scope: "external",
+            access: "inspect-only",
+            representation: "json"
+        },
+        {
+            id: CLAUDE_SURFACE_IDS.plugin,
+            path: "~/.claude/plugins",
+            scope: "external",
+            access: "inspect-only",
+            representation: "javascript"
+        }
+    ];
+}

package/dist/runtime/src/adapters/codex/config.js

@@ -1,10 +1,26 @@
 import { AgentOpsError } from "../../fs/paths.js";
-const COMMAND_PREFIX = "agent-ops hook codex ";
+export const CODEX_MANAGED_MARKER = "--managed-by=agent-ops";
+/**
+ * Releases up to 0.1.4 registered a bare `agent-ops` command resolved through
+ * PATH. Detection still recognizes it so an update replaces it instead of
+ * leaving the hijackable handler behind.
+ */
+const LEGACY_COMMAND_PREFIX = "agent-ops hook codex ";
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function commandHook(event) {
-    const command = `${COMMAND_PREFIX}${event}`;
+function assertRuntimePath(runtimePath) {
+    if (runtimePath.length === 0 ||
+        runtimePath.length > 4096 ||
+        runtimePath.includes("\0") ||
+        // The command is a single shell string, so a quote would break the
+        // argument boundary the surrounding quotes establish.
+        runtimePath.includes('"')) {
+        throw new AgentOpsError("CODEX_HOOK_PATH_INVALID", "Codex hook runtime path is invalid.");
+    }
+}
+function commandHook(event, runtimePath) {
+    const command = `node "${runtimePath}" codex ${event} ${CODEX_MANAGED_MARKER}`;
     return {
         type: "command",
         command,
@@ -13,10 +29,10 @@ function commandHook(event) {
         statusMessage: `Running agent-ops ${event}`
     };
 }
-function matcherGroup(event) {
+function matcherGroup(event, runtimePath) {
     return {
         ...(event === "PreToolUse" ? { matcher: "^Bash$" } : {}),
-        hooks: [commandHook(event)]
+        hooks: [commandHook(event, runtimePath)]
     };
 }
 export function codexHookTarget(scope) {
@@ -26,26 +42,28 @@ export function codexHookTarget(scope) {
         requiresProjectTrust: scope === "project"
     };
 }
-export function buildCodexHookConfig(capabilities) {
+export function buildCodexHookConfig(capabilities, runtimePath) {
+    assertRuntimePath(runtimePath);
     const hooks = {};
     if (capabilities.includes("lifecycle-summary")) {
-        hooks.SessionStart = [matcherGroup("SessionStart")];
+        hooks.SessionStart = [matcherGroup("SessionStart", runtimePath)];
     }
     if (capabilities.includes("command-policy")) {
-        hooks.PreToolUse = [matcherGroup("PreToolUse")];
+        hooks.PreToolUse = [matcherGroup("PreToolUse", runtimePath)];
     }
     if (capabilities.includes("optional-stop-verify")) {
-        hooks.Stop = [matcherGroup("Stop")];
+        hooks.Stop = [matcherGroup("Stop", runtimePath)];
     }
     return {
-        description: "Portable agent-ops lifecycle hooks.",
+        description: "agent-ops lifecycle hooks.",
         hooks
     };
 }
 function isOwnedHandler(hook) {
     return (isRecord(hook) &&
         typeof hook.command === "string" &&
-        hook.command.startsWith(COMMAND_PREFIX));
+        (hook.command.includes(CODEX_MANAGED_MARKER) ||
+            hook.command.startsWith(LEGACY_COMMAND_PREFIX)));
 }
 function withoutOwnedHandlers(value) {
     if (!isRecord(value) || !Array.isArray(value.hooks)) {

package/dist/runtime/src/adapters/codex/events.js

@@ -6,3 +6,29 @@ export const CODEX_SUPPORTED_EVENTS = [
 export function codexMatcherSupport(event) {
     return event === "PreToolUse" ? "tool-name" : "unsupported";
 }
+export const CODEX_CAPABILITY_REGISTRATIONS = [
+    {
+        capability: "lifecycle-summary",
+        normalizedEvent: "session-start",
+        nativeEvent: "SessionStart",
+        surfaceId: "codex-hooks",
+        support: "supported",
+        runtimeFailure: "fail-open"
+    },
+    {
+        capability: "command-policy",
+        normalizedEvent: "command",
+        nativeEvent: "PreToolUse",
+        surfaceId: "codex-hooks",
+        support: "unknown",
+        runtimeFailure: "native-unknown"
+    },
+    {
+        capability: "optional-stop-verify",
+        normalizedEvent: "stop",
+        nativeEvent: "Stop",
+        surfaceId: "codex-hooks",
+        support: "unsupported",
+        runtimeFailure: "fail-open"
+    }
+];

package/dist/runtime/src/adapters/codex/output.js

@@ -1,6 +1,16 @@
 export const CODEX_NON_ZERO_EXIT_BEHAVIOR = "UNKNOWN";
 export const CODEX_PRE_TOOL_BLOCKING = "UNKNOWN";
 export function codexHookOutput(event, result) {
+    if (event === "Stop" && result.evidence !== undefined) {
+        return {
+            exitCode: 0,
+            stdout: JSON.stringify({
+                continue: true,
+                systemMessage: `agent-ops: ${result.code}`,
+                evidence: result.evidence
+            })
+        };
+    }
     if (result.action === "continue" && result.status === "PASS") {
         return { exitCode: 0, stdout: "" };
     }

package/dist/runtime/src/adapters/codex/surfaces.js

@@ -0,0 +1,12 @@
+export const CODEX_SURFACE_ID = "codex-hooks";
+export function codexSurfaces(scope) {
+    return [
+        {
+            id: CODEX_SURFACE_ID,
+            path: ".codex/hooks.json",
+            scope,
+            access: "managed-default",
+            representation: "json"
+        }
+    ];
+}

package/dist/runtime/src/adapters/opencode/config.js

@@ -0,0 +1,170 @@
+import { homedir } from "node:os";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+import { AgentOpsError } from "../../fs/paths.js";
+export const OPENCODE_MANAGED_MARKER = "--managed-by=agent-ops";
+export const OPENCODE_PLUGIN_PATH = ".opencode/plugins/agent-ops.js";
+export const OPENCODE_USER_PLUGIN_PATH = ".config/opencode/plugins/agent-ops.js";
+function userPluginPath(root, configuredHome = process.env.XDG_CONFIG_HOME, configuredDirectory = process.env.OPENCODE_CONFIG_DIR) {
+    const installationRoot = resolve(root ?? process.env.AGENT_OPS_HOME ?? homedir());
+    const customConfigDirectory = configuredDirectory?.trim();
+    const configDirectory = customConfigDirectory !== undefined && customConfigDirectory.length > 0
+        ? customConfigDirectory
+        : configuredHome === undefined || configuredHome.trim().length === 0
+            ? join(installationRoot, ".config", "opencode")
+            : join(configuredHome, "opencode");
+    if (!isAbsolute(configDirectory)) {
+        throw new AgentOpsError("OPENCODE_CONFIG_PATH_INVALID", "OpenCode's config directory must be an absolute path for user-scope installation.");
+    }
+    const target = resolve(configDirectory, "plugins", "agent-ops.js");
+    const relativeTarget = relative(installationRoot, target);
+    if (relativeTarget.length === 0 ||
+        relativeTarget === ".." ||
+        relativeTarget.startsWith(`..${sep}`) ||
+        isAbsolute(relativeTarget)) {
+        throw new AgentOpsError("OPENCODE_CONFIG_PATH_INVALID", "OpenCode's config directory must stay inside the managed user-scope root.");
+    }
+    return relativeTarget.split(sep).join("/");
+}
+export function opencodePluginTarget(scope, root, configuredHome, configuredDirectory) {
+    return {
+        path: scope === "project"
+            ? OPENCODE_PLUGIN_PATH
+            : root === undefined && configuredHome === undefined &&
+                configuredDirectory === undefined &&
+                process.env.XDG_CONFIG_HOME === undefined &&
+                process.env.OPENCODE_CONFIG_DIR === undefined
+                ? OPENCODE_USER_PLUGIN_PATH
+                : userPluginPath(root, configuredHome, configuredDirectory),
+        representation: "javascript",
+        requiresProjectTrust: scope === "project"
+    };
+}
+/**
+ * Validates the persisted plugin shape without consulting the current
+ * environment. User-scope installations may use a custom config directory,
+ * so their manifest path is allowed to have any safe prefix but must still
+ * name OpenCode's plugin entrypoint.
+ */
+export function isOpencodePluginPath(scope, path) {
+    if (scope === "project") {
+        return path === OPENCODE_PLUGIN_PATH;
+    }
+    return /^(?:[A-Za-z0-9._-]+\/)*plugins\/agent-ops\.js$/u.test(path);
+}
+function isAbsoluteRuntimePath(value) {
+    return (value.startsWith("/") ||
+        /^[A-Za-z]:[\\/]/u.test(value) ||
+        value.startsWith("\\\\"));
+}
+function assertRuntimePath(runtimePath) {
+    if (!isAbsoluteRuntimePath(runtimePath) ||
+        runtimePath.length > 4096 ||
+        runtimePath.includes("\0") ||
+        runtimePath.includes("\n") ||
+        runtimePath.includes("\r")) {
+        throw new AgentOpsError("OPENCODE_PLUGIN_PATH_INVALID", "opencode plugin runtime path must be absolute and valid.");
+    }
+}
+export function opencodePluginEvents(capabilities) {
+    const events = [];
+    if (capabilities.includes("lifecycle-summary")) {
+        events.push("SessionStart");
+    }
+    if (capabilities.includes("command-policy")) {
+        events.push("PreToolUse");
+    }
+    if (capabilities.includes("optional-stop-verify")) {
+        events.push("Stop");
+    }
+    return events;
+}
+/**
+ * Generates the dependency-free plugin installed under the selected local
+ * or user plugin directory.
+ * The only host dependency is opencode's Bun `$` shell tag, supplied by the
+ * plugin context. Keeping the shell function in the context makes the source
+ * importable under Node tests with a small fake.
+ */
+export function buildOpencodePlugin(capabilities, runtimePath) {
+    const events = opencodePluginEvents(capabilities);
+    if (events.length === 0) {
+        return null;
+    }
+    assertRuntimePath(runtimePath);
+    const lines = [
+        "// Managed by agent-ops. Do not edit: `agent-ops update` rewrites this file.",
+        `const RUNTIME_PATH = ${JSON.stringify(runtimePath)};`,
+        `const MARKER = ${JSON.stringify(OPENCODE_MANAGED_MARKER)};`,
+        "",
+        "function outputText(result) {",
+        "  if (typeof result?.stdout === \"string\") return result.stdout;",
+        "  return new TextDecoder().decode(result?.stdout ?? new Uint8Array());",
+        "}",
+        "",
+        "async function invokeRuntime($, event, payload, projectRoot) {",
+        "  try {",
+        "    const result = await $`node ${RUNTIME_PATH} opencode ${event} ${MARKER} < ${new Response(JSON.stringify(payload))}`.cwd(projectRoot).quiet();",
+        "    const decision = JSON.parse(outputText(result).trim());",
+        "    if (decision?.decision !== \"allow\" && decision?.decision !== \"deny\") return null;",
+        "    return decision;",
+        "  } catch {",
+        "    return null;",
+        "  }",
+        "}",
+        "",
+        "async function runManagedHook($, event, payload) {",
+        "  const decision = await invokeRuntime($, event, payload, payload.projectRoot);",
+        "  if (decision === null) {",
+        "    if (event === \"PreToolUse\") throw new Error(\"agent-ops: command policy is unavailable\");",
+        "    return;",
+        "  }",
+        "  if (decision.decision === \"deny\") {",
+        "    throw new Error(`agent-ops: ${decision.reason ?? \"denied\"}`);",
+        "  }",
+        "}",
+        "",
+        "export const AgentOps = async ({ $, directory, worktree } = {}) => {",
+        "  const projectRoot = directory ?? worktree ?? process.cwd();",
+        "  const hooks = {};"
+    ];
+    if (events.includes("SessionStart")) {
+        lines.push("  // opencode initializes plugins once per app, not once per session.", "  await runManagedHook($, \"SessionStart\", {", "    event: \"SessionStart\",", "    projectRoot", "  });");
+    }
+    if (events.includes("PreToolUse")) {
+        lines.push('  hooks["tool.execute.before"] = async (input, output) => {', '    if (input?.tool !== "bash") return;', "    await runManagedHook($, \"PreToolUse\", {", "      event: \"PreToolUse\",", "      projectRoot,", "      input,", "      output", "    });", "  };");
+    }
+    if (events.includes("Stop")) {
+        lines.push("  hooks.event = async ({ event }) => {", '    if (event?.type !== "session.idle") return;', "    await runManagedHook($, \"Stop\", { event: \"Stop\", projectRoot });", "  };");
+    }
+    lines.push("  return hooks;", "};", "");
+    return lines.join("\n");
+}
+export function isOpencodeManagedPlugin(source) {
+    return (source !== null &&
+        source.includes("Managed by agent-ops") &&
+        source.includes(OPENCODE_MANAGED_MARKER));
+}
+/**
+ * Registration probing checks the generated source's managed marker and the
+ * capability-implied hook registrations. The artifact hash check remains the
+ * exact-content check; this probe answers whether the relevant hooks exist.
+ */
+export function isOpencodePluginRegistered(source, capabilities) {
+    if (typeof source !== "string") {
+        return opencodePluginEvents(capabilities).length === 0;
+    }
+    if (!isOpencodeManagedPlugin(source)) {
+        return false;
+    }
+    return opencodePluginEvents(capabilities).every((event) => {
+        if (event === "SessionStart") {
+            return source.includes('runManagedHook($, "SessionStart"');
+        }
+        if (event === "PreToolUse") {
+            return source.includes('"tool.execute.before"') &&
+                source.includes('runManagedHook($, "PreToolUse"');
+        }
+        return source.includes('event?.type !== "session.idle"') &&
+            source.includes('runManagedHook($, "Stop"');
+    });
+}

package/dist/runtime/src/adapters/opencode/events.js

@@ -0,0 +1,49 @@
+export const OPENCODE_SUPPORTED_EVENTS = [
+    "SessionStart",
+    "PreToolUse",
+    "Stop"
+];
+/**
+ * opencode exposes plugin hooks rather than named lifecycle events. Only
+ * `tool.execute.before` is documented as able to stop an action, so blocking
+ * outcomes for the other two stay UNKNOWN the way the Codex adapter records
+ * unconfirmed native behavior.
+ */
+export const OPENCODE_PLUGIN_HOOKS = {
+    SessionStart: "plugin-init",
+    PreToolUse: "tool.execute.before",
+    Stop: "event:session.idle"
+};
+export const OPENCODE_PRE_TOOL_BLOCKING = "throws";
+export const OPENCODE_STOP_BLOCKING = "UNKNOWN";
+/**
+ * A plugin's factory runs once when opencode starts, not once per session, so
+ * SessionStart is a degraded approximation rather than an equivalent.
+ */
+export const OPENCODE_SESSION_START_FIDELITY = "app-init";
+export const OPENCODE_CAPABILITY_REGISTRATIONS = [
+    {
+        capability: "lifecycle-summary",
+        normalizedEvent: "session-start",
+        nativeEvent: "SessionStart",
+        surfaceId: "opencode-plugin",
+        support: "degraded",
+        runtimeFailure: "fail-open"
+    },
+    {
+        capability: "command-policy",
+        normalizedEvent: "command",
+        nativeEvent: "PreToolUse",
+        surfaceId: "opencode-plugin",
+        support: "supported",
+        runtimeFailure: "fail-closed"
+    },
+    {
+        capability: "optional-stop-verify",
+        normalizedEvent: "stop",
+        nativeEvent: "Stop",
+        surfaceId: "opencode-plugin",
+        support: "degraded",
+        runtimeFailure: "fail-open"
+    }
+];

package/dist/runtime/src/adapters/opencode/input.js

@@ -0,0 +1,32 @@
+import { normalizeHookEvent } from "../../hooks/normalize.js";
+import { normalizeShellHookEvent } from "../../hooks/shell.js";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+ * The managed plugin forwards opencode's own hook payload untouched under
+ * `input`, so every field this adapter reads is documented plugin input rather
+ * than a shape the plugin invented.
+ */
+export function normalizeOpencodeHookInput(input) {
+    if (!isRecord(input)) {
+        return normalizeHookEvent(input);
+    }
+    const projectRoot = input.projectRoot;
+    if (input.event === "SessionStart") {
+        return normalizeHookEvent({ event: "session-start", projectRoot });
+    }
+    if (input.event === "Stop") {
+        return normalizeHookEvent({ event: "stop", projectRoot });
+    }
+    if (input.event === "PreToolUse" &&
+        isRecord(input.input) &&
+        input.input.tool === "bash" &&
+        isRecord(input.output) &&
+        isRecord(input.output.args) &&
+        typeof input.output.args.command === "string" &&
+        typeof projectRoot === "string") {
+        return normalizeShellHookEvent(input.output.args.command, projectRoot);
+    }
+    return normalizeHookEvent({ event: "unsupported", projectRoot });
+}

package/dist/runtime/src/adapters/opencode/output.js

@@ -0,0 +1,23 @@
+/**
+ * The consumer is the managed plugin, so the wire format is ours to define: one
+ * JSON decision on stdout. Only `tool.execute.before` can act on a denial, so
+ * the other events always report `allow` and carry the code for logging.
+ */
+export function opencodeHookOutput(event, result) {
+    const decision = event === "PreToolUse" && result.action === "block"
+        ? { decision: "deny", reason: result.code }
+        : {
+            decision: "allow",
+            ...(result.status === "PASS" && event !== "Stop"
+                ? {}
+                : { reason: result.code }),
+            ...(event === "Stop" && result.evidence !== undefined
+                ? { evidence: result.evidence }
+                : {})
+        };
+    return {
+        exitCode: 0,
+        stdout: JSON.stringify(decision),
+        stderr: ""
+    };
+}