intentdna 1.7.4 → 1.8.0

package/dist/runtime/codex-adapter.js

@@ -0,0 +1,1204 @@
+import { execFile, spawn } from "node:child_process";
+import { createHash, randomUUID } from "node:crypto";
+import { constants } from "node:fs";
+import { access, mkdir, readFile, unlink } from "node:fs/promises";
+import { delimiter, dirname, join, relative, resolve, sep } from "node:path";
+import { promisify } from "node:util";
+import { RUNTIME_DECISION_EVENT_SCHEMA_VERSION, trustedEvidenceCaptureAttribution, validateRuntimeDecisionEvent } from "../governance/index.js";
+import { appendEvidenceCaptureEvent, appendRuntimeDecisionEvent, atomicWrite, EVIDENCE_CAPTURE_SCHEMA_VERSION } from "../hooks/state.js";
+export const CODEX_ADAPTER_MINIMUM_VERSION = "0.134.0";
+export const CODEX_NATIVE_HOOK_EVENTS = [
+    "SessionStart",
+    "PreToolUse",
+    "PostToolUse",
+    "UserPromptSubmit",
+    "PreCompact",
+    "PostCompact",
+    "Stop",
+];
+const EVENT_LABELS = {
+    SessionStart: "session_start",
+    PreToolUse: "pre_tool_use",
+    PostToolUse: "post_tool_use",
+    UserPromptSubmit: "user_prompt_submit",
+    PreCompact: "pre_compact",
+    PostCompact: "post_compact",
+    Stop: "stop",
+};
+const EVENT_MATCHERS = {
+    SessionStart: "startup|resume|clear",
+    PreToolUse: "Bash",
+};
+const EVENT_TIMEOUTS = {
+    Stop: 30,
+};
+const OWNED_HOOK_STATUS_MESSAGE = "intentdna:codex-adapter";
+const OWNED_PLUGIN_NAME = "intentdna-codex";
+const TRUST_STATE_START = "# Intent DNA-owned Codex hook trust state";
+const TRUST_STATE_END = "# End Intent DNA-owned Codex hook trust state";
+const execFileAsync = promisify(execFile);
+function compareSemver(a, b) {
+    const parse = (value) => value.split(".").map((part) => Number.parseInt(part, 10) || 0);
+    const left = parse(a);
+    const right = parse(b);
+    const length = Math.max(left.length, right.length);
+    for (let index = 0; index < length; index++) {
+        const leftPart = left[index] ?? 0;
+        const rightPart = right[index] ?? 0;
+        if (leftPart > rightPart)
+            return 1;
+        if (leftPart < rightPart)
+            return -1;
+    }
+    return 0;
+}
+function parseCodexVersion(output) {
+    return output.match(/\d+\.\d+\.\d+/)?.[0] ?? null;
+}
+async function executableFromPath(name, envPath = process.env.PATH ?? "") {
+    for (const dir of envPath.split(delimiter)) {
+        if (!dir)
+            continue;
+        const candidate = join(dir, name);
+        try {
+            await access(candidate, constants.X_OK);
+            return candidate;
+        }
+        catch { /* keep searching */ }
+    }
+    return null;
+}
+async function runCodexProbeCommand(executablePath, args) {
+    try {
+        await execFileAsync(executablePath, args, { timeout: 5000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function probeCodexRuntime(options = {}) {
+    const executablePath = options.executablePath ?? await executableFromPath("codex", options.envPath);
+    if (!executablePath) {
+        return {
+            executable_path: null,
+            version: null,
+            minimum_version: CODEX_ADAPTER_MINIMUM_VERSION,
+            satisfies_minimum_version: false,
+            exec_json_available: false,
+            execpolicy_check_available: false,
+            output_schema_available: false,
+            classification: "diagnostic_only",
+            reason: "Codex executable was not found on PATH",
+        };
+    }
+    try {
+        const versionOutput = await execFileAsync(executablePath, ["--version"], { timeout: 5000 });
+        const version = parseCodexVersion(`${versionOutput.stdout}\n${versionOutput.stderr}`);
+        const satisfiesMinimum = version ? compareSemver(version, CODEX_ADAPTER_MINIMUM_VERSION) >= 0 : false;
+        const execJsonAvailable = await runCodexProbeCommand(executablePath, ["exec", "--help"]);
+        const execpolicyCheckAvailable = await runCodexProbeCommand(executablePath, ["execpolicy", "check", "--help"]);
+        return {
+            executable_path: executablePath,
+            version,
+            minimum_version: CODEX_ADAPTER_MINIMUM_VERSION,
+            satisfies_minimum_version: satisfiesMinimum,
+            exec_json_available: execJsonAvailable,
+            execpolicy_check_available: execpolicyCheckAvailable,
+            output_schema_available: execJsonAvailable,
+            classification: satisfiesMinimum ? "diagnostic_only" : "diagnostic_only",
+            reason: satisfiesMinimum ? "Codex runtime probe succeeded; runtime enforcement still requires trusted hook execution evidence" : "Codex runtime is missing or below the minimum supported version",
+        };
+    }
+    catch {
+        return {
+            executable_path: executablePath,
+            version: null,
+            minimum_version: CODEX_ADAPTER_MINIMUM_VERSION,
+            satisfies_minimum_version: false,
+            exec_json_available: false,
+            execpolicy_check_available: false,
+            output_schema_available: false,
+            classification: "diagnostic_only",
+            reason: "Codex version probe failed",
+        };
+    }
+}
+function parseJsonlEvents(stdout) {
+    return stdout.split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .flatMap((line) => {
+        try {
+            const parsed = JSON.parse(line);
+            return isRecord(parsed) ? [{ raw: parsed }] : [];
+        }
+        catch {
+            return [];
+        }
+    });
+}
+function execFileWithTimeout(executablePath, args, options) {
+    return new Promise((resolve) => {
+        const child = spawn(executablePath, args, {
+            cwd: options.cwd,
+            env: { ...process.env, ...options.env },
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        const stdoutChunks = [];
+        const stderrChunks = [];
+        let settled = false;
+        const finish = (status, exitCode) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve({
+                status,
+                stdout: Buffer.concat(stdoutChunks).toString("utf-8"),
+                stderr: Buffer.concat(stderrChunks).toString("utf-8"),
+                exitCode,
+            });
+        };
+        const timer = setTimeout(() => {
+            child.kill("SIGTERM");
+            finish("timeout", null);
+        }, options.timeoutMs);
+        child.stdout?.on("data", (chunk) => stdoutChunks.push(chunk));
+        child.stderr?.on("data", (chunk) => stderrChunks.push(chunk));
+        child.on("error", () => finish("failed", null));
+        child.on("close", (code) => finish(code === 0 ? "completed" : "failed", code));
+    });
+}
+export async function runCodexExecDogfood(options) {
+    const probe = await probeCodexRuntime({ executablePath: options.executablePath, envPath: options.env?.PATH });
+    const executablePath = probe.executable_path;
+    const prompt = options.prompt ?? "Reply exactly INTENTDNA-CODEX-DOGFOOD-OK and do not run shell commands.";
+    const args = [
+        "exec",
+        "--ephemeral",
+        "--json",
+        "--skip-git-repo-check",
+        "-C",
+        options.projectDir,
+        "--sandbox",
+        "read-only",
+        ...(options.extraArgs ?? []),
+        prompt,
+    ];
+    if (!executablePath || !probe.satisfies_minimum_version || !probe.exec_json_available) {
+        return {
+            probe,
+            status: "skipped",
+            classification: "diagnostic_only",
+            command: [executablePath ?? "codex", ...args],
+            events: [],
+            stdout: "",
+            stderr: "",
+            reason: probe.reason,
+        };
+    }
+    const result = await execFileWithTimeout(executablePath, args, {
+        cwd: options.projectDir,
+        timeoutMs: options.timeoutMs ?? 30000,
+        env: options.env,
+    });
+    const events = parseJsonlEvents(result.stdout);
+    return {
+        probe,
+        status: result.status,
+        classification: result.status === "completed" && events.length > 0 ? "diagnostic_only" : "diagnostic_only",
+        command: [executablePath, ...args],
+        events,
+        stdout: result.stdout,
+        stderr: result.stderr,
+        reason: result.status === "completed" ? "Codex exec --json dogfood completed; hook trust and RuntimeDecisionEvent provenance still determine enforcement classification" : `Codex dogfood ${result.status}`,
+    };
+}
+export function withCodexDogfoodEvidence(evidence, dogfood) {
+    return {
+        ...evidence,
+        runtime_probe: dogfood.probe,
+        notes: [
+            ...evidence.notes,
+            `Codex exec dogfood status: ${dogfood.status}`,
+            dogfood.reason,
+        ],
+    };
+}
+export function codexInstallModeSemantics(mode) {
+    if (mode === "plugin_scoped") {
+        return {
+            mode,
+            writes_plugin_artifacts: true,
+            writes_project_fallback: false,
+            writes_trust_state: false,
+            support_status: "partial",
+            classification: "diagnostic_only",
+            reason: "Plugin-scoped hooks are a distribution surface until Codex trust is verified by runtime evidence",
+        };
+    }
+    if (mode === "project_fallback") {
+        return {
+            mode,
+            writes_plugin_artifacts: true,
+            writes_project_fallback: true,
+            writes_trust_state: true,
+            support_status: "partial",
+            classification: "diagnostic_only",
+            reason: "Project fallback hooks need matching trust state and hook execution evidence before enterprise classification",
+        };
+    }
+    if (mode === "managed") {
+        return {
+            mode,
+            writes_plugin_artifacts: true,
+            writes_project_fallback: true,
+            writes_trust_state: true,
+            support_status: "partial",
+            classification: "diagnostic_only",
+            reason: "Managed hooks require managed root and runtime execution evidence before enterprise classification",
+        };
+    }
+    return {
+        mode,
+        writes_plugin_artifacts: false,
+        writes_project_fallback: false,
+        writes_trust_state: false,
+        support_status: "unsupported",
+        classification: "unsupported",
+        reason: "No Codex runtime files are installed in none mode",
+    };
+}
+function quoteCommandPart(value) {
+    if (/[\0\r\n]/.test(value))
+        throw new Error("Codex adapter command paths must not contain control characters");
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function resolveDispatcherScript(options) {
+    const adapterRoot = resolve(options.adapterRoot);
+    const dispatcherScript = resolve(adapterRoot, options.dispatcherScript);
+    const relativePath = relative(adapterRoot, dispatcherScript);
+    if (relativePath === "" || relativePath.startsWith("..") || relativePath.includes("..")) {
+        throw new Error("Codex adapter dispatcherScript must stay inside adapterRoot");
+    }
+    return dispatcherScript;
+}
+export function buildCodexDispatcherCommand(options) {
+    if (options.dispatcherCommand !== undefined) {
+        if (options.dispatcherCommand.trim().length === 0)
+            throw new Error("Codex adapter dispatcherCommand is required");
+        if (/[\0\r\n]/.test(options.dispatcherCommand))
+            throw new Error("Codex adapter command paths must not contain control characters");
+        return options.dispatcherCommand;
+    }
+    const nodePath = options.nodePath ?? process.execPath;
+    if (nodePath.trim().length === 0)
+        throw new Error("Codex adapter nodePath is required");
+    return `${quoteCommandPart(nodePath)} ${quoteCommandPart(resolveDispatcherScript(options))}`;
+}
+function canonicalJson(value) {
+    if (Array.isArray(value))
+        return value.map((item) => canonicalJson(item));
+    if (value && typeof value === "object") {
+        const record = value;
+        return Object.fromEntries(Object.keys(record).sort().map((key) => [key, canonicalJson(record[key])]));
+    }
+    return value;
+}
+export function codexHookTrustedHash(identity) {
+    return `sha256:${createHash("sha256").update(JSON.stringify(canonicalJson(identity)), "utf-8").digest("hex")}`;
+}
+function hookGroup(event, command, hookInstallMode) {
+    const hook = {
+        type: "command",
+        command: `${command} CodexHook --codex-event ${event} --codex-install-mode ${hookInstallMode}`,
+        statusMessage: OWNED_HOOK_STATUS_MESSAGE,
+        ...(EVENT_TIMEOUTS[event] ? { timeout: EVENT_TIMEOUTS[event] } : {}),
+    };
+    return {
+        ...(EVENT_MATCHERS[event] ? { matcher: EVENT_MATCHERS[event] } : {}),
+        hooks: [hook],
+    };
+}
+export function compileCodexPluginManifest(options) {
+    return {
+        name: options.pluginName ?? OWNED_PLUGIN_NAME,
+        version: options.pluginVersion ?? "0.1.0",
+        description: options.pluginDescription ?? "Intent DNA Codex CLI adapter hooks",
+        hooks: options.pluginHooksPath ?? "./hooks/hooks.json",
+    };
+}
+function compileCodexHooksConfigForCommand(dispatcherCommand, hookInstallMode) {
+    if (dispatcherCommand.trim().length === 0)
+        throw new Error("Codex adapter dispatcherCommand is required");
+    return {
+        hooks: Object.fromEntries(CODEX_NATIVE_HOOK_EVENTS.map((event) => [event, [hookGroup(event, dispatcherCommand, hookInstallMode)]])),
+    };
+}
+export function compileCodexHooksConfig(options) {
+    return compileCodexHooksConfigForCommand(buildCodexDispatcherCommand(options), options.hookInstallMode ?? "project_fallback");
+}
+function sourceList(values) {
+    return [...new Set(values.map((value) => value.source_role ?? value.source_gene).filter(Boolean))].join(", ") || "unknown";
+}
+export function compileCodexInstructionArtifact(ir, options) {
+    const path = options.instructionPath ?? "AGENTS.intentdna.md";
+    const lines = [
+        "# Intent DNA Codex Instructions",
+        "",
+        "<!-- intentdna:codex-instructions:start -->",
+        "These instructions are generated from Intent DNA Constraint IR for Codex CLI. They are soft guidance; hooks, permissions, and RuntimeDecisionEvent evidence remain the stronger enforcement surfaces.",
+        "",
+    ];
+    if (ir.active_role)
+        lines.push(`Active role: ${ir.active_role}`, "");
+    if (ir.role_scope)
+        lines.push(`Role scope: ${JSON.stringify(ir.role_scope)}`, "");
+    if (ir.prompt_directives.length > 0) {
+        lines.push("## Prompt directives");
+        for (const directive of ir.prompt_directives)
+            lines.push(`- [${directive.priority}] ${directive.text} (source: ${directive.source_gene})`);
+        lines.push("");
+    }
+    if (ir.context_injections.length > 0) {
+        lines.push("## Context injections");
+        for (const injection of ir.context_injections)
+            lines.push(`- [${injection.type}] ${injection.text} (tags: ${injection.relevance_tags.join(", ")})`);
+        lines.push("");
+    }
+    if (ir.pre_execution_gates.length > 0) {
+        lines.push("## Pre-execution gates summarized for Codex");
+        for (const gate of ir.pre_execution_gates)
+            lines.push(`- ${gate.action.toUpperCase()} when ${gate.condition}: ${gate.message} (source: ${gate.source_gene})`);
+        lines.push("");
+    }
+    if (ir.post_execution_validators.length > 0 || (ir.verifier_specs?.length ?? 0) > 0) {
+        lines.push("## Validation expectations");
+        for (const validator of ir.post_execution_validators)
+            lines.push(`- Check ${validator.check} (source: ${validator.source_gene})`);
+        for (const spec of ir.verifier_specs ?? [])
+            lines.push(`- ${spec.kind} verifier ${spec.id} at ${spec.when} (${spec.severity})`);
+        lines.push("");
+    }
+    lines.push("<!-- intentdna:codex-instructions:end -->", "");
+    return { path, content: lines.join("\n") };
+}
+function policyMapEntry(source, codexSurface, supportStatus, evidenceRef, notes) {
+    return { source, codex_surface: codexSurface, support_status: supportStatus, evidence_ref: evidenceRef, notes };
+}
+export function compileCodexPolicyMapArtifact(ir, options) {
+    const path = options.policyMapPath ?? ".dna/compiled/codex-policy-map.json";
+    const entries = [];
+    if (ir.prompt_directives.length > 0)
+        entries.push(policyMapEntry(sourceList(ir.prompt_directives), options.instructionPath ?? "AGENTS.intentdna.md", "partial", "codex-instruction-artifact", ["Prompt directives are soft Codex instructions, not deterministic enforcement."]));
+    if (ir.role_scope || ir.role_tool_permissions || ir.roles_scope_map?.length)
+        entries.push(policyMapEntry(sourceList(ir.roles_scope_map?.map((entry) => ({ source_role: entry.role_name })) ?? []), "Codex permissions/rules plus hook diagnostics", "partial", "codex-role-scope-map", ["Role scope and tool permissions require Codex permissions/rules or hooks for each concrete runtime path."]));
+    if (ir.pre_execution_gates.length > 0)
+        entries.push(policyMapEntry(sourceList(ir.pre_execution_gates), "PreToolUse project_fallback hook", "partial", "codex-pre-tool-use-hook", ["Only supported Codex PreToolUse paths can be intercepted; non-Bash/non-MCP gaps stay explicit."]));
+    if (ir.tool_filters.length > 0)
+        entries.push(policyMapEntry(sourceList(ir.tool_filters), "Codex execpolicy/rules and PreToolUse hook subset", "partial", "codex-tool-filter-map", ["Codex execpolicy syntax is runtime-specific; adapter records the mapping and does not claim all tool filters are enforceable."]));
+    if (ir.post_execution_validators.length > 0 || (ir.verifier_specs?.length ?? 0) > 0)
+        entries.push(policyMapEntry(sourceList(ir.post_execution_validators), "PostToolUse/Stop validation evidence", "partial", "codex-validation-hook", ["Post execution validation can record evidence but cannot roll back side effects."]));
+    if (ir.context_injections.length > 0)
+        entries.push(policyMapEntry(sourceList(ir.context_injections.map((entry) => ({ source_gene: entry.type }))), options.instructionPath ?? "AGENTS.intentdna.md", "partial", "codex-context-instruction-artifact", ["Static context can be rendered into instructions; dynamic context remains event-limited."]));
+    return {
+        path,
+        content: {
+            schema_version: "intentdna.codex_policy_map.v1",
+            generated_at: options.generatedAt ?? new Date().toISOString(),
+            adapter: "codex_cli",
+            entries,
+            unsupported: unsupportedCodexCapabilities(ir),
+        },
+    };
+}
+function normalizedCommandHookIdentity(event, group, hook) {
+    return {
+        event_name: EVENT_LABELS[event],
+        ...(group.matcher ? { matcher: group.matcher } : {}),
+        hooks: [{
+                type: "command",
+                command: hook.command,
+                timeout: Math.max(1, hook.timeout ?? 600),
+                async: false,
+                ...(hook.statusMessage ? { statusMessage: hook.statusMessage } : {}),
+            }],
+    };
+}
+function trustStateKey(hooksPath, event, groupIndex, handlerIndex) {
+    return `${hooksPath}:${EVENT_LABELS[event]}:${groupIndex}:${handlerIndex}`;
+}
+export function buildCodexHookTrustState(hooksPath, hooksConfig) {
+    if (hooksPath.trim().length === 0)
+        return {};
+    const state = {};
+    for (const event of CODEX_NATIVE_HOOK_EVENTS) {
+        const groups = hooksConfig.hooks[event] ?? [];
+        groups.forEach((group, groupIndex) => {
+            group.hooks.forEach((hook, handlerIndex) => {
+                if (hook.type !== "command" || !isIntentDnaOwnedHook(hook))
+                    return;
+                state[trustStateKey(hooksPath, event, groupIndex, handlerIndex)] = {
+                    trusted_hash: codexHookTrustedHash(normalizedCommandHookIdentity(event, group, hook)),
+                };
+            });
+        });
+    }
+    return state;
+}
+function trustStateMatches(expected, actual) {
+    const expectedEntries = Object.entries(expected);
+    return expectedEntries.length > 0 && expectedEntries.every(([key, value]) => actual[key]?.trusted_hash === value.trusted_hash);
+}
+export function verifyCodexHookTrust(input) {
+    const reasons = [];
+    const evidenceRefs = [
+        { type: "artifact", ref: "codex-runtime-probe" },
+        { type: "artifact", ref: "codex-hook-trust-state" },
+    ];
+    const semantics = codexInstallModeSemantics(input.hookInstallMode);
+    if (input.hookInstallMode === "plugin_scoped" || semantics.classification === "unsupported")
+        reasons.push(semantics.reason);
+    if (!input.probe.satisfies_minimum_version)
+        reasons.push(input.probe.reason);
+    if (!input.actualTrustState || !trustStateMatches(input.expectedTrustState, input.actualTrustState))
+        reasons.push("Codex hook trust state does not match generated Intent DNA hook identity");
+    if (input.hookInstallMode === "managed")
+        reasons.push("Managed Codex hook policy proof is not implemented in this source-level slice");
+    if (!input.runtimeExecutionVerified)
+        reasons.push("Codex hook execution has not been verified by runtime evidence");
+    if (!input.provenanceComplete)
+        reasons.push("RuntimeDecisionEvent provenance is incomplete");
+    const trusted = reasons.length === 0 && input.hookInstallMode === "project_fallback";
+    return {
+        trusted,
+        support_status: trusted ? "supported" : semantics.support_status,
+        classification: trusted ? "enterprise_evidence" : semantics.classification,
+        evidence_refs: evidenceRefs,
+        reasons: reasons.length > 0 ? reasons : ["Codex hook trust verified with runtime execution evidence"],
+    };
+}
+export function compileCodexAdapterArtifacts(ir, options) {
+    const dispatcherScript = options.dispatcherCommand ? options.dispatcherCommand : resolveDispatcherScript(options);
+    const dispatcherCommand = buildCodexDispatcherCommand(options);
+    const pluginHooksPath = options.pluginHooksPath ?? "./hooks/hooks.json";
+    const instructionPath = options.instructionPath ?? "AGENTS.intentdna.md";
+    const policyMapPath = options.policyMapPath ?? ".dna/compiled/codex-policy-map.json";
+    const fallbackHooksPath = options.fallbackHooksPath ?? ".codex/hooks.json";
+    const fallbackConfigPath = options.fallbackConfigPath ?? ".codex/config.toml";
+    const hookInstallMode = options.hookInstallMode ?? "project_fallback";
+    const pluginHooks = compileCodexHooksConfigForCommand(dispatcherCommand, hookInstallMode);
+    const fallbackHooks = compileCodexHooksConfigForCommand(dispatcherCommand, hookInstallMode);
+    const instruction = compileCodexInstructionArtifact(ir, { ...options, instructionPath });
+    const policyMap = compileCodexPolicyMapArtifact(ir, { ...options, instructionPath, policyMapPath });
+    const trustState = buildCodexHookTrustState(fallbackHooksPath, fallbackHooks);
+    const unsupported = unsupportedCodexCapabilities(ir);
+    const generatedAt = options.generatedAt ?? new Date().toISOString();
+    return {
+        pluginManifest: compileCodexPluginManifest({ ...options, pluginHooksPath }),
+        pluginHooks,
+        fallbackHooks,
+        instruction,
+        policyMap,
+        trustState,
+        evidence: {
+            schema_version: "intentdna.codex_adapter_evidence.v1",
+            generated_at: generatedAt,
+            adapter: "codex_cli",
+            minimum_codex_version: CODEX_ADAPTER_MINIMUM_VERSION,
+            hook_install_mode: hookInstallMode,
+            install_mode_semantics: codexInstallModeSemantics(hookInstallMode),
+            dispatcher_command: dispatcherCommand,
+            dispatcher_script: dispatcherScript,
+            plugin_hooks_path: pluginHooksPath,
+            instruction_path: instructionPath,
+            policy_map_path: policyMapPath,
+            fallback_hooks_path: fallbackHooksPath,
+            fallback_config_path: fallbackConfigPath,
+            generated_events: [...CODEX_NATIVE_HOOK_EVENTS],
+            trust_state: trustState,
+            support_status: codexSupportStatus(ir),
+            unsupported,
+            notes: [
+                "Plugin-scoped Codex hooks are a distribution surface and require Codex trust review before enforcement.",
+                "Fallback hook trust hashes are generated for .codex/config.toml hooks.state evidence, not embedded in hooks.json.",
+                "RuntimeDecisionEvent is primary runtime evidence and must be written through appendRuntimeDecisionEvent; this file is adapter/config evidence only.",
+            ],
+        },
+    };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isIntentDnaOwnedHook(hook, dispatcherCommand) {
+    const commandMatches = dispatcherCommand === undefined ||
+        hookCommandStartsWith(hook, `${dispatcherCommand} CodexHook --codex-event`) ||
+        hookCommandIncludesCodexWrapper(hook);
+    return isRecord(hook) &&
+        hook.type === "command" &&
+        hook.statusMessage === OWNED_HOOK_STATUS_MESSAGE &&
+        commandMatches;
+}
+function hookCommandStartsWith(hook, prefix) {
+    return isRecord(hook) && typeof hook.command === "string" && hook.command.startsWith(prefix);
+}
+function hookCommandIncludesCodexWrapper(hook) {
+    return isRecord(hook) && typeof hook.command === "string" && hook.command.includes(" CodexHook --codex-event ");
+}
+function isIntentDnaOwnedGroup(group, dispatcherCommand) {
+    return isRecord(group) && Array.isArray(group.hooks) && group.hooks.some((hook) => isIntentDnaOwnedHook(hook, dispatcherCommand));
+}
+function isIntentDnaOwnedHooksConfig(value) {
+    if (!isRecord(value) || !isRecord(value.hooks))
+        return false;
+    const groupsByEvent = Object.values(value.hooks);
+    if (groupsByEvent.length === 0)
+        return false;
+    return groupsByEvent.every((groups) => Array.isArray(groups) && groups.every((group) => isRecord(group) && Array.isArray(group.hooks) && group.hooks.length > 0 && group.hooks.every((hook) => isIntentDnaOwnedHook(hook))));
+}
+export function mergeCodexFallbackHooks(existingContent, generated, dispatcherCommand) {
+    const existingRoot = parseCodexHooksConfig(existingContent);
+    const nextHooks = { ...existingRoot.hooks };
+    for (const event of CODEX_NATIVE_HOOK_EVENTS) {
+        const existingGroups = Array.isArray(nextHooks[event]) ? nextHooks[event] : [];
+        const preserved = existingGroups.map((group) => {
+            if (!isRecord(group) || !Array.isArray(group.hooks))
+                return group;
+            const hooks = group.hooks.filter((hook) => !isIntentDnaOwnedHook(hook, dispatcherCommand));
+            if (hooks.length === 0)
+                return null;
+            return { ...group, hooks };
+        }).filter((group) => group !== null && !isIntentDnaOwnedGroup(group, dispatcherCommand));
+        nextHooks[event] = [...preserved, ...(generated.hooks[event] ?? [])];
+    }
+    return { hooks: nextHooks };
+}
+export function removeCodexFallbackHooks(existingContent, dispatcherCommand) {
+    const existingRoot = parseCodexHooksConfig(existingContent);
+    const nextHooks = {};
+    for (const [event, groups] of Object.entries(existingRoot.hooks)) {
+        const preserved = Array.isArray(groups)
+            ? groups.map((group) => {
+                if (!isRecord(group) || !Array.isArray(group.hooks))
+                    return group;
+                const hooks = group.hooks.filter((hook) => !isIntentDnaOwnedHook(hook, dispatcherCommand));
+                return hooks.length > 0 ? { ...group, hooks } : null;
+            }).filter((group) => group !== null && !isIntentDnaOwnedGroup(group, dispatcherCommand))
+            : [];
+        if (preserved.length > 0)
+            nextHooks[event] = preserved;
+    }
+    if (Object.keys(nextHooks).length === 0)
+        return null;
+    return { hooks: nextHooks };
+}
+function parseCodexHooksConfig(content) {
+    if (!content)
+        return { hooks: {} };
+    const parsed = JSON.parse(content);
+    if (!isRecord(parsed))
+        throw new Error("Codex hooks config must be a JSON object");
+    if ("hooks" in parsed && !isRecord(parsed.hooks))
+        throw new Error("Codex hooks config hooks field must be an object");
+    const hooks = isRecord(parsed.hooks) ? parsed.hooks : {};
+    for (const [event, groups] of Object.entries(hooks)) {
+        if (!Array.isArray(groups))
+            throw new Error(`Codex hooks config event ${event} must be an array`);
+        groups.forEach((group, groupIndex) => {
+            if (!isRecord(group) || !Array.isArray(group.hooks))
+                throw new Error(`Codex hooks config event ${event}[${groupIndex}] must contain hooks array`);
+            group.hooks.forEach((hook, hookIndex) => {
+                if (!isRecord(hook) || hook.type !== "command" || typeof hook.command !== "string") {
+                    throw new Error(`Codex hooks config event ${event}[${groupIndex}].hooks[${hookIndex}] must be a command hook`);
+                }
+            });
+        });
+    }
+    return { hooks: hooks };
+}
+export function codexTrustStateToml(trustState) {
+    return Object.entries(trustState)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .flatMap(([key, hookState]) => [
+        `[hooks.state."${escapeTomlString(key)}"]`,
+        `trusted_hash = "${escapeTomlString(hookState.trusted_hash)}"`,
+        "",
+    ])
+        .join("\n")
+        .trimEnd();
+}
+function escapeTomlString(value) {
+    return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+export function mergeCodexTrustStateConfig(existingContent, trustState) {
+    const generated = codexTrustStateToml(trustState);
+    const preserved = stripIntentDnaTrustStateBlock(existingContent ?? "").trimEnd();
+    if (!generated)
+        return preserved ? `${preserved}\n` : "";
+    const block = [TRUST_STATE_START, generated, TRUST_STATE_END].join("\n");
+    return preserved ? `${preserved}\n\n${block}\n` : `${block}\n`;
+}
+export function removeCodexTrustStateConfig(existingContent) {
+    const preserved = stripIntentDnaTrustStateBlock(existingContent ?? "").trimEnd();
+    return preserved ? `${preserved}\n` : "";
+}
+function hasIntentDnaTrustStateBlock(content) {
+    return content.includes(TRUST_STATE_START) && content.includes(TRUST_STATE_END);
+}
+function stripIntentDnaTrustStateBlock(content) {
+    const pattern = new RegExp(`${escapeRegExp(TRUST_STATE_START)}[\\s\\S]*?${escapeRegExp(TRUST_STATE_END)}\\n?`, "g");
+    return content.replace(pattern, "");
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function projectPath(projectDir, configuredPath) {
+    const root = resolve(projectDir);
+    const candidate = resolve(root, configuredPath);
+    const relativePath = relative(root, candidate);
+    if (relativePath === "" || relativePath.startsWith("..") || relativePath.includes(`..${sep}`)) {
+        throw new Error(`Codex adapter path escapes project directory: ${configuredPath}`);
+    }
+    return candidate;
+}
+function codexArtifactPaths(projectDir, artifacts) {
+    return {
+        pluginManifest: join(projectDir, "codex-plugin", ".codex-plugin", "plugin.json"),
+        pluginHooks: join(projectDir, "codex-plugin", "hooks", "hooks.json"),
+        instruction: projectPath(projectDir, artifacts?.instruction.path ?? "AGENTS.intentdna.md"),
+        policyMap: projectPath(projectDir, artifacts?.policyMap.path ?? ".dna/compiled/codex-policy-map.json"),
+        adapterEvidence: join(projectDir, ".dna", "compiled", "codex-adapter-evidence.json"),
+        fallbackHooks: projectPath(projectDir, artifacts?.evidence.fallback_hooks_path ?? ".codex/hooks.json"),
+        fallbackConfig: projectPath(projectDir, artifacts?.evidence.fallback_config_path ?? ".codex/config.toml"),
+    };
+}
+async function assertWritableCodexPluginArtifact(path, validateExisting) {
+    const existing = await readFile(path, "utf-8").catch(() => null);
+    if (existing === null)
+        return;
+    const parsed = JSON.parse(existing);
+    if (!validateExisting(parsed))
+        throw new Error(`Refusing to overwrite non-Intent DNA Codex plugin artifact: ${path}`);
+}
+async function assertWritableOwnedTextArtifact(path, startMarker, errorLabel) {
+    const existing = await readFile(path, "utf-8").catch(() => null);
+    if (existing === null)
+        return;
+    if (!existing.includes(startMarker))
+        throw new Error(`Refusing to overwrite non-Intent DNA ${errorLabel}: ${path}`);
+}
+async function assertWritableOwnedJsonArtifact(path, schemaVersion, errorLabel) {
+    const existing = await readFile(path, "utf-8").catch(() => null);
+    if (existing === null)
+        return;
+    const parsed = JSON.parse(existing);
+    if (!isRecord(parsed) || parsed.schema_version !== schemaVersion)
+        throw new Error(`Refusing to overwrite non-Intent DNA ${errorLabel}: ${path}`);
+}
+async function unlinkOwnedCodexPluginArtifact(path, validateExisting, removed) {
+    const existing = await readFile(path, "utf-8").catch(() => null);
+    if (existing === null)
+        return;
+    const parsed = JSON.parse(existing);
+    if (!validateExisting(parsed))
+        return;
+    await unlink(path);
+    removed.push(path);
+}
+async function unlinkOwnedTextArtifact(path, marker, removed) {
+    const existing = await readFile(path, "utf-8").catch(() => null);
+    if (existing === null || !existing.includes(marker))
+        return;
+    await unlink(path);
+    removed.push(path);
+}
+async function unlinkOwnedJsonArtifact(path, schemaVersion, removed) {
+    const existing = await readFile(path, "utf-8").catch(() => null);
+    if (existing === null)
+        return;
+    const parsed = JSON.parse(existing);
+    if (!isRecord(parsed) || parsed.schema_version !== schemaVersion)
+        return;
+    await unlink(path);
+    removed.push(path);
+}
+export async function writeCodexAdapterArtifacts(projectDir, artifacts) {
+    const paths = codexArtifactPaths(projectDir, artifacts);
+    let evidence = artifacts.evidence;
+    let mergedHooks = null;
+    let finalTrustState = null;
+    let existingConfig = null;
+    await assertWritableOwnedTextArtifact(paths.instruction, "intentdna:codex-instructions:start", "Codex instruction artifact");
+    await assertWritableOwnedJsonArtifact(paths.policyMap, "intentdna.codex_policy_map.v1", "Codex policy map artifact");
+    await assertWritableOwnedJsonArtifact(paths.adapterEvidence, "intentdna.codex_adapter_evidence.v1", "Codex adapter evidence artifact");
+    if (artifacts.evidence.install_mode_semantics.writes_plugin_artifacts) {
+        await assertWritableCodexPluginArtifact(paths.pluginManifest, (value) => isRecord(value) && value.name === OWNED_PLUGIN_NAME);
+        await assertWritableCodexPluginArtifact(paths.pluginHooks, isIntentDnaOwnedHooksConfig);
+    }
+    if (artifacts.evidence.install_mode_semantics.writes_project_fallback) {
+        const existingHooks = await readFile(paths.fallbackHooks, "utf-8").catch(() => null);
+        mergedHooks = mergeCodexFallbackHooks(existingHooks, artifacts.fallbackHooks, artifacts.evidence.dispatcher_command);
+        finalTrustState = buildCodexHookTrustState(artifacts.evidence.fallback_hooks_path, mergedHooks);
+        existingConfig = await readFile(paths.fallbackConfig, "utf-8").catch(() => null);
+        mergeCodexTrustStateConfig(existingConfig, finalTrustState);
+        evidence = { ...evidence, trust_state: finalTrustState };
+    }
+    const written = [];
+    await mkdir(dirname(paths.instruction), { recursive: true });
+    await assertWritableOwnedTextArtifact(paths.instruction, "intentdna:codex-instructions:start", "Codex instruction artifact");
+    await atomicWrite(paths.instruction, artifacts.instruction.content);
+    written.push(paths.instruction);
+    await mkdir(dirname(paths.policyMap), { recursive: true });
+    await assertWritableOwnedJsonArtifact(paths.policyMap, "intentdna.codex_policy_map.v1", "Codex policy map artifact");
+    await atomicWrite(paths.policyMap, JSON.stringify(artifacts.policyMap.content, null, 2) + "\n");
+    written.push(paths.policyMap);
+    if (artifacts.evidence.install_mode_semantics.writes_project_fallback) {
+        await mkdir(dirname(paths.fallbackHooks), { recursive: true });
+        await atomicWrite(paths.fallbackHooks, JSON.stringify(mergedHooks, null, 2) + "\n");
+        written.push(paths.fallbackHooks);
+        await mkdir(dirname(paths.fallbackConfig), { recursive: true });
+        await atomicWrite(paths.fallbackConfig, mergeCodexTrustStateConfig(existingConfig, finalTrustState ?? {}));
+        written.push(paths.fallbackConfig);
+    }
+    await mkdir(dirname(paths.adapterEvidence), { recursive: true });
+    await atomicWrite(paths.adapterEvidence, JSON.stringify(evidence, null, 2) + "\n");
+    written.push(paths.adapterEvidence);
+    if (artifacts.evidence.install_mode_semantics.writes_plugin_artifacts) {
+        await mkdir(dirname(paths.pluginManifest), { recursive: true });
+        await assertWritableCodexPluginArtifact(paths.pluginManifest, (value) => isRecord(value) && value.name === OWNED_PLUGIN_NAME);
+        await atomicWrite(paths.pluginManifest, JSON.stringify(artifacts.pluginManifest, null, 2) + "\n");
+        written.push(paths.pluginManifest);
+        await mkdir(dirname(paths.pluginHooks), { recursive: true });
+        await assertWritableCodexPluginArtifact(paths.pluginHooks, isIntentDnaOwnedHooksConfig);
+        await atomicWrite(paths.pluginHooks, JSON.stringify(artifacts.pluginHooks, null, 2) + "\n");
+        written.push(paths.pluginHooks);
+    }
+    return written;
+}
+export async function removeCodexAdapterArtifacts(projectDir, dispatcherCommand, artifacts) {
+    const paths = codexArtifactPaths(projectDir, artifacts);
+    const removed = [];
+    await unlinkOwnedCodexPluginArtifact(paths.pluginManifest, (value) => isRecord(value) && value.name === OWNED_PLUGIN_NAME, removed);
+    await unlinkOwnedCodexPluginArtifact(paths.pluginHooks, isIntentDnaOwnedHooksConfig, removed);
+    await unlinkOwnedTextArtifact(paths.instruction, "intentdna:codex-instructions:start", removed);
+    await unlinkOwnedJsonArtifact(paths.policyMap, "intentdna.codex_policy_map.v1", removed);
+    await unlinkOwnedJsonArtifact(paths.adapterEvidence, "intentdna.codex_adapter_evidence.v1", removed);
+    const fallbackContent = await readFile(paths.fallbackHooks, "utf-8").catch(() => null);
+    if (fallbackContent !== null) {
+        const existingRoot = parseCodexHooksConfig(fallbackContent);
+        const hasOwnedHooks = Object.values(existingRoot.hooks).some((groups) => Array.isArray(groups) && groups.some((group) => isIntentDnaOwnedGroup(group, dispatcherCommand)));
+        if (hasOwnedHooks) {
+            const nextHooks = removeCodexFallbackHooks(fallbackContent, dispatcherCommand);
+            if (nextHooks) {
+                await atomicWrite(paths.fallbackHooks, JSON.stringify(nextHooks, null, 2) + "\n");
+            }
+            else {
+                await unlink(paths.fallbackHooks).catch(() => { });
+            }
+            removed.push(paths.fallbackHooks);
+        }
+    }
+    const configContent = await readFile(paths.fallbackConfig, "utf-8").catch(() => null);
+    if (configContent !== null && hasIntentDnaTrustStateBlock(configContent)) {
+        const nextConfig = removeCodexTrustStateConfig(configContent);
+        if (nextConfig) {
+            await atomicWrite(paths.fallbackConfig, nextConfig);
+        }
+        else {
+            await unlink(paths.fallbackConfig).catch(() => { });
+        }
+        removed.push(paths.fallbackConfig);
+    }
+    return removed;
+}
+export async function appendCodexRuntimeDecisionEvent(projectDir, event, sessionId) {
+    await appendRuntimeDecisionEvent(projectDir, event, sessionId);
+}
+function codexSupportStatus(ir) {
+    return {
+        prompt_directives: ir.prompt_directives.length > 0 ? "partial" : "unknown",
+        tool_filters: ir.tool_filters.length > 0 ? "partial" : "unknown",
+        pre_execution_gates: ir.pre_execution_gates.length > 0 ? "partial" : "unknown",
+        post_execution_validators: ir.post_execution_validators.length > 0 || ir.verifier_specs?.length ? "partial" : "unknown",
+        context_injections: ir.context_injections.length > 0 ? "partial" : "unknown",
+        role_scope: ir.role_scope ? "partial" : "unknown",
+        role_tool_permissions: ir.role_tool_permissions ? "partial" : "unknown",
+        runtime_decision_event: "partial",
+        permission_request: "unsupported",
+        subagent_lifecycle: "unsupported",
+    };
+}
+function unsupportedCodexCapabilities(ir) {
+    const unsupported = [
+        "full_claude_code_hook_parity",
+        "native_runtime_decision_event",
+        "plugin_hook_trust_without_review",
+        "permission_request_runtime_fixture_not_frozen",
+        "subagent_lifecycle_runtime_fixture_not_frozen",
+    ];
+    if (ir.tool_filters.length > 0)
+        unsupported.push("non_bash_tool_filter_interception");
+    if (ir.post_execution_validators.length > 0 || ir.verifier_specs?.some((spec) => spec.when === "post_tool_use" || spec.when === "stop")) {
+        unsupported.push("post_execution_side_effect_rollback");
+    }
+    return [...new Set(unsupported)];
+}
+function cascadeLayers(ir) {
+    const layers = ir.provenance?.cascade_layers;
+    const result = {};
+    for (const layer of ["species", "enterprise", "project", "personal", "role", "context", "task"]) {
+        const entry = layers?.[layer];
+        result[layer] = {
+            layer,
+            source_id: entry?.source_id ?? "unknown",
+            source_ref: entry?.source_ref ?? "unknown",
+            fingerprint: entry?.fingerprint ?? "unknown",
+            status: entry?.status ?? "unknown",
+        };
+    }
+    return result;
+}
+function fallbackConstraint(decision, reason, ir) {
+    return {
+        constraint_id: decision === "allow" ? "allow:no_blocking_constraint" : "unknown",
+        source_layer: decision === "allow" && ir.provenance?.policy_bundle_id ? "enterprise" : "unknown",
+        source_dna_id: decision === "allow" ? ir.provenance?.policy_bundle_id ?? "unknown" : "unknown",
+        gene_id: decision === "allow" ? "no_blocking_constraint" : "unknown",
+        codon_type: "threshold",
+        action: decision,
+        provenance_reason: reason || "unknown",
+    };
+}
+function candidateMatches(candidate, decision) {
+    return candidate.action === decision;
+}
+function winningConstraint(ir, decision, reason) {
+    if (decision === "allow")
+        return fallbackConstraint(decision, reason, ir);
+    const matched = ir.provenance?.constraint_winners.find((candidate) => candidateMatches(candidate, decision));
+    return matched ? { ...matched, action: decision } : fallbackConstraint(decision, reason, ir);
+}
+function enforcementPointFor(input) {
+    if (input.hookInstallMode === "project_fallback" && input.hookTrusted === true && input.hookEvent === "PreToolUse")
+        return "hook";
+    return "unsupported";
+}
+function firstString(...values) {
+    for (const value of values) {
+        if (typeof value === "string" && value.trim().length > 0)
+            return value;
+    }
+    return undefined;
+}
+function firstNumber(...values) {
+    for (const value of values) {
+        if (typeof value === "number" && Number.isFinite(value))
+            return value;
+        if (typeof value === "string" && value.trim().length > 0) {
+            const parsed = Number(value);
+            if (Number.isFinite(parsed))
+                return parsed;
+        }
+    }
+    return undefined;
+}
+function nestedRecord(value, key) {
+    if (!isRecord(value))
+        return undefined;
+    const nested = value[key];
+    return isRecord(nested) ? nested : undefined;
+}
+function normalizeEvidenceResult(value) {
+    if (!value)
+        return undefined;
+    const normalized = value.toLowerCase().trim();
+    if (normalized === "success" || normalized === "succeeded" || normalized === "pass" || normalized === "passed" || normalized === "ok")
+        return "success";
+    if (normalized === "failure" || normalized === "failed" || normalized === "fail" || normalized === "error")
+        return "failure";
+    if (normalized === "blocked" || normalized === "block")
+        return "blocked";
+    if (normalized === "skipped" || normalized === "skip")
+        return "skipped";
+    if (normalized === "unsupported")
+        return "unsupported";
+    if (normalized === "unknown")
+        return "unknown";
+    return undefined;
+}
+function normalizeEvidenceRetry(root, payload, toolInput) {
+    const retry = nestedRecord(root, "retry") ?? nestedRecord(payload, "retry") ?? nestedRecord(toolInput, "retry");
+    const attempt = firstNumber(retry?.attempt, retry?.retry_attempt, root.retry_attempt, root.retryAttempt, payload.retry_attempt, payload.retryAttempt, toolInput?.retry_attempt, toolInput?.retryAttempt);
+    const maxAttempts = firstNumber(retry?.max_attempts, retry?.maxAttempts, root.max_attempts, root.maxAttempts, root.retry_max_attempts, root.retryMaxAttempts, payload.max_attempts, payload.maxAttempts, payload.retry_max_attempts, payload.retryMaxAttempts, toolInput?.max_attempts, toolInput?.maxAttempts, toolInput?.retry_max_attempts, toolInput?.retryMaxAttempts);
+    if (attempt === undefined || maxAttempts === undefined)
+        return undefined;
+    const reason = firstString(retry?.reason, retry?.retry_reason, root.retry_reason, root.retryReason, payload.retry_reason, payload.retryReason, toolInput?.retry_reason, toolInput?.retryReason) ?? "retry observed";
+    return { attempt, max_attempts: maxAttempts, reason };
+}
+function normalizeCodexEvent(value) {
+    if (!value)
+        return "unsupported";
+    if (CODEX_NATIVE_HOOK_EVENTS.includes(value) || value === "PermissionRequest")
+        return value;
+    const compact = value.replace(/[_-](\w)/g, (_match, char) => char.toUpperCase());
+    const normalized = compact.charAt(0).toUpperCase() + compact.slice(1);
+    if (CODEX_NATIVE_HOOK_EVENTS.includes(normalized) || normalized === "PermissionRequest")
+        return normalized;
+    return value;
+}
+export function normalizeCodexHookInput(rawInput, fallbackEvent) {
+    const root = isRecord(rawInput) ? rawInput : {};
+    const payload = isRecord(root.payload) ? root.payload : root;
+    const tool = nestedRecord(payload, "tool") ?? nestedRecord(root, "tool");
+    const toolInput = nestedRecord(payload, "tool_input") ?? nestedRecord(payload, "toolInput") ?? nestedRecord(payload, "input") ?? nestedRecord(root, "tool_input");
+    const event = normalizeCodexEvent(firstString(root.event, root.event_name, root.hook_event_name, root.hookEventName, payload.event, payload.event_name, payload.hook_event_name, fallbackEvent));
+    const command = firstString(root.command, payload.command, toolInput?.command, toolInput?.cmd, tool?.command);
+    const toolName = firstString(root.tool_name, root.toolName, payload.tool_name, payload.toolName, tool?.name, command ? "Bash" : undefined);
+    return {
+        event,
+        session_id: firstString(root.session_id, root.sessionId, payload.session_id, payload.sessionId),
+        run_id: firstString(root.run_id, root.runId, payload.run_id, payload.runId),
+        agent_id: firstString(root.agent_id, root.agentId, payload.agent_id, payload.agentId),
+        agent_role: firstString(root.agent_role, root.agentRole, payload.agent_role, payload.agentRole),
+        agent_type: firstString(root.agent_type, root.agentType, payload.agent_type, payload.agentType),
+        subagent_id: firstString(root.subagent_id, root.subagentId, payload.subagent_id, payload.subagentId),
+        tool_name: toolName,
+        command,
+        cwd: firstString(root.cwd, payload.cwd),
+        resource_ref: firstString(root.resource_ref, root.resourceRef, payload.resource_ref, payload.resourceRef, command),
+        result: normalizeEvidenceResult(firstString(root.result, root.status, root.outcome, payload.result, payload.status, payload.outcome, toolInput?.result, toolInput?.status)),
+        exit_code: firstNumber(root.exit_code, root.exitCode, payload.exit_code, payload.exitCode, toolInput?.exit_code, toolInput?.exitCode),
+        duration_ms: firstNumber(root.duration_ms, root.durationMs, payload.duration_ms, payload.durationMs, toolInput?.duration_ms, toolInput?.durationMs),
+        retry: normalizeEvidenceRetry(root, payload, toolInput),
+        payload,
+    };
+}
+function textMatchesCondition(text, condition) {
+    const normalizedText = text.toLowerCase();
+    const normalizedCondition = condition.toLowerCase().trim();
+    if (!normalizedCondition)
+        return false;
+    if (normalizedText.includes(normalizedCondition))
+        return true;
+    if (normalizedCondition.includes("dangerous command")) {
+        return /\b(rm\s+-rf|git\s+reset\s+--hard|git\s+clean\s+-f|drop\s+table|shutdown|reboot)\b/.test(normalizedText);
+    }
+    return normalizedCondition.split(/\s+/).filter(Boolean).every((token) => normalizedText.includes(token));
+}
+function matchingPreExecutionGate(ir, input) {
+    const subject = [input.tool_name, input.command, input.resource_ref, JSON.stringify(input.payload)].filter(Boolean).join(" ");
+    return ir.pre_execution_gates.find((gate) => textMatchesCondition(subject, gate.condition));
+}
+function codexHookOutputForGate(gate) {
+    if (gate.action === "block") {
+        return { output: { continue: false, decision: "block", reason: gate.message }, decision: "block", reason: gate.message };
+    }
+    if (gate.action === "escalate") {
+        return {
+            output: { continue: true, hookSpecificOutput: { permissionDecision: "ask", additionalContext: gate.message } },
+            decision: "escalate",
+            reason: gate.message,
+        };
+    }
+    return {
+        output: { continue: true, hookSpecificOutput: { additionalContext: `WARN: ${gate.message}` } },
+        decision: "warn",
+        reason: gate.message,
+    };
+}
+function codexDecisionForInput(ir, input) {
+    if (input.event === "PreToolUse" || input.event === "PermissionRequest") {
+        const gate = matchingPreExecutionGate(ir, input);
+        if (gate)
+            return codexHookOutputForGate(gate);
+        return { output: { continue: true, suppressOutput: true }, decision: "allow", reason: "No Codex pre-execution gate matched" };
+    }
+    if (input.event === "PostToolUse" || input.event === "Stop") {
+        const hasValidators = ir.post_execution_validators.length > 0 || (ir.verifier_specs?.length ?? 0) > 0;
+        if (!hasValidators)
+            return { output: { continue: true, suppressOutput: true }, decision: "allow", reason: "No Codex post-execution validator configured" };
+        return {
+            output: input.event === "Stop" ? { continue: true, systemMessage: "Intent DNA Codex validation evidence recorded" } : { continue: true, suppressOutput: true },
+            decision: "validate",
+            reason: "Codex post-execution validation evidence recorded",
+        };
+    }
+    return { output: { continue: true, suppressOutput: true }, decision: "allow", reason: `Codex event ${input.event} is unsupported by this runner slice` };
+}
+function runtimeEventClassification(event) {
+    const validation = validateRuntimeDecisionEvent(event);
+    return validation.classification === "enterprise_evidence" ? "enterprise_evidence" : "diagnostic_only";
+}
+function codexEvidenceResult(input, decision) {
+    if (input.result)
+        return input.result;
+    if (input.exit_code !== undefined)
+        return input.exit_code === 0 ? "success" : "failure";
+    if (decision === "block" || decision === "escalate")
+        return "blocked";
+    if (input.event === "unsupported")
+        return "unsupported";
+    return "success";
+}
+function codexEvidenceFact(input, decision) {
+    if (decision === "escalate")
+        return "manual_intervention";
+    if (input.retry)
+        return "retry";
+    if (input.event === "PostToolUse" || input.event === "Stop" || input.result || input.exit_code !== undefined)
+        return "result";
+    if (input.command)
+        return "command";
+    if (decision === "block")
+        return "blocker";
+    return "result";
+}
+function buildCodexEvidenceCaptureEvent(params) {
+    const fact = codexEvidenceFact(params.input, params.decision);
+    const command = params.input.command ?? params.input.resource_ref;
+    const result = codexEvidenceResult(params.input, params.decision);
+    const toolLabel = params.input.tool_name ?? "unknown tool";
+    const subject = command ? `${toolLabel}: ${command}` : `${toolLabel} ${params.input.event}`;
+    const summary = fact === "manual_intervention"
+        ? `Codex hook requested human intervention for ${subject}: ${params.reason}`
+        : fact === "retry" && params.input.retry
+            ? `Codex hook observed retry ${params.input.retry.attempt}/${params.input.retry.max_attempts} for ${subject}: ${params.input.retry.reason}`
+            : `Codex hook observed ${fact} for ${subject}: ${result}`;
+    const attribution = trustedEvidenceCaptureAttribution(params.ir, {
+        workflowAsset: params.workflowAsset,
+        workflowId: params.workflowId,
+        stepId: params.runtimeEvent.step_id,
+    });
+    return {
+        schema_version: EVIDENCE_CAPTURE_SCHEMA_VERSION,
+        event_id: `c5:${params.runtimeEvent.event_id}`,
+        captured_at: params.runtimeEvent.timestamp,
+        project_root: params.projectDir,
+        source: "dna_hook",
+        workflow_asset: attribution.workflowAsset,
+        workflow_id: attribution.workflowId,
+        run_id: params.runtimeEvent.run_id || "unknown",
+        step_id: attribution.stepId,
+        fact,
+        summary,
+        command,
+        result,
+        exit_code: params.input.exit_code,
+        duration_ms: params.input.duration_ms,
+        retry: params.input.retry,
+        manual_intervention: fact === "manual_intervention"
+            ? { required: true, reason: params.reason, actor: "human" }
+            : undefined,
+        evidence_refs: [
+            { type: "runtime_decision_event", ref: params.runtimeEvent.event_id },
+            ...params.runtimeEvent.evidence_refs.map((ref) => ({ type: ref.type, ref: ref.ref })),
+        ],
+        redaction: "intentdna.c5.codex_hook_secret_redaction.v1",
+    };
+}
+function projectCodexHookReference(kind, value) {
+    const material = value && value.trim().length > 0 ? value : "unknown";
+    const digest = createHash("sha256").update(material).digest("hex");
+    return `codex-hook-${kind}:sha256:${digest}`;
+}
+export async function runCodexHook(rawInput, options) {
+    const input = normalizeCodexHookInput(rawInput);
+    const decision = codexDecisionForInput(options.ir, input);
+    const sessionId = options.sessionId ?? input.session_id;
+    const runId = options.runId ?? input.run_id ?? sessionId;
+    const rawReference = input.resource_ref ?? input.command;
+    const projectedResourceRef = projectCodexHookReference("resource", rawReference);
+    const projectedEvidenceRef = projectCodexHookReference("evidence", rawReference ?? `codex-hook:${input.event}`);
+    const event = mapCodexDecisionEvent({
+        ir: options.ir,
+        decision: decision.decision,
+        decisionReason: decision.reason,
+        hookEvent: input.event,
+        hookInstallMode: options.hookInstallMode,
+        hookTrusted: options.hookTrusted,
+        codexVersion: options.codexVersion,
+        sessionId,
+        runId,
+        stepId: options.stepId,
+        toolName: input.tool_name,
+        actionKind: input.event,
+        resourceRef: projectedResourceRef,
+        agentId: input.agent_id,
+        agentRole: input.agent_role,
+        agentType: input.agent_type,
+        sessionAgent: input.subagent_id,
+        orgId: options.orgId,
+        teamId: options.teamId,
+        userId: options.userId,
+        projectId: options.projectId ?? options.projectDir,
+        evidenceRefs: [{ type: "artifact", ref: projectedEvidenceRef }],
+        timestamp: options.timestamp,
+    });
+    const classification = runtimeEventClassification(event);
+    const reasons = classification === "enterprise_evidence"
+        ? [decision.reason]
+        : [decision.reason, "RuntimeDecisionEvent validation kept this event diagnostic-only"];
+    if (options.appendEvent !== false) {
+        await appendCodexRuntimeDecisionEvent(options.projectDir, event, sessionId);
+        await appendEvidenceCaptureEvent(options.projectDir, buildCodexEvidenceCaptureEvent({
+            projectDir: options.projectDir,
+            input,
+            decision: decision.decision,
+            reason: decision.reason,
+            runtimeEvent: event,
+            workflowAsset: options.workflowAsset,
+            workflowId: options.workflowId,
+            ir: options.ir,
+        }));
+    }
+    return { output: decision.output, decision: decision.decision, classification, event, reasons };
+}
+export function mapCodexDecisionEvent(input) {
+    const runtime = `codex_cli@${input.codexVersion ?? "unknown"}`;
+    const agentId = input.agentId ?? "unknown";
+    const agentRole = input.agentRole ?? input.ir.active_role ?? "unknown";
+    const agentType = input.agentType ?? "codex_cli";
+    const sessionAgent = input.sessionAgent ?? input.sessionId ?? "unknown";
+    const evidenceRefs = input.evidenceRefs && input.evidenceRefs.length > 0
+        ? input.evidenceRefs
+        : [{ type: input.hookTrusted ? "artifact" : "unknown", ref: input.hookTrusted ? "codex-hook-execution" : "unknown" }];
+    return {
+        schema_version: RUNTIME_DECISION_EVENT_SCHEMA_VERSION,
+        event_id: input.eventId ?? randomUUID(),
+        timestamp: input.timestamp ?? new Date().toISOString(),
+        org_id: input.orgId ?? "unknown",
+        team_id: input.teamId ?? "unknown",
+        user_id: input.userId ?? "unknown",
+        project_id: input.projectId ?? "unknown",
+        agent_id: agentId,
+        agent_role: agentRole,
+        agent_type: agentType,
+        session_agent: sessionAgent,
+        harness_adapter: "codex_cli",
+        runtime,
+        policy_bundle_id: input.ir.provenance?.policy_bundle_id ?? "unknown",
+        policy_bundle_version: input.ir.provenance?.policy_bundle_version ?? "unknown",
+        cascade_layers: cascadeLayers(input.ir),
+        winning_constraint: winningConstraint(input.ir, input.decision, input.decisionReason),
+        compiled_ir_hash: input.ir.compiled_ir_hash ?? input.ir.provenance?.compiled_ir_hash ?? "unknown",
+        decision: input.decision,
+        decision_reason: input.decisionReason || "unknown",
+        enforcement_point: enforcementPointFor(input),
+        harness_runtime_context: {
+            agent_id: agentId,
+            agent_role: agentRole,
+            agent_type: agentType,
+            session_agent: sessionAgent,
+            harness_adapter: "codex_cli",
+            runtime,
+        },
+        session_id: input.sessionId ?? "unknown",
+        run_id: input.runId ?? input.sessionId ?? "unknown",
+        step_id: input.stepId ?? "unknown",
+        tool_name: input.toolName ?? "unknown",
+        action_kind: input.actionKind ?? input.hookEvent ?? "unknown",
+        resource_ref: input.resourceRef ?? "unknown",
+        evidence_refs: evidenceRefs,
+    };
+}