intentdna 1.5.2 → 1.5.4

package/dist/hooks/enforce.js

@@ -23,11 +23,21 @@ import { relative, normalize } from "node:path";
  * Optional `roles` parameter provides output_schema enforcement.
  */
 export function enforcePreToolUse(ir, input, state, roles) {
+    // G4 Layer 1: Step enforce rules (state-driven)
+    if (state?.workflowState && ir.workflows_ir) {
+        const stepRuleResult = enforceStepRules(ir, input, state);
+        if (stepRuleResult !== null)
+            return stepRuleResult;
+    }
     // Layer 2: Role scope
     if (input.agent_type && ir.roles_scope_map && ir.roles_scope_map.length > 0) {
-        const result = enforceRoleScope(ir.roles_scope_map, input);
-        if (result)
-            return result;
+        // G4: Check if scope is relaxed by iteration-based rule
+        const relaxed = isStepScopeRelaxed(ir, state);
+        if (!relaxed) {
+            const result = enforceRoleScope(ir.roles_scope_map, input, getStepAdditionalPaths(ir, state));
+            if (result)
+                return result;
+        }
     }
     // Layer 3: Tool filters
     if (ir.tool_filters.length > 0) {
@@ -293,6 +303,53 @@ export function enforceStop(ir, input, workflowState) {
     return blockOutput(`[Intent DNA] Workflow '${workflowState.workflow}' has unmet checkpoints at step '${workflowState.current_step}':\n` +
         messages.map(m => `  - ${m}`).join("\n"));
 }
+// ── G4: State-driven Step Enforcement ─────────────────────
+/** Write tools that step read_only rule should block */
+const ALL_WRITE_TOOLS = new Set(["Edit", "Write", "NotebookEdit", "Bash"]);
+/**
+ * Find the StepEnforceRule for the current step in the active workflow.
+ */
+function findStepRule(ir, state) {
+    if (!state?.workflowState || !ir.workflows_ir)
+        return null;
+    const wf = ir.workflows_ir.find(w => w.workflow_name === state.workflowState.workflow);
+    if (!wf?.step_enforce_rules)
+        return null;
+    return wf.step_enforce_rules.find(r => r.step_id === state.workflowState.current_step) ?? null;
+}
+/**
+ * G4: Enforce step-level rules.
+ * Returns HookOutput if a rule triggers (block for read_only), null to continue.
+ */
+function enforceStepRules(ir, input, state) {
+    const rule = findStepRule(ir, state);
+    if (!rule)
+        return null;
+    // read_only: block all write tools
+    if (rule.read_only && ALL_WRITE_TOOLS.has(input.tool_name)) {
+        return blockOutput(`[Intent DNA] Step '${rule.step_id}' is read-only. Write tool '${input.tool_name}' blocked.`);
+    }
+    return null;
+}
+/**
+ * G4: Check if scope enforcement is relaxed for this step based on iteration.
+ * When iteration >= relax_after_iteration, scope checks are skipped (rescue mode).
+ */
+function isStepScopeRelaxed(ir, state) {
+    const rule = findStepRule(ir, state);
+    if (!rule?.relax_after_iteration)
+        return false;
+    const iteration = state?.workflowState?.iteration ?? 1;
+    return iteration >= rule.relax_after_iteration;
+}
+/**
+ * G4: Get additional write paths granted to the current step.
+ * These extend the role's scope for this specific step only.
+ */
+function getStepAdditionalPaths(ir, state) {
+    const rule = findStepRule(ir, state);
+    return rule?.additional_write_paths ?? [];
+}
 // ── Internal: Layer Enforcement ────────────────────────────
 /**
  * Enforce handoff consumes — verify that the current step's consumed
@@ -344,7 +401,7 @@ export function enforceHandoffProduces(ir, wfState) {
     }
     return null;
 }
-function enforceRoleScope(rolesScopeMap, input) {
+function enforceRoleScope(rolesScopeMap, input, additionalWritePaths = []) {
     if (!input.agent_type)
         return null;
     // Standard write tools: check single file path
@@ -352,7 +409,7 @@ function enforceRoleScope(rolesScopeMap, input) {
         const filePath = extractFilePath(input);
         if (!filePath)
             return null;
-        return checkPathAgainstScope(rolesScopeMap, input, filePath);
+        return checkPathAgainstScope(rolesScopeMap, input, filePath, additionalWritePaths);
     }
     // Bash: extract potential write targets from command
     if (input.tool_name === "Bash") {
@@ -363,7 +420,7 @@ function enforceRoleScope(rolesScopeMap, input) {
         if (writePaths.length === 0)
             return null;
         for (const p of writePaths) {
-            const result = checkPathAgainstScope(rolesScopeMap, input, p);
+            const result = checkPathAgainstScope(rolesScopeMap, input, p, additionalWritePaths);
             if (result)
                 return result;
         }
@@ -372,7 +429,7 @@ function enforceRoleScope(rolesScopeMap, input) {
     return null;
 }
 /** Check a single file path against role scope. Shared by Write tools and Bash. */
-function checkPathAgainstScope(rolesScopeMap, input, filePath) {
+function checkPathAgainstScope(rolesScopeMap, input, filePath, additionalWritePaths = []) {
     const cwd = input.cwd;
     let relativePath = cwd && filePath.startsWith("/") ? relative(cwd, filePath) : filePath;
     // Normalize to resolve traversal (e.g., "src/../../test/x.ts" → "../test/x.ts")
@@ -382,11 +439,15 @@ function checkPathAgainstScope(rolesScopeMap, input, filePath) {
         if (input.agent_type !== agentTypeName)
             continue;
         const writeGlobs = entry.scope.write ?? [];
-        if (writeGlobs.length === 0) {
+        // G4: merge step-specific additional_write_paths
+        const allWriteGlobs = additionalWritePaths.length > 0
+            ? [...writeGlobs, ...additionalWritePaths]
+            : writeGlobs;
+        if (allWriteGlobs.length === 0) {
             return allowOutput(`WARN [Intent DNA]: Role '${entry.role_name}' has no write permission (path: ${filePath}). Merge-time scope gate will filter.`);
         }
-        if (!checkWriteAllowed(relativePath, writeGlobs)) {
-            return allowOutput(`WARN [Intent DNA]: Role '${entry.role_name}' cannot write to '${filePath}' (allowed: ${writeGlobs.join(", ")}). Merge-time scope gate will filter.`);
+        if (!checkWriteAllowed(relativePath, allWriteGlobs)) {
+            return allowOutput(`WARN [Intent DNA]: Role '${entry.role_name}' cannot write to '${filePath}' (allowed: ${allWriteGlobs.join(", ")}). Merge-time scope gate will filter.`);
         }
         return null; // Role matched, write allowed
     }

package/dist/hooks/state.d.ts

@@ -79,19 +79,31 @@ export interface TraceEntry {
     timestamp: string;
 }
 /**
- * Append a trace entry to the daily trace file.
- * With sessionId: `.dna/state/trace/trace-YYYY-MM-DD-{sessionId}.jsonl`
- * Without: `.dna/state/trace/trace-YYYY-MM-DD.jsonl` (backward compat)
+ * Append a trace entry with dual-write strategy:
+ *   1. Always → global trace: `.dna/state/trace/trace-YYYY-MM-DD.jsonl` (merged view)
+ *   2. If sessionId → session-local: `.dna/state/sessions/{id}/trace.jsonl`
+ *
+ * G1: Session isolation — session traces live in the session directory,
+ * global trace provides a unified view across all sessions.
  * Fail-open: never throws.
  */
 export declare function appendTrace(projectDir: string, entry: TraceEntry, sessionId?: string): Promise<void>;
 /**
- * Read trace entries from the last N days.
- * With sessionId: reads only that session's trace files.
- * Without: reads all trace files (merged view).
+ * Read trace entries.
+ *
+ * G1 session isolation:
+ *   - With sessionId: reads from `.dna/state/sessions/{id}/trace.jsonl`
+ *     (falls back to legacy global files with sessionId in name for backward compat)
+ *   - Without sessionId: reads from `.dna/state/trace/trace-{date}.jsonl` (global merged view)
+ *
  * Returns parsed entries sorted by timestamp.
  */
 export declare function readTraces(projectDir: string, days?: number, sessionId?: string): Promise<TraceEntry[]>;
+/**
+ * List active session directories under `.dna/state/sessions/`.
+ * Returns session IDs (directory names).
+ */
+export declare function listSessions(projectDir: string): Promise<string[]>;
 /**
  * Clean up trace files older than retention period.
  * Removes `.dna/state/trace/trace-*.jsonl` files older than TRACE_RETENTION_DAYS.

package/dist/hooks/state.js

@@ -140,48 +140,104 @@ const TRACE_DIR = "trace";
 const MAX_TRACE_SIZE = 10 * 1024 * 1024; // 10MB
 const TRACE_RETENTION_DAYS = 7;
 /**
- * Build trace file name.
- * With session isolation: `trace-{date}-{sessionId}.jsonl`
- * Without: `trace-{date}.jsonl` (backward compat / merged view)
+ * Build global trace file name (merged view, no sessionId).
+ * Legacy files with sessionId in name are still readable for backward compat.
  */
-function traceFileName(date, sessionId) {
-    if (sessionId) {
-        return `trace-${date}-${sessionId}.jsonl`;
-    }
+function globalTraceFileName(date) {
     return `trace-${date}.jsonl`;
 }
 /**
- * Append a trace entry to the daily trace file.
- * With sessionId: `.dna/state/trace/trace-YYYY-MM-DD-{sessionId}.jsonl`
- * Without: `.dna/state/trace/trace-YYYY-MM-DD.jsonl` (backward compat)
+ * Append a trace entry with dual-write strategy:
+ *   1. Always → global trace: `.dna/state/trace/trace-YYYY-MM-DD.jsonl` (merged view)
+ *   2. If sessionId → session-local: `.dna/state/sessions/{id}/trace.jsonl`
+ *
+ * G1: Session isolation — session traces live in the session directory,
+ * global trace provides a unified view across all sessions.
  * Fail-open: never throws.
  */
 export async function appendTrace(projectDir, entry, sessionId) {
     try {
-        const traceDir = join(projectDir, ".dna", "state", TRACE_DIR);
-        await mkdir(traceDir, { recursive: true });
+        const line = JSON.stringify(entry) + "\n";
         const date = entry.timestamp.slice(0, 10);
-        const tracePath = join(traceDir, traceFileName(date, sessionId));
-        // Check file size — rotate if over limit
+        // 1. Global trace (merged view)
+        const globalTraceDir = join(projectDir, ".dna", "state", TRACE_DIR);
+        await mkdir(globalTraceDir, { recursive: true });
+        const globalPath = join(globalTraceDir, globalTraceFileName(date));
         try {
-            const stats = await stat(tracePath);
+            const stats = await stat(globalPath);
             if (stats.size >= MAX_TRACE_SIZE)
-                return; // silently skip if file too large
+                return;
         }
         catch { /* file doesn't exist yet */ }
-        await appendFile(tracePath, JSON.stringify(entry) + "\n", "utf-8");
+        await appendFile(globalPath, line, "utf-8");
+        // 2. Session-local trace (if session isolated)
+        if (sessionId) {
+            const sessionDir = resolveStateDir(projectDir, sessionId);
+            await mkdir(sessionDir, { recursive: true });
+            const sessionTracePath = join(sessionDir, "trace.jsonl");
+            try {
+                const stats = await stat(sessionTracePath);
+                if (stats.size >= MAX_TRACE_SIZE)
+                    return;
+            }
+            catch { /* file doesn't exist yet */ }
+            await appendFile(sessionTracePath, line, "utf-8");
+        }
     }
     catch {
         // Fail-open: trace write failure never affects hook execution
     }
 }
 /**
- * Read trace entries from the last N days.
- * With sessionId: reads only that session's trace files.
- * Without: reads all trace files (merged view).
+ * Read trace entries.
+ *
+ * G1 session isolation:
+ *   - With sessionId: reads from `.dna/state/sessions/{id}/trace.jsonl`
+ *     (falls back to legacy global files with sessionId in name for backward compat)
+ *   - Without sessionId: reads from `.dna/state/trace/trace-{date}.jsonl` (global merged view)
+ *
  * Returns parsed entries sorted by timestamp.
  */
 export async function readTraces(projectDir, days = 1, sessionId) {
+    const entries = [];
+    if (sessionId) {
+        // Session-specific: read from session directory first
+        const sessionDir = resolveStateDir(projectDir, sessionId);
+        const sessionTracePath = join(sessionDir, "trace.jsonl");
+        const sessionEntries = await readTraceFile(sessionTracePath);
+        entries.push(...sessionEntries);
+        // Backward compat: also check legacy files in global trace dir
+        if (entries.length === 0) {
+            const legacyEntries = await readGlobalTraces(projectDir, days, sessionId);
+            entries.push(...legacyEntries);
+        }
+    }
+    else {
+        // Global merged view
+        const globalEntries = await readGlobalTraces(projectDir, days);
+        entries.push(...globalEntries);
+    }
+    return entries.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+}
+/** Read all entries from a single trace file. */
+async function readTraceFile(filePath) {
+    const entries = [];
+    try {
+        const content = await readFile(filePath, "utf-8");
+        for (const line of content.trim().split("\n")) {
+            if (!line)
+                continue;
+            try {
+                entries.push(JSON.parse(line));
+            }
+            catch { /* skip malformed */ }
+        }
+    }
+    catch { /* file doesn't exist */ }
+    return entries;
+}
+/** Read global trace files from `.dna/state/trace/`. */
+async function readGlobalTraces(projectDir, days, sessionIdFilter) {
     const traceDir = join(projectDir, ".dna", "state", TRACE_DIR);
     const entries = [];
     const cutoff = new Date();
@@ -192,28 +248,20 @@ export async function readTraces(projectDir, days = 1, sessionId) {
         const traceFiles = files
             .filter(f => f.startsWith("trace-") && f.endsWith(".jsonl"))
             .filter(f => {
-            // Extract date from filename: trace-YYYY-MM-DD.jsonl or trace-YYYY-MM-DD-{sessionId}.jsonl
             const fileDate = f.slice(6, 16); // "trace-YYYY-MM-DD..."
             if (fileDate < cutoffDate)
                 return false;
-            // Session filter: only include files for this session (or shared files)
-            if (sessionId) {
-                const suffix = f.slice(16); // "-{sessionId}.jsonl" or ".jsonl"
-                return suffix === `-${sessionId}.jsonl` || suffix === ".jsonl";
+            // Legacy session filter: files with sessionId in name
+            if (sessionIdFilter) {
+                const suffix = f.slice(16);
+                return suffix === `-${sessionIdFilter}.jsonl` || suffix === ".jsonl";
             }
             return true;
         })
             .sort();
         for (const file of traceFiles) {
-            const content = await readFile(join(traceDir, file), "utf-8");
-            for (const line of content.trim().split("\n")) {
-                if (!line)
-                    continue;
-                try {
-                    entries.push(JSON.parse(line));
-                }
-                catch { /* skip malformed */ }
-            }
+            const fileEntries = await readTraceFile(join(traceDir, file));
+            entries.push(...fileEntries);
         }
     }
     catch {
@@ -221,6 +269,29 @@ export async function readTraces(projectDir, days = 1, sessionId) {
     }
     return entries;
 }
+/**
+ * List active session directories under `.dna/state/sessions/`.
+ * Returns session IDs (directory names).
+ */
+export async function listSessions(projectDir) {
+    const sessionsDir = join(projectDir, ".dna", "state", "sessions");
+    try {
+        const entries = await readdir(sessionsDir);
+        const sessions = [];
+        for (const entry of entries) {
+            try {
+                const entryStat = await stat(join(sessionsDir, entry));
+                if (entryStat.isDirectory())
+                    sessions.push(entry);
+            }
+            catch { /* skip */ }
+        }
+        return sessions;
+    }
+    catch {
+        return [];
+    }
+}
 /**
  * Clean up trace files older than retention period.
  * Removes `.dna/state/trace/trace-*.jsonl` files older than TRACE_RETENTION_DAYS.

package/dist/mcp/index.d.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+/**
+ * Intent DNA — MCP Server (`dna-mcp`)
+ *
+ * Claude Code MCP server providing DNA governance tools:
+ *   G2: State management (workflow, trace, status)
+ *   G3: Compile toolchain (compile, validate, sync)
+ *
+ * Usage: dna-mcp [--project-dir <path>]
+ *
+ * Speaks JSON-RPC 2.0 over stdio (MCP protocol).
+ */
+export {};

package/dist/mcp/index.js

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+/**
+ * Intent DNA — MCP Server (`dna-mcp`)
+ *
+ * Claude Code MCP server providing DNA governance tools:
+ *   G2: State management (workflow, trace, status)
+ *   G3: Compile toolchain (compile, validate, sync)
+ *
+ * Usage: dna-mcp [--project-dir <path>]
+ *
+ * Speaks JSON-RPC 2.0 over stdio (MCP protocol).
+ */
+import { createMCPServer } from "./server.js";
+import { createStateTools } from "./tools-state.js";
+import { createCompileTools } from "./tools-compile.js";
+import { createEnforceTools } from "./tools-enforce.js";
+// Parse args
+const args = process.argv.slice(2);
+let projectDir = process.cwd();
+const dirIdx = args.indexOf("--project-dir");
+if (dirIdx !== -1 && args[dirIdx + 1]) {
+    projectDir = args[dirIdx + 1];
+}
+// Resolve version from package.json (best-effort)
+let version = "1.5.3";
+try {
+    const { readFileSync } = await import("node:fs");
+    const { resolve } = await import("node:path");
+    const { fileURLToPath } = await import("node:url");
+    const pkgPath = resolve(fileURLToPath(import.meta.url), "..", "..", "..", "package.json");
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    version = pkg.version ?? version;
+}
+catch { /* use default */ }
+const tools = [
+    ...createStateTools(projectDir),
+    ...createCompileTools(projectDir),
+    ...createEnforceTools(projectDir),
+];
+createMCPServer({ name: "intentdna", version }, tools);

package/dist/mcp/server.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Intent DNA — MCP Server Framework
+ *
+ * Minimal MCP server supporting:
+ *   - initialize / initialized handshake
+ *   - tools/list — list available tools
+ *   - tools/call — execute a tool
+ *   - ping — health check
+ *
+ * Zero external dependencies. Speaks MCP protocol over stdio.
+ */
+export interface ToolDef {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: Record<string, unknown>;
+        required?: string[];
+    };
+    handler: (args: Record<string, unknown>) => Promise<ToolResult>;
+}
+export interface ToolResult {
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    isError?: boolean;
+}
+export declare function textResult(text: string): ToolResult;
+export declare function errorResult(text: string): ToolResult;
+export interface ServerInfo {
+    name: string;
+    version: string;
+}
+/**
+ * Create and start an MCP server with the given tools.
+ * Blocks on stdin — call this as the last thing in your entry point.
+ */
+export declare function createMCPServer(info: ServerInfo, tools: ToolDef[]): void;

package/dist/mcp/server.js

@@ -0,0 +1,84 @@
+/**
+ * Intent DNA — MCP Server Framework
+ *
+ * Minimal MCP server supporting:
+ *   - initialize / initialized handshake
+ *   - tools/list — list available tools
+ *   - tools/call — execute a tool
+ *   - ping — health check
+ *
+ * Zero external dependencies. Speaks MCP protocol over stdio.
+ */
+import { startTransport, sendResult, sendError } from "./transport.js";
+// ── Result Helpers ───────────────────────────────────────
+export function textResult(text) {
+    return { content: [{ type: "text", text }] };
+}
+export function errorResult(text) {
+    return { content: [{ type: "text", text }], isError: true };
+}
+/**
+ * Create and start an MCP server with the given tools.
+ * Blocks on stdin — call this as the last thing in your entry point.
+ */
+export function createMCPServer(info, tools) {
+    const toolMap = new Map();
+    for (const tool of tools) {
+        toolMap.set(tool.name, tool);
+    }
+    startTransport(async (msg) => {
+        switch (msg.method) {
+            case "initialize":
+                sendResult(msg.id ?? null, {
+                    protocolVersion: "2024-11-05",
+                    capabilities: { tools: {} },
+                    serverInfo: { name: info.name, version: info.version },
+                });
+                break;
+            case "notifications/initialized":
+                // Client acknowledgement — no response needed
+                break;
+            case "ping":
+                sendResult(msg.id ?? null, {});
+                break;
+            case "tools/list":
+                sendResult(msg.id ?? null, {
+                    tools: tools.map(t => ({
+                        name: t.name,
+                        description: t.description,
+                        inputSchema: t.inputSchema,
+                    })),
+                });
+                break;
+            case "tools/call": {
+                const params = msg.params ?? {};
+                const toolName = params.name;
+                const args = (params.arguments ?? {});
+                const tool = toolMap.get(toolName);
+                if (!tool) {
+                    sendResult(msg.id ?? null, {
+                        content: [{ type: "text", text: `Unknown tool: ${toolName}` }],
+                        isError: true,
+                    });
+                    break;
+                }
+                try {
+                    const result = await tool.handler(args);
+                    sendResult(msg.id ?? null, result);
+                }
+                catch (err) {
+                    sendResult(msg.id ?? null, {
+                        content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }],
+                        isError: true,
+                    });
+                }
+                break;
+            }
+            default:
+                if (msg.id !== undefined) {
+                    sendError(msg.id, -32601, `Method not found: ${msg.method}`);
+                }
+                break;
+        }
+    });
+}

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

@@ -0,0 +1,10 @@
+/**
+ * Intent DNA — MCP Compile Tools (G3)
+ *
+ * Tools for compiling and managing DNA via MCP:
+ *   - dna_compile: Compile DNA config to Constraint IR
+ *   - dna_validate: Validate a DNA config file
+ *   - dna_sync: Run full sync pipeline (compile + inject + hooks)
+ */
+import type { ToolDef } from "./server.js";
+export declare function createCompileTools(projectDir: string): ToolDef[];