intentdna 1.7.0 → 1.7.4

package/dist/compiler/cascade.js

@@ -10,6 +10,21 @@
  *   - attract/repel: same target accumulates, different targets independent
  *   - amplify/suppress: factors multiply (1.5x × 2.0x = 3.0x)
  */
+const PROTECTED_THRESHOLD_LAYERS = new Set(["species", "enterprise"]);
+function originForDNA(dna) {
+    return {
+        source_dna_id: dna.id,
+        source_layer: dna.type,
+        cascade_priority: dna.cascade.priority,
+        protected_threshold: PROTECTED_THRESHOLD_LAYERS.has(dna.type),
+    };
+}
+function withCodonOrigins(gene, origin) {
+    return {
+        ...gene,
+        codons: gene.codons.map((codon) => codon.type === "threshold" ? { ...codon, origin } : { ...codon }),
+    };
+}
 /**
  * Normalize workflow/workflows from an IntentDNA into a unified Record.
  * Validation ensures workflow and workflows are mutually exclusive.
@@ -228,6 +243,7 @@ export function cascadeDNA(layers) {
     const sorted = [...layers].sort((a, b) => a.cascade.priority - b.cascade.priority);
     const mergedGenes = {};
     const geneSourceNs = {}; // track which namespace defined each gene
+    const protectedThresholdGenes = new Set();
     const mergedContexts = {};
     const mergedRoles = {};
     const mergedWorkflows = {};
@@ -239,7 +255,12 @@ export function cascadeDNA(layers) {
         sourceIds.push(dna.id);
         const ns = dna.namespace;
         // Merge genes (cross-namespace: additive merge + warning)
-        for (const [name, gene] of Object.entries(dna.genes)) {
+        const origin = originForDNA(dna);
+        for (const [name, rawGene] of Object.entries(dna.genes)) {
+            const gene = withCodonOrigins(rawGene, origin);
+            if (origin.protected_threshold && gene.codons.some((codon) => codon.type === "threshold")) {
+                protectedThresholdGenes.add(name);
+            }
             if (mergedGenes[name]) {
                 const existingNs = geneSourceNs[name];
                 if (ns !== existingNs) {
@@ -332,5 +353,6 @@ export function cascadeDNA(layers) {
         context_sources: contextSources,
         planning_context: planningContext,
         verifier_policy: verifierPolicy,
+        protected_threshold_genes: protectedThresholdGenes.size > 0 ? [...protectedThresholdGenes].sort() : undefined,
     };
 }

package/dist/compiler/compile.js

@@ -105,6 +105,7 @@ function geneToGates(name, gene) {
                 action: "block",
                 message: `DNA threshold violation: ${codon.condition} (gene: ${name})`,
                 source_gene: name,
+                origin: codon.origin,
             });
         }
         if (codon.type === "sense" && codon.response === "escalate_to_human") {

package/dist/compiler/index.d.ts

@@ -9,10 +9,12 @@ export { cascadeDNA } from "./cascade.js";
 export { activateDNA } from "./activate.js";
 export { compileDNA } from "./compile.js";
 export { compileWorkflow } from "./workflow.js";
+export { PROVENANCE_LAYERS, PROVENANCE_SCHEMA_VERSION, attachProvenance, buildCascadeLayers, buildConstraintWinners, hashObject, hashString, } from "./provenance.js";
 export type { CompileWorkflowOptions, CompileWorkflowResult, CompileWorkflowError, } from "./workflow.js";
 export type { Diagnostic, DiagnosticSeverity } from "./diagnostics.js";
 export { DNADiagnosticsError, formatDiagnostic, formatDiagnostics } from "./diagnostics.js";
-export { assertNoNamespaceCollisions, checkNamespaceCollisions, detectDNAConfigs, expandDNAInputFiles, loadDNAWithDiagnostics, resolveDNAInputs, resolveSpeciesReference, } from "./input-resolver.js";
+export { assertNoNamespaceCollisions, checkNamespaceCollisions, detectDNAConfigs, expandDNAInputFiles, expandDNAInputs, loadDNAWithDiagnostics, resolveDNAInputs, resolveSpeciesReference, } from "./input-resolver.js";
+export type { ExpandedDNAInput, ExpandDNAInputOptions } from "./input-resolver.js";
 /**
  * Load and parse a DNA file from disk.
  */
@@ -20,6 +22,8 @@ export declare function loadDNA(filePath: string): Promise<IntentDNA>;
 export interface CompileOptions {
     context?: string;
     role?: string;
+    cwd?: string;
+    enterprisePolicyDirs?: string[];
     /** Additional epigenetic markers from evolution store */
     epigenetic_markers?: EpigeneticMarker[];
 }

package/dist/compiler/index.js

@@ -8,13 +8,15 @@ import { cascadeDNA } from "./cascade.js";
 import { activateDNA } from "./activate.js";
 import { compileDNA } from "./compile.js";
 import { DNADiagnosticsError, formatDiagnostics } from "./diagnostics.js";
-import { loadDNAWithDiagnostics } from "./input-resolver.js";
+import { expandDNAInputs, loadDNAWithDiagnostics } from "./input-resolver.js";
+import { attachProvenance } from "./provenance.js";
 export { cascadeDNA } from "./cascade.js";
 export { activateDNA } from "./activate.js";
 export { compileDNA } from "./compile.js";
 export { compileWorkflow } from "./workflow.js";
+export { PROVENANCE_LAYERS, PROVENANCE_SCHEMA_VERSION, attachProvenance, buildCascadeLayers, buildConstraintWinners, hashObject, hashString, } from "./provenance.js";
 export { DNADiagnosticsError, formatDiagnostic, formatDiagnostics } from "./diagnostics.js";
-export { assertNoNamespaceCollisions, checkNamespaceCollisions, detectDNAConfigs, expandDNAInputFiles, loadDNAWithDiagnostics, resolveDNAInputs, resolveSpeciesReference, } from "./input-resolver.js";
+export { assertNoNamespaceCollisions, checkNamespaceCollisions, detectDNAConfigs, expandDNAInputFiles, expandDNAInputs, loadDNAWithDiagnostics, resolveDNAInputs, resolveSpeciesReference, } from "./input-resolver.js";
 /**
  * Load and parse a DNA file from disk.
  */
@@ -33,8 +35,9 @@ export async function compileFromFiles(filePaths, contextOrOptions) {
     const opts = typeof contextOrOptions === "string"
         ? { context: contextOrOptions }
         : contextOrOptions ?? {};
+    const expanded = await expandDNAInputs(filePaths, { cwd: opts.cwd, enterprisePolicyDirs: opts.enterprisePolicyDirs });
     const dnas = [];
-    for (const path of filePaths) {
+    for (const path of expanded.files) {
         dnas.push(await loadDNA(path));
     }
     const cascaded = cascadeDNA(dnas);
@@ -43,5 +46,5 @@ export async function compileFromFiles(filePaths, contextOrOptions) {
         cascaded.epigenetic_markers.push(...opts.epigenetic_markers);
     }
     const activated = activateDNA(cascaded, opts.context ?? null, opts.role ?? null);
-    return compileDNA(activated, cascaded);
+    return attachProvenance(compileDNA(activated, cascaded), expanded.provenance);
 }

package/dist/compiler/input-resolver.d.ts

@@ -1,4 +1,4 @@
-import type { IntentDNA } from "../schema/types.js";
+import type { DNASourceProvenance, IntentDNA } from "../schema/types.js";
 import type { Diagnostic } from "./diagnostics.js";
 export interface ResolveDNAInputOptions {
     cwd?: string;
@@ -14,7 +14,14 @@ export declare function resolveSpeciesReference(ref: string): string | null;
 export declare function detectDNAConfigs(projectDir?: string): Promise<string[]>;
 export interface ExpandDNAInputOptions {
     cwd?: string;
+    enterprisePolicyDirs?: string[];
 }
+export interface ExpandedDNAInput {
+    files: string[];
+    provenance: DNASourceProvenance[];
+    diagnostics: Diagnostic[];
+}
+export declare function expandDNAInputs(files: string[], options?: ExpandDNAInputOptions): Promise<ExpandedDNAInput>;
 export declare function expandDNAInputFiles(files: string[], options?: ExpandDNAInputOptions): Promise<string[]>;
 export declare function checkNamespaceCollisions(configPaths: string[]): Promise<Diagnostic[]>;
 export declare function assertNoNamespaceCollisions(configPaths: string[]): Promise<void>;

package/dist/compiler/input-resolver.js

@@ -1,3 +1,5 @@
+import { createHash } from "node:crypto";
+import { homedir } from "node:os";
 import { readdir, readFile, stat } from "node:fs/promises";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -57,35 +59,139 @@ export async function detectDNAConfigs(projectDir = process.cwd()) {
     }
     return [];
 }
-export async function expandDNAInputFiles(files, options) {
+function fingerprint(raw) {
+    return `sha256:${createHash("sha256").update(raw, "utf-8").digest("hex")}`;
+}
+function enterprisePolicyCandidates(name, cwd, options) {
+    const configuredDirs = [
+        ...(process.env.INTENTDNA_ENTERPRISE_POLICY_DIR ? [process.env.INTENTDNA_ENTERPRISE_POLICY_DIR] : []),
+        ...(options?.enterprisePolicyDirs ?? []),
+    ];
+    const dirs = [
+        ...configuredDirs.map((dir) => ({ dir, trust: "admin_shared" })),
+        { dir: resolve(cwd, ".dna", "policies", "enterprise"), trust: "project_local" },
+        { dir: resolve(homedir(), ".intentdna", "policies", "enterprise"), trust: "user_local" },
+    ];
+    const names = [`${name}.dna.yaml`, `${name}.dna.yml`, `${name}.dna.json`];
+    return dirs.flatMap(({ dir, trust }) => names.map((file) => ({ path: resolve(dir, file), trust })));
+}
+async function resolveEnterpriseReference(ref, cwd, options) {
+    if (!ref.startsWith("enterprise:"))
+        return {};
+    const name = ref.slice("enterprise:".length);
+    for (const candidate of enterprisePolicyCandidates(name, cwd, options)) {
+        if (await fileExists(candidate.path))
+            return candidate;
+    }
+    return {};
+}
+function resolveFileReference(ref, fromFile) {
+    if (!ref.startsWith("file:"))
+        return {};
+    const raw = ref.slice("file:".length);
+    if (!raw)
+        return {};
+    return { path: resolve(dirname(fromFile), raw), trust: "explicit_file" };
+}
+function sourceTrustForInput(file, ref, cwd) {
+    if (ref.startsWith("species:"))
+        return "builtin";
+    if (ref.startsWith("enterprise:"))
+        return file.includes(`${resolve(cwd, ".dna", "policies", "enterprise")}`) ? "project_local" : "admin_shared";
+    if (ref.startsWith("file:"))
+        return "explicit_file";
+    return "input";
+}
+async function readDNAWithRaw(path) {
+    const raw = await readFile(path, "utf-8");
+    return { raw, dna: parseDNAContent(path, raw) };
+}
+export async function expandDNAInputs(files, options) {
     const cwd = options?.cwd ?? process.cwd();
-    const expanded = [];
+    const ordered = [];
     const seen = new Set();
-    const add = (path, position) => {
-        if (seen.has(path))
-            return;
-        seen.add(path);
-        if (position === "front")
-            expanded.unshift(path);
-        else
-            expanded.push(path);
-    };
-    for (const file of files) {
+    const diagnostics = [];
+    const provenance = new Map();
+    const stack = [];
+    const visit = async (file, ref, inheritedBy, trust) => {
         const abs = resolve(cwd, file);
-        add(abs, "back");
+        if (stack.includes(abs)) {
+            diagnostics.push({
+                severity: "error",
+                code: "inheritance_cycle",
+                message: `DNA inheritance cycle detected: ${[...stack, abs].join(" -> ")}`,
+                file: abs,
+            });
+            return;
+        }
+        if (seen.has(abs))
+            return;
+        let loaded;
         try {
-            const dna = await parseDNAFile(abs);
-            for (const ref of dna.cascade?.inherits ?? []) {
-                const speciesPath = resolveSpeciesReference(ref);
-                if (speciesPath)
-                    add(speciesPath, "front");
-            }
+            loaded = await readDNAWithRaw(abs);
         }
-        catch {
-            // Validation/loading reports the concrete parse error later.
+        catch (error) {
+            diagnostics.push({
+                severity: "error",
+                code: "inheritance_unresolved",
+                message: `Unable to resolve inherited DNA reference '${ref}': ${error instanceof Error ? error.message : String(error)}`,
+                file: inheritedBy ?? abs,
+            });
+            return;
         }
+        stack.push(abs);
+        for (const inheritRef of loaded.dna.cascade?.inherits ?? []) {
+            const speciesPath = resolveSpeciesReference(inheritRef);
+            if (speciesPath) {
+                await visit(speciesPath, inheritRef, abs, "builtin");
+                continue;
+            }
+            const fileRef = resolveFileReference(inheritRef, abs);
+            if (fileRef.path) {
+                await visit(fileRef.path, inheritRef, abs, fileRef.trust);
+                continue;
+            }
+            const enterpriseRef = await resolveEnterpriseReference(inheritRef, cwd, options);
+            if (enterpriseRef.path) {
+                await visit(enterpriseRef.path, inheritRef, abs, enterpriseRef.trust);
+                continue;
+            }
+            if (inheritRef.startsWith("enterprise:") || inheritRef.startsWith("file:")) {
+                diagnostics.push({
+                    severity: "error",
+                    code: "inheritance_unresolved",
+                    message: `Unable to resolve inherited DNA reference '${inheritRef}'`,
+                    file: abs,
+                    path: "cascade.inherits",
+                });
+            }
+        }
+        stack.pop();
+        seen.add(abs);
+        ordered.push(abs);
+        provenance.set(abs, {
+            source_id: loaded.dna.id,
+            source_ref: ref,
+            resolved_path: abs,
+            fingerprint: fingerprint(loaded.raw),
+            type: loaded.dna.type,
+            cascade_priority: loaded.dna.cascade.priority,
+            version: loaded.dna.version,
+            trust: trust ?? sourceTrustForInput(abs, ref, cwd),
+            inherited_by: inheritedBy,
+            genes: Object.keys(loaded.dna.genes ?? {}).sort(),
+        });
+    };
+    for (const file of files) {
+        await visit(resolve(cwd, file), file, undefined, "input");
+    }
+    if (hasDiagnosticErrors(diagnostics)) {
+        throw new DNADiagnosticsError("DNA inheritance resolution failed", diagnostics);
     }
-    return expanded;
+    return { files: ordered, provenance: ordered.map((file) => provenance.get(file)).filter(Boolean), diagnostics };
+}
+export async function expandDNAInputFiles(files, options) {
+    return (await expandDNAInputs(files, options)).files;
 }
 export async function checkNamespaceCollisions(configPaths) {
     const diagnostics = [];

package/dist/compiler/provenance.d.ts

@@ -0,0 +1,8 @@
+import type { CascadeLayerProvenance, ConstraintIR, ConstraintProvenance, DNASourceProvenance, ProvenanceCascadeLayerName } from "../schema/types.js";
+export declare const PROVENANCE_SCHEMA_VERSION: "intentdna.provenance.v1.7.2";
+export declare const PROVENANCE_LAYERS: readonly ProvenanceCascadeLayerName[];
+export declare function hashString(content: string): string;
+export declare function hashObject(value: unknown): string;
+export declare function buildCascadeLayers(sources: DNASourceProvenance[]): Record<ProvenanceCascadeLayerName, CascadeLayerProvenance>;
+export declare function buildConstraintWinners(ir: ConstraintIR, sources: DNASourceProvenance[]): ConstraintProvenance[];
+export declare function attachProvenance(ir: ConstraintIR, sources: DNASourceProvenance[]): ConstraintIR;

package/dist/compiler/provenance.js

@@ -0,0 +1,127 @@
+import { createHash } from "node:crypto";
+export const PROVENANCE_SCHEMA_VERSION = "intentdna.provenance.v1.7.2";
+export const PROVENANCE_LAYERS = [
+    "species",
+    "enterprise",
+    "project",
+    "personal",
+    "role",
+    "context",
+    "task",
+];
+function stable(value) {
+    if (Array.isArray(value))
+        return `[${value.map(stable).join(",")}]`;
+    if (value && typeof value === "object") {
+        return `{${Object.entries(value)
+            .filter(([key]) => key !== "compiled_ir_hash" && key !== "provenance" && key !== "compiled_at")
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([key, entry]) => `${JSON.stringify(key)}:${stable(entry)}`)
+            .join(",")}}`;
+    }
+    return JSON.stringify(value);
+}
+export function hashString(content) {
+    return `sha256:${createHash("sha256").update(content, "utf-8").digest("hex")}`;
+}
+export function hashObject(value) {
+    return hashString(stable(value));
+}
+function placeholderLayer(layer) {
+    return {
+        layer,
+        source_id: "unknown",
+        source_ref: "unknown",
+        fingerprint: "unknown",
+        status: "unknown",
+    };
+}
+export function buildCascadeLayers(sources) {
+    const layers = Object.fromEntries(PROVENANCE_LAYERS.map((layer) => [layer, placeholderLayer(layer)]));
+    for (const layer of PROVENANCE_LAYERS) {
+        const layerSources = sources.filter((source) => source.type === layer);
+        if (layerSources.length === 0)
+            continue;
+        const fingerprint = hashObject(layerSources.map((source) => ({
+            source_id: source.source_id,
+            source_ref: source.source_ref,
+            fingerprint: source.fingerprint,
+            cascade_priority: source.cascade_priority,
+        })));
+        layers[layer] = {
+            layer,
+            source_id: layerSources.map((source) => source.source_id).join("+"),
+            source_ref: layerSources.map((source) => source.source_ref).join(","),
+            fingerprint,
+            status: "active",
+            sources: layerSources.map((source) => source.source_id),
+        };
+    }
+    return layers;
+}
+function sourceForGene(sources, geneId) {
+    return [...sources].reverse().find((source) => source.genes?.includes(geneId));
+}
+function constraintId(kind, sourceGene, discriminator) {
+    return `${kind}:${sourceGene || "unknown"}:${hashString(discriminator).slice("sha256:".length, "sha256:".length + 12)}`;
+}
+function actionFor(kind, constraint) {
+    if (constraint.action === "escalate")
+        return "escalate";
+    if (constraint.action === "warn")
+        return "warn";
+    if (kind === "post_validator")
+        return "validate";
+    return "block";
+}
+function constraintFrom(kind, constraint, sources) {
+    const sourceGene = constraint.source_gene ?? "unknown";
+    const originSource = constraint.origin
+        ? sources.find((source) => source.source_id === constraint.origin?.source_dna_id)
+        : undefined;
+    const source = originSource ?? sourceForGene(sources, sourceGene);
+    const discriminator = constraint.condition ?? constraint.target ?? constraint.check ?? stable(constraint);
+    const sourceLayer = (constraint.origin?.source_layer ?? source?.type);
+    const sourceDnaId = constraint.origin?.source_dna_id ?? source?.source_id;
+    return {
+        constraint_id: constraintId(kind, sourceGene, discriminator),
+        source_layer: sourceLayer ?? "unknown",
+        source_dna_id: sourceDnaId ?? "unknown",
+        gene_id: sourceGene,
+        codon_type: kind === "tool_filter" ? "repel" : kind === "post_validator" ? "sense" : "threshold",
+        action: actionFor(kind, constraint),
+        provenance_reason: sourceDnaId && sourceLayer
+            ? `${kind} '${discriminator}' compiled from ${sourceLayer} DNA '${sourceDnaId}'`
+            : `${kind} '${discriminator}' has no resolved source DNA`,
+    };
+}
+export function buildConstraintWinners(ir, sources) {
+    return [
+        ...ir.pre_execution_gates.map((gate) => constraintFrom("pre_gate", gate, sources)),
+        ...ir.tool_filters.map((filter) => constraintFrom("tool_filter", filter, sources)),
+        ...ir.post_execution_validators.map((validator) => constraintFrom("post_validator", validator, sources)),
+    ];
+}
+export function attachProvenance(ir, sources) {
+    const baseIR = {
+        ...ir,
+        provenance: undefined,
+        compiled_ir_hash: undefined,
+    };
+    const compiledHash = hashObject(baseIR);
+    const enterprise = sources.find((source) => source.type === "enterprise");
+    const manifest = {
+        schema_version: PROVENANCE_SCHEMA_VERSION,
+        policy_bundle_id: enterprise?.source_id ?? "unknown",
+        policy_bundle_version: enterprise?.version ?? "unknown",
+        sources,
+        cascade_layers: buildCascadeLayers(sources),
+        constraint_winners: buildConstraintWinners(ir, sources),
+        compiled_ir_hash: compiledHash,
+    };
+    return {
+        ...ir,
+        compiled_ir_hash: compiledHash,
+        provenance: manifest,
+    };
+}

package/dist/governance/index.d.ts

@@ -1,7 +1,8 @@
 /**
- * Intent DNA — Remote Governance Module
+ * Intent DNA — Governance Module
  *
- * Architecture reservation for Phase 7 enterprise governance.
- * Currently exports type definitions only — no runtime implementation.
+ * Exports the v1.7.1 enterprise evidence contract plus reserved remote governance interfaces.
  */
 export type { AuditReport, RemoteDNAPolicy, PolicyContent, PolicyScope, PolicyUpdate, GovernanceConfig, GovernanceClient, GovernanceResponse, GovernanceSubscription, } from "./types.js";
+export { CASCADE_LAYER_NAMES, RUNTIME_DECISION_EVENT_SCHEMA_VERSION, validateRuntimeDecisionEvent, } from "./runtime-decision-event.js";
+export type { CascadeDecisionTrace, CascadeLayerFingerprint, CascadeLayerName, CascadeLayers, EnforcementPoint, ExplicitPlaceholder, HarnessRuntimeContext, PolicyBundle, RuntimeDecision, RuntimeDecisionEvent, RuntimeDecisionEventValidationResult, RuntimeEvidenceRef, WinningConstraint, } from "./runtime-decision-event.js";

package/dist/governance/index.js

@@ -1,7 +1,6 @@
 /**
- * Intent DNA — Remote Governance Module
+ * Intent DNA — Governance Module
  *
- * Architecture reservation for Phase 7 enterprise governance.
- * Currently exports type definitions only — no runtime implementation.
+ * Exports the v1.7.1 enterprise evidence contract plus reserved remote governance interfaces.
  */
-export {};
+export { CASCADE_LAYER_NAMES, RUNTIME_DECISION_EVENT_SCHEMA_VERSION, validateRuntimeDecisionEvent, } from "./runtime-decision-event.js";

package/dist/governance/runtime-decision-event.d.ts

@@ -0,0 +1,85 @@
+export declare const RUNTIME_DECISION_EVENT_SCHEMA_VERSION: "intentdna.runtime_decision_event.v1.7.1";
+export declare const CASCADE_LAYER_NAMES: readonly ["species", "enterprise", "project", "personal", "role", "context", "task"];
+export type ExplicitPlaceholder = "unknown" | "unsupported";
+export type RuntimeDecision = "allow" | "warn" | "block" | "escalate" | "validate";
+export type EnforcementPoint = "hook" | "sdk" | "ci" | "plugin_runtime" | "mcp_external_write" | ExplicitPlaceholder;
+export type CascadeLayerName = typeof CASCADE_LAYER_NAMES[number];
+export type RuntimeEvidenceRefType = "trace" | "audit" | "artifact" | "verifier" | "handoff" | "legacy" | ExplicitPlaceholder;
+export interface PolicyBundle {
+    policy_bundle_id: string;
+    policy_bundle_version: string;
+    source_ref: string;
+    fingerprint: string;
+}
+export interface CascadeLayerFingerprint {
+    layer: CascadeLayerName;
+    source_id: string;
+    source_ref: string;
+    fingerprint: string;
+    status: "active" | ExplicitPlaceholder;
+}
+export type CascadeLayers = Record<CascadeLayerName, CascadeLayerFingerprint>;
+export interface WinningConstraint {
+    constraint_id: string;
+    source_layer: CascadeLayerName | ExplicitPlaceholder;
+    source_dna_id: string;
+    gene_id: string;
+    codon_type: string;
+    action: RuntimeDecision;
+    provenance_reason: string;
+}
+export interface CascadeDecisionTrace {
+    cascade_layers: CascadeLayers;
+    winning_constraint: WinningConstraint;
+    compiled_ir_hash: string;
+    decision_reason: string;
+}
+export interface RuntimeEvidenceRef {
+    type: RuntimeEvidenceRefType;
+    ref: string;
+}
+export interface HarnessRuntimeContext {
+    agent_id: string;
+    agent_role: string;
+    agent_type: string;
+    session_agent: string;
+    harness_adapter: string;
+    runtime: string;
+}
+export interface RuntimeDecisionEvent {
+    schema_version: typeof RUNTIME_DECISION_EVENT_SCHEMA_VERSION;
+    event_id: string;
+    timestamp: string;
+    org_id: string;
+    team_id: string;
+    user_id: string;
+    project_id: string;
+    agent_id: string;
+    agent_role: string;
+    agent_type: string;
+    session_agent: string;
+    harness_adapter: string;
+    runtime: string;
+    policy_bundle_id: string;
+    policy_bundle_version: string;
+    cascade_layers: CascadeLayers;
+    winning_constraint: WinningConstraint;
+    compiled_ir_hash: string;
+    decision: RuntimeDecision;
+    decision_reason: string;
+    enforcement_point: EnforcementPoint;
+    harness_runtime_context: HarnessRuntimeContext;
+    session_id: string;
+    run_id: string;
+    step_id: string;
+    tool_name: string;
+    action_kind: string;
+    resource_ref: string;
+    evidence_refs: RuntimeEvidenceRef[];
+}
+export interface RuntimeDecisionEventValidationResult {
+    valid: boolean;
+    classification: "enterprise_evidence" | "legacy_diagnostic";
+    errors: string[];
+}
+export declare function validateRuntimeDecisionEvent(event: unknown): RuntimeDecisionEventValidationResult;