intentdna 1.6.2 → 1.6.4

package/dist/mcp/index.js

@@ -14,6 +14,7 @@ import { createMCPServer } from "./server.js";
 import { createStateTools } from "./tools-state.js";
 import { createCompileTools } from "./tools-compile.js";
 import { createEnforceTools } from "./tools-enforce.js";
+import { createObservabilityTools } from "./tools-observability.js";
 // Parse args
 const args = process.argv.slice(2);
 let projectDir = process.cwd();
@@ -36,5 +37,6 @@ const tools = [
     ...createStateTools(projectDir),
     ...createCompileTools(projectDir),
     ...createEnforceTools(projectDir),
+    ...createObservabilityTools(projectDir),
 ];
 createMCPServer({ name: "intentdna", version }, tools);

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

@@ -0,0 +1,2 @@
+import type { ToolDef } from "./server.js";
+export declare function createObservabilityTools(projectDir: string): ToolDef[];

package/dist/mcp/tools-observability.js

@@ -0,0 +1,34 @@
+import { textResult } from "./server.js";
+import { buildKernelReport, formatKernelReport } from "../report/kernel-report.js";
+export function createObservabilityTools(projectDir) {
+    return [
+        {
+            name: "dna_kernel_report",
+            description: "Observability-only local kernel report. Reads traces/verifier results and optional preview-only marker changes; does not execute verifiers or mutate state.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    days: { type: "number", description: "Days to look back (default 7)" },
+                    session_id: { type: "string", description: "Session ID filter" },
+                    dna_id: { type: "string", description: "DNA ID for marker preview; derived from compiled IR if omitted and unambiguous" },
+                    include_marker_preview: { type: "boolean", description: "Include preview-only marker changes (default false)" },
+                    format: { type: "string", enum: ["json", "text"], description: "Return JSON schema or text summary (default text)" },
+                },
+            },
+            handler: async (args) => {
+                const report = await buildKernelReport({
+                    projectDir,
+                    days: typeof args.days === "number" ? args.days : 7,
+                    sessionId: typeof args.session_id === "string" ? args.session_id : undefined,
+                    dnaId: typeof args.dna_id === "string" ? args.dna_id : undefined,
+                    includeMarkerPreview: typeof args.include_marker_preview === "boolean" ? args.include_marker_preview : false,
+                });
+                if (args.format === "json") {
+                    return textResult(JSON.stringify(report, null, 2));
+                }
+                return textResult(formatKernelReport(report) +
+                    "\nMCP observability only: this tool does not execute verifiers, does not enforce hook parity, and does not mutate state or markers.\n");
+            },
+        },
+    ];
+}

package/dist/report/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./kernel-report.js";
+export * from "./kernel-signals.js";

package/dist/report/index.js

@@ -0,0 +1,2 @@
+export * from "./kernel-report.js";
+export * from "./kernel-signals.js";

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

@@ -0,0 +1,79 @@
+import type { MarkerChange } from "../evolution/index.js";
+import { type ClassifiedSignal, type KernelSignalClassification } from "./kernel-signals.js";
+export interface KernelReportOptions {
+    projectDir: string;
+    days?: number;
+    sessionId?: string;
+    dnaId?: string;
+    includeMarkerPreview?: boolean;
+}
+export interface KernelReport {
+    schema_version: "intentdna.kernel_report.v1";
+    generated_at: string;
+    source: {
+        project_dir: string;
+        session_id?: string;
+        dna_id?: string;
+        dna_id_source?: "explicit" | "compiled_ir_single_source" | "unresolved";
+        period_days: number;
+    };
+    summary: {
+        traces: number;
+        verifier_results: number;
+        signals: number;
+        marker_preview_changes?: number;
+    };
+    classifications: Record<KernelSignalClassification, number>;
+    quality: {
+        quality_positive: number;
+        quality_negative: number;
+    };
+    enforcement: {
+        blocks: number;
+        warns: number;
+        allows: number;
+        policy_denied_verifiers: number;
+    };
+    signals: ClassifiedSignal[];
+    verifier_summary: {
+        total: number;
+        passes: number;
+        failures: number;
+    };
+    trace_summary: {
+        total: number;
+        blocks: number;
+        warns: number;
+        allows: number;
+        top_blocked_tools: Array<{
+            tool: string;
+            count: number;
+        }>;
+        top_blocked_paths: Array<{
+            path: string;
+            count: number;
+        }>;
+        top_block_reasons: Array<{
+            reason: string;
+            count: number;
+        }>;
+    };
+    marker_preview?: {
+        preview_only: true;
+        dna_id?: string;
+        dna_id_source?: "explicit" | "compiled_ir_single_source" | "unresolved";
+        changes: MarkerChange[];
+        excluded_signal_refs: string[];
+        exclusion_reasons: Record<string, string>;
+        error?: string;
+    };
+    mutation: {
+        command_class: "read-only" | "preview-only";
+        wrote_state: false;
+        wrote_evolution: false;
+        persisted_outcomes: false;
+        mutated_markers: false;
+    };
+}
+export declare function buildKernelReport(options: KernelReportOptions): Promise<KernelReport>;
+export declare function formatKernelReport(report: KernelReport): string;

package/dist/report/kernel-report.js

@@ -0,0 +1,259 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { readTraces, readVerifierResults, safePathComponent } from "../hooks/state.js";
+import { describeMarkerChanges } from "../evolution/marker-gen.js";
+import { classifiedSignalsToOutcomes, classifyKernelSignals, } from "./kernel-signals.js";
+const CLASSIFICATIONS = [
+    "protective",
+    "friction",
+    "positive",
+    "negative",
+    "neutral",
+    "unknown",
+];
+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 sortedCounts(items, limit, key) {
+    const counts = new Map();
+    for (const item of items)
+        counts.set(item, (counts.get(item) ?? 0) + 1);
+    return [...counts.entries()]
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, limit)
+        .map(([value, count]) => ({ [key]: value, count }));
+}
+function buildTraceSummary(traces) {
+    const blocks = traces.filter((trace) => trace.decision === "block");
+    const warns = traces.filter((trace) => trace.decision === "warn").length;
+    const allows = traces.filter((trace) => trace.decision === "allow").length;
+    const reasons = blocks
+        .map((trace) => trace.reason?.split("\n")[0].replace(/^\[Intent DNA\]\s*/, "").slice(0, 100))
+        .filter((reason) => Boolean(reason));
+    return {
+        total: traces.length,
+        blocks: blocks.length,
+        warns,
+        allows,
+        top_blocked_tools: sortedCounts(blocks.map((trace) => trace.tool_name).filter((tool) => Boolean(tool)), 5, "tool"),
+        top_blocked_paths: sortedCounts(blocks.map((trace) => trace.target_path).filter((path) => Boolean(path)), 5, "path"),
+        top_block_reasons: sortedCounts(reasons, 5, "reason"),
+    };
+}
+function buildVerifierSummary(results) {
+    return {
+        total: results.length,
+        passes: results.filter((result) => result.status === "pass").length,
+        failures: results.filter((result) => result.status === "fail").length,
+    };
+}
+async function readCompiledSourceIds(projectDir) {
+    try {
+        const raw = await readFile(join(projectDir, ".dna", "compiled", "ir.json"), "utf-8");
+        const parsed = JSON.parse(raw);
+        const sourceIds = Array.isArray(parsed.source_dna_ids)
+            ? parsed.source_dna_ids
+            : Array.isArray(parsed.ir?.source_dna_ids)
+                ? parsed.ir.source_dna_ids
+                : [];
+        return sourceIds.filter((id) => typeof id === "string");
+    }
+    catch {
+        return [];
+    }
+}
+async function resolveDnaId(projectDir, explicitDnaId) {
+    if (explicitDnaId) {
+        try {
+            return { dnaId: safePathComponent(explicitDnaId, "dna_id"), source: "explicit" };
+        }
+        catch {
+            return { source: "unresolved", error: "Invalid DNA ID." };
+        }
+    }
+    const sourceIds = await readCompiledSourceIds(projectDir);
+    const safeIds = [];
+    for (const id of sourceIds) {
+        try {
+            safeIds.push(safePathComponent(id, "dna_id"));
+        }
+        catch {
+            return { source: "unresolved", error: "Invalid DNA ID." };
+        }
+    }
+    const uniqueIds = [...new Set(safeIds)];
+    if (uniqueIds.length === 1) {
+        return { dnaId: uniqueIds[0], source: "compiled_ir_single_source" };
+    }
+    if (uniqueIds.length > 1) {
+        return { source: "unresolved", error: "Multiple DNA IDs found; pass --dna-id." };
+    }
+    return { source: "unresolved", error: "Cannot derive DNA ID; run dna sync or pass --dna-id." };
+}
+async function loadMarkersReadOnly(projectDir, dnaId) {
+    try {
+        const safeDnaId = safePathComponent(dnaId, "dna_id");
+        const raw = await readFile(join(projectDir, ".dna", "evolution", "markers", `${safeDnaId}.json`), "utf-8");
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed) ? parsed : [];
+    }
+    catch {
+        return [];
+    }
+}
+async function buildMarkerPreview(projectDir, explicitDnaId, signals) {
+    const resolution = await resolveDnaId(projectDir, explicitDnaId);
+    if (!resolution.dnaId) {
+        const excluded = {};
+        for (const signal of signals)
+            excluded[signal.source_ref] = resolution.error ?? "DNA ID unresolved";
+        return {
+            preview_only: true,
+            dna_id_source: resolution.source,
+            changes: [],
+            excluded_signal_refs: signals.map((signal) => signal.source_ref),
+            exclusion_reasons: excluded,
+            error: resolution.error,
+        };
+    }
+    const { outcomes, excluded } = classifiedSignalsToOutcomes(signals, resolution.dnaId);
+    const existingMarkers = await loadMarkersReadOnly(projectDir, resolution.dnaId);
+    const changes = describeMarkerChanges(outcomes, existingMarkers);
+    const exclusionReasons = {};
+    for (const item of excluded)
+        exclusionReasons[item.source_ref] = item.reason;
+    return {
+        preview_only: true,
+        dna_id: resolution.dnaId,
+        dna_id_source: resolution.source,
+        changes,
+        excluded_signal_refs: excluded.map((item) => item.source_ref),
+        exclusion_reasons: exclusionReasons,
+    };
+}
+export async function buildKernelReport(options) {
+    const days = options.days ?? 7;
+    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 classifications = Object.fromEntries(CLASSIFICATIONS.map((classification) => [classification, 0]));
+    for (const signal of signals)
+        classifications[signal.classification]++;
+    const traceSummary = buildTraceSummary(traces);
+    const verifierSummary = buildVerifierSummary(verifierResults);
+    const markerPreview = options.includeMarkerPreview
+        ? await buildMarkerPreview(options.projectDir, options.dnaId, signals)
+        : undefined;
+    return {
+        schema_version: "intentdna.kernel_report.v1",
+        generated_at: new Date().toISOString(),
+        source: {
+            project_dir: options.projectDir,
+            session_id: options.sessionId,
+            dna_id: markerPreview?.dna_id ?? options.dnaId,
+            dna_id_source: markerPreview?.dna_id_source ?? (options.dnaId ? "explicit" : "unresolved"),
+            period_days: days,
+        },
+        summary: {
+            traces: traces.length,
+            verifier_results: verifierResults.length,
+            signals: signals.length,
+            marker_preview_changes: markerPreview?.changes.length,
+        },
+        classifications,
+        quality: {
+            quality_positive: signals.filter((signal) => signal.semantic === "quality-positive").length,
+            quality_negative: signals.filter((signal) => signal.semantic === "quality-negative").length,
+        },
+        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,
+        },
+        signals,
+        verifier_summary: verifierSummary,
+        trace_summary: traceSummary,
+        marker_preview: markerPreview,
+        mutation: {
+            command_class: options.includeMarkerPreview ? "preview-only" : "read-only",
+            wrote_state: false,
+            wrote_evolution: false,
+            persisted_outcomes: false,
+            mutated_markers: false,
+        },
+    };
+}
+export function formatKernelReport(report) {
+    const lines = [];
+    lines.push(`DNA Kernel Report (last ${report.source.period_days} day${report.source.period_days > 1 ? "s" : ""})`);
+    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("");
+    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}`);
+        lines.push("");
+    }
+    lines.push(`Classified signals: ${report.summary.signals}`);
+    lines.push(`  Positive: ${report.classifications.positive}`);
+    lines.push(`  Negative: ${report.classifications.negative}`);
+    lines.push(`  Friction: ${report.classifications.friction}`);
+    lines.push(`  Protective: ${report.classifications.protective}`);
+    lines.push(`  Neutral: ${report.classifications.neutral}`);
+    lines.push(`  Unknown: ${report.classifications.unknown}`);
+    lines.push("");
+    if (report.trace_summary.top_blocked_tools.length > 0) {
+        lines.push("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:");
+        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:");
+        for (const item of report.trace_summary.top_block_reasons)
+            lines.push(`  \"${item.reason}\": ${item.count}`);
+        lines.push("");
+    }
+    if (report.marker_preview) {
+        lines.push("Marker preview:");
+        if (report.marker_preview.error) {
+            lines.push(`  Error: ${report.marker_preview.error}`);
+        }
+        else {
+            lines.push(`  DNA ID: ${report.marker_preview.dna_id}`);
+            lines.push(`  Changes: ${report.marker_preview.changes.length}`);
+            for (const change of report.marker_preview.changes) {
+                const action = change.action ? ` → ${change.action} x${change.factor?.toFixed(2)}` : "";
+                lines.push(`    ${change.type.toUpperCase()} ${change.gene}${action} (${change.feedback_count} feedbacks)`);
+            }
+        }
+        lines.push(`  Excluded signals: ${report.marker_preview.excluded_signal_refs.length}`);
+        lines.push("  Preview only: no outcomes or markers were persisted.");
+        lines.push("");
+    }
+    lines.push("Mutation contract:");
+    lines.push(`  Command class: ${report.mutation.command_class}`);
+    lines.push("  Wrote state: false");
+    lines.push("  Wrote evolution: false");
+    lines.push("  Persisted outcomes: false");
+    lines.push("  Mutated markers: false");
+    lines.push("");
+    return lines.join("\n");
+}

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

@@ -0,0 +1,38 @@
+import type { TraceEntry, VerifierResultEntry } from "../hooks/state.js";
+import type { ExecutionOutcome } from "../evolution/types.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 interface ClassifiedSignal {
+    id: string;
+    source_type: "trace" | "verifier" | "external";
+    source_ref: string;
+    timestamp: string;
+    gene?: string;
+    semantic: KernelSignalSemantic;
+    classification: KernelSignalClassification;
+    classification_reason: string;
+    evolution_effect: KernelEvolutionEffect;
+    eligible_for_marker_preview: boolean;
+    evidence_ref?: string;
+    evidence_payload?: Record<string, unknown>;
+}
+export interface KernelSignalContext {
+    friction_trace_ids?: string[];
+    friction_verifier_ids?: string[];
+}
+export interface ClassifyKernelSignalsInput {
+    traces?: TraceEntry[];
+    verifierResults?: VerifierResultEntry[];
+    context?: KernelSignalContext;
+}
+export declare function classifyVerifierResult(result: VerifierResultEntry, context?: KernelSignalContext): 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): {
+    outcomes: ExecutionOutcome[];
+    excluded: Array<{
+        source_ref: string;
+        reason: string;
+    }>;
+};

package/dist/report/kernel-signals.js

@@ -0,0 +1,228 @@
+function extractGeneFromReason(reason) {
+    if (!reason)
+        return undefined;
+    const geneMatch = reason.match(/\(gene:\s*([A-Za-z0-9:_-]+)\)/);
+    if (geneMatch)
+        return geneMatch[1];
+    const roleMatch = reason.match(/Role '([A-Za-z0-9:_-]+)'/);
+    if (roleMatch)
+        return `scope:${roleMatch[1]}`;
+    const sourceMatch = reason.match(/source_gene:\s*([A-Za-z0-9:_-]+)/);
+    return sourceMatch?.[1];
+}
+function verifierSourceRef(result) {
+    return [
+        "verifier",
+        result.workflow ?? "unknown-workflow",
+        result.step_id ?? "unknown-step",
+        result.verifier_id,
+        result.timestamp,
+    ].join(":");
+}
+function verifierEvidencePayload(result) {
+    const payload = {
+        verifier_id: result.verifier_id,
+        when: result.when,
+        severity: result.severity,
+        kind: result.kind,
+        workflow: result.workflow,
+        step_id: result.step_id,
+        target: result.target,
+        evidence: result.evidence,
+        exit_code: result.exit_code,
+        artifact: result.artifact,
+        message: result.message,
+    };
+    for (const key of Object.keys(payload)) {
+        if (payload[key] === undefined)
+            delete payload[key];
+    }
+    return Object.keys(payload).length > 0 ? payload : undefined;
+}
+function traceEvidencePayload(trace) {
+    const payload = {
+        trace_id: trace.trace_id,
+        event: trace.event,
+        tool_name: trace.tool_name,
+        agent_type: trace.agent_type,
+        workflow: trace.workflow,
+        step: trace.step,
+        decision: trace.decision,
+        reason: trace.reason,
+        target_path: trace.target_path,
+        duration_ms: trace.duration_ms,
+    };
+    for (const key of Object.keys(payload)) {
+        if (payload[key] === undefined)
+            delete payload[key];
+    }
+    return Object.keys(payload).length > 0 ? payload : undefined;
+}
+function isPolicyDeniedVerifier(result) {
+    return result.evidence === "policy_denied" || result.exit_code === 126;
+}
+export function classifyVerifierResult(result, context = {}) {
+    const genes = result.source_genes && result.source_genes.length > 0 ? result.source_genes : [undefined];
+    const sourceRef = verifierSourceRef(result);
+    const explicitFriction = context.friction_verifier_ids?.includes(result.verifier_id) ?? false;
+    return genes.map((gene) => {
+        if (isPolicyDeniedVerifier(result)) {
+            return {
+                id: `${sourceRef}:${gene ?? "unknown"}`,
+                source_type: "verifier",
+                source_ref: sourceRef,
+                timestamp: result.timestamp,
+                gene,
+                semantic: "policy-denied-verifier",
+                classification: explicitFriction ? "friction" : "unknown",
+                classification_reason: explicitFriction
+                    ? "policy-denied verifier explicitly classified as friction"
+                    : "policy-denied verifier is raw evidence but not marker-preview evidence by default",
+                evolution_effect: explicitFriction ? "hindered" : "neutral",
+                eligible_for_marker_preview: Boolean(gene && explicitFriction),
+                evidence_ref: sourceRef,
+                evidence_payload: verifierEvidencePayload(result),
+            };
+        }
+        if (result.status === "pass") {
+            return {
+                id: `${sourceRef}:${gene ?? "unknown"}`,
+                source_type: "verifier",
+                source_ref: sourceRef,
+                timestamp: result.timestamp,
+                gene,
+                semantic: "quality-positive",
+                classification: "positive",
+                classification_reason: "verifier pass is positive quality evidence",
+                evolution_effect: "helped",
+                eligible_for_marker_preview: Boolean(gene),
+                evidence_ref: sourceRef,
+                evidence_payload: verifierEvidencePayload(result),
+            };
+        }
+        return {
+            id: `${sourceRef}:${gene ?? "unknown"}`,
+            source_type: "verifier",
+            source_ref: sourceRef,
+            timestamp: result.timestamp,
+            gene,
+            semantic: "quality-negative",
+            classification: explicitFriction ? "friction" : "negative",
+            classification_reason: explicitFriction
+                ? "verifier failure has explicit friction evidence"
+                : "verifier failure is negative quality evidence",
+            evolution_effect: "hindered",
+            eligible_for_marker_preview: Boolean(gene),
+            evidence_ref: sourceRef,
+            evidence_payload: verifierEvidencePayload(result),
+        };
+    });
+}
+export function classifyTraceEntry(trace, context = {}) {
+    const gene = extractGeneFromReason(trace.reason);
+    const sourceRef = `trace:${trace.trace_id}`;
+    const explicitFriction = context.friction_trace_ids?.includes(trace.trace_id) ?? false;
+    if (trace.decision === "allow") {
+        return {
+            id: sourceRef,
+            source_type: "trace",
+            source_ref: sourceRef,
+            timestamp: trace.timestamp,
+            gene,
+            semantic: "enforcement-allow",
+            classification: "neutral",
+            classification_reason: "enforcement allow is report-visible but not quality evidence",
+            evolution_effect: "neutral",
+            eligible_for_marker_preview: false,
+            evidence_ref: sourceRef,
+            evidence_payload: traceEvidencePayload(trace),
+        };
+    }
+    if (trace.decision === "warn") {
+        return {
+            id: sourceRef,
+            source_type: "trace",
+            source_ref: sourceRef,
+            timestamp: trace.timestamp,
+            gene,
+            semantic: "enforcement-warn",
+            classification: "neutral",
+            classification_reason: "enforcement warn is report-visible but not marker-preview evidence by default",
+            evolution_effect: "neutral",
+            eligible_for_marker_preview: false,
+            evidence_ref: sourceRef,
+            evidence_payload: traceEvidencePayload(trace),
+        };
+    }
+    return {
+        id: sourceRef,
+        source_type: "trace",
+        source_ref: sourceRef,
+        timestamp: trace.timestamp,
+        gene,
+        semantic: "enforcement-block",
+        classification: explicitFriction ? "friction" : "protective",
+        classification_reason: explicitFriction
+            ? "enforcement block has explicit friction evidence"
+            : "enforcement block is protective by default and excluded from marker preview",
+        evolution_effect: explicitFriction ? "hindered" : "neutral",
+        eligible_for_marker_preview: Boolean(gene && explicitFriction),
+        evidence_ref: sourceRef,
+        evidence_payload: traceEvidencePayload(trace),
+    };
+}
+export function classifyKernelSignals(input) {
+    const traces = input.traces ?? [];
+    const verifierResults = input.verifierResults ?? [];
+    return [
+        ...traces.map((trace) => classifyTraceEntry(trace, input.context)),
+        ...verifierResults.flatMap((result) => classifyVerifierResult(result, input.context)),
+    ].sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+}
+export function classifiedSignalsToOutcomes(signals, dnaId) {
+    const feedbackByGene = new Map();
+    const excluded = [];
+    for (const signal of signals) {
+        if (!signal.eligible_for_marker_preview) {
+            excluded.push({
+                source_ref: signal.source_ref,
+                reason: signal.classification_reason,
+            });
+            continue;
+        }
+        if (!signal.gene) {
+            excluded.push({ source_ref: signal.source_ref, reason: "signal has no gene" });
+            continue;
+        }
+        if (signal.classification === "protective" || signal.classification === "unknown") {
+            excluded.push({
+                source_ref: signal.source_ref,
+                reason: `${signal.classification} signals are not marker-preview evidence`,
+            });
+            continue;
+        }
+        const existing = feedbackByGene.get(signal.gene) ?? [];
+        existing.push({
+            gene: signal.gene,
+            effect: signal.evolution_effect,
+            detail: signal.classification_reason,
+        });
+        feedbackByGene.set(signal.gene, existing);
+    }
+    const outcomes = [];
+    for (const [gene, feedback] of feedbackByGene) {
+        const helped = feedback.filter((item) => item.effect === "helped").length;
+        const hindered = feedback.filter((item) => item.effect === "hindered").length;
+        outcomes.push({
+            id: `kernel_signal_${gene}_${feedback.length}`,
+            timestamp: new Date().toISOString(),
+            dna_id: dnaId,
+            action: `kernel_signals:${gene} helped=${helped} hindered=${hindered}`,
+            active_genes: [gene],
+            constraints_applied: [gene],
+            success: helped >= hindered,
+            constraint_feedback: feedback,
+        });
+    }
+    return { outcomes, excluded };
+}