intentdna 1.6.5 → 1.7.4

package/dist/mcp/tools-state.d.ts

@@ -5,7 +5,7 @@
  *   - dna_status: Overview of DNA state
  *   - dna_workflow_read: Read current workflow state
  *   - dna_workflow_write: Update workflow state
- *   - dna_trace_query: Query trace data with filters
+ *   - dna_trace_query: Query legacy diagnostic trace data with filters
  */
 import type { ToolDef } from "./server.js";
 export declare function createStateTools(projectDir: string): ToolDef[];

package/dist/mcp/tools-state.js

@@ -5,10 +5,11 @@
  *   - dna_status: Overview of DNA state
  *   - dna_workflow_read: Read current workflow state
  *   - dna_workflow_write: Update workflow state
- *   - dna_trace_query: Query trace data with filters
+ *   - dna_trace_query: Query legacy diagnostic trace data with filters
  */
 import { resolve } from "node:path";
-import { readWorkflowState, writeWorkflowState, readTraces, listSessions } from "../hooks/state.js";
+import { readWorkflowState, writeWorkflowState, readRuntimeDecisionEvents, readTraces, listSessions } from "../hooks/state.js";
+import { validateRuntimeDecisionEvent } from "../governance/index.js";
 import { loadCompiledIR } from "../runtime/plugin-adapter.js";
 import { textResult } from "./server.js";
 function isStringRecord(value) {
@@ -20,7 +21,7 @@ export function createStateTools(projectDir) {
         // ── dna_status ────────────────────────────────────────
         {
             name: "dna_status",
-            description: "Overview of DNA governance state: compiled IR info, active workflow, session list, and recent enforcement stats",
+            description: "Overview of DNA governance state: compiled IR info, active workflow, sessions, RuntimeDecisionEvent evidence, and legacy diagnostic trace stats",
             inputSchema: { type: "object", properties: {} },
             handler: async () => {
                 const lines = [];
@@ -58,12 +59,21 @@ export function createStateTools(projectDir) {
                     const preview = sessions.slice(0, 5).join(", ");
                     lines.push(`\nSessions: ${sessions.length} (${preview}${sessions.length > 5 ? "..." : ""})`);
                 }
+                // Recent RuntimeDecisionEvent stats
+                const runtimeDecisions = await readRuntimeDecisionEvents(projectDir, 1);
+                if (runtimeDecisions.length > 0) {
+                    const enterprise = runtimeDecisions.filter(e => validateRuntimeDecisionEvent(e).classification === "enterprise_evidence");
+                    const blocks = enterprise.filter(e => e.decision === "block").length;
+                    const warns = enterprise.filter(e => e.decision === "warn").length;
+                    const escalates = enterprise.filter(e => e.decision === "escalate").length;
+                    lines.push(`\nRuntimeDecisionEvent (24h): ${runtimeDecisions.length} events, ${enterprise.length} enterprise evidence, ${blocks} blocks, ${warns} warns, ${escalates} escalates`);
+                }
                 // Recent trace stats
                 const traces = await readTraces(projectDir, 1);
                 if (traces.length > 0) {
                     const blocks = traces.filter(t => t.decision === "block").length;
                     const warns = traces.filter(t => t.decision === "warn").length;
-                    lines.push(`\nTrace (24h): ${traces.length} events, ${blocks} blocks, ${warns} warns`);
+                    lines.push(`\nLegacy trace diagnostics (24h): ${traces.length} events, ${blocks} blocks, ${warns} warns`);
                 }
                 return textResult(lines.join("\n"));
             },
@@ -71,7 +81,7 @@ export function createStateTools(projectDir) {
         // ── dna_workflow_read ─────────────────────────────────
         {
             name: "dna_workflow_read",
-            description: "Read current workflow state (step, role, iteration, artifacts)",
+            description: "Read current workflow runtime state (diagnostic/cache only; not enterprise evidence)",
             inputSchema: {
                 type: "object",
                 properties: {
@@ -126,7 +136,7 @@ export function createStateTools(projectDir) {
         // ── dna_trace_query ──────────────────────────────────
         {
             name: "dna_trace_query",
-            description: "Query enforcement trace data with filters (blocks, warns, by tool, by path)",
+            description: "Query legacy diagnostic enforcement trace data with filters. Trace records are not enterprise evidence unless referenced by RuntimeDecisionEvent.",
             inputSchema: {
                 type: "object",
                 properties: {
@@ -150,7 +160,7 @@ export function createStateTools(projectDir) {
                     traces = traces.filter(t => t.tool_name === toolName);
                 const total = traces.length;
                 traces = traces.slice(-limit);
-                const lines = [`Trace: ${total} matching entries (showing last ${traces.length})`];
+                const lines = [`Legacy diagnostic trace: ${total} matching entries (showing last ${traces.length}); not enterprise evidence unless referenced by RuntimeDecisionEvent`];
                 for (const t of traces) {
                     const parts = [t.timestamp.slice(11, 19), t.event, t.decision];
                     if (t.tool_name)

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

@@ -18,6 +18,9 @@ export interface KernelReport {
         period_days: number;
     };
     summary: {
+        runtime_decisions: number;
+        enterprise_evidence: number;
+        legacy_diagnostics: number;
         traces: number;
         verifier_results: number;
         signals: number;
@@ -32,9 +35,33 @@ export interface KernelReport {
         blocks: number;
         warns: number;
         allows: number;
+        escalates: number;
+        validates: number;
         policy_denied_verifiers: number;
     };
     signals: ClassifiedSignal[];
+    runtime_decision_summary: {
+        total: number;
+        enterprise_evidence: number;
+        diagnostics: number;
+        blocks: number;
+        warns: number;
+        allows: number;
+        escalates: number;
+        validates: number;
+        top_policy_bundles: Array<{
+            policy_bundle_id: string;
+            count: number;
+        }>;
+        top_constraints: Array<{
+            constraint_id: string;
+            count: number;
+        }>;
+        top_decision_reasons: Array<{
+            reason: string;
+            count: number;
+        }>;
+    };
     verifier_summary: {
         total: number;
         passes: number;

package/dist/report/kernel-report.js

@@ -1,6 +1,7 @@
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
-import { readTraces, readVerifierResults, safePathComponent } from "../hooks/state.js";
+import { readRuntimeDecisionEvents, readTraces, readVerifierResults, safePathComponent } from "../hooks/state.js";
+import { validateRuntimeDecisionEvent } from "../governance/index.js";
 import { describeMarkerChanges } from "../evolution/marker-gen.js";
 import { classifiedSignalsToOutcomes, classifyKernelSignals, } from "./kernel-signals.js";
 const CLASSIFICATIONS = [
@@ -50,6 +51,30 @@ function buildVerifierSummary(results) {
         failures: results.filter((result) => result.status === "fail").length,
     };
 }
+function buildRuntimeDecisionSummary(events) {
+    const enterpriseEvidence = events.filter((event) => validateRuntimeDecisionEvent(event).classification === "enterprise_evidence");
+    const blocks = enterpriseEvidence.filter((event) => event.decision === "block");
+    const warns = enterpriseEvidence.filter((event) => event.decision === "warn").length;
+    const allows = enterpriseEvidence.filter((event) => event.decision === "allow").length;
+    const escalates = enterpriseEvidence.filter((event) => event.decision === "escalate").length;
+    const validates = enterpriseEvidence.filter((event) => event.decision === "validate").length;
+    const reasons = blocks
+        .map((event) => event.decision_reason.split("\n")[0].replace(/^\[Intent DNA\]\s*/, "").slice(0, 100))
+        .filter((reason) => Boolean(reason));
+    return {
+        total: events.length,
+        enterprise_evidence: enterpriseEvidence.length,
+        diagnostics: events.length - enterpriseEvidence.length,
+        blocks: blocks.length,
+        warns,
+        allows,
+        escalates,
+        validates,
+        top_policy_bundles: sortedCounts(enterpriseEvidence.map((event) => event.policy_bundle_id), 5, "policy_bundle_id"),
+        top_constraints: sortedCounts(enterpriseEvidence.map((event) => event.winning_constraint.constraint_id), 5, "constraint_id"),
+        top_decision_reasons: sortedCounts(reasons, 5, "reason"),
+    };
+}
 async function readCompiledSourceIds(projectDir) {
     try {
         const raw = await readFile(join(projectDir, ".dna", "compiled", "ir.json"), "utf-8");
@@ -136,13 +161,15 @@ async function buildMarkerPreview(projectDir, explicitDnaId, signals) {
 }
 export async function buildKernelReport(options) {
     const days = options.days ?? 7;
+    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));
-    const signals = classifyKernelSignals({ traces, verifierResults });
+    const signals = classifyKernelSignals({ runtimeDecisions, traces, verifierResults });
     const classifications = Object.fromEntries(CLASSIFICATIONS.map((classification) => [classification, 0]));
     for (const signal of signals)
         classifications[signal.classification]++;
+    const runtimeDecisionSummary = buildRuntimeDecisionSummary(runtimeDecisions);
     const traceSummary = buildTraceSummary(traces);
     const verifierSummary = buildVerifierSummary(verifierResults);
     const markerPreview = options.includeMarkerPreview
@@ -159,6 +186,9 @@ export async function buildKernelReport(options) {
             period_days: days,
         },
         summary: {
+            runtime_decisions: runtimeDecisions.length,
+            enterprise_evidence: runtimeDecisionSummary.enterprise_evidence,
+            legacy_diagnostics: traces.length + verifierResults.length + runtimeDecisionSummary.diagnostics,
             traces: traces.length,
             verifier_results: verifierResults.length,
             signals: signals.length,
@@ -166,16 +196,19 @@ export async function buildKernelReport(options) {
         },
         classifications,
         quality: {
-            quality_positive: signals.filter((signal) => signal.semantic === "quality-positive").length,
-            quality_negative: signals.filter((signal) => signal.semantic === "quality-negative").length,
+            quality_positive: 0,
+            quality_negative: 0,
         },
         enforcement: {
-            blocks: signals.filter((signal) => signal.semantic === "enforcement-block").length,
-            warns: signals.filter((signal) => signal.semantic === "enforcement-warn").length,
-            allows: signals.filter((signal) => signal.semantic === "enforcement-allow").length,
-            policy_denied_verifiers: signals.filter((signal) => signal.semantic === "policy-denied-verifier").length,
+            blocks: runtimeDecisionSummary.blocks,
+            warns: runtimeDecisionSummary.warns,
+            allows: runtimeDecisionSummary.allows,
+            escalates: runtimeDecisionSummary.escalates,
+            validates: runtimeDecisionSummary.validates,
+            policy_denied_verifiers: 0,
         },
         signals,
+        runtime_decision_summary: runtimeDecisionSummary,
         verifier_summary: verifierSummary,
         trace_summary: traceSummary,
         marker_preview: markerPreview,
@@ -194,15 +227,23 @@ export function formatKernelReport(report) {
     lines.push("=".repeat(50));
     lines.push("");
     lines.push(`Schema: ${report.schema_version}`);
-    lines.push(`Total events: ${report.trace_summary.total}`);
-    lines.push(`  Allowed: ${report.trace_summary.allows}`);
-    lines.push(`  Blocked: ${report.trace_summary.blocks}`);
-    lines.push(`  Warned:  ${report.trace_summary.warns}`);
+    lines.push(`RuntimeDecisionEvents: ${report.runtime_decision_summary.total}`);
+    lines.push(`  Enterprise evidence: ${report.runtime_decision_summary.enterprise_evidence}`);
+    lines.push(`  Diagnostic-only events: ${report.runtime_decision_summary.diagnostics}`);
+    lines.push(`  Allowed: ${report.runtime_decision_summary.allows}`);
+    lines.push(`  Blocked: ${report.runtime_decision_summary.blocks}`);
+    lines.push(`  Warned:  ${report.runtime_decision_summary.warns}`);
+    lines.push(`  Escalated: ${report.runtime_decision_summary.escalates}`);
+    lines.push(`  Validated: ${report.runtime_decision_summary.validates}`);
     lines.push("");
-    if (report.verifier_summary.total > 0) {
-        lines.push(`Verifier results: ${report.verifier_summary.total}`);
-        lines.push(`  Passed: ${report.verifier_summary.passes}`);
-        lines.push(`  Failed: ${report.verifier_summary.failures}`);
+    if (report.trace_summary.total > 0 || report.verifier_summary.total > 0) {
+        lines.push("Legacy diagnostics (not enterprise evidence without RuntimeDecisionEvent provenance):");
+        lines.push(`  Traces: ${report.trace_summary.total}`);
+        lines.push(`  Verifier results: ${report.verifier_summary.total}`);
+        if (report.verifier_summary.total > 0) {
+            lines.push(`    Passed: ${report.verifier_summary.passes}`);
+            lines.push(`    Failed: ${report.verifier_summary.failures}`);
+        }
         lines.push("");
     }
     lines.push(`Classified signals: ${report.summary.signals}`);
@@ -214,19 +255,19 @@ export function formatKernelReport(report) {
     lines.push(`  Unknown: ${report.classifications.unknown}`);
     lines.push("");
     if (report.trace_summary.top_blocked_tools.length > 0) {
-        lines.push("Top blocked tools:");
+        lines.push("Legacy diagnostic top blocked tools:");
         for (const item of report.trace_summary.top_blocked_tools)
             lines.push(`  ${item.tool}: ${item.count}`);
         lines.push("");
     }
     if (report.trace_summary.top_blocked_paths.length > 0) {
-        lines.push("Top blocked paths:");
+        lines.push("Legacy diagnostic top blocked paths:");
         for (const item of report.trace_summary.top_blocked_paths)
             lines.push(`  ${item.path}: ${item.count}`);
         lines.push("");
     }
     if (report.trace_summary.top_block_reasons.length > 0) {
-        lines.push("Top block reasons:");
+        lines.push("Legacy diagnostic top block reasons:");
         for (const item of report.trace_summary.top_block_reasons)
             lines.push(`  \"${item.reason}\": ${item.count}`);
         lines.push("");

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

@@ -1,11 +1,12 @@
 import type { TraceEntry, VerifierResultEntry } from "../hooks/state.js";
 import type { ExecutionOutcome } from "../evolution/types.js";
+import { type RuntimeDecisionEvent } from "../governance/index.js";
 export type KernelSignalClassification = "protective" | "friction" | "positive" | "negative" | "neutral" | "unknown";
 export type KernelEvolutionEffect = "helped" | "hindered" | "neutral";
-export type KernelSignalSemantic = "quality-positive" | "quality-negative" | "enforcement-block" | "enforcement-warn" | "enforcement-allow" | "policy-denied-verifier" | "external";
+export type KernelSignalSemantic = "quality-positive" | "quality-negative" | "enforcement-block" | "enforcement-warn" | "enforcement-allow" | "enforcement-escalate" | "enforcement-validate" | "policy-denied-verifier" | "external";
 export interface ClassifiedSignal {
     id: string;
-    source_type: "trace" | "verifier" | "external";
+    source_type: "runtime_decision" | "trace" | "verifier" | "external";
     source_ref: string;
     timestamp: string;
     gene?: string;
@@ -22,11 +23,13 @@ export interface KernelSignalContext {
     friction_verifier_ids?: string[];
 }
 export interface ClassifyKernelSignalsInput {
+    runtimeDecisions?: RuntimeDecisionEvent[];
     traces?: TraceEntry[];
     verifierResults?: VerifierResultEntry[];
     context?: KernelSignalContext;
 }
 export declare function classifyVerifierResult(result: VerifierResultEntry, context?: KernelSignalContext): ClassifiedSignal[];
+export declare function classifyRuntimeDecisionEvent(event: RuntimeDecisionEvent): ClassifiedSignal;
 export declare function classifyTraceEntry(trace: TraceEntry, context?: KernelSignalContext): ClassifiedSignal;
 export declare function classifyKernelSignals(input: ClassifyKernelSignalsInput): ClassifiedSignal[];
 export declare function classifiedSignalsToOutcomes(signals: ClassifiedSignal[], dnaId: string): {

package/dist/report/kernel-signals.js

@@ -1,3 +1,4 @@
+import { validateRuntimeDecisionEvent } from "../governance/index.js";
 function extractGeneFromReason(reason) {
     if (!reason)
         return undefined;
@@ -11,6 +12,8 @@ function extractGeneFromReason(reason) {
     return sourceMatch?.[1];
 }
 function verifierSourceRef(result) {
+    if (result.result_id)
+        return `verifier:${result.result_id}`;
     return [
         "verifier",
         result.workflow ?? "unknown-workflow",
@@ -21,6 +24,7 @@ function verifierSourceRef(result) {
 }
 function verifierEvidencePayload(result) {
     const payload = {
+        result_id: result.result_id,
         verifier_id: result.verifier_id,
         when: result.when,
         severity: result.severity,
@@ -58,6 +62,55 @@ function traceEvidencePayload(trace) {
     }
     return Object.keys(payload).length > 0 ? payload : undefined;
 }
+function runtimeDecisionEvidencePayload(event) {
+    return {
+        event_id: event.event_id,
+        decision: event.decision,
+        decision_reason: event.decision_reason,
+        policy_bundle_id: event.policy_bundle_id,
+        policy_bundle_version: event.policy_bundle_version,
+        compiled_ir_hash: event.compiled_ir_hash,
+        winning_constraint: event.winning_constraint,
+        evidence_refs: event.evidence_refs,
+        classification: validateRuntimeDecisionEvent(event).classification,
+    };
+}
+function semanticForRuntimeDecision(event) {
+    if (event.decision === "block")
+        return "enforcement-block";
+    if (event.decision === "warn")
+        return "enforcement-warn";
+    if (event.decision === "escalate")
+        return "enforcement-escalate";
+    if (event.decision === "validate")
+        return "enforcement-validate";
+    return "enforcement-allow";
+}
+function classificationForRuntimeDecision(event) {
+    const validation = validateRuntimeDecisionEvent(event);
+    if (validation.classification !== "enterprise_evidence") {
+        return {
+            classification: "unknown",
+            classification_reason: "RuntimeDecisionEvent is diagnostic-only because enterprise provenance is incomplete",
+            evolution_effect: "neutral",
+            eligible_for_marker_preview: false,
+        };
+    }
+    if (event.decision === "block") {
+        return {
+            classification: "protective",
+            classification_reason: "enterprise RuntimeDecisionEvent block is protective evidence",
+            evolution_effect: "neutral",
+            eligible_for_marker_preview: false,
+        };
+    }
+    return {
+        classification: "neutral",
+        classification_reason: "enterprise RuntimeDecisionEvent is primary evidence but not marker-preview feedback by default",
+        evolution_effect: "neutral",
+        eligible_for_marker_preview: false,
+    };
+}
 function isPolicyDeniedVerifier(result) {
     return result.evidence === "policy_denied" || result.exit_code === 126;
 }
@@ -118,6 +171,21 @@ export function classifyVerifierResult(result, context = {}) {
         };
     });
 }
+export function classifyRuntimeDecisionEvent(event) {
+    const sourceRef = `runtime_decision:${event.event_id}`;
+    const gene = event.winning_constraint.gene_id === "unknown" ? undefined : event.winning_constraint.gene_id;
+    return {
+        id: sourceRef,
+        source_type: "runtime_decision",
+        source_ref: sourceRef,
+        timestamp: event.timestamp,
+        gene,
+        semantic: semanticForRuntimeDecision(event),
+        ...classificationForRuntimeDecision(event),
+        evidence_ref: sourceRef,
+        evidence_payload: runtimeDecisionEvidencePayload(event),
+    };
+}
 export function classifyTraceEntry(trace, context = {}) {
     const gene = extractGeneFromReason(trace.reason);
     const sourceRef = `trace:${trace.trace_id}`;
@@ -172,11 +240,28 @@ export function classifyTraceEntry(trace, context = {}) {
     };
 }
 export function classifyKernelSignals(input) {
+    const runtimeDecisions = input.runtimeDecisions ?? [];
     const traces = input.traces ?? [];
     const verifierResults = input.verifierResults ?? [];
     return [
-        ...traces.map((trace) => classifyTraceEntry(trace, input.context)),
-        ...verifierResults.flatMap((result) => classifyVerifierResult(result, input.context)),
+        ...runtimeDecisions.map((event) => classifyRuntimeDecisionEvent(event)),
+        ...traces.map((trace) => {
+            const signal = classifyTraceEntry(trace, input.context);
+            return {
+                ...signal,
+                classification: "unknown",
+                classification_reason: `legacy diagnostic trace only: ${signal.classification_reason}`,
+                evolution_effect: "neutral",
+                eligible_for_marker_preview: false,
+            };
+        }),
+        ...verifierResults.flatMap((result) => classifyVerifierResult(result, input.context).map((signal) => ({
+            ...signal,
+            classification: "unknown",
+            classification_reason: `legacy diagnostic verifier only: ${signal.classification_reason}`,
+            evolution_effect: "neutral",
+            eligible_for_marker_preview: false,
+        }))),
     ].sort((a, b) => a.timestamp.localeCompare(b.timestamp));
 }
 export function classifiedSignalsToOutcomes(signals, dnaId) {

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

@@ -0,0 +1,64 @@
+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;
+} | {
+    type: "artifact";
+    artifact_id: string;
+    path?: string;
+};
+export interface CriticalDecision {
+    decision_id: string;
+    kind: "block" | "warn" | "escalate" | "verifier_failure" | "handoff_gate";
+    summary: string;
+    refs: EvidenceRef[];
+}
+export interface ReportPackage {
+    schema_version: "intentdna.report_package.v1";
+    generated_at: string;
+    source: KernelReport["source"];
+    kernel_report: KernelReport;
+    runtime_decisions: RuntimeDecisionEvent[];
+    traces: TraceEntry[];
+    verifier_results: VerifierResultEntry[];
+    handoffs: {
+        workflow_state?: DNAWorkflowState;
+        completed_artifacts: CompletedArtifactEntry[];
+        artifact_refs: Array<{
+            artifact_id: string;
+            path: string;
+            metadata?: Record<string, unknown>;
+        }>;
+    };
+    diagnostics: Array<{
+        severity: "error" | "warning" | "info";
+        message: string;
+        code?: string;
+    }>;
+    deferrals: Array<{
+        id: string;
+        reason: string;
+        refs: EvidenceRef[];
+    }>;
+    critical_decisions: CriticalDecision[];
+    mutation: {
+        command_class: "read-only" | "preview-only";
+        wrote_state: false;
+        wrote_evolution: false;
+        persisted_outcomes: false;
+        mutated_markers: false;
+    };
+}
+export declare function buildReportPackage(options: KernelReportOptions): Promise<ReportPackage>;

package/dist/report/report-package.js

@@ -0,0 +1,90 @@
+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);
+    if (Number.isNaN(parsed))
+        return true;
+    return parsed >= Date.now() - days * 24 * 60 * 60 * 1000;
+}
+function artifactRefs(completed) {
+    const refs = [];
+    for (const entry of completed) {
+        for (const artifact of entry.artifacts) {
+            refs.push({
+                artifact_id: artifact.artifact_id ?? `${entry.step_id}:${artifact.type}:${artifact.path}`,
+                path: artifact.path,
+                metadata: artifact.metadata,
+            });
+        }
+    }
+    return refs;
+}
+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 event of runtimeDecisions) {
+        if (validateRuntimeDecisionEvent(event).classification !== "enterprise_evidence")
+            continue;
+        if (event.decision !== "block" && event.decision !== "warn" && event.decision !== "escalate")
+            continue;
+        decisions.push({
+            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;
+}
+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));
+    const workflowState = await readWorkflowState(options.projectDir, options.sessionId, 0) ?? undefined;
+    const completedArtifacts = workflowState?.completed_artifacts ?? [];
+    return {
+        schema_version: "intentdna.report_package.v1",
+        generated_at: new Date().toISOString(),
+        source: kernelReport.source,
+        kernel_report: kernelReport,
+        runtime_decisions: runtimeDecisions,
+        traces,
+        verifier_results: verifierResults,
+        handoffs: {
+            workflow_state: workflowState,
+            completed_artifacts: completedArtifacts,
+            artifact_refs: artifactRefs(completedArtifacts),
+        },
+        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(runtimeDecisions),
+        mutation: {
+            command_class: options.includeMarkerPreview ? "preview-only" : "read-only",
+            wrote_state: false,
+            wrote_evolution: false,
+            persisted_outcomes: false,
+            mutated_markers: false,
+        },
+    };
+}

package/dist/runtime/agent-md.d.ts

@@ -31,6 +31,7 @@ export interface AgentMDResult {
  * Convert camelCase or snake_case to kebab-case.
  */
 export declare function toKebabCase(name: string): string;
+export declare function assertSafeGeneratedName(name: string, label?: string): void;
 /**
  * Compile a single RoleDef into an agent MD file.
  * Pure function, no side effects.

package/dist/runtime/agent-md.js

@@ -9,8 +9,9 @@
  * Output directory: .claude/agents/<name>.md
  */
 import { mkdir, writeFile, readFile, readdir, rm } from "node:fs/promises";
-import { join } from "node:path";
+import { join, resolve, sep } from "node:path";
 const SENTINEL_COMMENT = "<!-- intentdna:managed — do not edit manually -->";
+const SAFE_GENERATED_NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 // ── Helpers ────────────────────────────────────────────────
 /**
  * Convert camelCase or snake_case to kebab-case.
@@ -23,12 +24,26 @@ export function toKebabCase(name) {
         .replace(/[_\s]+/g, "-")
         .toLowerCase();
 }
+export function assertSafeGeneratedName(name, label = "generated name") {
+    if (!SAFE_GENERATED_NAME.test(name)) {
+        throw new Error(`${label} '${name}' must contain only lowercase letters, digits, and single hyphens`);
+    }
+}
+function resolveContainedPath(baseDir, ...segments) {
+    const base = resolve(baseDir);
+    const target = resolve(baseDir, ...segments);
+    if (target !== base && !target.startsWith(`${base}${sep}`)) {
+        throw new Error(`generated path escapes output directory: ${target}`);
+    }
+    return target;
+}
 /**
  * Render YAML frontmatter string (without --- delimiters).
  */
 function renderFrontmatter(name, role, options) {
     const prefix = options?.namePrefix ?? "dna-";
     const fullName = `${prefix}${toKebabCase(name)}`;
+    assertSafeGeneratedName(fullName, "agent name");
     const lines = [];
     lines.push(`name: ${fullName}`);
     lines.push(`description: "${escapeYamlString(role.description)}"`);
@@ -65,6 +80,7 @@ function renderConstraints(ir) {
 function renderBody(name, role, ir, options) {
     const prefix = options?.namePrefix ?? "dna-";
     const fullName = `${prefix}${toKebabCase(name)}`;
+    assertSafeGeneratedName(fullName, "agent name");
     const compiledAt = new Date().toISOString();
     const includeDNA = options?.includeDNAGuidelines ?? true;
     const sections = [];
@@ -184,7 +200,9 @@ function renderBody(name, role, ir, options) {
 export function compileRoleToAgentMD(roleName, role, ir, options) {
     const prefix = options?.namePrefix ?? "dna-";
     const kebabName = toKebabCase(roleName);
-    const fileName = `${prefix}${kebabName}.md`;
+    const fullName = `${prefix}${kebabName}`;
+    assertSafeGeneratedName(fullName, "agent name");
+    const fileName = `${fullName}.md`;
     const frontmatter = renderFrontmatter(roleName, role, options);
     const body = renderBody(roleName, role, ir, options);
     const content = `---\n${frontmatter}\n---\n\n${body}`;
@@ -207,7 +225,7 @@ export async function writeAgentMDFiles(results, outputDir) {
     await mkdir(outputDir, { recursive: true });
     const written = [];
     for (const result of results) {
-        const path = join(outputDir, result.fileName);
+        const path = resolveContainedPath(outputDir, result.fileName);
         await writeFile(path, result.content, "utf-8");
         written.push(path);
     }