intentdna 1.7.0 → 1.7.4

package/.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
     {
       "name": "intentdna",
       "description": "Declarative policy layer for AI agent behavior with plugin-managed hook runtime for Claude Code.",
-      "version": "1.7.0",
+      "version": "1.7.4",
       "author": {
         "name": "Samuel"
       },
@@ -25,5 +25,5 @@
       ]
     }
   ],
-  "version": "1.7.0"
+  "version": "1.7.4"
 }

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "intentdna",
-  "version": "1.7.0",
+  "version": "1.7.4",
   "description": "Declarative policy layer for AI agent behavior",
   "author": {
     "name": "Samuel"

package/README.md

@@ -1,26 +1,32 @@
 # Intent DNA
 
-**Declarative control plane for AI agent behavior.**
+**Enterprise safety control plane for AI agent behavior.**
 
-Intent DNA turns intent, policy, and accumulated experience into enforceable agent constraints. Instead of relying on prompts alone, it compiles DNA into the native control surfaces of Claude Code and related harnesses. It governs how agents operate across existing tools and systems; it does not replace your business systems or act as a domain-specific automation runtime.
+Intent DNA lets an organization declare safety policy once, cascade it through Species → Enterprise → Project → Personal → Role → Context → Task, and compile it into deterministic gates for every agent, project, and harness. It governs how agents operate across existing tools and systems; it does not replace your business systems or act as a domain-specific automation runtime.
 
 ---
 
 ## What It Is
 
-Intent DNA is a compiler and runtime toolkit for managing agent behavior across four layers:
+Intent DNA is an enforcement-first control plane for organization-wide agent safety:
 
-- **Behavioral guidance** via generated prompt/context files
-- **Deterministic enforcement** via hooks and runtime checks
-- **Artifact handoff** via session-scoped manifests and resolver facts
-- **Feedback loops** via trace, audit, and epigenetic evolution
+- **Enterprise / Species policy bundles** define shared red lines across projects and teams
+- **Cascade governance** preserves provenance and prevents lower layers from relaxing organization thresholds
+- **Constraint IR** carries policy provenance into hook, SDK-check, and CI strict gates
+- **RuntimeDecisionEvent evidence** records who/what/why/from which policy for every allow/warn/block/escalate/validate decision
+- **MCP, reports, state, trace, audit, and evolution** query or package evidence; they are not the policy source of truth
 
 It governs the agents operating on your systems rather than re-implementing the systems themselves.
 
 The core model is:
 
 ```text
-DNA config → compiler pipeline → Constraint IR → harness-specific outputs
+Enterprise / Species Policy Bundle
+  → Species→Enterprise→Project→Personal→Role→Context→Task Cascade
+  → Constraint IR + Provenance Manifest
+  → Hook / SDK-check / CI strict gate
+  → RuntimeDecisionEvent
+  → MCP / report / dashboard / evolution evidence layer
 ```
 
 For the architectural model and long-term design, see [DESIGN.md](DESIGN.md).  
@@ -30,9 +36,10 @@ For the schema contract, see [spec/schema-spec.md](spec/schema-spec.md).
 ## Design Principles
 
 - Govern agents rather than re-implementing business systems.
-- Declare intent and boundaries first, then compile them into native control surfaces.
-- Combine guidance, enforcement, validation, and feedback into one governance loop.
-- Treat runtime state, validators, and signals as first-class governance assets.
+- Declare enterprise safety red lines first, then compile them into native control surfaces.
+- Treat Species and Enterprise thresholds as non-relaxable by Project, Personal, Role, Context, or Task layers.
+- Keep enforcement points authoritative: hooks, SDK checks, and CI gates make decisions from compiled IR and provenance.
+- Treat runtime state, validators, traces, reports, MCP queries, and signals as evidence assets, not policy truth.
 - Keep adapters and signal ingestion pluggable so the control plane outlives any single tool.
 
 ---
@@ -70,10 +77,10 @@ dna init --upgrade <template-name>
 
 ## How It Works
 
-Intent DNA compiles to your tool's native control surfaces:
+Intent DNA compiles organization policy to your tool's native control surfaces:
 
 ```text
-DNA → Constraint IR → CLAUDE.md / settings / agents / skills / runtime state
+DNA → Cascade provenance → Constraint IR → hooks / SDK checks / CI gates → evidence
 ```
 
 Typical outputs include:
@@ -82,12 +89,14 @@ Typical outputs include:
 |--------|---------|
 | `CLAUDE.md` | Behavioral guidance |
 | `.dna/compiled/ir.json` | Runtime-readable compiled constraints |
+| provenance manifest | Policy bundle, cascade layers, winners, and compiled IR hash |
+| RuntimeDecisionEvent | Enterprise evidence for allow/warn/block/escalate/validate decisions |
 | `.dna/state/sessions/*/handoffs/*.json` | Local artifact manifests for workflow handoff facts |
 | `.claude/agents/*.md` | Role definitions |
 | `.claude/skills/*/SKILL.md` | Workflow entrypoints |
 | `.claude/settings.json` or plugin runtime | Hook wiring |
 
-**Key idea:** prompts can drift, but runtime constraints, resolver-backed handoffs, and feedback loops make behavior governable.
+**Key idea:** prompts can drift, but non-relaxable enterprise thresholds, compiled gates, and provenance-backed runtime evidence make behavior governable.
 
 ---
 
@@ -95,11 +104,13 @@ Typical outputs include:
 
 Intent DNA currently focuses on:
 
+- Enterprise Safety Slice: shared policy bundles, cascade provenance, and non-relaxable organization thresholds
 - Claude Code / Claude-style harnesses
 - Role-based agent workflows
 - Template-driven project bootstrap and upgrades
 - Deterministic guardrails and stateful enforcement
 - Resolver-backed artifact handoff between workflow steps
+- Evidence-layer MCP/report/state/trace/audit surfaces
 - Dogfood-driven template iteration
 
 Adapter and ecosystem direction are tracked in [ROADMAP.md](ROADMAP.md), not duplicated here.
@@ -157,7 +168,7 @@ workflows:
         description: Review the implementation
 ```
 
-**Cascade:** DNA files inherit and override by priority. `threshold` codons (safety rules) can never be relaxed — even by higher priority DNA.
+**Cascade:** DNA files inherit and override by priority. `threshold` codons (safety rules) from Species or Enterprise are red lines: Project, Personal, Role, Context, and Task layers may add stricter rules but cannot relax them.
 
 **Genes:** Behavioral traits (attract/repel/threshold/weight/sense).
 

package/dist/cli/commands/feedback.d.ts

@@ -1,8 +1,8 @@
 /**
  * dna feedback [--days <N>] [--json] [--evolve]
  *
- * Build a local kernel observability report from traces and verifier results.
- * With --evolve: include a preview-only marker diff derived from local signals.
+ * Build a local kernel observability report from RuntimeDecisionEvent evidence.
+ * Legacy traces and verifier results are included as diagnostic context only.
  */
 export interface FeedbackOptions {
     days: number;

package/dist/cli/commands/feedback.js

@@ -1,8 +1,8 @@
 /**
  * dna feedback [--days <N>] [--json] [--evolve]
  *
- * Build a local kernel observability report from traces and verifier results.
- * With --evolve: include a preview-only marker diff derived from local signals.
+ * Build a local kernel observability report from RuntimeDecisionEvent evidence.
+ * Legacy traces and verifier results are included as diagnostic context only.
  */
 import { buildKernelReport, formatKernelReport } from "../../report/kernel-report.js";
 import { buildReportPackage } from "../../report/report-package.js";
@@ -23,9 +23,9 @@ export async function runFeedback(opts) {
         includeMarkerPreview: opts.evolve,
         dnaId: opts.dnaId,
     });
-    if (report.summary.traces === 0 && report.summary.verifier_results === 0) {
-        process.stderr.write(`No trace or verifier data found for the last ${opts.days} day(s).\n`);
-        process.stderr.write("Signals are generated by dna-hook during Claude Code sessions.\n");
+    if (report.summary.runtime_decisions === 0 && report.summary.legacy_diagnostics === 0) {
+        process.stderr.write(`No RuntimeDecisionEvent evidence or legacy diagnostics found for the last ${opts.days} day(s).\n`);
+        process.stderr.write("RuntimeDecisionEvent evidence is generated by dna-hook during Claude Code sessions.\n");
         return 0;
     }
     if (opts.json) {

package/dist/cli/commands/sync.js

@@ -14,7 +14,7 @@ import { resolve, dirname } from "node:path";
 import { readFile, writeFile as writeFileAsync, stat, mkdir, readdir, unlink, rm } from "node:fs/promises";
 import { createHash } from "node:crypto";
 import { createInterface } from "node:readline";
-import { assertNoNamespaceCollisions, compileFromFiles, detectDNAConfigs, expandDNAInputFiles, loadDNA, } from "../../compiler/index.js";
+import { assertNoNamespaceCollisions, compileFromFiles, detectDNAConfigs, expandDNAInputs, loadDNA, } from "../../compiler/index.js";
 import { parseYAML } from "../../schema/yaml-parser.js";
 import { findTemplateCatalogEntry } from "../../templates/catalog.js";
 import { compileToMarkdown, injectIntoFile, removeFromFile } from "../../runtime/markdown.js";
@@ -318,7 +318,7 @@ function lockTrackedOutputPaths(trackedOutputs) {
         .filter((output) => getSyncOutputArtifactMetadata(output.artifact)?.trackedByLock)
         .map((output) => output.path);
 }
-async function generateLockFile(lockPath, dnaSources, outputFiles) {
+async function generateLockFile(lockPath, dnaSources, outputFiles, provenance, compiledIrHash) {
     const outputs = {};
     for (const f of outputFiles) {
         outputs[f] = { sha256: await computeFileHash(f) };
@@ -327,6 +327,8 @@ async function generateLockFile(lockPath, dnaSources, outputFiles) {
         synced_at: new Date().toISOString(),
         dna_sources: dnaSources,
         outputs,
+        compiled_ir_hash: compiledIrHash,
+        provenance,
     };
     await mkdir(dirname(lockPath), { recursive: true });
     await writeFileAsync(lockPath, JSON.stringify(lock, null, 2) + "\n", "utf-8");
@@ -441,7 +443,8 @@ export async function runSync(opts) {
         // Step 0: Expand and pre-validate all DNA files before any work
         // loadDNA() calls validateDNA() internally — validation failures throw here,
         // before evolve/compile/inject waste any work.
-        const expandedFiles = await expandDNAInputFiles(opts.files);
+        const expandedInputs = await expandDNAInputs(opts.files);
+        const expandedFiles = expandedInputs.files;
         await checkTemplateVersions(expandedFiles);
         const loadedDNAs = await Promise.all(expandedFiles.map(loadDNA));
         if (opts.dryRun) {
@@ -464,7 +467,7 @@ export async function runSync(opts) {
             }
         }
         // Step 2: Compile
-        const ir = await compileFromFiles(expandedFiles, {
+        const ir = await compileFromFiles(opts.files, {
             context: opts.context,
             role: opts.role,
             epigenetic_markers: epigeneticMarkers,
@@ -721,7 +724,7 @@ export async function runSync(opts) {
                 process.stderr.write(`Dry-run: would write lock file: ${lockPath}\n`);
             }
             else {
-                await generateLockFile(lockPath, expandedFiles, lockTrackedOutputPaths(trackedOutputs));
+                await generateLockFile(lockPath, opts.files, lockTrackedOutputPaths(trackedOutputs), ir.provenance, ir.compiled_ir_hash);
                 process.stderr.write(`Lock file: ${lockPath}\n`);
             }
             trackSyncOutput(trackedOutputs, "lock-file", lockPath);

package/dist/cli/commands/verify.d.ts

@@ -9,10 +9,13 @@
  *   1 — drift detected (modified or missing files)
  *   2 — usage error (e.g. lock file not found)
  */
+import type { CompiledProvenanceManifest } from "../../schema/types.js";
 export interface VerifyOptions {
     lockFile: string;
     stats?: boolean;
     health?: boolean;
+    strict?: boolean;
+    projectDir?: string;
 }
 export interface LockFileEntry {
     sha256: string;
@@ -21,6 +24,8 @@ export interface LockFile {
     synced_at: string;
     dna_sources: string[];
     outputs: Record<string, LockFileEntry>;
+    compiled_ir_hash?: string;
+    provenance?: CompiledProvenanceManifest;
 }
 export interface VerifyResult {
     file: string;
@@ -28,9 +33,36 @@ export interface VerifyResult {
     expected?: string;
     actual?: string;
 }
+export interface ProvenanceVerifyResult {
+    source_id: string;
+    file: string;
+    status: "match" | "mismatch" | "missing";
+    expected?: string;
+    actual?: string;
+}
+export interface InheritanceGraphVerifyResult {
+    source_id: string;
+    file: string;
+    status: "match" | "mismatch" | "missing" | "extra";
+    expected?: string;
+    actual?: string;
+}
 export declare function sha256(content: string): string;
 export declare function parseLockFile(raw: string): LockFile;
 export declare function verifyLock(lock: LockFile): Promise<VerifyResult[]>;
+export declare function verifyInheritanceGraph(lock: LockFile): Promise<InheritanceGraphVerifyResult[]>;
+export declare function verifyProvenance(provenance?: CompiledProvenanceManifest): Promise<ProvenanceVerifyResult[]>;
+export interface StrictRuntimeEvidenceExpectation {
+    compiledIrHash?: string;
+    policyBundleId?: string;
+    policyBundleVersion?: string;
+}
+export declare function verifyStrictRuntimeEvidence(projectDir: string, expected?: StrictRuntimeEvidenceExpectation): Promise<{
+    ok: boolean;
+    total: number;
+    enterprise: number;
+    errors: string[];
+}>;
 export declare function runVerify(opts: VerifyOptions): Promise<number>;
 export interface HealthCheckResult {
     name: string;

package/dist/cli/commands/verify.js

@@ -11,7 +11,11 @@
  */
 import { readFile } from "node:fs/promises";
 import { createHash } from "node:crypto";
-import { readTraces } from "../../hooks/state.js";
+import { dirname, resolve } from "node:path";
+import { readRuntimeDecisionEvents, readTraces } from "../../hooks/state.js";
+import { expandDNAInputs, formatDiagnostics } from "../../compiler/index.js";
+import { DNADiagnosticsError } from "../../compiler/diagnostics.js";
+import { validateRuntimeDecisionEvent } from "../../governance/index.js";
 // ── Helpers ────────────────────────────────────────────────
 export function sha256(content) {
     return createHash("sha256").update(content, "utf-8").digest("hex");
@@ -52,6 +56,108 @@ export async function verifyLock(lock) {
     }
     return results;
 }
+function enterpriseDirsFromLock(lock) {
+    const dirs = new Set();
+    for (const source of lock.provenance?.sources ?? []) {
+        if (source.source_ref.startsWith("enterprise:"))
+            dirs.add(dirname(source.resolved_path));
+    }
+    return [...dirs];
+}
+function sourceGraphKey(source) {
+    return JSON.stringify([source.source_id, source.source_ref, source.inherited_by ?? ""]);
+}
+function comparableSource(source) {
+    return JSON.stringify({
+        source_ref: source.source_ref,
+        resolved_path: source.resolved_path,
+        fingerprint: source.fingerprint,
+        inherited_by: source.inherited_by,
+    });
+}
+export async function verifyInheritanceGraph(lock) {
+    if (!lock.provenance)
+        return [];
+    const expanded = await expandDNAInputs(lock.dna_sources, { enterprisePolicyDirs: enterpriseDirsFromLock(lock) });
+    const current = new Map(expanded.provenance.map((source) => [sourceGraphKey(source), source]));
+    const locked = new Map(lock.provenance.sources.map((source) => [sourceGraphKey(source), source]));
+    const results = [];
+    for (const [key, expected] of locked) {
+        const actual = current.get(key);
+        if (!actual) {
+            results.push({ source_id: expected.source_id, file: expected.resolved_path, status: "missing", expected: comparableSource(expected) });
+            continue;
+        }
+        const expectedComparable = comparableSource(expected);
+        const actualComparable = comparableSource(actual);
+        results.push({
+            source_id: expected.source_id,
+            file: expected.resolved_path,
+            status: expectedComparable === actualComparable ? "match" : "mismatch",
+            expected: expectedComparable,
+            actual: actualComparable,
+        });
+    }
+    for (const [key, actual] of current) {
+        if (!locked.has(key)) {
+            results.push({ source_id: actual.source_id, file: actual.resolved_path, status: "extra", actual: comparableSource(actual) });
+        }
+    }
+    return results;
+}
+export async function verifyProvenance(provenance) {
+    if (!provenance)
+        return [];
+    const results = [];
+    for (const source of provenance.sources) {
+        try {
+            const content = await readFile(source.resolved_path, "utf-8");
+            const actual = `sha256:${sha256(content)}`;
+            results.push({
+                source_id: source.source_id,
+                file: source.resolved_path,
+                status: actual === source.fingerprint ? "match" : "mismatch",
+                expected: source.fingerprint,
+                actual,
+            });
+        }
+        catch {
+            results.push({
+                source_id: source.source_id,
+                file: source.resolved_path,
+                status: "missing",
+                expected: source.fingerprint,
+            });
+        }
+    }
+    return results;
+}
+export async function verifyStrictRuntimeEvidence(projectDir, expected = {}) {
+    const events = await readRuntimeDecisionEvents(projectDir, 7);
+    const errors = [];
+    let enterprise = 0;
+    for (const event of events) {
+        const result = validateRuntimeDecisionEvent(event);
+        if (!result.valid)
+            errors.push(...result.errors.map((error) => `${event.event_id ?? "unknown"}: ${error}`));
+        if (expected.compiledIrHash && event.compiled_ir_hash !== expected.compiledIrHash) {
+            errors.push(`${event.event_id ?? "unknown"}: compiled_ir_hash does not match current lock`);
+        }
+        if (expected.policyBundleId && event.policy_bundle_id !== expected.policyBundleId) {
+            errors.push(`${event.event_id ?? "unknown"}: policy_bundle_id does not match current lock`);
+        }
+        if (expected.policyBundleVersion && event.policy_bundle_version !== expected.policyBundleVersion) {
+            errors.push(`${event.event_id ?? "unknown"}: policy_bundle_version does not match current lock`);
+        }
+        if (result.classification === "enterprise_evidence")
+            enterprise++;
+        else
+            errors.push(`${event.event_id ?? "unknown"}: RuntimeDecisionEvent is diagnostic-only, not enterprise evidence`);
+    }
+    if (events.length === 0)
+        errors.push("no RuntimeDecisionEvent evidence found");
+    return { ok: errors.length === 0, total: events.length, enterprise, errors };
+}
 // ── CLI entry ──────────────────────────────────────────────
 export async function runVerify(opts) {
     // Handle --health mode
@@ -79,8 +185,24 @@ export async function runVerify(opts) {
         process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}\n`);
         return 2;
     }
+    let inheritanceResults = [];
+    if (lock.provenance) {
+        try {
+            inheritanceResults = await verifyInheritanceGraph(lock);
+        }
+        catch (err) {
+            if (err instanceof DNADiagnosticsError) {
+                process.stderr.write(`Error: DNA inheritance graph is invalid:\n${formatDiagnostics(err.diagnostics)}\n`);
+            }
+            else {
+                process.stderr.write(`Error: DNA inheritance graph is invalid: ${err instanceof Error ? err.message : String(err)}\n`);
+            }
+            return 1;
+        }
+    }
     // Verify
     const results = await verifyLock(lock);
+    const provenanceResults = await verifyProvenance(lock.provenance);
     // Report
     let hasFailure = false;
     for (const r of results) {
@@ -96,17 +218,62 @@ export async function runVerify(opts) {
             hasFailure = true;
         }
     }
-    const total = results.length;
-    const ok = results.filter((r) => r.status === "match").length;
+    for (const r of inheritanceResults) {
+        if (r.status === "match") {
+            process.stderr.write(`  ok  inheritance ${r.source_id}: ${r.file}\n`);
+        }
+        else if (r.status === "mismatch") {
+            process.stderr.write(`  MISMATCH  inheritance ${r.source_id}: ${r.file}\n`);
+            hasFailure = true;
+        }
+        else if (r.status === "missing") {
+            process.stderr.write(`  MISSING   inheritance ${r.source_id}: ${r.file}\n`);
+            hasFailure = true;
+        }
+        else {
+            process.stderr.write(`  EXTRA     inheritance ${r.source_id}: ${r.file}\n`);
+            hasFailure = true;
+        }
+    }
+    for (const r of provenanceResults) {
+        if (r.status === "match") {
+            process.stderr.write(`  ok  provenance ${r.source_id}: ${r.file}\n`);
+        }
+        else if (r.status === "mismatch") {
+            process.stderr.write(`  MISMATCH  provenance ${r.source_id}: ${r.file}\n`);
+            hasFailure = true;
+        }
+        else {
+            process.stderr.write(`  MISSING   provenance ${r.source_id}: ${r.file}\n`);
+            hasFailure = true;
+        }
+    }
+    if (lock.provenance?.compiled_ir_hash && lock.compiled_ir_hash && lock.provenance.compiled_ir_hash !== lock.compiled_ir_hash) {
+        process.stderr.write("  MISMATCH  compiled_ir_hash differs between lock and provenance\n");
+        hasFailure = true;
+    }
+    const total = results.length + inheritanceResults.length + provenanceResults.length;
+    const ok = results.filter((r) => r.status === "match").length + inheritanceResults.filter((r) => r.status === "match").length + provenanceResults.filter((r) => r.status === "match").length;
     const failed = total - ok;
     if (hasFailure) {
         process.stderr.write(`\nDrift detected: ${failed}/${total} file(s) changed since last sync\n`);
         return 1;
     }
-    else {
-        process.stderr.write(`\nAll ${total} file(s) verified — no drift\n`);
-        return 0;
+    if (opts.strict) {
+        const strictProjectDir = opts.projectDir ?? dirname(dirname(resolve(opts.lockFile)));
+        const strict = await verifyStrictRuntimeEvidence(strictProjectDir, {
+            compiledIrHash: lock.compiled_ir_hash,
+            policyBundleId: lock.provenance?.policy_bundle_id,
+            policyBundleVersion: lock.provenance?.policy_bundle_version,
+        });
+        if (!strict.ok) {
+            process.stderr.write(`\nStrict runtime evidence failed: ${strict.errors.join("; ")}\n`);
+            return 1;
+        }
+        process.stderr.write(`\nStrict runtime evidence: ${strict.enterprise}/${strict.total} enterprise event(s) valid\n`);
     }
+    process.stderr.write(`\nAll ${total} file(s) verified — no drift\n`);
+    return 0;
 }
 // ── Stats Mode ────────────────────────────────────────────
 async function runStats() {

package/dist/cli/index.js

@@ -71,7 +71,7 @@ Examples:
 `;
 const COMMAND_HELP = {
     sync: `Usage: dna sync [files...] [options]\n\nOptions:\n  --mode auto|plugin|bin   Sync mode (default: auto)\n  --dry-run                Print planned outputs without writing files\n  --post-summary           Print registry-backed output summary\n  --target <target>        Markdown target for injection\n  --inject <path>          File to inject markdown into\n  --agents <dir>           Generate agent files\n  --skills <dir>           Generate skill files\n  --workflow <dir>         Generate workflow shell scripts\n  --settings <path>        Write hook settings in bin mode\n  --lock <path>            Write lock file (default .dna/lock)\n`,
-    verify: `Usage: dna verify [--lock <path>] [--stats] [--health]\n\nOptions:\n  --health                 Comprehensive installation health check\n  --stats                  Show hook call statistics\n  --lock <path>            Lock file path (default .dna/lock)\n`,
+    verify: `Usage: dna verify [--lock <path>] [--stats] [--health] [--strict]\n\nOptions:\n  --health                 Comprehensive installation health check\n  --stats                  Show hook call statistics\n  --strict                 Require valid RuntimeDecisionEvent enterprise evidence\n  --lock <path>            Lock file path (default .dna/lock)\n`,
     templates: `Usage: dna templates <list|show|deploy>\n\nSubcommands:\n  list                     List built-in and project templates\n  show <name>              Show template metadata and YAML\n  deploy                   Copy local templates to global install\n`,
     context: `Usage: dna context <index|search|doc> [query|id] [files...]\n\nSubcommands:\n  index                    List explicitly declared planning-only advisory context sources\n  search <query>           Search source metadata\n  doc <id>                 Read a local file/doc source body\n`,
     run: `Usage: dna run --dna <file> --workflow <name> --task <id> [options]\n\nOptions:\n  --dry-run                Print execution plan only\n  --permission-mode <mode> Claude permission mode (default: default)\n`,
@@ -166,6 +166,7 @@ async function main() {
                     lock: { type: "string", default: ".dna/lock" },
                     stats: { type: "boolean", default: false },
                     health: { type: "boolean", default: false },
+                    strict: { type: "boolean", default: false },
                 },
                 allowPositionals: true,
                 strict: false,
@@ -175,6 +176,7 @@ async function main() {
                 lockFile: verifyValues.lock,
                 stats: verifyValues.stats,
                 health: verifyValues.health,
+                strict: verifyValues.strict,
             });
             process.exit(code);
             break;

package/dist/compiler/activate.js

@@ -10,7 +10,9 @@
 /**
  * Apply a modifier to a gene's expression level.
  */
-function applyModifier(level, mod) {
+function applyModifier(level, mod, protectedThreshold = false) {
+    if (protectedThreshold && (mod.action === "deactivate" || mod.action === "suppress"))
+        return Math.max(level, 1.0);
     switch (mod.action) {
         case "amplify":
             return level * (mod.factor ?? 2.0);
@@ -28,7 +30,7 @@ function applyModifier(level, mod) {
  * Apply epigenetic markers to gene expression levels.
  * Markers decay over time based on their decay factor and age.
  */
-function applyEpigeneticMarkers(genes, markers) {
+function applyEpigeneticMarkers(genes, markers, protectedThresholdGenes) {
     const now = Date.now();
     for (const marker of markers) {
         // Calculate decay based on time elapsed
@@ -40,6 +42,8 @@ function applyEpigeneticMarkers(genes, markers) {
             continue; // marker too old, skip
         for (const effect of marker.effects) {
             if (effect.gene && genes[effect.gene] && effect.action && effect.factor) {
+                if (protectedThresholdGenes.has(effect.gene) && effect.action === "suppress")
+                    continue;
                 const gene = genes[effect.gene];
                 const effectiveFactor = 1 + (effect.factor - 1) * decayedStrength;
                 if (effect.action === "amplify") {
@@ -77,18 +81,19 @@ export function activateDNA(cascaded, contextName = null, activeRole = null) {
             role: gene.role,
         };
     }
+    const protectedThresholdGenes = new Set(cascaded.protected_threshold_genes ?? []);
     // Apply context modifiers if a context is active
     if (contextName && cascaded.contexts[contextName]) {
         const ctx = cascaded.contexts[contextName];
         // Apply gene modifiers
         for (const mod of ctx.modifiers ?? []) {
             if (activated[mod.gene]) {
-                activated[mod.gene].expression_level = applyModifier(activated[mod.gene].expression_level, mod);
+                activated[mod.gene].expression_level = applyModifier(activated[mod.gene].expression_level, mod, protectedThresholdGenes.has(mod.gene));
             }
         }
         // Deactivate genes
         for (const g of ctx.deactivate_genes ?? []) {
-            if (activated[g]) {
+            if (activated[g] && !protectedThresholdGenes.has(g)) {
                 activated[g].expression_level = 0;
             }
         }
@@ -125,13 +130,13 @@ export function activateDNA(cascaded, contextName = null, activeRole = null) {
         }
         // Suppress genes
         for (const geneName of role.suppresses_genes ?? []) {
-            if (activated[geneName]) {
+            if (activated[geneName] && !protectedThresholdGenes.has(geneName)) {
                 activated[geneName].expression_level *= 0.1;
             }
         }
     }
     // Apply epigenetic markers
-    applyEpigeneticMarkers(activated, cascaded.epigenetic_markers);
+    applyEpigeneticMarkers(activated, cascaded.epigenetic_markers, protectedThresholdGenes);
     return {
         genes: activated,
         active_context: contextName,

package/dist/compiler/cascade.d.ts

@@ -10,7 +10,7 @@
  *   - attract/repel: same target accumulates, different targets independent
  *   - amplify/suppress: factors multiply (1.5x × 2.0x = 3.0x)
  */
-import type { IntentDNA, Gene, ContextRegion, EpigeneticMarker, RoleDef, WorkflowDef, LegibilityAssetMap, VerifierCommandPolicy, ControllerDef, AdvisoryContextSource, PlanningContext } from "../schema/types.js";
+import type { IntentDNA, Gene, ContextRegion, EpigeneticMarker, RoleDef, WorkflowDef, LegibilityAssetMap, VerifierCommandPolicy, ControllerDef, AdvisoryContextSource, PlanningContext, CompiledProvenanceManifest } from "../schema/types.js";
 export interface CascadedDNA {
     genes: Record<string, Gene>;
     contexts: Record<string, ContextRegion>;
@@ -30,6 +30,8 @@ export interface CascadedDNA {
     context_sources?: AdvisoryContextSource[];
     planning_context?: PlanningContext;
     verifier_policy?: VerifierCommandPolicy;
+    provenance?: CompiledProvenanceManifest;
+    protected_threshold_genes?: string[];
 }
 /**
  * Cascade multiple DNA layers into a single merged DNA.