intentdna 1.4.4 → 1.4.6

package/.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
     {
       "name": "intentdna",
       "description": "DNA template compilation + runtime enforcement",
-      "version": "1.4.4",
+      "version": "1.4.6",
       "source": "./"
     }
   ]

package/.claude-plugin/plugin.json

@@ -1,5 +1,5 @@
 {
   "name": "intentdna",
-  "version": "1.4.4",
+  "version": "1.4.6",
   "description": "Declarative policy layer for AI agent governance"
 }

package/dist/cli/commands/feedback.d.ts

@@ -0,0 +1,33 @@
+/**
+ * dna feedback [--days <N>] [--json]
+ *
+ * Analyze trace/audit data and produce actionable feedback for template optimization.
+ *
+ * Reads: .dna/state/trace/trace-*.jsonl
+ * Outputs: human-readable report (or JSON with --json)
+ */
+export interface FeedbackOptions {
+    days: number;
+    json: boolean;
+}
+export interface FeedbackReport {
+    period_days: number;
+    total_events: 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;
+    }>;
+    suggestions: string[];
+}
+export declare function runFeedback(opts: FeedbackOptions): Promise<number>;

package/dist/cli/commands/feedback.js

@@ -0,0 +1,140 @@
+/**
+ * dna feedback [--days <N>] [--json]
+ *
+ * Analyze trace/audit data and produce actionable feedback for template optimization.
+ *
+ * Reads: .dna/state/trace/trace-*.jsonl
+ * Outputs: human-readable report (or JSON with --json)
+ */
+import { readTraces } from "../../hooks/state.js";
+function aggregate(traces) {
+    let blocks = 0, warns = 0, allows = 0;
+    const toolCounts = new Map();
+    const pathCounts = new Map();
+    const reasonCounts = new Map();
+    for (const t of traces) {
+        if (t.decision === "block") {
+            blocks++;
+            if (t.tool_name)
+                toolCounts.set(t.tool_name, (toolCounts.get(t.tool_name) ?? 0) + 1);
+            if (t.target_path)
+                pathCounts.set(t.target_path, (pathCounts.get(t.target_path) ?? 0) + 1);
+            if (t.reason) {
+                // Normalize reason to first line
+                const shortReason = t.reason.split("\n")[0].replace(/^\[Intent DNA\]\s*/, "").slice(0, 100);
+                reasonCounts.set(shortReason, (reasonCounts.get(shortReason) ?? 0) + 1);
+            }
+        }
+        else if (t.decision === "warn") {
+            warns++;
+        }
+        else {
+            allows++;
+        }
+    }
+    const sorted = (map, limit, key) => [...map.entries()]
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, limit)
+        .map(([k, count]) => ({ [key]: k, count }));
+    return {
+        total_events: traces.length,
+        blocks,
+        warns,
+        allows,
+        top_blocked_tools: sorted(toolCounts, 5, "tool"),
+        top_blocked_paths: sorted(pathCounts, 5, "path"),
+        top_block_reasons: sorted(reasonCounts, 5, "reason"),
+    };
+}
+function generateSuggestions(report) {
+    const suggestions = [];
+    if (report.blocks === 0 && report.warns === 0) {
+        suggestions.push("No blocks or warnings — DNA constraints are not firing. Consider tightening rules or verifying hooks are active.");
+        return suggestions;
+    }
+    const blockRate = report.total_events > 0 ? report.blocks / report.total_events : 0;
+    if (blockRate > 0.3) {
+        suggestions.push(`High block rate (${(blockRate * 100).toFixed(0)}%). Review if DNA rules are too restrictive — this may slow development.`);
+    }
+    // Tool-specific suggestions
+    for (const t of report.top_blocked_tools) {
+        if (t.count >= 5) {
+            suggestions.push(`Tool '${t.tool}' blocked ${t.count} times. Consider expanding permissions if this is expected usage.`);
+        }
+    }
+    // Path-specific suggestions
+    for (const p of report.top_blocked_paths) {
+        if (p.count >= 3) {
+            suggestions.push(`Path '${p.path}' blocked ${p.count} times. Consider adding to write scope if agents need access.`);
+        }
+    }
+    // Repeated reason patterns
+    for (const r of report.top_block_reasons) {
+        if (r.count >= 3) {
+            suggestions.push(`Repeated block: "${r.reason}" (${r.count}x). May indicate a rule-scope mismatch.`);
+        }
+    }
+    if (suggestions.length === 0) {
+        suggestions.push("Constraints are working within normal parameters. No action needed.");
+    }
+    return suggestions;
+}
+function formatReport(report) {
+    const lines = [];
+    lines.push(`DNA Feedback Report (last ${report.period_days} day${report.period_days > 1 ? "s" : ""})`);
+    lines.push("=".repeat(50));
+    lines.push("");
+    lines.push(`Total events: ${report.total_events}`);
+    lines.push(`  Allowed: ${report.allows}`);
+    lines.push(`  Blocked: ${report.blocks}`);
+    lines.push(`  Warned:  ${report.warns}`);
+    lines.push("");
+    if (report.top_blocked_tools.length > 0) {
+        lines.push("Top blocked tools:");
+        for (const t of report.top_blocked_tools) {
+            lines.push(`  ${t.tool}: ${t.count}`);
+        }
+        lines.push("");
+    }
+    if (report.top_blocked_paths.length > 0) {
+        lines.push("Top blocked paths:");
+        for (const p of report.top_blocked_paths) {
+            lines.push(`  ${p.path}: ${p.count}`);
+        }
+        lines.push("");
+    }
+    if (report.top_block_reasons.length > 0) {
+        lines.push("Top block reasons:");
+        for (const r of report.top_block_reasons) {
+            lines.push(`  "${r.reason}": ${r.count}`);
+        }
+        lines.push("");
+    }
+    if (report.suggestions.length > 0) {
+        lines.push("Suggestions:");
+        for (const s of report.suggestions) {
+            lines.push(`  - ${s}`);
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+export async function runFeedback(opts) {
+    const projectDir = process.cwd();
+    const traces = await readTraces(projectDir, opts.days);
+    if (traces.length === 0) {
+        process.stderr.write(`No trace data found for the last ${opts.days} day(s).\n`);
+        process.stderr.write("Traces are generated by dna-hook during Claude Code sessions.\n");
+        return 0;
+    }
+    const stats = aggregate(traces);
+    const suggestions = generateSuggestions(stats);
+    const report = { ...stats, period_days: opts.days, suggestions };
+    if (opts.json) {
+        process.stdout.write(JSON.stringify(report, null, 2) + "\n");
+    }
+    else {
+        process.stderr.write(formatReport(report));
+    }
+    return 0;
+}

package/dist/cli/commands/generate.js

@@ -38,6 +38,9 @@ const TEMPLATE_KEYWORDS = {
     "brainstorming-first": ["brainstorm", "explore", "ideation", "探索"],
     "branch-finishing": ["branch", "finish", "cleanup", "pr prep"],
     "pr-submitter": ["pr", "pull request", "submit"],
+    "migration-safety": ["migration", "migrate", "upgrade", "database migration", "dependency upgrade", "迁移"],
+    "incident-response": ["incident", "production issue", "hotfix", "outage", "postmortem", "事故"],
+    "performance-audit": ["performance", "profiling", "benchmark", "optimize", "latency", "性能"],
 };
 function scoreTemplates(description) {
     const lower = description.toLowerCase();

package/dist/cli/commands/setup.d.ts

@@ -17,5 +17,6 @@ export type SetupScope = "user" | "project";
 export interface SetupOptions {
     scope: SetupScope;
     yes: boolean;
+    upgrade: boolean;
 }
 export declare function runSetup(opts: SetupOptions): Promise<number>;

package/dist/cli/commands/setup.js

@@ -95,7 +95,132 @@ function isPluginRegistered() {
     }
 }
 // ── Main ──────────────────────────────────────────────────
+/**
+ * Get the currently installed version of intentdna.
+ */
+function getInstalledVersion() {
+    try {
+        const result = execSync("npm list -g intentdna --json 2>/dev/null", {
+            encoding: "utf-8",
+            timeout: 10000,
+        });
+        const data = JSON.parse(result);
+        return data?.dependencies?.intentdna?.version ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Get the latest published version from npm registry.
+ */
+function getLatestVersion() {
+    try {
+        return execSync("npm view intentdna version 2>/dev/null", {
+            encoding: "utf-8",
+            timeout: 10000,
+        }).trim();
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Upgrade flow: npm update → re-register marketplace → re-install plugin.
+ */
+async function runUpgrade(opts) {
+    // Step 1: Detect claude CLI
+    const claudeVersion = detectClaudeCLI();
+    if (!claudeVersion) {
+        log("Claude Code CLI not detected. Cannot upgrade plugin.");
+        return 1;
+    }
+    log(`Claude Code detected: ${claudeVersion}`);
+    // Step 2: Check versions
+    const currentVer = getInstalledVersion();
+    const latestVer = getLatestVersion();
+    if (currentVer)
+        log(`Current version: ${currentVer}`);
+    if (latestVer)
+        log(`Latest version:  ${latestVer}`);
+    if (currentVer && latestVer && currentVer === latestVer) {
+        log("Already at latest version.");
+    }
+    else {
+        // Step 3: npm update
+        log("");
+        log("Updating intentdna...");
+        try {
+            execSync("npm update -g intentdna", {
+                encoding: "utf-8",
+                timeout: 60000,
+                stdio: ["inherit", "pipe", "pipe"],
+            });
+            const newVer = getInstalledVersion();
+            log(`Updated to: ${newVer ?? "unknown"}`);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            log(`npm update failed: ${msg}`);
+            log("Try manually: npm update -g intentdna");
+            return 1;
+        }
+    }
+    // Step 4: Re-resolve package path
+    const pkgPath = await resolvePackagePath();
+    if (!pkgPath) {
+        log("Error: Could not find intentdna package after update.");
+        return 1;
+    }
+    log(`Package path: ${pkgPath}`);
+    // Step 5: Re-register marketplace (picks up new plugin.json version)
+    try {
+        log("");
+        log(`Re-registering marketplace: ${pkgPath}`);
+        execSync(`claude plugin marketplace add "${pkgPath}"`, {
+            encoding: "utf-8",
+            timeout: 30000,
+            stdio: ["inherit", "pipe", "pipe"],
+        });
+        log("Marketplace updated.");
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        log(`Warning: marketplace re-register failed: ${msg}`);
+    }
+    // Step 6: Re-install plugin (picks up new hooks.json)
+    try {
+        const installCmd = `claude plugin install intentdna@intentdna --scope ${opts.scope}`;
+        log(`Re-installing plugin: ${installCmd}`);
+        execSync(installCmd, {
+            encoding: "utf-8",
+            timeout: 30000,
+            stdio: ["inherit", "pipe", "pipe"],
+        });
+        log("Plugin re-installed.");
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        log(`Warning: plugin re-install failed: ${msg}`);
+    }
+    // Step 7: Verify
+    if (isPluginRegistered()) {
+        log("");
+        log("Upgrade complete. Run 'dna sync' to recompile your DNA templates.");
+        return 0;
+    }
+    else {
+        log("");
+        log("Upgrade completed but plugin verification failed.");
+        log("Try: claude plugin list");
+        return 1;
+    }
+}
 export async function runSetup(opts) {
+    // Upgrade mode
+    if (opts.upgrade) {
+        return runUpgrade(opts);
+    }
     const scope = opts.scope;
     // Step 1: Detect claude CLI
     const claudeVersion = detectClaudeCLI();

package/dist/cli/index.js

@@ -17,7 +17,7 @@ const HELP = `Intent DNA CLI v0.3.0
 Usage: dna <command> [options]
 
 Commands:
-  setup         Register intentdna as a Claude Code plugin (--scope user|project, --yes)
+  setup         Register intentdna as a Claude Code plugin (--scope user|project, --upgrade, --yes)
   guard         Zero-config guardrails — detect environment, apply safety rules
   sync          Compile + inject DNA into target file (CLAUDE.md, SOUL.md, etc.)
   verify        Verify synced files match .dna/lock checksums (drift detection)
@@ -29,6 +29,7 @@ Commands:
   show          Show gene expression state
   evolve        Generate epigenetic markers from outcomes
   epigenetic    Record outcomes, view markers and summaries
+  feedback      Analyze trace data, suggest template optimizations (--days <N>, --json)
 
 Options:
   --help, -h    Show help for a command
@@ -387,6 +388,7 @@ async function main() {
                 options: {
                     scope: { type: "string", short: "s", default: "user" },
                     yes: { type: "boolean", short: "y", default: false },
+                    upgrade: { type: "boolean", short: "u", default: false },
                 },
                 strict: false,
             });
@@ -399,6 +401,24 @@ async function main() {
             const code = await runSetup({
                 scope: setupScope,
                 yes: setupValues.yes,
+                upgrade: setupValues.upgrade,
+            });
+            process.exit(code);
+            break;
+        }
+        case "feedback": {
+            const { values: fbValues } = parseArgs({
+                args: rest,
+                options: {
+                    days: { type: "string", short: "d", default: "7" },
+                    json: { type: "boolean", default: false },
+                },
+                strict: false,
+            });
+            const { runFeedback } = await import("./commands/feedback.js");
+            const code = await runFeedback({
+                days: parseInt(fbValues.days, 10) || 7,
+                json: fbValues.json,
             });
             process.exit(code);
             break;

package/dist/compiler/workflow.d.ts

@@ -5,7 +5,7 @@
  * Performs topological sort, parallel group detection, transition compilation,
  * retry config resolution, cycle detection, and optional Mermaid diagram generation.
  */
-import type { WorkflowDef, WorkflowPlan, RoleDef } from "../schema/types.js";
+import type { WorkflowDef, WorkflowStepDef, WorkflowPlan, RoleDef, RawWorkflowStepEntry } from "../schema/types.js";
 export interface CompileWorkflowOptions {
     /** Generate Mermaid diagram (default: false) */
     mermaid?: boolean;
@@ -21,6 +21,22 @@ export interface CompileWorkflowResult {
     plan?: WorkflowPlan;
     errors: CompileWorkflowError[];
 }
+/**
+ * Expand parallel blocks into regular steps with depends_on.
+ *
+ * A parallel block:
+ *   - parallel:
+ *       isolation: worktree
+ *       steps: [{id: "a", role: "x"}, {id: "b", role: "y"}]
+ *
+ * Becomes:
+ *   - {id: "a", role: "x", depends_on: [<prev_step>], isolation: worktree}
+ *   - {id: "b", role: "y", depends_on: [<prev_step>], isolation: worktree}
+ *
+ * The step immediately before the parallel block is the dependency.
+ * If no previous step, the parallel steps have no depends_on.
+ */
+export declare function expandParallelBlocks(steps: RawWorkflowStepEntry[]): WorkflowStepDef[];
 /**
  * Check if two sets of write glob patterns have overlapping scope.
  * Uses prefix-based matching: "src/xx" and "src/lib/xx" overlap.

package/dist/compiler/workflow.js

@@ -6,6 +6,66 @@
  * retry config resolution, cycle detection, and optional Mermaid diagram generation.
  */
 // ── Internal helpers ─────────────────────────────────────────
+/**
+ * Type guard: check if a step entry is a parallel block (syntax sugar).
+ */
+function isParallelBlock(entry) {
+    return "parallel" in entry && typeof entry.parallel === "object";
+}
+/**
+ * Expand parallel blocks into regular steps with depends_on.
+ *
+ * A parallel block:
+ *   - parallel:
+ *       isolation: worktree
+ *       steps: [{id: "a", role: "x"}, {id: "b", role: "y"}]
+ *
+ * Becomes:
+ *   - {id: "a", role: "x", depends_on: [<prev_step>], isolation: worktree}
+ *   - {id: "b", role: "y", depends_on: [<prev_step>], isolation: worktree}
+ *
+ * The step immediately before the parallel block is the dependency.
+ * If no previous step, the parallel steps have no depends_on.
+ */
+export function expandParallelBlocks(steps) {
+    const result = [];
+    let lastStepId = null;
+    for (const entry of steps) {
+        if (isParallelBlock(entry)) {
+            const block = entry.parallel;
+            const expandedIds = [];
+            for (const inner of block.steps) {
+                const expanded = {
+                    ...inner,
+                    // Add depends_on from last step before this block
+                    depends_on: lastStepId
+                        ? [...(inner.depends_on ?? []), lastStepId]
+                        : inner.depends_on,
+                    // Inherit isolation from parallel block if step doesn't override
+                    isolation: inner.isolation ?? block.isolation,
+                };
+                result.push(expanded);
+                expandedIds.push(inner.id);
+            }
+            // After expansion, "lastStepId" stays as the set of expanded IDs.
+            // The next step should depend on ALL parallel steps.
+            // We can't set a single lastStepId, so we track it differently:
+            // We set lastStepId to null and let the NEXT regular step
+            // depend on all expanded IDs via explicit depends_on in the input.
+            // Actually, the simplest approach: peek at the next step.
+            // If the next step already has depends_on referencing these IDs, good.
+            // Otherwise, we need a way to inject deps.
+            // Since this is sugar, we rely on the user specifying depends_on
+            // on the join step (like in the spec example).
+            lastStepId = null; // Reset — next step must use explicit depends_on
+        }
+        else {
+            result.push(entry);
+            lastStepId = entry.id;
+        }
+    }
+    return result;
+}
 /**
  * If no step in the workflow has depends_on, inject implicit sequential
  * dependencies based on array order (step[i] depends_on step[i-1]).
@@ -332,8 +392,10 @@ export function compileWorkflow(workflow, options) {
         });
         return { ok: false, errors };
     }
+    // 1.5. Expand parallel blocks (syntax sugar) into regular steps
+    const expandedSteps = expandParallelBlocks(workflow.steps);
     // 2. Infer implicit deps if no step has depends_on
-    const resolvedSteps = inferImplicitDeps(workflow.steps);
+    const resolvedSteps = inferImplicitDeps(expandedSteps);
     // 3. Build dependency graph
     const graph = buildDependencyGraph(resolvedSteps);
     // 4. Topological sort + cycle detection

package/dist/hooks/cli.d.ts

@@ -14,4 +14,23 @@
  *
  * Fail-open: all errors → { continue: true, suppressOutput: true }
  */
-export {};
+export interface SessionSummary {
+    total: number;
+    blocks: number;
+    warns: number;
+    topBlockedTools: Array<{
+        tool: string;
+        count: number;
+    }>;
+    topBlockedPaths: Array<{
+        path: string;
+        count: number;
+    }>;
+}
+export declare function computeSummary(traces: Array<{
+    decision: string;
+    tool_name?: string;
+    target_path?: string;
+    reason?: string;
+}>): SessionSummary;
+export declare function formatSummary(s: SessionSummary): string | null;

package/dist/hooks/cli.js

@@ -17,15 +17,54 @@
 import { readFile, stat } from "node:fs/promises";
 import { resolve } from "node:path";
 import { randomUUID } from "node:crypto";
-import { readStdin, writeOutput, silentOutput } from "./protocol.js";
+import { readStdin, writeOutput, silentOutput, allowOutput } from "./protocol.js";
 import { enforcePreToolUse, enforcePostToolUse, enforceUserPromptSubmit, enforceSubagentStop, enforcePreCompact, enforceNotification, enforceSessionStart, enforceStop, } from "./enforce.js";
-import { appendAudit, readWorkflowState, appendTrace, rotateTraces } from "./state.js";
+import { appendAudit, readWorkflowState, appendTrace, rotateTraces, readTraces } 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",
 ]);
+export function computeSummary(traces) {
+    let blocks = 0, warns = 0;
+    const toolCounts = new Map();
+    const pathCounts = new Map();
+    for (const t of traces) {
+        if (t.decision === "block") {
+            blocks++;
+            if (t.tool_name)
+                toolCounts.set(t.tool_name, (toolCounts.get(t.tool_name) ?? 0) + 1);
+            if (t.target_path)
+                pathCounts.set(t.target_path, (pathCounts.get(t.target_path) ?? 0) + 1);
+        }
+        else if (t.decision === "warn") {
+            warns++;
+        }
+    }
+    const topBlockedTools = [...toolCounts.entries()]
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 3)
+        .map(([tool, count]) => ({ tool, count }));
+    const topBlockedPaths = [...pathCounts.entries()]
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 3)
+        .map(([path, count]) => ({ path, count }));
+    return { total: traces.length, blocks, warns, topBlockedTools, topBlockedPaths };
+}
+export function formatSummary(s) {
+    if (s.blocks === 0 && s.warns === 0)
+        return null;
+    const lines = [];
+    lines.push(`[Intent DNA] Session summary: ${s.total} events, ${s.blocks} blocked, ${s.warns} warned`);
+    if (s.topBlockedTools.length > 0) {
+        lines.push("  Top blocked tools: " + s.topBlockedTools.map(t => `${t.tool}(${t.count})`).join(", "));
+    }
+    if (s.topBlockedPaths.length > 0) {
+        lines.push("  Top blocked paths: " + s.topBlockedPaths.map(p => `${p.path}(${p.count})`).join(", "));
+    }
+    return lines.join("\n");
+}
 // ── Main ───────────────────────────────────────────────────
 async function main() {
     // Parse args
@@ -67,7 +106,7 @@ async function main() {
             state.existingArtifactPaths = await scanConsumedArtifactPaths(projectDir, ir, wfState.workflow, wfState.current_step);
         }
     }
-    // Special handling for Stop — needs async workflow state read
+    // Special handling for Stop — needs async workflow state read + session summary
     if (event === "Stop") {
         const wfState = await readWorkflowState(projectDir, sessionId);
         const stopContext = wfState ? {
@@ -78,11 +117,28 @@ async function main() {
             started_at: wfState.started_at,
             completed_artifacts: wfState.completed_artifacts,
         } : null;
-        const stopOutput = enforceStop(ir, {
+        let 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);
+        // Session summary: aggregate block/warn stats from trace
+        try {
+            const traces = await readTraces(projectDir, 1);
+            const summary = computeSummary(traces);
+            const summaryText = formatSummary(summary);
+            if (summaryText) {
+                if (stopOutput.suppressOutput) {
+                    // Was silent → upgrade to allow with summary
+                    stopOutput = allowOutput(summaryText, "Stop");
+                }
+                else if (stopOutput.reason) {
+                    // Was a block → append summary to reason
+                    stopOutput.reason += "\n\n" + summaryText;
+                }
+            }
+        }
+        catch { /* fail-open: summary failure never blocks */ }
         writeOutput(stopOutput);
         // Trace for Stop
         appendTrace(projectDir, {
@@ -91,7 +147,7 @@ async function main() {
             workflow: wfState?.workflow,
             step: wfState?.current_step,
             decision: stopOutput.continue === false ? "block" : "allow",
-            duration_ms: Date.now() - Date.now(), // minimal
+            duration_ms: 0,
             timestamp: new Date().toISOString(),
         }).catch(() => { });
         return;

package/dist/hooks/index.d.ts

@@ -7,3 +7,4 @@
 export { type HookEvent, type HookInput, type HookOutput, type HookInputBase, type PreToolUseInput, type PostToolUseInput, type UserPromptSubmitInput, type SubagentStopInput, type PreCompactInput, type NotificationInput, type StopInput, type SessionStartInput as SessionStartHookInput, readStdin, writeOutput, allowOutput, blockOutput, escalateOutput, silentOutput, } from "./protocol.js";
 export { type EnforceState, type SessionStartInput, type StopEnforceInput, type StopWorkflowContext, enforcePreToolUse, enforcePostToolUse, enforceUserPromptSubmit, enforceSubagentStop, enforcePreCompact, enforceNotification, enforceSessionStart, enforceStop, checkWriteAllowed, globToPrefix, evaluateGateCondition, resolveToolTarget, } from "./enforce.js";
 export { type DNAWorkflowState, type AuditEntry, resolveStateDir, readWorkflowState, writeWorkflowState, clearWorkflowState, appendAudit, } from "./state.js";
+export { type SessionSummary, computeSummary, formatSummary, } from "./cli.js";

package/dist/hooks/index.js

@@ -10,3 +10,5 @@ export { readStdin, writeOutput, allowOutput, blockOutput, escalateOutput, silen
 export { enforcePreToolUse, enforcePostToolUse, enforceUserPromptSubmit, enforceSubagentStop, enforcePreCompact, enforceNotification, enforceSessionStart, enforceStop, checkWriteAllowed, globToPrefix, evaluateGateCondition, resolveToolTarget, } from "./enforce.js";
 // State management
 export { resolveStateDir, readWorkflowState, writeWorkflowState, clearWorkflowState, appendAudit, } from "./state.js";
+// Session summary
+export { computeSummary, formatSummary, } from "./cli.js";

package/dist/runtime/skill-adapter.js

@@ -63,6 +63,14 @@ export function compileWorkflowToSkill(plan, roles, ir, variables) {
     }
     lines.push("</Steps>");
     lines.push("");
+    // Execution Policy — force-complete standard
+    lines.push("<Execution_Policy>");
+    lines.push("- Use TodoWrite to track each step as pending/in_progress/completed.");
+    lines.push("- After completing each step, immediately proceed to the next — do not stop, summarize, or wait for confirmation.");
+    lines.push("- If a step fails, mark it as failed in TodoWrite, log the error, and continue to the next non-dependent step.");
+    lines.push("- Do not ask the user for permission between steps — the workflow is pre-approved.");
+    lines.push("</Execution_Policy>");
+    lines.push("");
     // Tool_Usage — only if roles have permissions or scope
     const toolUsageLines = [];
     for (const roleName of usedRoles) {

package/dist/runtime/workflow-runner.js

@@ -22,6 +22,13 @@ const SENTINEL_COMMENT = "# intentdna:managed -- do not edit manually";
 function sanitizeForBash(id) {
     return id.replace(/[^a-zA-Z0-9_]/g, "_");
 }
+/**
+ * Sanitize a step ID for safe use in shell paths and git branch names.
+ * Allows alphanumeric, hyphen, underscore, and dot only.
+ */
+function sanitizeForShell(id) {
+    return id.replace(/[^a-zA-Z0-9_.-]/g, "_");
+}
 /**
  * Get the agent name for a role, using toKebabCase and the configured prefix.
  */
@@ -203,7 +210,8 @@ function generateGroupExecution(group, stepMap, options, plan) {
     const lines = [];
     const isParallel = group.step_ids.length > 1;
     if (isParallel) {
-        lines.push(`  # Group ${group.group_index}: ${group.step_ids.join(", ")} (parallel)`);
+        const isoLabel = group.isolation === "worktree" ? "parallel, worktree" : "parallel";
+        lines.push(`  # Group ${group.group_index}: ${group.step_ids.join(", ")} (${isoLabel})`);
     }
     else {
         lines.push(`  # Group ${group.group_index}: ${group.step_ids[0]} (sequential)`);
@@ -213,8 +221,62 @@ function generateGroupExecution(group, stepMap, options, plan) {
         const varId = sanitizeForBash(id);
         lines.push(`  STEP_${varId}_STATUS=0`);
     }
-    if (isParallel) {
-        // Background jobs
+    if (isParallel && group.isolation === "worktree") {
+        // Worktree-isolated parallel execution
+        lines.push("");
+        lines.push('  MAIN_BRANCH=$(git rev-parse --abbrev-ref HEAD)');
+        // Create worktrees
+        for (const id of group.step_ids) {
+            const safeId = sanitizeForShell(id);
+            lines.push(`  git worktree add ".dna/worktrees/${safeId}" -b "dna-wt-${safeId}" HEAD 2>/dev/null`);
+        }
+        // Background jobs in worktree dirs
+        for (const id of group.step_ids) {
+            const step = stepMap.get(id);
+            const varId = sanitizeForBash(id);
+            const safeId = sanitizeForShell(id);
+            const agent = agentName(step.role, options.agentPrefix);
+            const prompt = escapeShellSingleQuote(step.prompt ?? step.description);
+            lines.push("");
+            lines.push(`  (cd ".dna/worktrees/${safeId}" && run_agent "${agent}" '${prompt}' "${safeId}") &`);
+            lines.push(`  PID_${varId}=$!`);
+        }
+        lines.push("");
+        // Wait for all
+        for (const id of group.step_ids) {
+            const step = stepMap.get(id);
+            const varId = sanitizeForBash(id);
+            if (step.optional) {
+                lines.push(`  wait $PID_${varId} || {`);
+                lines.push(`    STEP_${varId}_STATUS=1`);
+                lines.push(`    echo "[$(date '+%H:%M:%S')] Optional step '${step.id}' failed, continuing..."`);
+                lines.push("  }");
+            }
+            else {
+                lines.push(`  wait $PID_${varId} || STEP_${varId}_STATUS=1`);
+            }
+        }
+        // Merge worktrees back (escalate on conflict)
+        lines.push("");
+        lines.push("  # Merge worktrees back to main branch");
+        for (const id of group.step_ids) {
+            const varId = sanitizeForBash(id);
+            const safeId = sanitizeForShell(id);
+            lines.push(`  if [ "$STEP_${varId}_STATUS" -eq 0 ]; then`);
+            lines.push(`    merge_worktree "dna-wt-${safeId}" "${safeId}"`);
+            lines.push("  fi");
+        }
+        // Cleanup worktrees
+        lines.push("");
+        lines.push("  # Cleanup worktrees");
+        for (const id of group.step_ids) {
+            const safeId = sanitizeForShell(id);
+            lines.push(`  git worktree remove ".dna/worktrees/${safeId}" 2>/dev/null || true`);
+            lines.push(`  git branch -D "dna-wt-${safeId}" 2>/dev/null || true`);
+        }
+    }
+    else if (isParallel) {
+        // Standard parallel execution (no isolation)
         for (const id of group.step_ids) {
             const step = stepMap.get(id);
             const varId = sanitizeForBash(id);
@@ -248,6 +310,32 @@ function generateGroupExecution(group, stepMap, options, plan) {
     }
     return lines;
 }
+/**
+ * Check if any parallel group in the plan uses worktree isolation.
+ */
+function needsWorktreeSupport(plan) {
+    return plan.parallel_groups.some(g => g.isolation === "worktree" && g.step_ids.length > 1);
+}
+/**
+ * Generate the merge_worktree bash helper function.
+ * Only included in scripts that have worktree-isolated parallel groups.
+ */
+function generateMergeWorktreeFn() {
+    return [
+        "# Merge a worktree branch back to main (escalate on conflict)",
+        "merge_worktree() {",
+        '  local branch="$1" name="$2"',
+        '  if ! git merge --no-commit --no-ff "$branch" 2>/dev/null; then',
+        "    git merge --abort",
+        '    echo "[Intent DNA] CONFLICT: $name conflicts with current branch. Manual resolution required."',
+        '    echo "[Intent DNA] Branch preserved: $branch"',
+        "    return 1",
+        "  fi",
+        '  git commit -m "merge: $name" --no-edit 2>/dev/null || true',
+        "}",
+        "",
+    ];
+}
 /**
  * Generate transition check code after all groups execute.
  */
@@ -316,6 +404,10 @@ export function compileWorkflowToShell(plan, options) {
     // run_agent function
     lines.push(...generateRunAgentFn(opts));
     lines.push("");
+    // merge_worktree function (only if needed)
+    if (needsWorktreeSupport(plan)) {
+        lines.push(...generateMergeWorktreeFn());
+    }
     // Main execution
     if (plan.retry.max_retries > 0) {
         // With retry loop

package/dist/schema/types.d.ts

@@ -154,6 +154,16 @@ export interface WorkflowDef {
     default_isolation?: "none" | "worktree" | "auto";
     merge_strategy?: "escalate";
 }
+/** Parallel block syntax sugar — expanded by compiler into steps with depends_on */
+export interface ParallelBlockDef {
+    parallel: {
+        isolation?: "none" | "worktree" | "auto";
+        merge_strategy?: "escalate";
+        steps: WorkflowStepDef[];
+    };
+}
+/** Raw workflow step entry: either a regular step or a parallel block (syntax sugar) */
+export type RawWorkflowStepEntry = WorkflowStepDef | ParallelBlockDef;
 export interface EpigeneticEffect {
     gene?: string;
     action?: ModifierAction;

package/dist/templates/incident-response.dna.yaml

@@ -0,0 +1,66 @@
+# incident-response: 生产事故响应
+# 适用: 线上故障排查、紧急修复、事后复盘
+# 核心: 快速止血、根因分析、防止复发
+
+version: "0.1.0"
+id: template_incident_response
+name: Incident Response
+type: project
+namespace: ir
+
+cascade:
+  inherits: ["species:default"]
+  priority: 100
+
+genes:
+  triage_first:
+    description: Assess severity and blast radius before fixing
+    codons:
+      - type: attract
+        target: severity_assessment
+      - type: attract
+        target: blast_radius_check
+      - type: repel
+        target: premature_fix
+      - type: sense
+        signal: production_alert
+        response: prioritize_investigation
+
+  minimal_fix:
+    description: Apply the smallest change that stops the bleeding
+    codons:
+      - type: attract
+        target: targeted_hotfix
+      - type: attract
+        target: revert_option
+      - type: repel
+        target: refactor_during_incident
+      - type: weight
+        a: speed
+        b: elegance
+        ratio: 0.9
+
+  evidence_driven:
+    description: Collect evidence before hypothesizing
+    codons:
+      - type: attract
+        target: logs_and_metrics
+      - type: attract
+        target: reproduction_steps
+      - type: repel
+        target: guessing_root_cause
+      - type: threshold
+        condition: "has_evidence == true"
+        action: escalate
+
+  prevent_recurrence:
+    description: Every fix must include prevention measures
+    codons:
+      - type: attract
+        target: regression_test
+      - type: attract
+        target: monitoring_alert
+      - type: repel
+        target: fix_without_test
+
+contexts: {}

package/dist/templates/migration-safety.dna.yaml

@@ -0,0 +1,67 @@
+# migration-safety: 安全迁移
+# 适用: 数据库迁移、依赖升级、框架版本迁移、API 版本切换
+# 核心: 回滚优先、渐进式、验证每一步
+
+version: "0.1.0"
+id: template_migration_safety
+name: Migration Safety
+type: project
+namespace: mig
+
+cascade:
+  inherits: ["species:default"]
+  priority: 100
+
+genes:
+  rollback_first:
+    description: Every migration step must have a rollback plan
+    codons:
+      - type: attract
+        target: reversible_changes
+      - type: attract
+        target: rollback_script
+      - type: repel
+        target: destructive_migration
+      - type: threshold
+        condition: "has_rollback_plan == true"
+        action: block
+
+  incremental_migration:
+    description: Migrate incrementally, verify at each stage
+    codons:
+      - type: attract
+        target: phased_migration
+      - type: attract
+        target: canary_first
+      - type: repel
+        target: big_bang_migration
+      - type: weight
+        a: safety
+        b: speed
+        ratio: 0.9
+
+  backward_compatible:
+    description: Maintain backward compatibility during transition
+    codons:
+      - type: attract
+        target: dual_write
+      - type: attract
+        target: feature_flags
+      - type: repel
+        target: breaking_change_without_migration
+      - type: sense
+        signal: deprecation_warning
+        response: plan_migration_path
+
+  verify_data_integrity:
+    description: Validate data consistency after each migration step
+    codons:
+      - type: attract
+        target: data_validation_checks
+      - type: attract
+        target: diff_before_after
+      - type: threshold
+        condition: "data_loss == false"
+        action: block
+
+contexts: {}

package/dist/templates/performance-audit.dna.yaml

@@ -0,0 +1,67 @@
+# performance-audit: 性能优化
+# 适用: 性能分析、基准测试、瓶颈排查、优化实施
+# 核心: 先测量再优化、数据驱动、避免过早优化
+
+version: "0.1.0"
+id: template_performance_audit
+name: Performance Audit
+type: project
+namespace: perf
+
+cascade:
+  inherits: ["species:default"]
+  priority: 100
+
+genes:
+  measure_first:
+    description: Profile and benchmark before making any change
+    codons:
+      - type: attract
+        target: profiling_data
+      - type: attract
+        target: baseline_benchmark
+      - type: repel
+        target: optimize_without_measurement
+      - type: threshold
+        condition: "has_baseline_metrics == true"
+        action: escalate
+
+  targeted_optimization:
+    description: Optimize the actual bottleneck, not hunches
+    codons:
+      - type: attract
+        target: hotspot_analysis
+      - type: attract
+        target: algorithmic_improvement
+      - type: repel
+        target: premature_optimization
+      - type: weight
+        a: correctness
+        b: performance
+        ratio: 0.7
+
+  regression_prevention:
+    description: Ensure optimizations don't break functionality
+    codons:
+      - type: attract
+        target: before_after_comparison
+      - type: attract
+        target: existing_tests_pass
+      - type: repel
+        target: optimization_breaks_tests
+      - type: threshold
+        condition: "test_regression == false"
+        action: block
+
+  document_results:
+    description: Record measurements and decisions for future reference
+    codons:
+      - type: attract
+        target: performance_report
+      - type: attract
+        target: optimization_rationale
+      - type: sense
+        signal: performance_improvement
+        response: record_technique
+
+contexts: {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "intentdna",
-  "version": "1.4.4",
+  "version": "1.4.6",
   "description": "Intent DNA — Declarative policy layer for AI agent behavior",
   "type": "module",
   "main": "dist/index.js",