intentdna 1.2.2 → 1.3.0

package/dist/compiler/activate.js

@@ -138,4 +138,3 @@ export function activateDNA(cascaded, contextName = null, activeRole = null) {
         source_ids: cascaded.source_ids,
     };
 }
-//# sourceMappingURL=activate.js.map

package/dist/compiler/cascade.d.ts

@@ -10,12 +10,11 @@
  *   - 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, ModeDef } from "../schema/types.js";
+import type { IntentDNA, Gene, ContextRegion, EpigeneticMarker, RoleDef, WorkflowDef } from "../schema/types.js";
 export interface CascadedDNA {
     genes: Record<string, Gene>;
     contexts: Record<string, ContextRegion>;
     roles: Record<string, RoleDef>;
-    modes: Record<string, ModeDef>;
     workflows: Record<string, WorkflowDef>;
     epigenetic_markers: EpigeneticMarker[];
     source_ids: string[];
@@ -31,4 +30,3 @@ export interface CascadedDNA {
  *   - Same namespace: higher priority replaces (expected cascade behavior)
  */
 export declare function cascadeDNA(layers: IntentDNA[]): CascadedDNA;
-//# sourceMappingURL=cascade.d.ts.map

package/dist/compiler/cascade.js

@@ -81,7 +81,6 @@ function prefixWorkflowRoles(wf, ns) {
         steps: wf.steps.map((step) => ({
             ...step,
             role: `${ns}_${step.role}`,
-            mode: step.mode ? `${ns}_${step.mode}` : undefined,
         })),
     };
 }
@@ -101,7 +100,6 @@ export function cascadeDNA(layers) {
     const mergedGenes = {};
     const mergedContexts = {};
     const mergedRoles = {};
-    const mergedModes = {};
     const mergedWorkflows = {};
     const allMarkers = [];
     const sourceIds = [];
@@ -126,12 +124,7 @@ export function cascadeDNA(layers) {
             const key = ns ? `${ns}_${name}` : name;
             mergedRoles[key] = role;
         }
-        // Merge modes: namespace-prefixed keys coexist, same-namespace overrides
-        for (const [name, mode] of Object.entries(dna.modes ?? {})) {
-            const key = ns ? `${ns}_${name}` : name;
-            mergedModes[key] = mode;
-        }
-        // Merge workflows: namespace-prefixed keys + step role/mode references
+        // Merge workflows: namespace-prefixed keys + step role references
         const normalized = normalizeWorkflowsFromDNA(dna);
         for (const [name, wf] of Object.entries(normalized)) {
             if (ns) {
@@ -151,10 +144,8 @@ export function cascadeDNA(layers) {
         genes: mergedGenes,
         contexts: mergedContexts,
         roles: mergedRoles,
-        modes: mergedModes,
         workflows: mergedWorkflows,
         epigenetic_markers: allMarkers,
         source_ids: sourceIds,
     };
 }
-//# sourceMappingURL=cascade.js.map

package/dist/compiler/compile.d.ts

@@ -14,4 +14,3 @@ import type { CascadedDNA } from "./cascade.js";
  * Compile activated DNA into a Constraint IR.
  */
 export declare function compileDNA(activated: ActivatedDNA, cascaded?: CascadedDNA): ConstraintIR;
-//# sourceMappingURL=compile.d.ts.map

package/dist/compiler/compile.js

@@ -198,32 +198,49 @@ export function compileDNA(activated, cascaded) {
             }
         }
     }
-    // Build mode_constraints from all cascaded modes
-    const modeConstraints = [];
-    if (cascaded?.modes) {
-        for (const [name, mode] of Object.entries(cascaded.modes)) {
-            modeConstraints.push({
-                mode_name: name,
-                description: mode.description,
-                tool_deny: mode.tool_permissions?.deny,
-                scope_write: mode.scope?.write,
-            });
-        }
-    }
-    // Build step_checkpoints from all workflow steps that have checkpoints + a mode
+    // Build step_checkpoints from all workflow steps that have checkpoints
     const stepCheckpoints = [];
     const allWorkflows = Object.values(cascaded?.workflows ?? {});
     for (const wf of allWorkflows) {
         for (const step of wf.steps ?? []) {
-            if (step.checkpoints && step.checkpoints.length > 0 && step.mode) {
+            if (step.checkpoints && step.checkpoints.length > 0) {
                 stepCheckpoints.push({
-                    step_mode: step.mode,
+                    step_role: step.role,
                     step_id: step.id,
                     checkpoints: [...step.checkpoints],
                 });
             }
         }
     }
+    // Build workflows_ir: per-workflow partitioned view with namespace context
+    const workflowsIR = [];
+    if (cascaded?.workflows) {
+        for (const [wfKey, wf] of Object.entries(cascaded.workflows)) {
+            const wfStepCheckpoints = [];
+            const activeRoles = [];
+            for (const step of wf.steps ?? []) {
+                if (!activeRoles.includes(step.role)) {
+                    activeRoles.push(step.role);
+                }
+                if (step.checkpoints && step.checkpoints.length > 0) {
+                    wfStepCheckpoints.push({
+                        step_role: step.role,
+                        step_id: step.id,
+                        checkpoints: [...step.checkpoints],
+                    });
+                }
+            }
+            // Derive namespace from workflow key: "ns_wfname" → "ns", "wfname" → ""
+            const underscoreIdx = wfKey.indexOf("_");
+            const namespace = underscoreIdx > 0 ? wfKey.slice(0, underscoreIdx) : "";
+            workflowsIR.push({
+                workflow_name: wfKey,
+                namespace,
+                step_checkpoints: wfStepCheckpoints,
+                active_roles: activeRoles,
+            });
+        }
+    }
     // Sort directives by priority
     const priorityOrder = { high: 0, medium: 1, low: 2 };
     directives.sort((a, b) => priorityOrder[a.priority] - priorityOrder[b.priority]);
@@ -240,8 +257,7 @@ export function compileDNA(activated, cascaded) {
         role_tool_permissions: roleToolPermissions,
         role_scope: roleScope,
         roles_scope_map: rolesScopeMap.length > 0 ? rolesScopeMap : undefined,
-        mode_constraints: modeConstraints.length > 0 ? modeConstraints : undefined,
         step_checkpoints: stepCheckpoints.length > 0 ? stepCheckpoints : undefined,
+        workflows_ir: workflowsIR.length > 0 ? workflowsIR : undefined,
     };
 }
-//# sourceMappingURL=compile.js.map

package/dist/compiler/index.d.ts

@@ -25,4 +25,3 @@ export interface CompileOptions {
  * Optionally injects stored epigenetic markers from the evolution engine.
  */
 export declare function compileFromFiles(filePaths: string[], contextOrOptions?: string | CompileOptions): Promise<ConstraintIR>;
-//# sourceMappingURL=index.d.ts.map

package/dist/compiler/index.js

@@ -48,4 +48,3 @@ export async function compileFromFiles(filePaths, contextOrOptions) {
     const activated = activateDNA(cascaded, opts.context ?? null, opts.role ?? null);
     return compileDNA(activated, cascaded);
 }
-//# sourceMappingURL=index.js.map

package/dist/compiler/workflow.d.ts

@@ -34,4 +34,3 @@ export interface CompileWorkflowResult {
  * Returns a result object with either a plan or errors.
  */
 export declare function compileWorkflow(workflow: WorkflowDef, options?: CompileWorkflowOptions): CompileWorkflowResult;
-//# sourceMappingURL=workflow.d.ts.map

package/dist/compiler/workflow.js

@@ -166,7 +166,6 @@ function toWorkflowStep(def) {
     return {
         id: def.id,
         role: def.role,
-        mode: def.mode ?? null,
         description: def.description ?? def.id,
         optional: def.optional ?? false,
         run_if: resolveRunIf(def.run_if),
@@ -273,4 +272,3 @@ export function compileWorkflow(workflow, options) {
     }
     return { ok: true, plan, errors: [] };
 }
-//# sourceMappingURL=workflow.js.map

package/dist/evolution/collector.d.ts

@@ -49,4 +49,3 @@ export interface OutcomeSummary {
     oldest: string | null;
     newest: string | null;
 }
-//# sourceMappingURL=collector.d.ts.map

package/dist/evolution/collector.js

@@ -69,4 +69,3 @@ export class OutcomeCollector {
         };
     }
 }
-//# sourceMappingURL=collector.js.map

package/dist/evolution/fitness.d.ts

@@ -30,4 +30,3 @@ export declare function computeModulationFactor(geneName: string, outcomes: Exec
  * Returns 0-1 where 0 means fully decayed.
  */
 export declare function computeMarkerStrength(marker: EpigeneticMarker): number;
-//# sourceMappingURL=fitness.d.ts.map

package/dist/evolution/fitness.js

@@ -93,4 +93,3 @@ export function computeMarkerStrength(marker) {
     // Decay per 30-day period
     return Math.pow(marker.decay, markerAge / 30);
 }
-//# sourceMappingURL=fitness.js.map

package/dist/evolution/index.d.ts

@@ -50,4 +50,3 @@ export declare class EvolutionEngine {
      */
     summary(dnaId: string): Promise<OutcomeSummary>;
 }
-//# sourceMappingURL=index.d.ts.map

package/dist/evolution/index.js

@@ -66,4 +66,3 @@ export class EvolutionEngine {
         return this.collector.getSummary(dnaId);
     }
 }
-//# sourceMappingURL=index.js.map

package/dist/evolution/marker-gen.d.ts

@@ -28,4 +28,3 @@ export interface MarkerChange {
     feedback_count: number;
     needed?: number;
 }
-//# sourceMappingURL=marker-gen.d.ts.map

package/dist/evolution/marker-gen.js

@@ -138,4 +138,3 @@ export function describeMarkerChanges(outcomes, existingMarkers, config = {}) {
     }
     return changes;
 }
-//# sourceMappingURL=marker-gen.js.map

package/dist/evolution/store.d.ts

@@ -21,4 +21,3 @@ export declare class EvolutionStore {
     loadMarkers(dnaId: string): Promise<EpigeneticMarker[]>;
     saveMarkers(dnaId: string, markers: EpigeneticMarker[]): Promise<void>;
 }
-//# sourceMappingURL=store.d.ts.map

package/dist/evolution/store.js

@@ -75,4 +75,3 @@ export class EvolutionStore {
         await writeFile(this.markersPath(dnaId), JSON.stringify(markers, null, 2), "utf-8");
     }
 }
-//# sourceMappingURL=store.js.map

package/dist/evolution/types.d.ts

@@ -70,4 +70,3 @@ export interface EvolutionConfig {
     max_markers: number;
 }
 export declare const DEFAULT_EVOLUTION_CONFIG: EvolutionConfig;
-//# sourceMappingURL=types.d.ts.map

package/dist/evolution/types.js

@@ -11,4 +11,3 @@ export const DEFAULT_EVOLUTION_CONFIG = {
     prune_threshold: 0.01,
     max_markers: 50,
 };
-//# sourceMappingURL=types.js.map

package/dist/hooks/cli.d.ts

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+/**
+ * Intent DNA — Hook CLI (`dna-hook`)
+ *
+ * Claude Code invokes this binary for each hook event:
+ *   dna-hook <event> [--ir <path>] [--state-dir <path>]
+ *
+ * Runtime flow:
+ *   1. Read JSON from stdin (Claude Code hook protocol)
+ *   2. Load compiled IR from .dna/compiled/ir.json
+ *   3. Read state from .dna/state/
+ *   4. Call enforcement engine
+ *   5. Write JSON result to stdout
+ *
+ * Fail-open: all errors → { continue: true, suppressOutput: true }
+ */
+export {};

package/dist/hooks/cli.js

@@ -0,0 +1,156 @@
+#!/usr/bin/env node
+/**
+ * Intent DNA — Hook CLI (`dna-hook`)
+ *
+ * Claude Code invokes this binary for each hook event:
+ *   dna-hook <event> [--ir <path>] [--state-dir <path>]
+ *
+ * Runtime flow:
+ *   1. Read JSON from stdin (Claude Code hook protocol)
+ *   2. Load compiled IR from .dna/compiled/ir.json
+ *   3. Read state from .dna/state/
+ *   4. Call enforcement engine
+ *   5. Write JSON result to stdout
+ *
+ * Fail-open: all errors → { continue: true, suppressOutput: true }
+ */
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { readStdin, writeOutput, silentOutput } from "./protocol.js";
+import { enforcePreToolUse, enforcePostToolUse, enforceUserPromptSubmit, enforceSubagentStop, enforcePreCompact, enforceNotification, enforceSessionStart, enforceStop, } from "./enforce.js";
+import { appendAudit, readWorkflowState } from "./state.js";
+// ── Constants ──────────────────────────────────────────────
+const DEFAULT_IR_PATH = ".dna/compiled/ir.json";
+const VALID_EVENTS = new Set([
+    "PreToolUse", "PostToolUse", "UserPromptSubmit",
+    "SubagentStop", "PreCompact", "Notification", "Stop", "SessionStart",
+]);
+// ── Main ───────────────────────────────────────────────────
+async function main() {
+    // Parse args
+    const args = process.argv.slice(2);
+    const event = args[0];
+    if (!event || !VALID_EVENTS.has(event)) {
+        writeOutput(silentOutput());
+        return;
+    }
+    let irPath = DEFAULT_IR_PATH;
+    const irFlagIdx = args.indexOf("--ir");
+    if (irFlagIdx !== -1 && args[irFlagIdx + 1]) {
+        irPath = args[irFlagIdx + 1];
+    }
+    // Read stdin
+    const rawInput = await readStdin(5000);
+    // Resolve project directory from input or cwd
+    const projectDir = typeof rawInput.cwd === "string" ? rawInput.cwd : process.cwd();
+    const sessionId = typeof rawInput.sessionId === "string" ? rawInput.sessionId : undefined;
+    // Load compiled IR
+    const resolvedIRPath = resolve(projectDir, irPath);
+    const ir = await loadIR(resolvedIRPath);
+    if (!ir) {
+        writeOutput(silentOutput());
+        return;
+    }
+    const state = {};
+    // Special handling for Stop — needs async workflow state read
+    if (event === "Stop") {
+        const wfState = await readWorkflowState(projectDir, sessionId);
+        const stopContext = wfState ? {
+            active: wfState.active,
+            workflow: wfState.workflow,
+            current_step: wfState.current_step,
+            current_role: wfState.current_role,
+            started_at: wfState.started_at,
+        } : null;
+        const stopOutput = enforceStop(ir, {
+            cwd: typeof rawInput.cwd === "string" ? rawInput.cwd : undefined,
+            session_id: sessionId,
+            stop_reason: typeof rawInput.stop_reason === "string" ? rawInput.stop_reason : undefined,
+        }, stopContext);
+        writeOutput(stopOutput);
+        return;
+    }
+    // Dispatch to enforcement engine
+    const output = dispatch(event, ir, rawInput, state);
+    writeOutput(output);
+    // Side effect: audit log for notifications
+    if (event === "Notification" && output.hookSpecificOutput?.additionalContext?.includes("violation")) {
+        const message = typeof rawInput.message === "string" ? rawInput.message : "";
+        await appendAudit(projectDir, {
+            timestamp: new Date().toISOString(),
+            event: "violation",
+            message,
+            session_id: sessionId,
+        }).catch(() => { }); // Fail-open
+    }
+}
+// ── Dispatch ───────────────────────────────────────────────
+function dispatch(event, ir, input, state) {
+    switch (event) {
+        case "PreToolUse":
+            return enforcePreToolUse(ir, {
+                tool_name: String(input.tool_name ?? ""),
+                tool_input: (input.tool_input ?? {}),
+                agent_type: typeof input.agent_type === "string" ? input.agent_type : undefined,
+                cwd: typeof input.cwd === "string" ? input.cwd : undefined,
+                sessionId: typeof input.sessionId === "string" ? input.sessionId : undefined,
+            }, state);
+        case "PostToolUse":
+            return enforcePostToolUse(ir, {
+                tool_name: String(input.tool_name ?? ""),
+                tool_input: (input.tool_input ?? {}),
+                tool_output: typeof input.tool_output === "string" ? input.tool_output : undefined,
+                agent_type: typeof input.agent_type === "string" ? input.agent_type : undefined,
+            });
+        case "UserPromptSubmit":
+            return enforceUserPromptSubmit(ir, {
+                prompt: typeof input.prompt === "string" ? input.prompt : undefined,
+            });
+        case "SubagentStop":
+            return enforceSubagentStop(ir, {
+                agent_name: typeof input.agent_name === "string" ? input.agent_name : undefined,
+                agent_type: typeof input.agent_type === "string" ? input.agent_type : undefined,
+            });
+        case "PreCompact":
+            return enforcePreCompact(ir);
+        case "Notification":
+            return enforceNotification(ir, {
+                title: typeof input.title === "string" ? input.title : undefined,
+                message: typeof input.message === "string" ? input.message : undefined,
+            });
+        case "Stop":
+            return silentOutput(); // DNA doesn't block stops
+        case "SessionStart":
+            return enforceSessionStart(ir, {
+                cwd: typeof input.cwd === "string" ? input.cwd : undefined,
+                session_id: typeof input.sessionId === "string" ? input.sessionId : undefined,
+                trigger: typeof input.trigger === "string" ? input.trigger : undefined,
+            });
+        default:
+            return silentOutput();
+    }
+}
+// ── IR Loading ─────────────────────────────────────────────
+async function loadIR(irPath) {
+    try {
+        const raw = await readFile(irPath, "utf-8");
+        const data = JSON.parse(raw);
+        // Support both raw IR and wrapped CompiledIRFile format
+        if (data.ir_version && data.ir) {
+            return data.ir;
+        }
+        // Direct ConstraintIR
+        if (data.compiled_at && data.source_dna_ids) {
+            return data;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+// ── Entry Point ────────────────────────────────────────────
+main().catch(() => {
+    // Fail-open: never block Claude Code on unexpected errors
+    writeOutput(silentOutput());
+});

package/dist/hooks/enforce.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Intent DNA — Enforcement Engine
+ *
+ * Pure functions that evaluate ConstraintIR against hook inputs.
+ * No I/O — reads no files, runs no commands, writes no state.
+ * The hook CLI handles stdin/stdout, IR loading, state, and checkpoint execution.
+ *
+ * Enforcement order for PreToolUse:
+ *   1. Role scope (agent_type → write glob patterns)
+ *   2. Tool filters (block/warn/deprioritize by tool name)
+ *   3. Pre-execution gates (condition-based block/escalate)
+ *   4. Output schema (required sections for Write tool)
+ *
+ * Step checkpoints are handled by the CLI, not here.
+ */
+import type { ConstraintIR, RoleDef } from "../schema/types.js";
+import type { PreToolUseInput, PostToolUseInput, UserPromptSubmitInput, SubagentStopInput, NotificationInput, HookOutput } from "./protocol.js";
+/** SessionStart input fields */
+export interface SessionStartInput {
+    cwd?: string;
+    session_id?: string;
+    trigger?: string;
+}
+export interface EnforceState {
+}
+/**
+ * Enforce PreToolUse constraints.
+ * Returns the first blocking/escalating result, or allow if all pass.
+ *
+ * Optional `roles` parameter provides output_schema enforcement.
+ */
+export declare function enforcePreToolUse(ir: ConstraintIR, input: PreToolUseInput, state?: EnforceState, roles?: Record<string, RoleDef>): HookOutput;
+/**
+ * Enforce PostToolUse validators.
+ * Currently logs validators for audit. Returns allow with context.
+ */
+export declare function enforcePostToolUse(ir: ConstraintIR, input: PostToolUseInput): HookOutput;
+/**
+ * Inject DNA policy reminders on each user prompt.
+ * Only injects when there are high-priority directives.
+ */
+export declare function enforceUserPromptSubmit(ir: ConstraintIR, _input: UserPromptSubmitInput): HookOutput;
+/**
+ * Audit role scope compliance when a subagent finishes.
+ */
+export declare function enforceSubagentStop(ir: ConstraintIR, input: SubagentStopInput): HookOutput;
+/**
+ * Preserve DNA directive summary before context compaction.
+ */
+export declare function enforcePreCompact(ir: ConstraintIR): HookOutput;
+/**
+ * Check if a notification is a DNA violation and return audit info.
+ * The CLI handles actual audit file writes.
+ */
+export declare function enforceNotification(ir: ConstraintIR, input: NotificationInput): HookOutput;
+/**
+ * Initialize DNA state and inject policy summary on session start.
+ * Returns silent if no DNA policies are active.
+ */
+export declare function enforceSessionStart(ir: ConstraintIR, input: SessionStartInput): HookOutput;
+/** Stop enforcement input — includes workflow awareness */
+export interface StopEnforceInput {
+    cwd?: string;
+    session_id?: string;
+    stop_reason?: string;
+}
+/** Workflow state context for stop enforcement */
+export interface StopWorkflowContext {
+    active: boolean;
+    workflow: string;
+    current_step: string;
+    current_role: string;
+    started_at: string;
+}
+/**
+ * Enforce Stop hook — verify workflow checkpoint completion.
+ *
+ * Safety valves (NEVER block):
+ *   - context_limit / context_window stops
+ *   - Stale workflow state (>2h)
+ *   - No active workflow
+ *   - No checkpoints defined
+ *
+ * Block when:
+ *   - Workflow active + unmet checkpoints for current step
+ */
+export declare function enforceStop(ir: ConstraintIR, input: StopEnforceInput, workflowState: StopWorkflowContext | null): HookOutput;
+/** Check if a file path is allowed by a list of write globs (prefix matching). */
+export declare function checkWriteAllowed(filePath: string, allowedGlobs: string[]): boolean;
+/**
+ * Extract directory prefix from a glob pattern.
+ * "src/**\/*.ts" → "src/"
+ * "test/**" → "test/"
+ * "*.md" → "" (root)
+ * "package.json" → "package.json" (exact path)
+ */
+export declare function globToPrefix(glob: string): string;
+/**
+ * Evaluate a gate condition against a PreToolUse input.
+ * Returns true if the condition triggers, false if not, null if too complex.
+ */
+export declare function evaluateGateCondition(condition: string, input: PreToolUseInput): boolean | null;
+/**
+ * Resolve a tool filter target to concrete Claude Code tool names.
+ */
+export declare function resolveToolTarget(target?: string): string[] | null;