intentdna 1.7.0 → 1.7.4

package/dist/report/report-package.d.ts

@@ -1,9 +1,16 @@
 import type { DNAWorkflowState, TraceEntry, VerifierResultEntry } from "../hooks/state.js";
 import type { CompletedArtifactEntry } from "../schema/types.js";
+import { type RuntimeDecisionEvent } from "../governance/index.js";
 import { type KernelReport, type KernelReportOptions } from "./kernel-report.js";
 export type EvidenceRef = {
+    type: "runtime_decision";
+    event_id: string;
+} | {
     type: "trace";
     trace_id: string;
+} | {
+    type: "audit";
+    audit_id: string;
 } | {
     type: "verifier_result";
     result_id: string;
@@ -14,7 +21,7 @@ export type EvidenceRef = {
 };
 export interface CriticalDecision {
     decision_id: string;
-    kind: "block" | "warn" | "verifier_failure" | "handoff_gate";
+    kind: "block" | "warn" | "escalate" | "verifier_failure" | "handoff_gate";
     summary: string;
     refs: EvidenceRef[];
 }
@@ -23,6 +30,7 @@ export interface ReportPackage {
     generated_at: string;
     source: KernelReport["source"];
     kernel_report: KernelReport;
+    runtime_decisions: RuntimeDecisionEvent[];
     traces: TraceEntry[];
     verifier_results: VerifierResultEntry[];
     handoffs: {

package/dist/report/report-package.js

@@ -1,4 +1,5 @@
-import { readTraces, readVerifierResults, readWorkflowState } from "../hooks/state.js";
+import { readRuntimeDecisionEvents, readTraces, readVerifierResults, readWorkflowState } from "../hooks/state.js";
+import { validateRuntimeDecisionEvent } from "../governance/index.js";
 import { buildKernelReport } from "./kernel-report.js";
 function withinDays(timestamp, days) {
     const parsed = Date.parse(timestamp);
@@ -19,34 +20,32 @@ function artifactRefs(completed) {
     }
     return refs;
 }
-function buildCriticalDecisions(traces, verifierResults, completed) {
+function refsForRuntimeDecision(event) {
+    const refs = [{ type: "runtime_decision", event_id: event.event_id }];
+    for (const ref of event.evidence_refs) {
+        if (ref.type === "trace")
+            refs.push({ type: "trace", trace_id: ref.ref });
+        if (ref.type === "audit")
+            refs.push({ type: "audit", audit_id: ref.ref });
+        if (ref.type === "verifier")
+            refs.push({ type: "verifier_result", result_id: ref.ref });
+        if (ref.type === "artifact" || ref.type === "handoff")
+            refs.push({ type: "artifact", artifact_id: ref.ref });
+    }
+    return refs;
+}
+function buildCriticalDecisions(runtimeDecisions) {
     const decisions = [];
-    for (const trace of traces) {
-        if (trace.decision !== "block" && trace.decision !== "warn")
+    for (const event of runtimeDecisions) {
+        if (validateRuntimeDecisionEvent(event).classification !== "enterprise_evidence")
             continue;
-        decisions.push({
-            decision_id: `${trace.decision}:${trace.trace_id}`,
-            kind: trace.decision,
-            summary: trace.reason?.split("\n")[0] ?? `${trace.decision} decision`,
-            refs: [{ type: "trace", trace_id: trace.trace_id }],
-        });
-    }
-    for (const result of verifierResults) {
-        if (result.status !== "fail")
+        if (event.decision !== "block" && event.decision !== "warn" && event.decision !== "escalate")
             continue;
         decisions.push({
-            decision_id: `verifier_failure:${result.result_id ?? result.verifier_id}`,
-            kind: "verifier_failure",
-            summary: result.message ?? `Verifier failed: ${result.verifier_id}`,
-            refs: [{ type: "verifier_result", result_id: result.result_id ?? result.verifier_id }],
-        });
-    }
-    for (const ref of artifactRefs(completed)) {
-        decisions.push({
-            decision_id: `handoff_gate:${ref.artifact_id}`,
-            kind: "handoff_gate",
-            summary: `Completed handoff artifact ${ref.artifact_id}`,
-            refs: [{ type: "artifact", artifact_id: ref.artifact_id, path: ref.path }],
+            decision_id: `${event.decision}:${event.event_id}`,
+            kind: event.decision,
+            summary: event.decision_reason.split("\n")[0] || `${event.decision} decision`,
+            refs: refsForRuntimeDecision(event),
         });
     }
     return decisions;
@@ -54,6 +53,7 @@ function buildCriticalDecisions(traces, verifierResults, completed) {
 export async function buildReportPackage(options) {
     const days = options.days ?? 7;
     const kernelReport = await buildKernelReport(options);
+    const runtimeDecisions = await readRuntimeDecisionEvents(options.projectDir, days, options.sessionId);
     const traces = await readTraces(options.projectDir, days, options.sessionId);
     const verifierResults = (await readVerifierResults(options.projectDir, options.sessionId))
         .filter((result) => withinDays(result.timestamp, days));
@@ -64,6 +64,7 @@ export async function buildReportPackage(options) {
         generated_at: new Date().toISOString(),
         source: kernelReport.source,
         kernel_report: kernelReport,
+        runtime_decisions: runtimeDecisions,
         traces,
         verifier_results: verifierResults,
         handoffs: {
@@ -71,9 +72,13 @@ export async function buildReportPackage(options) {
             completed_artifacts: completedArtifacts,
             artifact_refs: artifactRefs(completedArtifacts),
         },
-        diagnostics: [],
+        diagnostics: [
+            ...(traces.length > 0 ? [{ severity: "info", code: "legacy_trace_diagnostic", message: `${traces.length} trace record(s) included as diagnostic-only evidence` }] : []),
+            ...(verifierResults.length > 0 ? [{ severity: "info", code: "legacy_verifier_diagnostic", message: `${verifierResults.length} verifier result(s) included as diagnostic-only evidence` }] : []),
+            ...(completedArtifacts.length > 0 ? [{ severity: "info", code: "workflow_state_diagnostic", message: `${completedArtifacts.length} workflow handoff entry group(s) included as diagnostic-only evidence` }] : []),
+        ],
         deferrals: [],
-        critical_decisions: buildCriticalDecisions(traces, verifierResults, completedArtifacts),
+        critical_decisions: buildCriticalDecisions(runtimeDecisions),
         mutation: {
             command_class: options.includeMarkerPreview ? "preview-only" : "read-only",
             wrote_state: false,

package/dist/runtime/claude-sdk.d.ts

@@ -8,7 +8,7 @@
  *   post_execution_validators → PostToolUse hooks
  *   context_injections    → UserPromptSubmit hook
  */
-import type { ConstraintIR } from "../schema/types.js";
+import type { CompiledProvenanceManifest, ConstraintIR, ConstraintProvenance } from "../schema/types.js";
 export interface DNAHookOutput {
     hookSpecificOutput?: {
         hookEventName: string;
@@ -32,19 +32,24 @@ export interface ClaudeDNAConfig {
     source_dna_ids: string[];
     /** Compilation timestamp */
     compiled_at: string;
+    /** Stable compiled IR hash for runtime decision events */
+    compiled_ir_hash?: string;
+    /** Cascade/source provenance for SDK-side checks */
+    provenance?: CompiledProvenanceManifest;
 }
 export interface PreToolRule {
     condition: string;
     action: "block" | "escalate" | "warn";
     message: string;
     source_gene: string;
+    constraint_provenance?: ConstraintProvenance;
+    compiled_ir_hash?: string;
 }
 export interface PostToolRule {
     check: string;
     threshold?: number;
     source_gene: string;
+    constraint_provenance?: ConstraintProvenance;
+    compiled_ir_hash?: string;
 }
-/**
- * Compile Constraint IR to Claude Agent SDK configuration.
- */
 export declare function compileForClaude(ir: ConstraintIR): ClaudeDNAConfig;

package/dist/runtime/claude-sdk.js

@@ -12,6 +12,9 @@
 /**
  * Compile Constraint IR to Claude Agent SDK configuration.
  */
+function provenanceForGene(ir, geneId) {
+    return ir.provenance?.constraint_winners.find((constraint) => constraint.gene_id === geneId);
+}
 export function compileForClaude(ir) {
     // Build system prompt addition from directives
     const promptLines = [];
@@ -61,11 +64,15 @@ export function compileForClaude(ir) {
             action: g.action,
             message: g.message,
             source_gene: g.source_gene,
+            constraint_provenance: provenanceForGene(ir, g.source_gene),
+            compiled_ir_hash: ir.compiled_ir_hash,
         })),
         post_tool_rules: ir.post_execution_validators.map((v) => ({
             check: v.check,
             threshold: v.threshold,
             source_gene: v.source_gene,
+            constraint_provenance: provenanceForGene(ir, v.source_gene),
+            compiled_ir_hash: ir.compiled_ir_hash,
         })),
         context_additions: ir.context_injections.map((c) => c.text),
         deprioritized_tools: ir.tool_filters
@@ -73,5 +80,7 @@ export function compileForClaude(ir) {
             .map((f) => f.target),
         source_dna_ids: ir.source_dna_ids,
         compiled_at: ir.compiled_at,
+        compiled_ir_hash: ir.compiled_ir_hash,
+        provenance: ir.provenance,
     };
 }

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

@@ -6,7 +6,7 @@
  *
  * This is the bridge between compile-time (dna sync) and runtime (hook execution).
  */
-import type { ConstraintIR, RoleDef } from "../schema/types.js";
+import type { CompiledProvenanceManifest, ConstraintIR, RoleDef } from "../schema/types.js";
 /** Wrapper around ConstraintIR with versioning metadata */
 export interface CompiledIRFile {
     /** Schema version for forward compatibility */
@@ -19,6 +19,10 @@ export interface CompiledIRFile {
     ir: ConstraintIR;
     /** Cascaded role definitions (for output_schema enforcement) */
     roles?: Record<string, RoleDef>;
+    /** Stable hash of the compiled IR payload, excluding provenance/hash fields */
+    compiled_ir_hash?: string;
+    /** Cascade and source provenance used by enterprise evidence */
+    provenance?: CompiledProvenanceManifest;
 }
 /**
  * Create a CompiledIRFile wrapper around a ConstraintIR.

package/dist/runtime/plugin-adapter.js

@@ -20,6 +20,8 @@ export function createCompiledIR(ir, roles) {
         source_dna_ids: ir.source_dna_ids,
         ir,
         roles: roles && Object.keys(roles).length > 0 ? roles : undefined,
+        compiled_ir_hash: ir.compiled_ir_hash,
+        provenance: ir.provenance,
     };
 }
 /**

package/dist/schema/types.d.ts

@@ -17,9 +17,16 @@ export interface RepelCodon {
     type: "repel";
     target: string;
 }
+export interface ConstraintOrigin {
+    source_dna_id: string;
+    source_layer: DNAType;
+    cascade_priority: number;
+    protected_threshold?: boolean;
+}
 export interface ThresholdCodon {
     type: "threshold";
     condition: string;
+    origin?: ConstraintOrigin;
 }
 export interface WeightCodon {
     type: "weight";
@@ -262,6 +269,47 @@ export interface CascadeConfig {
     inherits: string[];
     priority: number;
 }
+export type ProvenanceCascadeLayerName = "species" | "enterprise" | "project" | "personal" | "role" | "context" | "task";
+export type ProvenanceLayerStatus = "active" | "unknown" | "unsupported";
+export type ProvenanceSourceTrust = "builtin" | "admin_shared" | "project_local" | "user_local" | "explicit_file" | "input";
+export interface DNASourceProvenance {
+    source_id: string;
+    source_ref: string;
+    resolved_path: string;
+    fingerprint: string;
+    type: DNAType;
+    cascade_priority: number;
+    version: string;
+    trust: ProvenanceSourceTrust;
+    inherited_by?: string;
+    genes?: string[];
+}
+export interface CascadeLayerProvenance {
+    layer: ProvenanceCascadeLayerName;
+    source_id: string;
+    source_ref: string;
+    fingerprint: string;
+    status: ProvenanceLayerStatus;
+    sources?: string[];
+}
+export interface ConstraintProvenance {
+    constraint_id: string;
+    source_layer: ProvenanceCascadeLayerName | "unknown" | "unsupported";
+    source_dna_id: string;
+    gene_id: string;
+    codon_type: CodonType | "unknown";
+    action: "allow" | "warn" | "block" | "escalate" | "validate";
+    provenance_reason: string;
+}
+export interface CompiledProvenanceManifest {
+    schema_version: "intentdna.provenance.v1.7.2";
+    policy_bundle_id: string;
+    policy_bundle_version: string;
+    sources: DNASourceProvenance[];
+    cascade_layers: Record<ProvenanceCascadeLayerName, CascadeLayerProvenance>;
+    constraint_winners: ConstraintProvenance[];
+    compiled_ir_hash: string;
+}
 export interface VariableDef {
     description: string;
     default: string;
@@ -372,6 +420,7 @@ export interface PreExecutionGate {
     action: "block" | "escalate" | "warn";
     message: string;
     source_gene: string;
+    origin?: ConstraintOrigin;
 }
 export interface PostExecutionValidator {
     check: string;
@@ -488,6 +537,8 @@ export interface ConstraintIR {
         per_workflow?: Record<string, string[]>;
     };
     verifier_policy?: VerifierCommandPolicy;
+    provenance?: CompiledProvenanceManifest;
+    compiled_ir_hash?: string;
 }
 /** A compiled workflow step with resolved metadata */
 export interface WorkflowStep {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "intentdna",
-  "version": "1.7.0",
+  "version": "1.7.4",
   "description": "Intent DNA — Declarative policy layer for AI agent behavior",
   "type": "module",
   "main": "dist/index.js",

package/spec/README.md

@@ -15,7 +15,7 @@ This directory contains engineering specs. Use [ROADMAP.md](../ROADMAP.md) as th
 
 | Spec | Status | Purpose |
 |------|--------|---------|
-| [schema-spec.md](schema-spec.md) | Canonical | Intent DNA document structure, genes, roles, workflows, cascade, and IR contract. |
+| [schema-spec.md](schema-spec.md) | Canonical | Intent DNA document structure, genes, roles, workflows, cascade, Enterprise bundle inheritance, RuntimeDecisionEvent, and IR contract. |
 | [foundation-hardening.md](foundation-hardening.md) | Active reference | Reliability, governance, MCP, and tool-experience hardening plan. |
 | [hooks-infra-harness-hardening.md](hooks-infra-harness-hardening.md) | Active reference | Hook boundary schema, enforcement result types, state manager, context/reflection/workflow gates. |
 | [workflow-pipeline.md](workflow-pipeline.md) | Active reference | Workflow pipeline design and state management unification. |

package/spec/schema-spec.md

@@ -386,7 +386,7 @@ Or shorthand: `max_rounds: 3` (equivalent to max_retries: 2)
 
 ## Cascade (Inheritance)
 
-DNA configs inherit from parent layers using CSS-like cascade.
+DNA configs inherit from parent layers using CSS-like cascade. The enterprise safety cascade order is Species → Enterprise → Project → Personal → Role → Context → Task.
 
 ```yaml
 cascade:
@@ -404,6 +404,83 @@ cascade:
 ### Threshold Protection
 Threshold codons from lower-priority layers **cannot be removed** by higher-priority layers. This ensures safety invariants propagate up the chain.
 
+Species and Enterprise thresholds are organization red lines. Project, Personal, Role, Context, and Task layers may add stricter thresholds, but they cannot relax, remove, bypass, or downgrade Species/Enterprise thresholds.
+
+### Enterprise Bundle Inheritance (v1.7.x local/shared slice)
+
+The v1.7.x Enterprise Safety Slice is scoped to local and shared policy bundle references only; it does not implement remote registry, signing, push/pull, or SaaS permissions. In v1.7.1 this section freezes the contract and resolver boundary; the concrete `dna sync` / `dna verify` resolver implementation is planned for v1.7.2.
+
+Candidate bundle locations:
+
+- `INTENTDNA_ENTERPRISE_POLICY_DIR` — admin/team-controlled shared root for authoritative local dogfood
+- `.dna/policies/enterprise/*.dna.yaml` — project-local bundle for development and fixture use
+- `~/.intentdna/policies/enterprise/*.dna.yaml` — user-local bundle for development and personal dogfood
+- `test/fixtures/enterprise-policies/` — test-only fixture root
+
+Project-local and user-local bundles are not organization-authoritative by themselves. They must be treated as local/dev provenance unless the future v1.7.2 resolver can tie them to an admin-controlled root or pinned fingerprint.
+
+Supported reference forms:
+
+```yaml
+cascade:
+  inherits:
+    - "enterprise:baseline"              # resolves baseline.dna.yaml from candidate dirs
+    - "file:../shared/baseline.dna.yaml" # explicit local/shared file
+```
+
+For v1.7.2, `dna sync` must materialize the resolved bundle id/version, source path, fingerprint, cascade layer fingerprints, and compiled IR hash into provenance. `dna verify` must reject unresolved references, inheritance cycles, missing bundle metadata, and attempts by lower layers to relax Species/Enterprise thresholds.
+
+---
+
+## Enterprise Provenance Contract (v1.7.1)
+
+v1.7.1 freezes the enterprise evidence contract before the full implementation lands. `RuntimeDecisionEvent` is required for enterprise governance evidence; legacy trace/audit/state records without this provenance remain diagnostic only.
+
+### PolicyBundle
+
+A policy bundle records the policy source that produced enforcement-relevant constraints:
+
+| Field | Required | Description |
+|-------|----------|-------------|
+| `policy_bundle_id` | yes | Stable bundle id, e.g. `enterprise_baseline` |
+| `policy_bundle_version` | yes | Bundle version used for the decision |
+| `source_ref` | yes | `enterprise:baseline`, `file:...`, or a local source path |
+| `fingerprint` | yes | Stable content/source fingerprint |
+
+### CascadeLayerFingerprint
+
+`cascade_layers` must include every layer: `species`, `enterprise`, `project`, `personal`, `role`, `context`, and `task`.
+
+| Field | Required | Description |
+|-------|----------|-------------|
+| `layer` | yes | One of the fixed cascade layer names |
+| `source_id` | yes | DNA or placeholder source id |
+| `source_ref` | yes | Resolved source path/reference or `unknown` / `unsupported` |
+| `fingerprint` | yes | Layer fingerprint or `unknown` / `unsupported` |
+| `status` | yes | `active`, `unknown`, or `unsupported` |
+
+### RuntimeDecisionEvent
+
+Every enterprise runtime decision must include these required fields:
+
+```text
+schema_version, event_id, timestamp,
+org_id, team_id, user_id, project_id,
+agent_id, agent_role, agent_type, session_agent,
+harness_adapter, runtime,
+policy_bundle_id, policy_bundle_version,
+cascade_layers, winning_constraint, compiled_ir_hash,
+decision, decision_reason,
+enforcement_point, harness_runtime_context,
+session_id, run_id, step_id,
+tool_name, action_kind, resource_ref,
+evidence_refs
+```
+
+`decision` is one of `allow`, `warn`, `block`, `escalate`, or `validate`. `enforcement_point` is one of `hook`, `sdk`, `ci`, `plugin_runtime`, `mcp_external_write`, `unknown`, or `unsupported`.
+
+The first implementation may fill unavailable dimensions with explicit `unknown` or `unsupported` values, but it must not omit required fields. Placeholder values make the event syntactically valid for phased rollout, not enterprise-authoritative: any required provenance field that remains `unknown` / `unsupported`, or any `legacy` / placeholder `evidence_refs` entry, keeps the event classified as `legacy_diagnostic`. Events missing required fields or classified as diagnostic cannot enter enterprise compliance statistics. MCP, reports, dashboards, and evolution consume this event as evidence; they do not create policy truth.
+
 ---
 
 ## Variables