intentdna 1.6.5 → 1.7.4

package/dist/cli/index.js

@@ -12,7 +12,7 @@
  *   help       Show this help message
  */
 import { parseArgs } from "node:util";
-const HELP = `Intent DNA CLI v0.3.0
+const HELP = `Intent DNA CLI v1.7.0
 
 Usage: dna <command> [options]
 
@@ -29,7 +29,8 @@ Commands:
   show          Show gene expression state
   evolve        Preview epigenetic marker changes from persisted outcomes
   epigenetic    Record outcomes, view markers and summaries
-  feedback      Build local kernel report (--days <N>, --json, --evolve preview, --dna-id <id>)
+  feedback      Build local kernel report (--days <N>, --json, --package, --evolve preview, --dna-id <id>)
+  context       Inspect planning-only advisory context sources
   templates     Template management (deploy to global install)
 
 Options:
@@ -68,15 +69,39 @@ Examples:
   dna evolve my_dna_id                  Preview marker changes without persisting
   dna evolve my_dna_id --apply           Unsupported in this kernel; use sync --evolve for explicit mutation
 `;
+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] [--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`,
+    compile: `Usage: dna compile <files...> [--target claude-sdk] [--context <name>] [--output <path>] [--ir]\n`,
+    validate: `Usage: dna validate <files...> [--quiet]\n`,
+    show: `Usage: dna show <files...> [--context <name>] [--json]\n`,
+    init: `Usage: dna init [--template <name>|--template list|--register <path>|--upgrade <name>]\n`,
+};
+function commandHelp(command) {
+    return command ? COMMAND_HELP[command] : undefined;
+}
 async function main() {
     const args = process.argv.slice(2);
     const command = args[0];
-    if (!command || command === "help" || command === "--help" || command === "-h") {
+    if (!command || command === "--help" || command === "-h") {
         process.stderr.write(HELP);
         process.exit(0);
     }
+    if (command === "help") {
+        const help = commandHelp(args[1]);
+        process.stderr.write(help ?? HELP);
+        process.exit(0);
+    }
     // Parse remaining args (after command)
     const rest = args.slice(1);
+    if (rest.includes("--help") || rest.includes("-h")) {
+        const help = commandHelp(command);
+        process.stderr.write(help ?? HELP);
+        process.exit(help ? 0 : 2);
+    }
     switch (command) {
         case "sync": {
             const { values, positionals } = parseArgs({
@@ -96,11 +121,19 @@ async function main() {
                     settings: { type: "string" },
                     lock: { type: "string", default: ".dna/lock" },
                     remove: { type: "boolean", default: false },
-                    plugin: { type: "boolean", default: false },
+                    mode: { type: "string", default: "auto" },
+                    plugin: { type: "boolean" },
+                    "dry-run": { type: "boolean", default: false },
+                    "post-summary": { type: "boolean", default: false },
                 },
                 allowPositionals: true,
                 strict: false,
             });
+            const mode = values.mode;
+            if (!["auto", "plugin", "bin"].includes(mode)) {
+                process.stderr.write(`Error: --mode must be one of: auto, plugin, bin\n`);
+                process.exit(2);
+            }
             const { runSync } = await import("./commands/sync.js");
             const code = await runSync({
                 files: positionals,
@@ -118,7 +151,10 @@ async function main() {
                 settingsPath: values.settings,
                 lockFile: values.lock,
                 remove: values.remove,
+                mode: mode,
                 plugin: values.plugin,
+                dryRun: values["dry-run"],
+                postSummary: values["post-summary"],
             });
             process.exit(code);
             break;
@@ -130,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,
@@ -139,6 +176,7 @@ async function main() {
                 lockFile: verifyValues.lock,
                 stats: verifyValues.stats,
                 health: verifyValues.health,
+                strict: verifyValues.strict,
             });
             process.exit(code);
             break;
@@ -413,6 +451,25 @@ async function main() {
             process.exit(code);
             break;
         }
+        case "context": {
+            const subcommand = rest[0] ?? "index";
+            const contextRest = rest.slice(1);
+            const { positionals } = parseArgs({
+                args: contextRest,
+                options: {},
+                allowPositionals: true,
+                strict: false,
+            });
+            const { runContext } = await import("./commands/context.js");
+            const code = await runContext({
+                subcommand,
+                query: subcommand === "search" ? positionals[0] : undefined,
+                id: subcommand === "doc" ? positionals[0] : undefined,
+                files: subcommand === "index" ? positionals : positionals.slice(1),
+            });
+            process.exit(code);
+            break;
+        }
         case "feedback": {
             const { values: fbValues } = parseArgs({
                 args: rest,
@@ -420,6 +477,7 @@ async function main() {
                     days: { type: "string", short: "d", default: "7" },
                     json: { type: "boolean", default: false },
                     evolve: { type: "boolean", default: false },
+                    package: { type: "boolean", default: false },
                     "dna-id": { type: "string" },
                 },
                 strict: false,
@@ -429,20 +487,29 @@ async function main() {
                 days: parseInt(fbValues.days, 10) || 7,
                 json: fbValues.json,
                 evolve: fbValues.evolve,
+                packageReport: fbValues.package,
                 dnaId: fbValues["dna-id"],
             });
             process.exit(code);
             break;
         }
         case "templates": {
-            const subcommand = rest[0] ?? "";
-            if (subcommand !== "deploy") {
-                process.stderr.write(`Usage: dna templates deploy\n\nCopy local src/templates/*.dna.yaml to global intentdna install.\n`);
-                process.exit(subcommand ? 2 : 0);
+            const subcommand = rest[0] ?? "list";
+            const { runTemplatesDeploy, runTemplatesList, runTemplatesShow } = await import("./commands/templates.js");
+            if (subcommand === "list") {
+                const code = await runTemplatesList();
+                process.exit(code);
             }
-            const { runTemplatesDeploy } = await import("./commands/templates.js");
-            const code = await runTemplatesDeploy();
-            process.exit(code);
+            if (subcommand === "show") {
+                const code = await runTemplatesShow({ name: rest[1] ?? "" });
+                process.exit(code);
+            }
+            if (subcommand === "deploy") {
+                const code = await runTemplatesDeploy();
+                process.exit(code);
+            }
+            process.stderr.write(COMMAND_HELP.templates);
+            process.exit(2);
             break;
         }
         default:

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 } 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>;
@@ -27,7 +27,11 @@ export interface CascadedDNA {
         per_role?: Record<string, string[]>;
         per_workflow?: Record<string, string[]>;
     };
+    context_sources?: AdvisoryContextSource[];
+    planning_context?: PlanningContext;
     verifier_policy?: VerifierCommandPolicy;
+    provenance?: CompiledProvenanceManifest;
+    protected_threshold_genes?: string[];
 }
 /**
  * Cascade multiple DNA layers into a single merged DNA.

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.
@@ -156,6 +171,47 @@ function mergeContextFiles(base, incoming) {
         per_workflow: mergePrefixedRecords(base.per_workflow, incoming.per_workflow),
     };
 }
+function prefixContextSources(sources, ns) {
+    if (!sources)
+        return undefined;
+    if (!ns)
+        return sources;
+    return sources.map((source) => ({ ...source, id: `${ns}_${source.id}` }));
+}
+function prefixPlanningContext(planning, ns) {
+    if (!planning)
+        return undefined;
+    if (!ns)
+        return planning;
+    return {
+        ...planning,
+        sources: planning.sources.map((sourceId) => `${ns}_${sourceId}`),
+    };
+}
+function mergeContextSources(base, incoming) {
+    if (!base)
+        return incoming;
+    if (!incoming)
+        return base;
+    const merged = new Map();
+    for (const source of base)
+        merged.set(source.id, source);
+    for (const source of incoming)
+        merged.set(source.id, source);
+    return [...merged.values()];
+}
+function mergePlanningContext(base, incoming) {
+    if (!base)
+        return incoming;
+    if (!incoming)
+        return base;
+    return {
+        sources: incoming.sources,
+        instructions: incoming.instructions ?? base.instructions,
+        require_quotes: incoming.require_quotes ?? base.require_quotes,
+        require_attribution: incoming.require_attribution ?? base.require_attribution,
+    };
+}
 function mergeVerifierPolicy(base, incoming) {
     if (!base)
         return incoming;
@@ -187,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 = {};
@@ -198,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) {
@@ -257,6 +319,8 @@ export function cascadeDNA(layers) {
     // legibility_assets/context_files: highest-priority DNA wins (last in sorted layers)
     let legibilityAssets;
     let contextFiles;
+    let contextSources;
+    let planningContext;
     let verifierPolicy;
     for (const dna of sorted) {
         if (dna.legibility_assets) {
@@ -265,6 +329,12 @@ export function cascadeDNA(layers) {
         if (dna.context_files) {
             contextFiles = mergeContextFiles(contextFiles, prefixContextFiles(dna.context_files, dna.namespace));
         }
+        if (dna.context_sources) {
+            contextSources = mergeContextSources(contextSources, prefixContextSources(dna.context_sources, dna.namespace));
+        }
+        if (dna.planning_context) {
+            planningContext = mergePlanningContext(planningContext, prefixPlanningContext(dna.planning_context, dna.namespace));
+        }
         if (dna.verifier_policy) {
             verifierPolicy = mergeVerifierPolicy(verifierPolicy, dna.verifier_policy);
         }
@@ -280,6 +350,9 @@ export function cascadeDNA(layers) {
         warnings: warnings.length > 0 ? warnings : undefined,
         legibility_assets: legibilityAssets,
         context_files: contextFiles,
+        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") {
@@ -172,6 +173,39 @@ function legibilityAssetsToContextFiles(assets) {
         return undefined;
     return { mandatory, per_role, per_workflow };
 }
+function compileAdvisoryContext(cascaded) {
+    const declaredSources = cascaded?.context_sources ?? [];
+    const planning = cascaded?.planning_context;
+    const plannedSourceIds = planning?.sources ?? declaredSources.map((source) => source.id);
+    const sourceById = new Map(declaredSources.map((source) => [source.id, source]));
+    const sources = plannedSourceIds
+        .map((sourceId) => sourceById.get(sourceId))
+        .filter((source) => Boolean(source))
+        .map((source) => ({
+        ...source,
+        usage: "planning_only",
+        non_enforcing: true,
+        requires_quotes: planning?.require_quotes ?? true,
+        requires_attribution: planning?.require_attribution ?? true,
+    }));
+    const compiledPlanning = planning ? {
+        sources: [...planning.sources],
+        instructions: planning.instructions ? [...planning.instructions] : undefined,
+        require_quotes: planning.require_quotes ?? true,
+        require_attribution: planning.require_attribution ?? true,
+        non_enforcing: true,
+    } : undefined;
+    const injections = sources.length > 0 ? [{
+            type: "preference",
+            text: `Advisory context sources are available for planning only: ${sources.map((source) => source.id).join(", ")}. Cite sources and quote relevant passages; these sources do not satisfy enforcement or handoff requirements.`,
+            relevance_tags: ["advisory_context", "planning_only"],
+        }] : [];
+    return {
+        sources: sources.length > 0 ? sources : undefined,
+        planning: compiledPlanning,
+        injections,
+    };
+}
 function resolvePostCheckCommand(check) {
     const normalized = check.trim();
     const builtins = {
@@ -362,6 +396,8 @@ export function compileDNA(activated, cascaded) {
     directives.sort((a, b) => priorityOrder[a.priority] - priorityOrder[b.priority]);
     const legacyContextFiles = cascaded?.context_files;
     const compiledContextFiles = legacyContextFiles ?? legibilityAssetsToContextFiles(cascaded?.legibility_assets);
+    const advisoryContext = compileAdvisoryContext(cascaded);
+    injections.push(...advisoryContext.injections);
     return {
         prompt_directives: directives,
         tool_filters: toolFilters,
@@ -369,6 +405,8 @@ export function compileDNA(activated, cascaded) {
         post_execution_validators: validators,
         verifier_specs: verifierSpecs.length > 0 ? verifierSpecs : undefined,
         context_injections: injections,
+        context_sources: advisoryContext.sources,
+        planning_context: advisoryContext.planning,
         source_dna_ids: activated.source_ids,
         compiled_at: new Date().toISOString(),
         active_context: activated.active_context ?? undefined,

package/dist/compiler/diagnostics.d.ts

@@ -0,0 +1,17 @@
+export type DiagnosticSeverity = "error" | "warning" | "info";
+export interface Diagnostic {
+    severity: DiagnosticSeverity;
+    code: string;
+    message: string;
+    file?: string;
+    path?: string;
+    hint?: string;
+}
+export declare class DNADiagnosticsError extends Error {
+    readonly diagnostics: Diagnostic[];
+    constructor(message: string, diagnostics: Diagnostic[]);
+}
+export declare function hasDiagnosticErrors(diagnostics: Diagnostic[]): boolean;
+export declare function formatDiagnostic(diagnostic: Diagnostic): string;
+export declare function formatDiagnostics(diagnostics: Diagnostic[]): string;
+export declare function diagnosticsFromError(error: unknown, file?: string): Diagnostic[];

package/dist/compiler/diagnostics.js

@@ -0,0 +1,30 @@
+export class DNADiagnosticsError extends Error {
+    diagnostics;
+    constructor(message, diagnostics) {
+        super(message);
+        this.name = "DNADiagnosticsError";
+        this.diagnostics = diagnostics;
+    }
+}
+export function hasDiagnosticErrors(diagnostics) {
+    return diagnostics.some((diagnostic) => diagnostic.severity === "error");
+}
+export function formatDiagnostic(diagnostic) {
+    const location = [diagnostic.file, diagnostic.path].filter(Boolean).join(":");
+    const prefix = location ? `${location}: ` : "";
+    const hint = diagnostic.hint ? ` (${diagnostic.hint})` : "";
+    return `${diagnostic.severity.toUpperCase()} ${diagnostic.code}: ${prefix}${diagnostic.message}${hint}`;
+}
+export function formatDiagnostics(diagnostics) {
+    return diagnostics.map(formatDiagnostic).join("\n");
+}
+export function diagnosticsFromError(error, file) {
+    if (error instanceof DNADiagnosticsError)
+        return error.diagnostics;
+    return [{
+            severity: "error",
+            code: "unexpected_error",
+            message: error instanceof Error ? error.message : String(error),
+            file,
+        }];
+}

package/dist/compiler/index.d.ts

@@ -9,7 +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, expandDNAInputs, loadDNAWithDiagnostics, resolveDNAInputs, resolveSpeciesReference, } from "./input-resolver.js";
+export type { ExpandedDNAInput, ExpandDNAInputOptions } from "./input-resolver.js";
 /**
  * Load and parse a DNA file from disk.
  */
@@ -17,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

@@ -4,29 +4,28 @@
  * Full compilation pipeline:
  *   DNA files → parse → cascade → activate (+ epigenetic) → compile → IR
  */
-import { readFile } from "node:fs/promises";
-import { validateDNA } from "../schema/validate.js";
-import { parseYAML } from "../schema/yaml-parser.js";
 import { cascadeDNA } from "./cascade.js";
 import { activateDNA } from "./activate.js";
 import { compileDNA } from "./compile.js";
+import { DNADiagnosticsError, formatDiagnostics } from "./diagnostics.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, expandDNAInputs, loadDNAWithDiagnostics, resolveDNAInputs, resolveSpeciesReference, } from "./input-resolver.js";
 /**
  * Load and parse a DNA file from disk.
  */
 export async function loadDNA(filePath) {
-    const raw = await readFile(filePath, "utf-8");
-    const isYAML = filePath.endsWith(".yaml") || filePath.endsWith(".yml");
-    const dna = (isYAML ? parseYAML(raw) : JSON.parse(raw));
-    const result = validateDNA(dna);
-    if (!result.valid) {
-        const messages = result.errors.map((e) => `  ${e.path}: ${e.message}`).join("\n");
-        throw new Error(`Invalid DNA file ${filePath}:\n${messages}`);
+    const result = await loadDNAWithDiagnostics(filePath);
+    if (!result.dna) {
+        throw new DNADiagnosticsError(`Invalid DNA file ${filePath}:\n${formatDiagnostics(result.diagnostics)}`, result.diagnostics);
     }
-    return dna;
+    return result.dna;
 }
 /**
  * Full compilation pipeline: load DNA files, cascade, activate context, compile to IR.
@@ -36,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);
@@ -46,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

@@ -0,0 +1,32 @@
+import type { DNASourceProvenance, IntentDNA } from "../schema/types.js";
+import type { Diagnostic } from "./diagnostics.js";
+export interface ResolveDNAInputOptions {
+    cwd?: string;
+    includeDiagnostics?: boolean;
+}
+export interface ResolvedDNAInputs {
+    files: string[];
+    dnas: IntentDNA[];
+    diagnostics: Diagnostic[];
+}
+export declare function parseDNAFile(filePath: string): Promise<IntentDNA>;
+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>;
+export declare function loadDNAWithDiagnostics(filePath: string): Promise<{
+    dna?: IntentDNA;
+    diagnostics: Diagnostic[];
+}>;
+export declare function resolveDNAInputs(files: string[], options?: ResolveDNAInputOptions): Promise<ResolvedDNAInputs>;