intentdna 1.4.5 → 1.4.7

package/.claude-plugin/marketplace.json

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

package/.claude-plugin/plugin.json

@@ -1,5 +1,5 @@
 {
   "name": "intentdna",
-  "version": "1.4.5",
+  "version": "1.4.7",
   "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/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/enforce.js

@@ -14,6 +14,7 @@
  * Step checkpoints are handled by the CLI, not here.
  */
 import { allowOutput, blockOutput, escalateOutput, silentOutput } from "./protocol.js";
+import { relative } from "node:path";
 // ── PreToolUse Enforcement ─────────────────────────────────
 /**
  * Enforce PreToolUse constraints.
@@ -319,6 +320,9 @@ function enforceRoleScope(rolesScopeMap, input) {
     const filePath = extractFilePath(input);
     if (!filePath)
         return null;
+    // Convert absolute path to relative for glob matching
+    const cwd = input.cwd;
+    const relativePath = cwd && filePath.startsWith("/") ? relative(cwd, filePath) : filePath;
     for (const entry of rolesScopeMap) {
         const agentTypeName = `dna-${toKebabCase(entry.role_name)}`;
         if (input.agent_type !== agentTypeName)
@@ -327,7 +331,7 @@ function enforceRoleScope(rolesScopeMap, input) {
         if (writeGlobs.length === 0) {
             return blockOutput(`[Intent DNA]: Role '${entry.role_name}' has no write permission (path: ${filePath})`);
         }
-        if (!checkWriteAllowed(filePath, writeGlobs)) {
+        if (!checkWriteAllowed(relativePath, writeGlobs)) {
             return blockOutput(`[Intent DNA]: Role '${entry.role_name}' cannot write to '${filePath}' (allowed: ${writeGlobs.join(", ")})`);
         }
         return null; // Role matched, write allowed

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/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.5",
+  "version": "1.4.7",
   "description": "Intent DNA — Declarative policy layer for AI agent behavior",
   "type": "module",
   "main": "dist/index.js",