intentdna 1.7.5 → 1.8.1

package/dist/runtime/codex-sync-target.d.ts

@@ -0,0 +1,33 @@
+import type { ConstraintIR } from "../schema/types.js";
+import { type CodexAdapterArtifacts, type CodexHookInstallMode } from "./codex-adapter.js";
+import type { AdapterCapabilityReport, CapabilityReportEntry, EvidencePlan, PlannedArtifact, SyncTargetPlan } from "./sync-target-plan.js";
+export interface CodexSyncTargetPlanOptions {
+    hookInstallMode?: CodexHookInstallMode;
+    packageVersion: string;
+}
+export type CodexPlannedArtifact = PlannedArtifact;
+export type CodexCapabilityReportEntry = CapabilityReportEntry;
+export type CodexAdapterCapabilityReport = AdapterCapabilityReport & {
+    adapter: "codex_cli";
+    runtime: "codex_cli";
+};
+export type CodexEvidencePlan = EvidencePlan;
+export interface CodexSyncTargetPlan extends SyncTargetPlan {
+    target: "codex_cli";
+    hookInstallMode: CodexHookInstallMode;
+    artifacts: CodexAdapterArtifacts;
+    plannedArtifacts: CodexPlannedArtifact[];
+    capabilityReport: CodexAdapterCapabilityReport;
+    evidencePlan: CodexEvidencePlan;
+    warnings: string[];
+    unsupported: string[];
+}
+export interface ExecuteCodexSyncTargetPlanOptions {
+    projectDir: string;
+    dogfood?: boolean;
+}
+export declare function createCodexSyncTargetPlan(ir: ConstraintIR, options: CodexSyncTargetPlanOptions): CodexSyncTargetPlan;
+export declare function executeCodexSyncTargetPlan(plan: CodexSyncTargetPlan, options: ExecuteCodexSyncTargetPlanOptions): Promise<string[]>;
+export declare function codexSyncDispatcherCommand(): string;
+export declare function removeCodexSyncTargetArtifacts(projectDir: string): Promise<string[]>;
+export declare function formatCodexSyncTargetPlanSummary(plan: CodexSyncTargetPlan): string;

package/dist/runtime/codex-sync-target.js

@@ -0,0 +1,241 @@
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { compileCodexAdapterArtifacts, removeCodexAdapterArtifacts, runCodexExecDogfood, withCodexDogfoodEvidence, writeCodexAdapterArtifacts, } from "./codex-adapter.js";
+import { formatSyncTargetPlanDiagnostics } from "./sync-target-plan.js";
+const PACKAGE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..");
+const CODEX_DISPATCHER_SCRIPT = "dist/hooks/cli.js";
+function plannedArtifacts(artifacts) {
+    const plans = [
+        {
+            kind: "codex_instruction",
+            path: artifacts.instruction.path,
+            ownership: "intentdna_owned",
+            trackedByLock: true,
+            outputArtifact: "codex-adapter",
+        },
+        {
+            kind: "codex_policy_map",
+            path: artifacts.policyMap.path,
+            ownership: "diagnostic",
+            trackedByLock: true,
+            outputArtifact: "codex-adapter",
+        },
+        {
+            kind: "codex_adapter_evidence",
+            path: ".dna/compiled/codex-adapter-evidence.json",
+            ownership: "diagnostic",
+            trackedByLock: true,
+            outputArtifact: "codex-adapter",
+        },
+    ];
+    if (artifacts.evidence.install_mode_semantics.writes_project_fallback) {
+        plans.push({
+            kind: "codex_fallback_hooks",
+            path: artifacts.evidence.fallback_hooks_path,
+            ownership: "merge_preserve_user",
+            trackedByLock: true,
+            outputArtifact: "codex-adapter",
+        }, {
+            kind: "codex_fallback_trust_state",
+            path: artifacts.evidence.fallback_config_path,
+            ownership: "merge_preserve_user",
+            trackedByLock: true,
+            outputArtifact: "codex-adapter",
+        });
+    }
+    if (artifacts.evidence.install_mode_semantics.writes_plugin_artifacts) {
+        plans.push({
+            kind: "codex_plugin_manifest",
+            path: "codex-plugin/.codex-plugin/plugin.json",
+            ownership: "intentdna_owned",
+            trackedByLock: true,
+            outputArtifact: "codex-adapter",
+        }, {
+            kind: "codex_plugin_hooks",
+            path: "codex-plugin/hooks/hooks.json",
+            ownership: "intentdna_owned",
+            trackedByLock: true,
+            outputArtifact: "codex-adapter",
+        });
+    }
+    return plans;
+}
+function supportStatus(status, keys, fallback = "unknown") {
+    const values = keys.map((key) => status[key]).filter((value) => value !== undefined);
+    if (values.includes("partial"))
+        return "partial";
+    if (values.includes("supported"))
+        return "supported";
+    if (values.includes("unsupported"))
+        return "unsupported";
+    return values[0] ?? fallback;
+}
+function capabilityReport(artifacts) {
+    const status = artifacts.evidence.support_status;
+    const instructionPath = artifacts.evidence.instruction_path;
+    const capabilities = {
+        intent_lock: {
+            status: supportStatus(status, ["prompt_directives"]),
+            surfaces: [instructionPath],
+            evidenceRefs: ["codex-instruction-artifact"],
+            notes: ["Prompt directives are rendered as Codex instructions and remain soft guidance until paired with runtime evidence."],
+        },
+        boundary_constraint: {
+            status: supportStatus(status, ["role_scope", "pre_execution_gates"]),
+            surfaces: ["Codex permissions/rules plus PreToolUse hook diagnostics"],
+            evidenceRefs: ["codex-role-scope-map", "codex-pre-tool-use-hook"],
+            notes: ["Scope constraints require concrete Codex permission and hook coverage for each runtime path."],
+        },
+        context_control: {
+            status: supportStatus(status, ["context_injections"]),
+            surfaces: [instructionPath],
+            evidenceRefs: ["codex-context-instruction-artifact"],
+            notes: ["Static context can be injected into instructions; dynamic context control remains event-limited."],
+        },
+        tool_policy: {
+            status: supportStatus(status, ["tool_filters", "role_tool_permissions"]),
+            surfaces: ["Codex execpolicy/rules and PreToolUse hook subset"],
+            evidenceRefs: ["codex-tool-filter-map", "codex-role-scope-map"],
+            notes: ["Non-Bash and unsupported tool paths stay explicit in unsupported gaps."],
+        },
+        approval_gate: {
+            status: supportStatus(status, ["pre_execution_gates", "permission_request"]),
+            surfaces: ["PreToolUse hook", "PermissionRequest unsupported fixture"],
+            evidenceRefs: ["codex-pre-tool-use-hook"],
+            notes: ["PreToolUse gates can diagnose or block supported paths; native permission-request parity is not claimed."],
+        },
+        checkpoint: {
+            status: supportStatus(status, ["post_execution_validators"]),
+            surfaces: ["PostToolUse/Stop validation evidence"],
+            evidenceRefs: ["codex-validation-hook"],
+            notes: ["Validation hooks can record evidence but cannot reverse completed side effects."],
+        },
+        completion_check: {
+            status: supportStatus(status, ["post_execution_validators"]),
+            surfaces: ["PostToolUse/Stop validation evidence"],
+            evidenceRefs: ["codex-validation-hook"],
+            notes: ["Completion checks remain partial until verifier outcomes are backed by RuntimeDecisionEvent provenance."],
+        },
+        artifact_handoff: {
+            status: "partial",
+            surfaces: [...new Set([artifacts.policyMap.path, artifacts.evidence.policy_map_path, artifacts.evidence.dispatcher_script])],
+            evidenceRefs: ["codex-policy-map", "codex-adapter-evidence"],
+            notes: ["Generated artifacts describe handoff surfaces but are diagnostic artifacts, not policy truth."],
+        },
+        isolation: {
+            status: "unknown",
+            surfaces: ["Codex sandbox flags are execution-time choices outside sync artifact generation"],
+            evidenceRefs: [],
+            notes: ["Workflow isolation requirements can be declared, but this sync target does not yet prove runtime sandbox isolation."],
+        },
+        dry_run: {
+            status: "supported",
+            surfaces: ["dna sync --dry-run Codex target plan"],
+            evidenceRefs: ["codex-sync-target-plan"],
+            notes: ["Dry-run reports planned Codex artifacts, support posture, evidence classification, and unsupported gaps without writing files."],
+        },
+        rollback_or_compensation: {
+            status: "unsupported",
+            surfaces: [],
+            evidenceRefs: ["post_execution_side_effect_rollback"],
+            notes: ["Codex validation hooks can observe outcomes but cannot roll back completed side effects."],
+        },
+        trace: {
+            status: supportStatus(status, ["runtime_decision_event"]),
+            surfaces: ["RuntimeDecisionEvent state writer", ".dna/compiled/codex-adapter-evidence.json"],
+            evidenceRefs: ["RuntimeDecisionEvent", "codex-adapter-evidence"],
+            notes: ["Adapter evidence is trace-adjacent diagnostic data; RuntimeDecisionEvent remains the primary trace contract."],
+        },
+        runtime_decision_evidence: {
+            status: supportStatus(status, ["runtime_decision_event"]),
+            surfaces: ["appendRuntimeDecisionEvent", ".dna/compiled/codex-adapter-evidence.json"],
+            evidenceRefs: ["RuntimeDecisionEvent", "codex-adapter-evidence"],
+            notes: ["Diagnostic adapter evidence must not be upgraded to enterprise evidence without trusted RuntimeDecisionEvent provenance."],
+        },
+        logic_equivalence_validation: {
+            status: "unknown",
+            surfaces: ["Workflow verifier specs and external test commands"],
+            evidenceRefs: ["verifier_specs", "RuntimeDecisionEvent"],
+            notes: ["Equivalence validation is a workflow capability, not a Codex-native sync artifact; concrete proof must come from verifier execution evidence."],
+        },
+    };
+    return {
+        adapter: "codex_cli",
+        runtime: "codex_cli",
+        capabilities,
+        unsupported: artifacts.evidence.unsupported,
+    };
+}
+function evidencePlan(artifacts) {
+    return {
+        primary: "RuntimeDecisionEvent",
+        diagnosticArtifacts: [
+            artifacts.evidence.policy_map_path,
+            ".dna/compiled/codex-adapter-evidence.json",
+            artifacts.evidence.instruction_path,
+        ],
+        classification: artifacts.evidence.trust_verification?.classification ?? artifacts.evidence.install_mode_semantics.classification,
+        notes: artifacts.evidence.notes,
+    };
+}
+export function createCodexSyncTargetPlan(ir, options) {
+    const hookInstallMode = options.hookInstallMode ?? "project_fallback";
+    const artifacts = compileCodexAdapterArtifacts(ir, {
+        adapterRoot: PACKAGE_ROOT,
+        dispatcherScript: CODEX_DISPATCHER_SCRIPT,
+        hookInstallMode,
+        pluginVersion: options.packageVersion,
+    });
+    return {
+        target: "codex_cli",
+        hookInstallMode,
+        artifacts,
+        plannedArtifacts: plannedArtifacts(artifacts),
+        capabilityReport: capabilityReport(artifacts),
+        evidencePlan: evidencePlan(artifacts),
+        warnings: artifacts.evidence.notes,
+        unsupported: artifacts.evidence.unsupported,
+    };
+}
+export async function executeCodexSyncTargetPlan(plan, options) {
+    let artifacts = plan.artifacts;
+    if (options.dogfood) {
+        const dogfood = await runCodexExecDogfood({ projectDir: options.projectDir });
+        artifacts = { ...artifacts, evidence: withCodexDogfoodEvidence(artifacts.evidence, dogfood) };
+    }
+    return writeCodexAdapterArtifacts(options.projectDir, artifacts);
+}
+export function codexSyncDispatcherCommand() {
+    return createCodexSyncTargetPlan({
+        source_dna_ids: [],
+        compiled_at: new Date().toISOString(),
+        prompt_directives: [],
+        tool_filters: [],
+        pre_execution_gates: [],
+        post_execution_validators: [],
+        context_injections: [],
+    }, {
+        packageVersion: "0.0.0",
+    }).artifacts.evidence.dispatcher_command;
+}
+export async function removeCodexSyncTargetArtifacts(projectDir) {
+    return removeCodexAdapterArtifacts(projectDir, codexSyncDispatcherCommand());
+}
+export function formatCodexSyncTargetPlanSummary(plan) {
+    const lines = [
+        `Codex target support posture: ${plan.artifacts.evidence.install_mode_semantics.support_status}`,
+        `Codex evidence plan: primary=${plan.evidencePlan.primary}, classification=${plan.evidencePlan.classification}`,
+        `Codex planned artifacts: ${plan.plannedArtifacts.length}`,
+    ];
+    for (const artifact of plan.plannedArtifacts) {
+        lines.push(`  - ${artifact.kind}: ${artifact.path} (${artifact.ownership})`);
+    }
+    const capabilityEntries = Object.entries(plan.capabilityReport.capabilities)
+        .sort(([left], [right]) => left.localeCompare(right));
+    lines.push("Codex capability report:");
+    for (const [capability, entry] of capabilityEntries) {
+        const surfaces = entry.surfaces.length > 0 ? entry.surfaces.join(", ") : "no Codex sync surface";
+        lines.push(`  - ${capability}: ${entry.status} via ${surfaces}`);
+    }
+    return `${lines.join("\n")}\n${formatSyncTargetPlanDiagnostics(plan)}`;
+}

package/dist/runtime/index.d.ts

@@ -7,3 +7,11 @@ export type { WorkflowShellOptions, WorkflowShellResult } from "./workflow-runne
 export { createCompiledIR, writeCompiledIR, loadCompiledIR, removeCompiledIR, } from "./plugin-adapter.js";
 export type { CompiledIRFile } from "./plugin-adapter.js";
 export { compilePluginSettings, detectEnabledEvents, } from "./settings-adapter.js";
+export { CODEX_ADAPTER_MINIMUM_VERSION, CODEX_NATIVE_HOOK_EVENTS, appendCodexRuntimeDecisionEvent, buildCodexDispatcherCommand, buildCodexHookTrustState, codexHookTrustedHash, codexInstallModeSemantics, codexTrustStateToml, compileCodexAdapterArtifacts, compileCodexHooksConfig, compileCodexInstructionArtifact, compileCodexPluginManifest, compileCodexPolicyMapArtifact, mapCodexDecisionEvent, mergeCodexFallbackHooks, mergeCodexTrustStateConfig, normalizeCodexHookInput, probeCodexRuntime, runCodexExecDogfood, removeCodexAdapterArtifacts, removeCodexFallbackHooks, removeCodexTrustStateConfig, runCodexHook, withCodexDogfoodEvidence, verifyCodexHookTrust, writeCodexAdapterArtifacts, } from "./codex-adapter.js";
+export type { CodexAdapterArtifacts, CodexAdapterEvidence, CodexAdapterSupportStatus, CodexCommandHook, CodexDecisionMappingInput, CodexDogfoodResult, CodexEvidenceClassification, CodexExecJsonEvent, CodexHookGroup, CodexHookInput, CodexHookInstallMode, CodexHookRunnerOptions, CodexHookRunnerResult, CodexHookTrustState, CodexHooksConfig, CodexInstallModeSemantics, CodexInstructionArtifact, CodexNativeHookEvent, CodexPluginManifest, CodexPolicyMap, CodexPolicyMapArtifact, CodexPolicyMapEntry, CodexRuntimeProbe, CodexTrustVerification, RunCodexDogfoodOptions, CodexTrustVerificationInput, CompileCodexAdapterOptions, } from "./codex-adapter.js";
+export { codexSyncDispatcherCommand, createCodexSyncTargetPlan, executeCodexSyncTargetPlan, formatCodexSyncTargetPlanSummary, removeCodexSyncTargetArtifacts, } from "./codex-sync-target.js";
+export type { CodexAdapterCapabilityReport, CodexCapabilityReportEntry, CodexEvidencePlan, CodexPlannedArtifact, CodexSyncTargetPlan, CodexSyncTargetPlanOptions, ExecuteCodexSyncTargetPlanOptions, } from "./codex-sync-target.js";
+export { createClaudeCoreSyncTargetPlan, executeClaudeCoreSyncTargetPlan, formatClaudeCoreSyncTargetPlanDryRun, removeLegacyBashHooks, } from "./claude-sync-target.js";
+export type { ClaudeCoreAdapterCapabilityReport, ClaudeCoreCapabilityReportEntry, ClaudeCorePlannedArtifact, ClaudeCoreSyncTargetPlan, ClaudeCoreSyncTargetPlanOptions, ClaudeSettingsHookRegistration, ClaudeSyncMode, ExecuteClaudeCoreSyncTargetPlanResult, } from "./claude-sync-target.js";
+export type { AdapterCapabilityReport, CapabilityReportEntry, CapabilitySupportStatus, EvidenceClassification, EvidencePlan, PlannedArtifact, SyncTarget, SyncTargetMode, SyncTargetPlan, } from "./sync-target-plan.js";
+export { formatSyncTargetPlanDiagnostics, trackedOutputsForSyncTargetPlan, } from "./sync-target-plan.js";

package/dist/runtime/index.js

@@ -3,3 +3,7 @@ export { compileRoleToAgentMD, compileAllRolesToAgentMD, writeAgentMDFiles, remo
 export { compileWorkflowToShell, writeWorkflowScript, removeWorkflowScripts, } from "./workflow-runner.js";
 export { createCompiledIR, writeCompiledIR, loadCompiledIR, removeCompiledIR, } from "./plugin-adapter.js";
 export { compilePluginSettings, detectEnabledEvents, } from "./settings-adapter.js";
+export { CODEX_ADAPTER_MINIMUM_VERSION, CODEX_NATIVE_HOOK_EVENTS, appendCodexRuntimeDecisionEvent, buildCodexDispatcherCommand, buildCodexHookTrustState, codexHookTrustedHash, codexInstallModeSemantics, codexTrustStateToml, compileCodexAdapterArtifacts, compileCodexHooksConfig, compileCodexInstructionArtifact, compileCodexPluginManifest, compileCodexPolicyMapArtifact, mapCodexDecisionEvent, mergeCodexFallbackHooks, mergeCodexTrustStateConfig, normalizeCodexHookInput, probeCodexRuntime, runCodexExecDogfood, removeCodexAdapterArtifacts, removeCodexFallbackHooks, removeCodexTrustStateConfig, runCodexHook, withCodexDogfoodEvidence, verifyCodexHookTrust, writeCodexAdapterArtifacts, } from "./codex-adapter.js";
+export { codexSyncDispatcherCommand, createCodexSyncTargetPlan, executeCodexSyncTargetPlan, formatCodexSyncTargetPlanSummary, removeCodexSyncTargetArtifacts, } from "./codex-sync-target.js";
+export { createClaudeCoreSyncTargetPlan, executeClaudeCoreSyncTargetPlan, formatClaudeCoreSyncTargetPlanDryRun, removeLegacyBashHooks, } from "./claude-sync-target.js";
+export { formatSyncTargetPlanDiagnostics, trackedOutputsForSyncTargetPlan, } from "./sync-target-plan.js";

package/dist/runtime/output-artifact-registry.d.ts

@@ -1,4 +1,4 @@
-export declare const SYNC_OUTPUT_ARTIFACT_IDS: readonly ["markdown-injection", "compiled-ir", "settings-hooks", "agents", "workflows", "skills-controllers", "mcp-config", "lock-file"];
+export declare const SYNC_OUTPUT_ARTIFACT_IDS: readonly ["markdown-injection", "compiled-ir", "settings-hooks", "agents", "workflows", "skills-controllers", "mcp-config", "codex-adapter", "lock-file"];
 export type SyncOutputArtifactId = typeof SYNC_OUTPUT_ARTIFACT_IDS[number];
 export interface SyncOutputArtifactMetadata {
     id: SyncOutputArtifactId;

package/dist/runtime/output-artifact-registry.js

@@ -6,6 +6,7 @@ export const SYNC_OUTPUT_ARTIFACT_IDS = [
     "workflows",
     "skills-controllers",
     "mcp-config",
+    "codex-adapter",
     "lock-file",
 ];
 export const SYNC_OUTPUT_ARTIFACT_REGISTRY = [
@@ -16,6 +17,7 @@ export const SYNC_OUTPUT_ARTIFACT_REGISTRY = [
     { id: "workflows", order: 60, label: "Workflows", trackedByLock: true },
     { id: "skills-controllers", order: 70, label: "Skills and controllers", trackedByLock: true },
     { id: "mcp-config", order: 80, label: "MCP config", trackedByLock: false },
+    { id: "codex-adapter", order: 85, label: "Codex adapter", trackedByLock: true },
     { id: "lock-file", order: 90, label: "Lock file", trackedByLock: false },
 ];
 const ARTIFACT_BY_ID = new Map(SYNC_OUTPUT_ARTIFACT_REGISTRY.map((entry) => [entry.id, entry]));

package/dist/runtime/settings-adapter.d.ts

@@ -4,7 +4,7 @@
  * Compiles DNA hook events into Claude Code settings.json
  * hook configurations for the dna-hook binary.
  *
- * See docs/references/cc-source-analysis.md §2 for the full hook event catalog.
+ * See docs/archive/2026H1/references/cc-source-analysis.md §2 for the full hook event catalog.
  */
 import { type SettingsHookEventKey } from "../hooks/event-registry.js";
 export type HookEventKey = SettingsHookEventKey;

package/dist/runtime/settings-adapter.js

@@ -4,7 +4,7 @@
  * Compiles DNA hook events into Claude Code settings.json
  * hook configurations for the dna-hook binary.
  *
- * See docs/references/cc-source-analysis.md §2 for the full hook event catalog.
+ * See docs/archive/2026H1/references/cc-source-analysis.md §2 for the full hook event catalog.
  */
 import { readFile, writeFile } from "node:fs/promises";
 import { getHookEventBySettingsKey, settingsHookEventKeys } from "../hooks/event-registry.js";

package/dist/runtime/skill-adapter.d.ts

@@ -45,7 +45,11 @@ export interface SkillResult {
     bodyFileName?: string;
     mapEntry?: SkillMapEntry;
 }
+export type WorkflowSkillSurface = "claude_code" | "codex_cli";
+export interface WorkflowSkillOptions {
+    surface?: WorkflowSkillSurface;
+}
 export declare function compileControllerToSkill(controllerKey: string, controller: ControllerDef, variables?: Record<string, string>, workflows?: Record<string, WorkflowDef>): SkillResult;
-export declare function compileWorkflowToSkill(plan: WorkflowPlan, roles: Record<string, RoleDef>, ir?: ConstraintIR, variables?: Record<string, string>): SkillResult;
+export declare function compileWorkflowToSkill(plan: WorkflowPlan, roles: Record<string, RoleDef>, ir?: ConstraintIR, variables?: Record<string, string>, options?: WorkflowSkillOptions): SkillResult;
 export declare function writeSkillFiles(results: SkillResult[], outputDir: string): Promise<string[]>;
 export declare function removeSkillFiles(outputDir: string): Promise<number>;