intentdna 1.5.16 → 1.5.18

package/dist/compiler/compile.js

@@ -150,6 +150,38 @@ function geneToValidators(name, gene) {
     }
     return validators;
 }
+function legibilityAssetsToContextFiles(assets) {
+    if (!assets)
+        return undefined;
+    const mandatory = assets.mandatory
+        ?.filter((asset) => asset.type === "required_read")
+        .map((asset) => asset.path);
+    const per_role = assets.per_role
+        ? Object.fromEntries(Object.entries(assets.per_role).map(([role, roleAssets]) => [
+            role,
+            roleAssets.filter((asset) => asset.type === "required_read").map((asset) => asset.path),
+        ]).filter(([, paths]) => paths.length > 0))
+        : undefined;
+    const per_workflow = assets.per_workflow
+        ? Object.fromEntries(Object.entries(assets.per_workflow).map(([workflow, wfAssets]) => [
+            workflow,
+            wfAssets.filter((asset) => asset.type === "required_read").map((asset) => asset.path),
+        ]).filter(([, paths]) => paths.length > 0))
+        : undefined;
+    if ((!mandatory || mandatory.length === 0) && !per_role && !per_workflow)
+        return undefined;
+    return { mandatory, per_role, per_workflow };
+}
+function resolvePostCheckCommand(check) {
+    const normalized = check.trim();
+    const builtins = {
+        vitest_run: "npm test",
+        tsc_no_errors: "npx tsc --noEmit",
+        dart_analyze: "dart analyze",
+        flutter_test: "flutter test",
+    };
+    return builtins[normalized] ?? normalized;
+}
 /**
  * Compile activated DNA into a Constraint IR.
  */
@@ -158,6 +190,7 @@ export function compileDNA(activated, cascaded) {
     const toolFilters = [];
     const gates = [];
     const validators = [];
+    const verifierSpecs = [];
     const injections = [];
     for (const [name, gene] of Object.entries(activated.genes)) {
         directives.push(...geneToDirectives(name, gene));
@@ -210,15 +243,67 @@ export function compileDNA(activated, cascaded) {
     }
     // Build step_checkpoints from all workflow steps that have checkpoints
     const stepCheckpoints = [];
-    const allWorkflows = Object.values(cascaded?.workflows ?? {});
-    for (const wf of allWorkflows) {
+    const allWorkflows = Object.entries(cascaded?.workflows ?? {});
+    for (const [workflowKey, wf] of allWorkflows) {
         for (const step of wf.steps ?? []) {
+            const roleGeneHints = cascaded?.roles?.[step.role]?.activates_genes ?? [];
             if (step.checkpoints && step.checkpoints.length > 0) {
                 stepCheckpoints.push({
                     step_role: step.role,
                     step_id: step.id,
                     checkpoints: [...step.checkpoints],
                 });
+                for (const checkpoint of step.checkpoints) {
+                    verifierSpecs.push({
+                        id: `${workflowKey}:${step.id}:checkpoint:${checkpoint.assert}`,
+                        when: "post_step",
+                        severity: checkpoint.action ?? "block",
+                        kind: "checkpoint",
+                        workflow_name: workflowKey,
+                        step_id: step.id,
+                        step_role: step.role,
+                        source_genes: roleGeneHints.length > 0 ? [...roleGeneHints] : undefined,
+                        checkpoint,
+                        source: "workflow_checkpoint",
+                    });
+                }
+            }
+            if (step.completion && step.completion.length > 0) {
+                for (let i = 0; i < step.completion.length; i++) {
+                    verifierSpecs.push({
+                        id: `${workflowKey}:${step.id}:completion:${i}`,
+                        when: "pre_handoff",
+                        severity: "block",
+                        kind: "completion",
+                        workflow_name: workflowKey,
+                        step_id: step.id,
+                        step_role: step.role,
+                        source_genes: roleGeneHints.length > 0 ? [...roleGeneHints] : undefined,
+                        completion: step.completion[i],
+                        source: "workflow_completion",
+                    });
+                }
+            }
+            const rolePostChecks = cascaded?.roles?.[step.role]?.post_checks ?? [];
+            for (let i = 0; i < rolePostChecks.length; i++) {
+                const resolvedCommand = resolvePostCheckCommand(rolePostChecks[i]);
+                verifierSpecs.push({
+                    id: `${workflowKey}:${step.id}:post-check:${i}`,
+                    when: "post_step",
+                    severity: "warn",
+                    kind: "checkpoint",
+                    workflow_name: workflowKey,
+                    step_id: step.id,
+                    step_role: step.role,
+                    source_genes: roleGeneHints.length > 0 ? [...roleGeneHints] : undefined,
+                    checkpoint: {
+                        assert: `role_post_check_${i}`,
+                        command: resolvedCommand,
+                        message: `Post-check failed: ${rolePostChecks[i]}`,
+                        action: "warn",
+                    },
+                    source: "role_post_check",
+                });
             }
         }
     }
@@ -275,11 +360,14 @@ export function compileDNA(activated, cascaded) {
     // Sort directives by priority
     const priorityOrder = { high: 0, medium: 1, low: 2 };
     directives.sort((a, b) => priorityOrder[a.priority] - priorityOrder[b.priority]);
+    const legacyContextFiles = cascaded?.context_files;
+    const compiledContextFiles = legacyContextFiles ?? legibilityAssetsToContextFiles(cascaded?.legibility_assets);
     return {
         prompt_directives: directives,
         tool_filters: toolFilters,
         pre_execution_gates: gates,
         post_execution_validators: validators,
+        verifier_specs: verifierSpecs.length > 0 ? verifierSpecs : undefined,
         context_injections: injections,
         source_dna_ids: activated.source_ids,
         compiled_at: new Date().toISOString(),
@@ -290,6 +378,8 @@ export function compileDNA(activated, cascaded) {
         roles_scope_map: rolesScopeMap.length > 0 ? rolesScopeMap : undefined,
         step_checkpoints: stepCheckpoints.length > 0 ? stepCheckpoints : undefined,
         workflows_ir: workflowsIR.length > 0 ? workflowsIR : undefined,
-        context_files: cascaded?.context_files,
+        legibility_assets: cascaded?.legibility_assets,
+        context_files: compiledContextFiles,
+        verifier_policy: cascaded?.verifier_policy,
     };
 }

package/dist/compiler/workflow.d.ts

@@ -11,6 +11,7 @@ export interface CompileWorkflowOptions {
     mermaid?: boolean;
     /** Roles for scope overlap analysis (needed for isolation: auto) */
     roles?: Record<string, RoleDef>;
+    workflow_key?: string;
 }
 export interface CompileWorkflowError {
     path: string;

package/dist/compiler/workflow.js

@@ -443,6 +443,7 @@ export function compileWorkflow(workflow, options) {
         retry,
         compiled_at: new Date().toISOString(),
         source_workflow: workflow.name,
+        workflow_key: options?.workflow_key ?? workflow.name,
     };
     // 10. Optional Mermaid diagram
     if (options?.mermaid) {

package/dist/evolution/trace-bridge.d.ts

@@ -10,7 +10,7 @@
  *   - Role scope: "Role '<name>'" → gene "scope:<role>"
  *   - Gates: "(gene: <name>)" pattern or fallback to "gate"
  */
-import type { TraceEntry } from "../hooks/state.js";
+import type { TraceEntry, VerifierResultEntry } from "../hooks/state.js";
 import type { ExecutionOutcome } from "./types.js";
 /**
  * Extract the gene name from a trace entry's reason string.
@@ -19,12 +19,11 @@ import type { ExecutionOutcome } from "./types.js";
 export declare function extractGeneFromReason(reason: string | undefined): string | null;
 /**
  * Convert trace entries into ExecutionOutcomes for the evolution engine.
- *
- * Groups block/warn traces by gene, creates one outcome per unique
- * (gene, decision) pair. Allow decisions are not converted since
- * they don't carry gene information.
+ * Backward-compatible wrapper over the normalized signals path.
  */
 export declare function traceToOutcomes(traces: TraceEntry[], dnaId?: string): ExecutionOutcome[];
+export declare function verifierResultsToOutcomes(results: VerifierResultEntry[], dnaId?: string): ExecutionOutcome[];
+export declare function mergeOutcomes(traces: TraceEntry[], verifierResults: VerifierResultEntry[], dnaId?: string): ExecutionOutcome[];
 /**
  * Summarize trace-to-outcome conversion for human review.
  */

package/dist/evolution/trace-bridge.js

@@ -10,7 +10,7 @@
  *   - Role scope: "Role '<name>'" → gene "scope:<role>"
  *   - Gates: "(gene: <name>)" pattern or fallback to "gate"
  */
-import { randomUUID } from "node:crypto";
+import { signalsToOutcomes, traceToSignals, verifierResultsToSignals } from "../signals/index.js";
 /**
  * Extract the gene name from a trace entry's reason string.
  * Returns null if no gene can be determined.
@@ -19,69 +19,34 @@ export function extractGeneFromReason(reason) {
     if (!reason)
         return null;
     // Pattern: (gene: <name>) — from tool filters and gates
-    const geneMatch = reason.match(/\(gene:\s*(\w+)\)/);
+    const geneMatch = reason.match(/\(gene:\s*([A-Za-z0-9:_-]+)\)/);
     if (geneMatch)
         return geneMatch[1];
     // Pattern: Role '<name>' — from scope enforcement
-    const roleMatch = reason.match(/Role '(\w+)'/);
+    const roleMatch = reason.match(/Role '([A-Za-z0-9:_-]+)'/);
     if (roleMatch)
         return `scope:${roleMatch[1]}`;
     // Pattern: source_gene in gate messages
-    const sourceMatch = reason.match(/source_gene:\s*(\w+)/);
+    const sourceMatch = reason.match(/source_gene:\s*([A-Za-z0-9:_-]+)/);
     if (sourceMatch)
         return sourceMatch[1];
     return null;
 }
 /**
  * Convert trace entries into ExecutionOutcomes for the evolution engine.
- *
- * Groups block/warn traces by gene, creates one outcome per unique
- * (gene, decision) pair. Allow decisions are not converted since
- * they don't carry gene information.
+ * Backward-compatible wrapper over the normalized signals path.
  */
 export function traceToOutcomes(traces, dnaId = "default") {
-    // Collect feedback per gene from block/warn traces
-    const geneFeedback = new Map();
-    for (const trace of traces) {
-        if (trace.decision === "allow")
-            continue;
-        const gene = extractGeneFromReason(trace.reason);
-        if (!gene)
-            continue;
-        const existing = geneFeedback.get(gene) ?? { hindered: 0, details: [] };
-        existing.hindered++;
-        if (trace.reason && existing.details.length < 3) {
-            const short = trace.reason.split("\n")[0].slice(0, 80);
-            existing.details.push(short);
-        }
-        geneFeedback.set(gene, existing);
-    }
-    // Convert to ExecutionOutcomes
-    const outcomes = [];
-    const totalEvents = traces.length;
-    const timestamp = new Date().toISOString();
-    for (const [gene, stats] of geneFeedback) {
-        const feedback = [];
-        // Each block counts as a "hindered" feedback
-        for (let i = 0; i < stats.hindered; i++) {
-            feedback.push({
-                gene,
-                effect: "hindered",
-                detail: stats.details[i] ?? `blocked ${stats.hindered} times`,
-            });
-        }
-        outcomes.push({
-            id: `trace_${randomUUID().slice(0, 8)}`,
-            timestamp,
-            dna_id: dnaId,
-            action: `enforcement: ${gene} blocked ${stats.hindered}/${totalEvents} events`,
-            active_genes: [gene],
-            constraints_applied: [gene],
-            success: false, // Blocks indicate friction
-            constraint_feedback: feedback,
-        });
-    }
-    return outcomes;
+    return signalsToOutcomes(traceToSignals(traces), dnaId);
+}
+export function verifierResultsToOutcomes(results, dnaId = "default") {
+    return signalsToOutcomes(verifierResultsToSignals(results), dnaId);
+}
+export function mergeOutcomes(traces, verifierResults, dnaId = "default") {
+    return signalsToOutcomes([
+        ...traceToSignals(traces),
+        ...verifierResultsToSignals(verifierResults),
+    ], dnaId);
 }
 /**
  * Summarize trace-to-outcome conversion for human review.
@@ -89,11 +54,22 @@ export function traceToOutcomes(traces, dnaId = "default") {
 export function summarizeConversion(outcomes) {
     if (outcomes.length === 0)
         return "No actionable gene feedback found in traces.";
-    const lines = ["Trace → Epigenetic conversion:"];
-    for (const o of outcomes) {
-        const gene = o.active_genes[0];
-        const count = o.constraint_feedback.length;
-        lines.push(`  ${gene}: ${count} block${count > 1 ? "s" : ""} → will suppress`);
+    const lines = ["Signals → Epigenetic conversion:"];
+    for (const outcome of outcomes) {
+        const gene = outcome.active_genes[0];
+        const helped = outcome.constraint_feedback.filter((item) => item.effect === "helped").length;
+        const hindered = outcome.constraint_feedback.filter((item) => item.effect === "hindered").length;
+        const neutral = outcome.constraint_feedback.filter((item) => item.effect === "neutral").length;
+        if (hindered > 0 && helped === 0 && neutral === 0) {
+            lines.push(`  ${gene}: ${hindered} block${hindered > 1 ? "s" : ""} → will suppress`);
+            continue;
+        }
+        if (helped > 0 && hindered === 0 && neutral === 0) {
+            lines.push(`  ${gene}: ${helped} success${helped > 1 ? "es" : ""} → will amplify`);
+            continue;
+        }
+        const direction = outcome.success ? "amplify" : "suppress";
+        lines.push(`  ${gene}: ${helped} positive, ${hindered} negative, ${neutral} neutral → net ${direction}`);
     }
     return lines.join("\n");
 }

package/dist/hooks/cli.d.ts

@@ -14,9 +14,11 @@
  *
  * Fail-open: all errors → { continue: true, suppressOutput: true }
  */
-import type { ConstraintIR } from "../schema/types.js";
+import type { ConstraintIR, VerifierSpec } from "../schema/types.js";
+import type { HookOutput } from "./protocol.js";
 import { blockOutput } from "./protocol.js";
 import { readWorkflowState } from "./state.js";
+import type { VerifierResultEntry } from "./state.js";
 export interface SessionSummary {
     total: number;
     blocks: number;
@@ -37,6 +39,21 @@ export declare function computeSummary(traces: Array<{
     reason?: string;
 }>): SessionSummary;
 export declare function formatSummary(s: SessionSummary): string | null;
+export declare function appendStopVerifierWarnings(output: HookOutput, verifierResults: VerifierResultEntry[], currentStep?: string): HookOutput;
+export declare function runVerifiersForTest(projectDir: string, ir: ConstraintIR, workflowState: {
+    workflow: string;
+    current_step: string;
+    current_role: string;
+}, when: VerifierSpec["when"], sessionId?: string, options?: {
+    commandTimeoutMs?: number;
+}): Promise<VerifierResultEntry[]>;
+export declare function runStopVerifiersForTest(projectDir: string, ir: ConstraintIR, workflowState: {
+    workflow: string;
+    current_step: string;
+    current_role: string;
+}, sessionId?: string, options?: {
+    commandTimeoutMs?: number;
+}): Promise<VerifierResultEntry[]>;
 /**
  * Evaluate PreToolUse gates in priority order:
  *   1. Workflow Boundary — block Skill() after workflow completed