intentdna 1.5.7 → 1.5.9

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