@kylecheng3146/agent-ops 0.1.4 → 0.1.5

package/dist/packages/cli/src/commands/update.js

@@ -1,25 +1,27 @@
 import { applyUpdatePlan, createUpdatePlan } from "../../../../runtime/src/install/update.js";
 import { okEnvelope } from "../output.js";
 import { formatOperationPlan } from "../plan-output.js";
+import { toPublicUpdatePlan } from "../public-plan.js";
 export function formatUpdatePlan(plan) {
     return formatOperationPlan({
         title: "Update plan",
         metadata: [
             `Target version: ${plan.targetVersion}`,
+            `Harness: ${plan.installation.harness.join(", ")}`,
             `Schema migrations: ${plan.migrationSteps.length === 0
                 ? "none"
                 : plan.migrationSteps
                     .map(({ fromVersion, toVersion }) => `${fromVersion} -> ${toVersion}`)
                     .join(", ")}`
         ],
-        operations: plan.installation.operations
+        operations: toPublicUpdatePlan(plan).installation.operations
     });
 }
 function updateError(code, message, plan) {
     return {
         code,
         status: "error",
-        data: { applied: false, plan, message },
+        data: { applied: false, plan: toPublicUpdatePlan(plan), message },
         errors: [{ code, message }]
     };
 }
@@ -27,6 +29,9 @@ export async function runUpdateCommand(options) {
     const plan = await createUpdatePlan({
         root: options.root,
         adapters: options.adapters,
+        ...(options.args.harness === undefined
+            ? {}
+            : { harness: options.args.harness }),
         ...(options.registry === undefined
             ? {}
             : { registry: options.registry }),
@@ -35,12 +40,15 @@ export async function runUpdateCommand(options) {
             : { targetVersion: options.targetVersion }),
         ...(options.hookRuntimePath === undefined
             ? {}
-            : { hookRuntimePath: options.hookRuntimePath })
+            : { hookRuntimePath: options.hookRuntimePath }),
+        ...((options.hookTargets ?? options.args.hookTargets) === undefined
+            ? {}
+            : { hookTargets: options.hookTargets ?? options.args.hookTargets })
     });
     if (options.args.dryRun) {
         return okEnvelope("UPDATE_PLAN_READY", {
             applied: false,
-            plan,
+            plan: toPublicUpdatePlan(plan),
             message: "Update plan calculated; no files were changed.",
             text: formatUpdatePlan(plan)
         });
@@ -55,7 +63,7 @@ export async function runUpdateCommand(options) {
     await applyUpdatePlan(options.root, plan);
     return okEnvelope("UPDATE_APPLIED", {
         applied: true,
-        plan,
+        plan: toPublicUpdatePlan(plan),
         message: `Managed installation updated to ${plan.targetVersion}.`
     });
 }

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

@@ -1,16 +1,22 @@
 import { execFileSync } from "node:child_process";
 import { homedir } from "node:os";
 import { join } from "node:path";
+import { calculateConfigHash } from "../../../runtime/src/config/hash.js";
+import { sha256 } from "../../../runtime/src/fs/hash.js";
 import { loadConfigFile } from "../../../runtime/src/config/load.js";
 import { mergeConfigLayers } from "../../../runtime/src/config/merge.js";
-import { sha256 } from "../../../runtime/src/fs/hash.js";
 import { AgentOpsError } from "../../../runtime/src/fs/paths.js";
 import { localStatePaths } from "../../../runtime/src/security/permissions.js";
 import { calculateTrustBinding, FileTrustStore } from "../../../runtime/src/security/trust.js";
 export const DEFAULT_CONFIG = {
-    schemaVersion: 1,
+    schemaVersion: 2,
     profiles: [],
     verification: { commands: [] },
+    features: {
+        stopVerification: {
+            enabled: false
+        }
+    },
     pathMappings: [],
     securityExceptions: []
 };
@@ -91,7 +97,7 @@ export async function repositoryTrust(root, config, cliVersion) {
         const binding = await calculateTrustBinding({
             repositoryPath: root,
             remoteUrl: repositoryRemoteUrl(root),
-            configHash: sha256(JSON.stringify(config)),
+            configHash: calculateConfigHash(config),
             runtimeHash: sha256(cliVersion)
         });
         return (await new FileTrustStore(state.trustStore, state.anchorDirectory).status(binding)).status;

package/dist/packages/cli/src/hook-process.js

@@ -1,7 +1,15 @@
+import { execFile as execFileCallback } from "node:child_process";
+import { promisify } from "node:util";
+import { calculateConfigHash } from "../../../runtime/src/config/hash.js";
+import { claudeStopRecursionMarker } from "../../../runtime/src/adapters/claude/input.js";
+import { HARNESS_IDS, harnessDescriptor } from "../../../runtime/src/install/harness.js";
+import { STOP_VERIFICATION_ENV, StopVerificationService } from "../../../runtime/src/hooks/stop-service.js";
+import { NodeVerificationProcessRunner } from "../../../runtime/src/verify/spawn.js";
 import { runHookCommand, HOOK_EVENTS } from "./commands/hook.js";
 import { loadEffectiveConfig, repositoryTrust } from "./context.js";
-const HARNESSES = new Set(["codex", "claude"]);
+const HARNESSES = new Set(HARNESS_IDS);
 const MAX_HOOK_INPUT_BYTES = 1024 * 1024;
+const execFile = promisify(execFileCallback);
 async function readStdin(stream) {
     const chunks = [];
     let total = 0;
@@ -17,28 +25,122 @@ async function readStdin(stream) {
     }
     return Buffer.concat(chunks, total).toString("utf8");
 }
+function parseInput(source) {
+    try {
+        return JSON.parse(source);
+    }
+    catch {
+        return null;
+    }
+}
+function defaultGitRunner(root) {
+    return {
+        run: async (args) => {
+            try {
+                const result = await execFile("git", [...args], {
+                    cwd: root,
+                    encoding: "buffer"
+                });
+                return {
+                    exitCode: 0,
+                    stdout: result.stdout
+                };
+            }
+            catch (error) {
+                const failure = error;
+                return {
+                    exitCode: failure.status ?? 1,
+                    stdout: failure.stdout ?? new Uint8Array()
+                };
+            }
+        }
+    };
+}
+function stopVerificationOptions(input) {
+    const nativeRecursion = input.harness === "claude" &&
+        claudeStopRecursionMarker(input.rawInput);
+    const recursionActive = nativeRecursion || process.env[STOP_VERIFICATION_ENV] === "1";
+    const configHash = calculateConfigHash(input.config);
+    return {
+        confirmedConfig: true,
+        trusted: input.trusted,
+        scopeMapped: true,
+        recursionMarker: recursionActive,
+        configHash,
+        verify: async () => await new StopVerificationService({
+            root: input.root,
+            config: input.config,
+            trusted: input.trusted,
+            gitRunner: input.gitRunner,
+            processRunner: input.processRunner,
+            recursionActive,
+            configHash
+        }).verify()
+    };
+}
+function shouldBuildStopVerification(harness, event, config, rawInput) {
+    if (event !== "Stop" || !config.features.stopVerification.enabled) {
+        return false;
+    }
+    let normalized;
+    try {
+        normalized = harnessDescriptor(harness).runtime.normalizeInput(rawInput);
+    }
+    catch {
+        return false;
+    }
+    if (normalized.event !== "stop") {
+        return false;
+    }
+    return harnessDescriptor(harness).control.registrations.some(({ capability, support }) => capability === "optional-stop-verify" && support !== "unsupported");
+}
 /**
  * Runs one hook invocation. Always resolves to exit code 0: a hook that
  * cannot answer must never block the harness it advises.
  */
-export async function runHookProcess(argv, io, cliVersion) {
+export async function runHookProcess(argv, io, cliVersion, dependencies = {}) {
     const [harness, event] = argv;
     if (harness === undefined ||
         !HARNESSES.has(harness) ||
         event === undefined ||
         !HOOK_EVENTS.includes(event)) {
-        io.writeStderr("Usage: agent-ops hook <codex|claude> <SessionStart|PreToolUse|Stop>\n");
+        io.writeStderr(`Usage: agent-ops hook <${HARNESS_IDS.join("|")}> <SessionStart|PreToolUse|Stop>\n`);
         return 0;
     }
     try {
-        const root = process.cwd();
-        const config = (await loadEffectiveConfig(root, "project")).config;
+        const root = dependencies.root ?? process.cwd();
+        const config = dependencies.loadConfig === undefined
+            ? (await loadEffectiveConfig(root, "project")).config
+            : await dependencies.loadConfig(root);
+        const trustStatus = dependencies.trust === undefined
+            ? await repositoryTrust(root, config, cliVersion)
+            : await dependencies.trust(root, config, cliVersion);
+        const rawInput = await readStdin(io.stdin);
+        const parsedInput = parseInput(rawInput);
+        const trusted = trustStatus === "TRUSTED";
+        const gitRunner = dependencies.gitRunner ?? defaultGitRunner(root);
+        const processRunner = dependencies.processRunner ?? new NodeVerificationProcessRunner();
+        const stopVerification = shouldBuildStopVerification(harness, event, config, parsedInput)
+            ? stopVerificationOptions({
+                harness: harness,
+                rawInput: parsedInput,
+                root,
+                config,
+                trusted,
+                gitRunner,
+                processRunner
+            })
+            : undefined;
         const output = await runHookCommand({
             harness: harness,
             event: event,
-            stdin: await readStdin(io.stdin),
+            stdin: rawInput,
             config,
-            trusted: (await repositoryTrust(root, config, cliVersion)) === "TRUSTED"
+            trusted,
+            ...(dependencies.advisory === undefined
+                ? {}
+                : { advisory: dependencies.advisory }),
+            ...(stopVerification === undefined ? {} : { stopVerification })
         });
         if (output.stdout.length > 0) {
             io.writeStdout(output.stdout);

package/dist/packages/cli/src/plan-output.js

@@ -18,10 +18,15 @@ export function formatOperationPlan(options) {
     for (const operation of options.operations) {
         lines.push(`- ${operation.kind} ${escapeTerminalText(operation.path)}`, `  expected: ${operation.expectedHash ?? "<absent>"}`);
         if (operation.kind === "write") {
-            lines.push("  content:", ...operation.content
-                .replace(/\n$/u, "")
-                .split("\n")
-                .map((line) => `    ${escapeTerminalText(line)}`));
+            if ("contentHash" in operation) {
+                lines.push(`  content: <opaque ${escapeTerminalText(operation.contentHash)}>`, `  summary: ${escapeTerminalText(operation.summary)}`);
+            }
+            else {
+                lines.push("  content:", ...operation.content
+                    .replace(/\n$/u, "")
+                    .split("\n")
+                    .map((line) => `    ${escapeTerminalText(line)}`));
+            }
         }
     }
     return `${lines.join("\n")}\n`;

package/dist/packages/cli/src/public-plan.js

@@ -0,0 +1,62 @@
+import { redactSecrets } from "../../../runtime/src/security/redact.js";
+import { sha256 } from "../../../runtime/src/fs/hash.js";
+const OPAQUE_SUMMARY = "Opaque managed settings content withheld.";
+function publicPath(path) {
+    return redactSecrets(path);
+}
+export function disclosureOf(operation) {
+    return operation.disclosure ?? "full";
+}
+export function toPublicOperation(operation) {
+    const path = publicPath(operation.path);
+    if (operation.kind === "remove") {
+        return {
+            kind: "remove",
+            path,
+            expectedHash: operation.expectedHash
+        };
+    }
+    if (disclosureOf(operation) === "opaque") {
+        return {
+            kind: "write",
+            path,
+            expectedHash: operation.expectedHash,
+            contentHash: sha256(operation.content),
+            summary: redactSecrets(OPAQUE_SUMMARY)
+        };
+    }
+    return {
+        kind: "write",
+        path,
+        expectedHash: operation.expectedHash,
+        content: operation.content
+    };
+}
+export function toPublicOperations(operations) {
+    return operations.map(toPublicOperation);
+}
+export function toPublicInstallPlan(plan) {
+    return {
+        scope: plan.scope,
+        harness: plan.harness,
+        profiles: plan.profiles,
+        capabilities: plan.capabilities,
+        manifest: plan.manifest,
+        operations: toPublicOperations(plan.operations)
+    };
+}
+export function toPublicUpdatePlan(plan) {
+    return {
+        targetVersion: plan.targetVersion,
+        migrationSteps: plan.migrationSteps,
+        installation: toPublicInstallPlan(plan.installation)
+    };
+}
+export function toPublicUninstallPlan(plan) {
+    return {
+        installed: plan.installed,
+        manifest: plan.manifest,
+        manifestHash: plan.manifestHash,
+        operations: toPublicOperations(plan.operations)
+    };
+}

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

@@ -1,3 +1,3 @@
 // Single source of the published CLI version. Release preparation updates
 // this constant; bin.ts and the hook entry both read it from here.
-export const CLI_VERSION = "0.1.4";
+export const CLI_VERSION = "0.1.5";

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

@@ -1,17 +1,14 @@
 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 = [
-    { label: "both", value: "both" },
-    { label: "claude", value: "claude" },
-    { label: "codex", value: "codex" }
-];
+const HARNESS_CHOICES = HARNESS_IDS.map((id) => ({ label: id, value: id }));
 const PROFILE_CHOICES = [
     {
         label: "core",
@@ -26,10 +23,10 @@ const PROFILE_CHOICES = [
     {
         label: "guardrails",
         value: "guardrails",
-        description: "Blocks high-confidence unsafe commands and enables optional Stop verification."
+        description: "Blocks high-confidence unsafe commands; Stop verification is a separate opt-in feature."
     }
 ];
-const WIZARD_SUBTITLE = "Safe setup for Codex + Claude Code with profile-driven rules, verification, and hooks.";
+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.");
@@ -60,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"]
@@ -81,14 +88,23 @@ 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.");
     }
-    if (io.input !== undefined && io.output !== undefined) {
+    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 selectOption("Harness", HARNESS_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, [], {
@@ -108,7 +124,7 @@ export async function completeInitChoices(args, io) {
         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"
+    }
+];