intentdna 1.5.8 → 1.5.9

package/.claude-plugin/marketplace.json

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

package/.claude-plugin/plugin.json

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

package/dist/compiler/activate.d.ts

@@ -20,6 +20,7 @@ export interface ActivatedGene {
     codons: Codon[];
     tags: string[];
     expression_level: number;
+    role?: "constraint" | "workflow_hint";
 }
 /**
  * Activate a cascaded DNA for a given context and role.

package/dist/compiler/activate.js

@@ -74,6 +74,7 @@ export function activateDNA(cascaded, contextName = null, activeRole = null) {
             codons: [...gene.codons],
             tags: [...(gene.tags ?? [])],
             expression_level: 1.0,
+            role: gene.role,
         };
     }
     // Apply context modifiers if a context is active

package/dist/compiler/compile.js

@@ -55,6 +55,14 @@ function geneToDirectives(name, gene) {
     if (weights.length > 0) {
         parts.push(`Trade-offs: ${weights.join("; ")}.`);
     }
+    // For workflow_hint genes, threshold codons become prompt directives instead of gates
+    if (gene.role === "workflow_hint") {
+        for (const codon of gene.codons) {
+            if (codon.type === "threshold") {
+                parts.push(`Condition: ${codon.condition}.`);
+            }
+        }
+    }
     if (parts.length > 1) {
         directives.push({
             priority,
@@ -153,9 +161,11 @@ export function compileDNA(activated, cascaded) {
     const injections = [];
     for (const [name, gene] of Object.entries(activated.genes)) {
         directives.push(...geneToDirectives(name, gene));
-        toolFilters.push(...geneToToolFilters(name, gene));
-        gates.push(...geneToGates(name, gene));
-        validators.push(...geneToValidators(name, gene));
+        if (gene.role !== "workflow_hint") {
+            toolFilters.push(...geneToToolFilters(name, gene));
+            gates.push(...geneToGates(name, gene));
+            validators.push(...geneToValidators(name, gene));
+        }
     }
     // Compile role constraints
     let roleToolPermissions;

package/dist/schema/types.d.ts

@@ -37,6 +37,7 @@ export interface Gene {
     description: string;
     codons: Codon[];
     tags?: string[];
+    role?: "constraint" | "workflow_hint";
 }
 export type ModifierAction = "amplify" | "suppress" | "activate" | "deactivate";
 export interface GeneModifier {

package/dist/templates/code-cleanup.dna.yaml

@@ -0,0 +1,152 @@
+version: "0.1.0"
+id: template_code_cleanup
+name: Code Cleanup (Regression-Safe)
+type: project
+namespace: cc
+
+cascade:
+  inherits: ["species:default"]
+  priority: 100
+
+genes:
+  test_between_passes:
+    description: Tests must pass between each cleanup pass
+    codons:
+      - type: threshold
+        condition: "tests_passing == true"
+        action: block
+      - type: attract
+        target: run_tests_after_each_pass
+
+  no_behavior_change:
+    description: Cleanup must not change observable behavior
+    codons:
+      - type: threshold
+        condition: "behavior_changed == false"
+        action: block
+      - type: repel
+        target: modify_public_api
+      - type: attract
+        target: same_inputs_same_outputs
+
+  smell_focused:
+    description: Clean by smell type in order - dead code, duplication, naming
+    role: workflow_hint
+    codons:
+      - type: attract
+        target: categorize_before_cleaning
+      - type: attract
+        target: one_smell_type_per_pass
+
+  minimal_cleanup:
+    description: Each pass focuses on one type of issue
+    codons:
+      - type: attract
+        target: single_concern_per_pass
+      - type: repel
+        target: mixed_cleanup_types
+      - type: threshold
+        condition: "files_changed_per_pass <= 10"
+        action: escalate
+
+contexts: {}
+
+roles:
+  analyzer:
+    description: Analyzes code for cleanup opportunities. Read-only.
+    tool_permissions:
+      allow: [Read, Grep, Glob, Bash]
+      deny: [Edit, Write, NotebookEdit]
+    scope:
+      read: ["**/*"]
+      write: []
+    instructions:
+      - Classify code smells by type (dead code, duplication, naming, complexity)
+      - Prioritize by impact and risk
+      - Do NOT suggest behavioral changes
+      - Output a categorized cleanup plan
+
+  cleaner:
+    description: Executes cleanup changes. Can modify code.
+    tool_permissions:
+      allow: [Read, Edit, Write, Grep, Glob, Bash]
+    scope:
+      read: ["**/*"]
+      write: ["src/**", "lib/**"]
+    instructions:
+      - Follow the analyzer's cleanup plan
+      - One smell type per pass
+      - Run tests after each file change
+      - Revert if tests fail
+      - Do not change public APIs or observable behavior
+      - Commit after each successful pass
+
+  reviewer:
+    description: Reviews cleanup changes for correctness. Read-only.
+    tool_permissions:
+      allow: [Read, Grep, Glob, Bash]
+      deny: [Edit, Write, NotebookEdit]
+    scope:
+      read: ["**/*"]
+      write: []
+    instructions:
+      - Review git diff for each cleanup pass
+      - Verify no behavioral changes
+      - Check test coverage unchanged
+      - "Verdict: APPROVE or REQUEST_CHANGES"
+
+workflows:
+  cleanup:
+    name: Code Cleanup
+    description: "Regression-safe code cleanup: analyze, classify, clean by smell type, verify"
+    steps:
+      - id: lock_behavior
+        role: analyzer
+        description: "Assess current test coverage and establish behavior baseline."
+        prompt: |
+          Run existing tests to establish baseline.
+          Record: total tests, passing, failing.
+          If test coverage is insufficient, warn before proceeding.
+          Output: baseline test results + coverage assessment.
+
+      - id: classify
+        role: analyzer
+        depends_on: [lock_behavior]
+        description: "Scan codebase and categorize code smells."
+        prompt: |
+          Scan the codebase for code smells. Categorize:
+          1. Dead code (unused imports, unreachable branches, commented-out code)
+          2. Duplication (copy-paste patterns, similar functions)
+          3. Naming (unclear names, inconsistent conventions)
+          4. Complexity (long functions, deep nesting)
+
+          Prioritize: dead code first (safest), then duplication, then naming.
+          Output: categorized cleanup plan with file paths and line numbers.
+
+      - id: clean
+        role: cleaner
+        depends_on: [classify]
+        description: "Execute cleanup one smell type at a time."
+        prompt: |
+          Follow the cleanup plan. Rules:
+          - One smell type per pass (start with dead code)
+          - Run tests after each file change
+          - If tests fail: revert immediately, report the issue
+          - Maximum 10 files per pass
+          - Commit after each successful pass: "cleanup($TYPE): description"
+          - Do NOT change any public API signatures
+          - Do NOT rename exported symbols
+          - Do NOT modify test files (unless removing dead test helpers)
+
+      - id: verify
+        role: reviewer
+        depends_on: [clean]
+        description: "Verify cleanup preserved behavior."
+        prompt: |
+          Review all cleanup changes (git diff from baseline):
+          1. Any behavioral changes? (API signatures, return values, side effects)
+          2. Test count unchanged or increased?
+          3. All tests still passing?
+          4. No unintended file modifications?
+
+          Verdict: APPROVE (cleanup complete) or REQUEST_CHANGES (list issues)

package/dist/templates/persistent-executor.dna.yaml

@@ -0,0 +1,144 @@
+version: "0.1.0"
+id: template_persistent_executor
+name: Persistent Executor (PRD-Driven)
+type: project
+namespace: pe
+
+cascade:
+  inherits: ["species:default"]
+  priority: 100
+
+genes:
+  prd_driven:
+    description: Every task must trace back to explicit acceptance criteria
+    codons:
+      - type: threshold
+        condition: "acceptance_criteria_defined == true"
+        action: block
+      - type: attract
+        target: reference_acceptance_criteria
+      - type: repel
+        target: work_without_spec
+
+  verify_before_done:
+    description: Never claim completion without passing acceptance criteria
+    codons:
+      - type: threshold
+        condition: "all_criteria_verified == true"
+        action: block
+      - type: attract
+        target: run_verification_before_reporting
+      - type: repel
+        target: claim_done_without_evidence
+
+  no_partial_completion:
+    description: Either fully complete a story or explicitly report what remains
+    codons:
+      - type: threshold
+        condition: "story_fully_complete == true"
+        action: escalate
+      - type: repel
+        target: silent_partial_delivery
+
+  small_increments:
+    description: One story per commit, verifiable increments
+    role: workflow_hint
+    codons:
+      - type: attract
+        target: one_story_one_commit
+      - type: repel
+        target: batch_multiple_stories
+      - type: attract
+        target: each_commit_passes_tests
+
+contexts: {}
+
+roles:
+  executor:
+    description: Implements stories from the PRD. Can modify code.
+    tool_permissions:
+      allow: [Read, Edit, Write, Grep, Glob, Bash]
+    scope:
+      read: ["**/*"]
+      write: ["src/**", "lib/**", "test/**"]
+    instructions:
+      - Pick the highest priority incomplete story
+      - Read acceptance criteria before starting
+      - Implement in small verifiable steps
+      - Run tests after each change
+      - Commit after each story completion
+      - "Commit message: feat($STORY): what was implemented"
+      - Do not move to next story until current one is verified
+
+  verifier:
+    description: Independently verifies story completion. Read-only + can run tests.
+    tool_permissions:
+      allow: [Read, Grep, Glob, Bash]
+      deny: [Edit, Write, NotebookEdit]
+    scope:
+      read: ["**/*"]
+      write: []
+    instructions:
+      - Read the acceptance criteria for the completed story
+      - Run tests independently (do not trust executor's output)
+      - Check each criterion individually
+      - "Mark each: VERIFIED / PARTIAL / MISSING"
+      - "Verdict: PASS (all verified) or FAIL (list what's missing)"
+      - On FAIL the executor must fix before proceeding
+
+workflows:
+  persistent-execution:
+    name: Persistent Execution
+    description: "PRD-driven story execution: pick, implement, verify, repeat until all done"
+    steps:
+      - id: pick_story
+        role: executor
+        description: "Select next story from PRD by priority."
+        prompt: |
+          Read the PRD or task list.
+          Select the highest priority incomplete story.
+          Confirm: acceptance criteria are clear and testable.
+          If criteria are vague, ask for clarification before starting.
+          Output: story ID, title, acceptance criteria.
+
+      - id: implement
+        role: executor
+        depends_on: [pick_story]
+        description: "Implement the selected story."
+        prompt: |
+          Implement the story. Rules:
+          - Read acceptance criteria carefully
+          - Small steps: change → test → verify
+          - Maximum scope: what the story requires, nothing more
+          - Run tests after each meaningful change
+          - If stuck for 3 attempts on the same issue: STOP and report blocker
+          - Commit when story implementation is complete
+          - Do not start the next story
+
+      - id: verify
+        role: verifier
+        depends_on: [implement]
+        description: "Independent verification of story completion."
+        prompt: |
+          Verify the completed story independently:
+          1. Read acceptance criteria
+          2. Run all relevant tests (do not trust executor's results)
+          3. Check each criterion: VERIFIED / PARTIAL / MISSING
+          4. Run full test suite for regression check
+
+          PASS: All criteria verified → story complete, ready for next
+          FAIL: List what's missing → executor must fix
+
+      - id: report
+        role: verifier
+        depends_on: [verify]
+        description: "Report progress and determine next action."
+        prompt: |
+          Summary:
+          - Story: [ID] [title]
+          - Criteria: N/M verified
+          - Tests: X passing, Y failing
+          - Verdict: COMPLETE or NEEDS_FIX
+
+          If COMPLETE: "Story done. Pick next story to continue."
+          If NEEDS_FIX: "Story incomplete. Issues: [list]. Fix before proceeding."

package/dist/templates/qa-loop.dna.yaml

@@ -0,0 +1,147 @@
+version: "0.1.0"
+id: template_qa_loop
+name: QA Loop (Test-Fix Cycle)
+type: project
+namespace: ql
+
+cascade:
+  inherits: ["species:default"]
+  priority: 100
+
+genes:
+  convergence_protection:
+    description: Stop if no progress after 2 consecutive rounds
+    codons:
+      - type: threshold
+        condition: "consecutive_no_progress_rounds <= 2"
+        action: block
+      - type: attract
+        target: track_test_progress_per_round
+      - type: repel
+        target: infinite_retry_loop
+
+  separate_test_fix:
+    description: Tester and fixer must be separate roles
+    codons:
+      - type: threshold
+        condition: "tester_is_not_fixer == true"
+        action: block
+      - type: repel
+        target: self_test_own_fix
+
+  evidence_based_diagnosis:
+    description: Diagnose from test output, not guessing
+    role: workflow_hint
+    codons:
+      - type: attract
+        target: read_error_output_first
+      - type: repel
+        target: guess_without_running_tests
+      - type: attract
+        target: categorize_failures_by_type
+
+  regression_awareness:
+    description: Fixes must not introduce new failures
+    codons:
+      - type: threshold
+        condition: "new_failures_introduced == 0"
+        action: escalate
+      - type: attract
+        target: run_full_suite_after_fix
+
+contexts: {}
+
+roles:
+  tester:
+    description: Runs tests, diagnoses failures, categorizes issues. Read-only.
+    tool_permissions:
+      allow: [Read, Grep, Glob, Bash]
+      deny: [Edit, Write, NotebookEdit]
+    scope:
+      read: ["**/*"]
+      write: []
+    instructions:
+      - Run the full test suite
+      - Categorize failures by type (compile, logic, integration, flaky)
+      - For each failure trace the root cause
+      - Prioritize by severity
+      - Compare results with previous round — track progress
+      - Do NOT suggest code changes
+
+  fixer:
+    description: Fixes issues identified by tester. Can modify code.
+    tool_permissions:
+      allow: [Read, Edit, Write, Grep, Glob, Bash]
+    scope:
+      read: ["**/*"]
+      write: ["src/**", "lib/**", "test/**"]
+    instructions:
+      - Fix issues in priority order (compile first, then logic, then integration)
+      - One fix at a time, run tests after each
+      - If a fix introduces new failures, revert immediately
+      - Maximum 5 files per round
+      - "Same issue failing 3 times → STOP, report as blocked"
+      - Commit after each successful fix batch
+
+workflows:
+  qa-cycle:
+    name: QA Cycle
+    description: "Test-fix loop: test, diagnose, fix, retest. Max 5 rounds with convergence protection."
+    max_rounds: 5
+    convergence_rule: "2 consecutive rounds with 0 test progress → STOP"
+    steps:
+      - id: test
+        role: tester
+        description: "Run tests and categorize failures."
+        prompt: |
+          Run the test suite. Record results:
+          - Total tests, passing, failing, skipped
+          - If round > 1: compare with previous round results
+          - Categorize each failure:
+            COMPILE: syntax/import errors — fix first
+            LOGIC: assertion failures — fix after compile
+            INTEGRATION: cross-module issues — fix after logic
+            FLAKY: intermittent failures — deprioritize
+          - If 0 failures: "All tests passing. QA complete."
+          - If round > 1 and no progress: warn "no improvement"
+
+      - id: diagnose
+        role: tester
+        depends_on: [test]
+        description: "Root cause analysis for top failures."
+        prompt: |
+          For the top 3 failures (by severity):
+          1. Read the error output carefully
+          2. Trace to the root cause in source code
+          3. Identify the minimal fix needed
+          4. Check if failures are related (shared root cause)
+          Output: prioritized fix list with file paths and line numbers.
+
+      - id: fix
+        role: fixer
+        depends_on: [diagnose]
+        description: "Apply fixes for diagnosed issues."
+        prompt: |
+          Fix the diagnosed issues. Rules:
+          - Follow the priority order from diagnosis
+          - One fix at a time → run tests → verify
+          - If fix causes new failures: revert and try different approach
+          - Maximum 5 files per round
+          - Same issue failed 3 times → STOP and report as blocked
+          - Commit: "fix($TYPE): description of what was fixed"
+
+      - id: retest
+        role: tester
+        depends_on: [fix]
+        description: "Verify fixes and check for regressions."
+        prompt: |
+          Run the full test suite again:
+          1. Are the targeted failures fixed?
+          2. Any new regressions introduced?
+          3. Test delta: +N fixed, -M new failures
+
+          Progress check:
+          - If all tests pass: "QA complete. All green."
+          - If progress made (fewer failures): "Round N: +X fixed. Continue."
+          - If no progress (same or more failures): "No progress. [2 rounds → STOP]"
+          - If blocked items exist: "Blocked on: [list]. Human intervention needed."

package/dist/templates/requirements-gate.dna.yaml

@@ -0,0 +1,116 @@
+# requirements-gate: 需求清晰度门控
+# 在需求明确（>=80%）之前阻止实现，每轮只问一个问题
+# 适用: 任何需要"先澄清需求再动手"的项目
+
+version: "0.1.0"
+id: template_requirements_gate
+name: Requirements Clarity Gate
+type: project
+namespace: rg
+
+cascade:
+  inherits: ["species:default"]
+  priority: 100
+
+genes:
+  clarity_threshold:
+    description: Block implementation until requirements are sufficiently clear (>=80%)
+    codons:
+      - type: threshold
+        condition: "requirements_clarity_score >= 80"
+        action: block
+      - type: attract
+        target: clarify_before_building
+      - type: repel
+        target: implement_with_ambiguity
+
+  one_question_per_round:
+    description: Ask one focused question at a time to reduce cognitive load
+    role: workflow_hint
+    codons:
+      - type: attract
+        target: single_focused_question
+      - type: repel
+        target: question_dump
+
+  target_weakest_dimension:
+    description: Always probe the least clear dimension first
+    role: workflow_hint
+    codons:
+      - type: attract
+        target: identify_weakest_area
+      - type: repel
+        target: redundant_clarification
+
+  structured_output:
+    description: Requirements must be structured and actionable
+    codons:
+      - type: attract
+        target: testable_acceptance_criteria
+      - type: repel
+        target: vague_requirements
+      - type: attract
+        target: explicit_constraints
+
+contexts: {}
+
+roles:
+  interviewer:
+    description: Evaluates requirements clarity and asks clarifying questions. Read-only.
+    tool_permissions:
+      allow: [Read, Grep, Glob, Bash]
+      deny: [Edit, Write, NotebookEdit]
+    scope:
+      read: ["**/*"]
+      write: []
+    instructions:
+      - Evaluate requirements across 4 dimensions (Goal, Constraints, Criteria, Context)
+      - Score each dimension 0-100
+      - If average < 80 output the most critical question targeting the weakest dimension
+      - If average >= 80 output structured requirements document
+      - One question per round — do not dump multiple questions
+      - "80% threshold rationale: below this, >1/5 dimensions are underspecified"
+
+workflows:
+  requirements-gate:
+    name: Requirements Gate
+    description: "Evaluate requirements clarity, block if ambiguous, proceed if clear"
+    steps:
+      - id: clarity_check
+        role: interviewer
+        description: "Score requirements across 4 dimensions."
+        prompt: |
+          Evaluate the given requirements across 4 dimensions:
+
+          1. Goal (0-100): Is the desired outcome clear and measurable?
+          2. Constraints (0-100): Are boundaries, limitations, and non-goals defined?
+          3. Criteria (0-100): Are acceptance criteria specific and testable?
+          4. Context (0-100): Is the technical/business context sufficient?
+
+          Calculate average score.
+
+          If average >= 80:
+            Output: structured requirements document with all 4 dimensions filled.
+            Status: PROCEED
+
+          If average < 80:
+            Identify the weakest dimension.
+            Output: one specific clarifying question targeting that dimension.
+            Status: BLOCK — "Requirements clarity at N%. Need clarification on: [dimension]"
+
+      - id: proceed_or_block
+        role: interviewer
+        depends_on: [clarity_check]
+        description: "Gate decision based on clarity score."
+        prompt: |
+          Based on clarity check results:
+
+          If PROCEED: Format the requirements as a structured spec:
+          - Goal: [what]
+          - Constraints: [boundaries]
+          - Acceptance Criteria: [testable conditions]
+          - Context: [technical/business background]
+          - Out of Scope: [explicit exclusions]
+
+          If BLOCK: Summarize what's missing and the question to ask.
+          Do NOT proceed with implementation planning until clarity >= 80%.

package/dist/templates/research-orchestration.dna.yaml

@@ -0,0 +1,145 @@
+# research-orchestration: 并行假设驱动研究
+# 适用: 需要结构化调研、多角度验证、有据可查结论的研究任务
+
+version: "0.1.0"
+id: template_research_orchestration
+name: Research Orchestration (Parallel Hypotheses)
+type: project
+namespace: ro
+
+cascade:
+  inherits: ["species:default"]
+  priority: 100
+
+genes:
+  hypothesis_driven:
+    description: Research must start with explicit hypotheses before investigation
+    codons:
+      - type: threshold
+        condition: "hypotheses_defined == true"
+        action: block
+      - type: attract
+        target: state_hypothesis_before_investigating
+      - type: repel
+        target: undirected_exploration
+
+  cross_verify:
+    description: Findings must be cross-verified by independent researchers
+    role: workflow_hint
+    codons:
+      - type: attract
+        target: independent_verification
+      - type: repel
+        target: single_source_conclusion
+
+  evidence_graded:
+    description: Grade evidence quality and distinguish fact from inference
+    role: workflow_hint
+    codons:
+      - type: attract
+        target: grade_source_reliability
+      - type: attract
+        target: separate_fact_from_interpretation
+      - type: repel
+        target: treat_all_evidence_equally
+
+  structured_synthesis:
+    description: Synthesis must address all hypotheses with evidence
+    codons:
+      - type: threshold
+        condition: "all_hypotheses_addressed == true"
+        action: escalate
+      - type: attract
+        target: evidence_based_conclusions
+
+contexts: {}
+
+roles:
+  lead_researcher:
+    description: Decomposes questions, synthesizes findings. Read-only.
+    tool_permissions:
+      allow: [Read, Grep, Glob, Bash]
+      deny: [Edit, Write, NotebookEdit]
+    scope:
+      read: ["**/*"]
+      write: []
+    instructions:
+      - Decompose the research question into sub-questions
+      - Formulate hypotheses for each sub-question
+      - After investigation synthesize findings across all researchers
+      - Grade overall confidence in conclusions
+      - Identify remaining unknowns and next steps
+
+  researcher:
+    description: Investigates specific sub-questions. Read-only with analysis tools.
+    tool_permissions:
+      allow: [Read, Grep, Glob, Bash]
+      deny: [Edit, Write, NotebookEdit]
+    scope:
+      read: ["**/*"]
+      write: []
+    instructions:
+      - Focus on assigned sub-question only
+      - State hypothesis before investigating
+      - Gather evidence from code, docs, logs, tests
+      - Grade each piece of evidence (strong/moderate/weak)
+      - Report findings with evidence quality ratings
+      - Flag uncertainties and assumptions explicitly
+
+workflows:
+  research:
+    name: Research
+    description: "Parallel hypothesis research: decompose, investigate, verify, synthesize"
+    steps:
+      - id: decompose
+        role: lead_researcher
+        description: "Break research question into sub-questions with hypotheses."
+        prompt: |
+          Analyze the research question:
+          1. Break into 2-4 independent sub-questions
+          2. For each sub-question:
+             - Hypothesis: what do we expect to find?
+             - Key sources: where to look (code, docs, logs, external)
+             - Success criteria: what constitutes a sufficient answer?
+          3. Identify dependencies between sub-questions
+          4. Assign investigation priority
+
+      - id: investigate
+        role: researcher
+        depends_on: [decompose]
+        description: "Investigate sub-questions in parallel."
+        prompt: |
+          Investigate assigned sub-question:
+          1. State the hypothesis clearly
+          2. Gather evidence from identified sources
+          3. For each evidence item:
+             - Source: where found
+             - Quality: strong / moderate / weak
+             - Supports or contradicts hypothesis?
+          4. Preliminary conclusion with confidence level
+          5. List remaining unknowns
+
+      - id: verify
+        role: lead_researcher
+        depends_on: [investigate]
+        description: "Cross-verify findings across researchers."
+        prompt: |
+          Cross-verification:
+          1. Do different researchers' findings contradict?
+          2. Are there gaps — sub-questions not fully answered?
+          3. Check: is the evidence quality sufficient for conclusions?
+          4. If contradictions exist: identify the most reliable source
+          5. If gaps exist: note what additional investigation is needed
+
+      - id: synthesize
+        role: lead_researcher
+        depends_on: [verify]
+        description: "Synthesize all findings into conclusions."
+        prompt: |
+          Final synthesis:
+          1. For each original sub-question: answer with evidence
+          2. For each hypothesis: confirmed / refuted / inconclusive
+          3. Overall conclusion with confidence level (high/medium/low)
+          4. Key findings (bullet points)
+          5. Remaining unknowns
+          6. Recommended next steps (if any)

package/dist/templates/root-cause-analysis.dna.yaml

@@ -0,0 +1,140 @@
+version: "0.1.0"
+id: template_root_cause_analysis
+name: Root Cause Analysis (Competing Hypotheses)
+type: project
+namespace: rca
+
+cascade:
+  inherits: ["species:default"]
+  priority: 100
+
+genes:
+  multiple_hypotheses:
+    description: Always generate multiple competing hypotheses before investigating
+    codons:
+      - type: threshold
+        condition: "hypotheses_count >= 3"
+        action: block
+      - type: attract
+        target: generate_alternatives
+      - type: repel
+        target: single_theory_bias
+
+  falsify_own:
+    description: Actively try to disprove your own hypotheses
+    codons:
+      - type: attract
+        target: seek_disconfirming_evidence
+      - type: repel
+        target: confirmation_bias
+      - type: threshold
+        condition: "each_hypothesis_has_counter_evidence == true"
+        action: escalate
+
+  evidence_ranked:
+    description: Rank evidence by strength and reliability
+    role: workflow_hint
+    codons:
+      - type: attract
+        target: grade_evidence_quality
+      - type: attract
+        target: distinguish_correlation_causation
+
+  minimal_reproduction:
+    description: Create minimal reproduction before investigating
+    codons:
+      - type: attract
+        target: reproduce_before_hypothesizing
+      - type: repel
+        target: guess_without_evidence
+
+contexts: {}
+
+roles:
+  hypothesis_generator:
+    description: Generates competing hypotheses from symptoms. Read-only.
+    tool_permissions:
+      allow: [Read, Grep, Glob, Bash]
+      deny: [Edit, Write, NotebookEdit]
+    scope:
+      read: ["**/*"]
+      write: []
+    instructions:
+      - Read error messages, logs, and stack traces
+      - Generate at least 3 competing hypotheses
+      - For each hypothesis state what evidence would confirm AND refute it
+      - Rank by prior probability (most likely first)
+      - Do NOT suggest fixes yet
+
+  investigator:
+    description: Gathers evidence for/against each hypothesis. Read-only.
+    tool_permissions:
+      allow: [Read, Grep, Glob, Bash]
+      deny: [Edit, Write, NotebookEdit]
+    scope:
+      read: ["**/*"]
+      write: []
+    instructions:
+      - Test each hypothesis by gathering specific evidence
+      - For each hypothesis record evidence FOR and AGAINST
+      - Try to DISPROVE the leading hypothesis first
+      - Use git blame, logs, test output as evidence
+      - Grade evidence strength (strong/moderate/weak)
+      - After investigation rank hypotheses by evidence weight
+
+workflows:
+  root-cause:
+    name: Root Cause Analysis
+    description: "Competing hypotheses debugging: hypothesize, investigate, rank, synthesize"
+    steps:
+      - id: reproduce
+        role: investigator
+        description: "Reproduce the issue and collect symptoms."
+        prompt: |
+          Reproduce the reported issue:
+          1. Run the failing test or trigger the bug
+          2. Collect all symptoms: error messages, stack traces, logs
+          3. Note: when did it start? What changed recently? (git log)
+          4. Output: symptom summary + reproduction steps
+
+      - id: hypothesize
+        role: hypothesis_generator
+        depends_on: [reproduce]
+        description: "Generate 3+ competing hypotheses."
+        prompt: |
+          Based on the symptoms, generate at least 3 competing hypotheses:
+          For each hypothesis:
+          - Statement: what is the root cause?
+          - Prior probability: how likely (high/medium/low)?
+          - Confirming evidence: what would prove this?
+          - Refuting evidence: what would disprove this?
+          - Quick test: what's the fastest way to check?
+
+          Order by prior probability. Do NOT investigate yet.
+
+      - id: investigate
+        role: investigator
+        depends_on: [hypothesize]
+        description: "Gather evidence for/against each hypothesis."
+        prompt: |
+          For each hypothesis, gather evidence:
+          1. Run the quick test suggested
+          2. Check code paths, git blame, recent changes
+          3. Record evidence FOR and AGAINST each hypothesis
+          4. Grade evidence strength: strong / moderate / weak
+          5. Try hardest to DISPROVE the leading hypothesis
+
+          After all evidence gathered, rank hypotheses by total evidence weight.
+
+      - id: synthesize
+        role: hypothesis_generator
+        depends_on: [investigate]
+        description: "Determine root cause and recommend fix."
+        prompt: |
+          Based on evidence:
+          1. Which hypothesis has the strongest evidence?
+          2. Which hypotheses were refuted?
+          3. Are there any remaining unknowns?
+          4. Root cause determination (with confidence level)
+          5. Recommended fix approach
+          6. What regression test would prevent recurrence?

package/dist/templates/systematic-debugging.dna.yaml

@@ -53,4 +53,98 @@ genes:
         condition: "bugfix_without_test == false"
         action: block
 
+  competing_hypotheses:
+    description: Always consider multiple possible causes
+    codons:
+      - type: threshold
+        condition: "hypotheses_count >= 2"
+        action: escalate
+      - type: attract
+        target: consider_alternative_explanations
+      - type: repel
+        target: jump_to_first_theory
+
 contexts: {}
+
+roles:
+  hypothesis_generator:
+    description: Generates competing debugging hypotheses. Read-only.
+    tool_permissions:
+      allow: [Read, Grep, Glob, Bash]
+      deny: [Edit, Write, NotebookEdit]
+    scope:
+      read: ["**/*"]
+      write: []
+    instructions:
+      - Read error messages, logs, stack traces
+      - Generate at least 2 competing hypotheses
+      - For each hypothesis state confirming and refuting evidence
+      - Rank by likelihood
+      - Do NOT suggest fixes
+
+  debugger:
+    description: Investigates hypotheses and applies fixes.
+    tool_permissions:
+      allow: [Read, Edit, Write, Grep, Glob, Bash]
+    scope:
+      read: ["**/*"]
+      write: ["src/**", "lib/**", "test/**"]
+    instructions:
+      - Test each hypothesis systematically
+      - Start with the most likely hypothesis
+      - Use git bisect, logging, and targeted tests
+      - When root cause found apply minimal fix
+      - Write regression test before fixing
+      - Run tests after fix
+
+workflows:
+  debug-with-hypotheses:
+    name: Debug with Hypotheses
+    description: "Hypothesis-driven debugging: hypothesize, investigate, fix, verify"
+    steps:
+      - id: hypothesize
+        role: hypothesis_generator
+        description: "Generate competing hypotheses from symptoms."
+        prompt: |
+          Analyze the bug symptoms:
+          1. Reproduce the issue
+          2. Collect error messages, logs, stack traces
+          3. Check recent git changes
+          4. Generate at least 2 competing hypotheses
+          5. For each: what evidence would confirm? What would refute?
+          6. Rank by likelihood
+
+      - id: investigate
+        role: debugger
+        depends_on: [hypothesize]
+        description: "Test hypotheses and find root cause."
+        prompt: |
+          Test each hypothesis:
+          1. Start with most likely
+          2. Gather targeted evidence (add logging, run specific tests)
+          3. If confirmed → proceed to fix
+          4. If refuted → move to next hypothesis
+          5. Record evidence for each hypothesis tested
+
+      - id: fix
+        role: debugger
+        depends_on: [investigate]
+        description: "Apply minimal fix and write regression test."
+        prompt: |
+          Fix the confirmed root cause:
+          1. Write a regression test that reproduces the bug FIRST
+          2. Apply the minimal fix
+          3. Verify the regression test passes
+          4. Run full test suite for regressions
+          5. Commit: "fix: [description] — root cause: [what and why]"
+
+      - id: verify
+        role: hypothesis_generator
+        depends_on: [fix]
+        description: "Verify fix is correct and complete."
+        prompt: |
+          Verify the fix:
+          1. Is the root cause actually addressed (not just symptoms)?
+          2. Does the regression test cover the exact failure mode?
+          3. Any related code paths that might have the same issue?
+          4. Verdict: VERIFIED or INCOMPLETE

package/dist/templates/tdd-strict.dna.yaml

@@ -52,19 +52,103 @@ genes:
 contexts: {}
 
 roles:
+  test_writer:
+    description: Writes failing tests before implementation. Can create test files.
+    tool_permissions:
+      allow: [Read, Edit, Write, Grep, Glob, Bash]
+    scope:
+      read: ["**/*"]
+      write: ["test/**", "tests/**", "spec/**", "__tests__/**"]
+    instructions:
+      - Write the test FIRST — it must fail initially (red phase)
+      - Test should describe the desired behavior, not the implementation
+      - One test case per behavior
+      - Run the test to confirm it fails for the right reason
+      - Do NOT write implementation code
+
   implementer:
-    description: TDD implementer — writes tests first, then code
+    description: Writes minimal code to make tests pass.
     tool_permissions:
       allow: [Read, Edit, Write, Grep, Glob, Bash]
     scope:
       read: ["**/*"]
-      write: ["src/**", "test/**"]
+      write: ["src/**", "lib/**"]
     instructions:
-      - Always write the failing test FIRST
-      - Run the test to confirm it fails (red)
-      - Write the minimum code to make it pass (green)
-      - Refactor if needed, keeping tests green
-      - Never commit with failing tests
-    post_checks:
-      - vitest_run
-      - tsc_no_errors
+      - Write the MINIMUM code to make the failing test pass (green phase)
+      - Do not add extra functionality beyond what the test requires
+      - Do not optimize or clean up code yet
+      - Run the test after each change to verify it passes
+      - Do not modify test files
+
+  refactorer:
+    description: Cleans up code while keeping tests green.
+    tool_permissions:
+      allow: [Read, Edit, Write, Grep, Glob, Bash]
+    scope:
+      read: ["**/*"]
+      write: ["src/**", "lib/**"]
+    instructions:
+      - Clean up the implementation (refactor phase)
+      - Run ALL tests after each refactoring step
+      - If any test breaks, revert immediately
+      - Focus on readability, removing duplication, improving naming
+      - Do NOT add new functionality during refactoring
+      - Do NOT modify test files
+
+workflows:
+  tdd-cycle:
+    name: TDD Cycle
+    description: "Red-Green-Refactor: write failing test, implement minimally, clean up"
+    steps:
+      - id: write_test
+        role: test_writer
+        description: "Write a failing test for the desired behavior (RED)."
+        prompt: |
+          TDD Red Phase:
+          1. Understand the behavior to implement
+          2. Write ONE test that describes this behavior
+          3. Run the test — it MUST fail
+          4. Verify it fails for the right reason (not a syntax error)
+          5. Commit: "test: add failing test for [behavior]"
+
+          Do NOT write any implementation code.
+
+      - id: implement
+        role: implementer
+        depends_on: [write_test]
+        description: "Write minimal code to pass the test (GREEN)."
+        prompt: |
+          TDD Green Phase:
+          1. Read the failing test carefully
+          2. Write the MINIMUM code to make it pass
+          3. Run the test — it must pass now
+          4. Run the full test suite — no regressions
+          5. Commit: "feat: implement [behavior] — test green"
+
+          Rules:
+          - Do NOT add code beyond what the test requires
+          - Do NOT optimize yet
+          - Do NOT modify test files
+
+      - id: refactor
+        role: refactorer
+        depends_on: [implement]
+        description: "Clean up code while keeping all tests green (REFACTOR)."
+        prompt: |
+          TDD Refactor Phase:
+          1. Review the implementation for code smells
+          2. Apply ONE refactoring at a time
+          3. Run ALL tests after each change
+          4. If any test breaks: REVERT immediately
+          5. Commit: "refactor: [what was cleaned up]"
+
+          Focus on:
+          - Remove duplication
+          - Improve naming
+          - Simplify logic
+          - Extract methods/functions if needed
+
+          Do NOT:
+          - Add new features
+          - Modify test files
+          - Change behavior

package/package.json

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