@dragonflymcp/plugin 1.0.0

package/templates/synchronizations/archive/execution-loop.yaml.template

@@ -0,0 +1,336 @@
+# Execution Loop Synchronization Rules
+# Enables self-repair and iterative refinement of code
+#
+# Based on research:
+# - ReVeal: Self-Evolving Code Agents (19+ inference turns possible)
+# - The Art of Repair: 78% improvement with iterative patching
+
+version: "1.0.0"
+
+# Global SLO defaults for execution loop (verification can be slow)
+slo_defaults:
+  expected_duration_ms: 15000
+  max_duration_ms: 120000
+  expected_cost_usd: 0.003
+  max_cost_usd: 0.015
+  expected_context_tokens: 3000
+  success_rate_target: 0.85
+  on_timeout:
+    action: "skip"
+    message: "Execution loop timed out - manual intervention may be needed"
+  on_cost_exceeded:
+    action: "alert"
+    continue: true
+
+synchronizations:
+  # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  # Verification Trigger
+  # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  # Trigger verification after implementation completes
+  - id: "impl-to-verify"
+    description: "Verify implementation with execution and tests after completion"
+    when:
+      concept: "implementation"
+      action: "generate"
+      status: "completed"
+    where:
+      query: "implementation.has_tests == true OR implementation.testable == true"
+    then:
+      - concept: "execution-loop"
+        action: "run_with_verification"
+        model: "sonnet"
+        inputs:
+          code: "${implementation.code}"
+          language: "${implementation.language}"
+          testCommand: "${implementation.test_command}"
+          maxIterations: 3
+
+    slo_expectations:
+      expected_duration_ms: 30000
+      max_duration_ms: 180000
+      expected_cost_usd: 0.003
+      max_cost_usd: 0.015
+      expected_context_tokens: 4000
+      on_timeout:
+        action: "skip"
+        fallback: "Proceed to quality review without verification"
+
+    provenance:
+      flow_id: "${flow.id}"
+      reason: "Self-repair loop verifies implementation before quality review"
+      category: "core"
+
+  # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  # Self-Repair Flow
+  # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  # Handle verification failure - trigger repair
+  - id: "verify-failed-repair"
+    description: "When verification fails, generate repair suggestions"
+    when:
+      concept: "execution-loop"
+      action: "run_with_verification"
+      status: "failed"
+    where:
+      query: "execution.requiresManualRepair == true"
+    then:
+      - concept: "execution-loop"
+        action: "self_debug"
+        model: "sonnet"  # Use smarter model for diagnosis
+        inputs:
+          code: "${execution.code}"
+          error: "${execution.lastError}"
+          language: "${execution.language}"
+
+    slo_expectations:
+      expected_duration_ms: 10000
+      max_duration_ms: 45000
+      expected_cost_usd: 0.004
+      max_cost_usd: 0.012
+      expected_context_tokens: 3500
+      on_timeout:
+        action: "escalate"
+        message: "Debug diagnosis timed out"
+
+    provenance:
+      flow_id: "${flow.id}"
+      reason: "Diagnosis needed for failed verification"
+      category: "recovery"
+
+  # After successful diagnosis, attempt implementation repair
+  - id: "diagnosis-to-impl-repair"
+    description: "Apply repair suggestion to fix implementation"
+    when:
+      concept: "execution-loop"
+      action: "self_debug"
+      status: "completed"
+    then:
+      - concept: "implementation"
+        action: "repair"
+        model: "sonnet"
+        inputs:
+          original_code: "${diagnosis.code}"
+          error_info: "${diagnosis.diagnosis}"
+          repair_suggestion: "${diagnosis.repairSuggestion}"
+          strategy: "${diagnosis.strategy}"
+
+    slo_expectations:
+      expected_duration_ms: 15000
+      max_duration_ms: 60000
+      expected_cost_usd: 0.005
+      max_cost_usd: 0.015
+      expected_context_tokens: 4000
+      on_timeout:
+        action: "escalate"
+        message: "Repair application timed out"
+
+    provenance:
+      flow_id: "${flow.id}"
+      reason: "Applying diagnosed repair to implementation"
+      category: "recovery"
+
+  # After repair, re-verify
+  - id: "repair-to-reverify"
+    description: "Re-run verification after repair attempt"
+    when:
+      concept: "implementation"
+      action: "repair"
+      status: "completed"
+    then:
+      - concept: "execution-loop"
+        action: "run_with_verification"
+        model: "sonnet"
+        inputs:
+          code: "${implementation.repaired_code}"
+          language: "${implementation.language}"
+          testCommand: "${implementation.test_command}"
+          maxIterations: 2  # Fewer iterations on retry
+
+    slo_expectations:
+      expected_duration_ms: 20000
+      max_duration_ms: 120000
+      expected_cost_usd: 0.002
+      max_cost_usd: 0.01
+      expected_context_tokens: 3000
+      on_timeout:
+        action: "skip"
+        fallback: "Proceed without re-verification"
+
+    provenance:
+      flow_id: "${flow.id}"
+      reason: "Verify repair was successful"
+      category: "validation"
+
+  # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  # Escalation
+  # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  # Maximum repair attempts exceeded - escalate to human
+  - id: "max-repairs-exceeded"
+    description: "Escalate to human when max repair attempts reached"
+    when:
+      concept: "execution-loop"
+      action: "run_with_verification"
+      status: "failed"
+    where:
+      query: "execution.totalIterations >= 3 AND execution.requiresManualRepair == true"
+    then:
+      - concept: "implementation"
+        action: "add_note"
+        model: "sonnet"
+        inputs:
+          note: |
+            ## Manual Repair Required
+
+            Automated repair failed after ${execution.totalIterations} attempts.
+
+            ### Last Error
+            ${execution.lastError}
+
+            ### Repair Suggestions Tried
+            ${execution.repairSuggestions}
+
+            ### Recommended Next Steps
+            1. Review the error carefully
+            2. Check related code for context
+            3. Consider if the approach needs fundamental rethinking
+
+    slo_expectations:
+      expected_duration_ms: 2000
+      max_duration_ms: 10000
+      expected_cost_usd: 0.001
+      max_cost_usd: 0.003
+      expected_context_tokens: 1500
+      on_timeout:
+        action: "proceed"
+        message: "Note generation timed out but escalation continues"
+
+    provenance:
+      flow_id: "${flow.id}"
+      reason: "Escalating to human after max repair attempts"
+      category: "recovery"
+
+  # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  # Test-Driven Development
+  # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  # Test-driven development flow
+  - id: "tdd-generate-tests-first"
+    description: "Generate tests before implementation when TDD mode is enabled"
+    when:
+      concept: "architecture"
+      action: "design"
+      status: "completed"
+    where:
+      query: "architecture.development_mode == 'tdd'"
+    then:
+      - concept: "test-generator"
+        action: "generate_unit_tests"
+        model: "sonnet"
+        inputs:
+          specification: "${architecture.component_specs}"
+          language: "${architecture.language}"
+          framework: "${architecture.test_framework}"
+
+    slo_expectations:
+      expected_duration_ms: 20000
+      max_duration_ms: 90000
+      expected_cost_usd: 0.004
+      max_cost_usd: 0.012
+      expected_context_tokens: 3500
+      on_timeout:
+        action: "skip"
+        fallback: "Proceed without TDD - generate tests after implementation"
+
+    provenance:
+      flow_id: "${flow.id}"
+      reason: "TDD: Generate tests before implementation"
+      category: "core"
+
+  # After test generation, proceed to implementation
+  - id: "tests-to-impl"
+    description: "Implement code to pass the generated tests"
+    when:
+      concept: "test-generator"
+      action: "generate_unit_tests"
+      status: "completed"
+    then:
+      - concept: "implementation"
+        action: "generate"
+        model: "sonnet"
+        inputs:
+          tests: "${test_generator.tests}"
+          specification: "${test_generator.specification}"
+          goal: "Write code that passes all generated tests"
+
+    slo_expectations:
+      expected_duration_ms: 30000
+      max_duration_ms: 180000
+      expected_cost_usd: 0.006
+      max_cost_usd: 0.02
+      expected_context_tokens: 5000
+      on_timeout:
+        action: "escalate"
+        message: "TDD implementation timed out"
+
+    provenance:
+      flow_id: "${flow.id}"
+      reason: "TDD: Implement to pass tests"
+      category: "core"
+
+  # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  # Quality Refinement
+  # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  # Iterative refinement for quality improvements
+  - id: "quality-refinement-needed"
+    description: "When quality review suggests improvements, iteratively refine"
+    when:
+      concept: "quality"
+      action: "review"
+      status: "completed"
+    where:
+      query: "review.status == 'approved_with_suggestions' AND review.suggestions.length > 0"
+    then:
+      - concept: "execution-loop"
+        action: "iterative_refine"
+        model: "sonnet"
+        inputs:
+          code: "${implementation.code}"
+          language: "${implementation.language}"
+          goals: "${review.suggestions}"
+          testCommand: "${implementation.test_command}"
+          maxPasses: 3
+
+    slo_expectations:
+      expected_duration_ms: 45000
+      max_duration_ms: 180000
+      expected_cost_usd: 0.006
+      max_cost_usd: 0.02
+      expected_context_tokens: 5000
+      on_timeout:
+        action: "skip"
+        fallback: "Accept current implementation without refinements"
+
+    provenance:
+      flow_id: "${flow.id}"
+      reason: "Iteratively refine based on review suggestions"
+      category: "optimization"
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# Execution Loop Summary
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+#
+# Self-Repair Cycle:
+#   Implementation → Verify → (fail) → Debug → Repair → Re-verify
+#                      ↓
+#                  (success)
+#                      ↓
+#                 Quality Review
+#
+# TDD Mode:
+#   Architecture (TDD) → Generate Tests → Implementation → Verify
+#
+# Max repair attempts: 3
+# Expected self-repair success rate: 78% (based on research)

package/templates/synchronizations/archive/exploration-flow.yaml.template

@@ -0,0 +1,369 @@
+# Exploration Flow Synchronization Rules
+# Enables Tree-of-Thoughts reasoning for complex decisions
+#
+# Based on research:
+# - Structured Chain-of-Thought for code generation
+# - RPM-MCTS: Monte Carlo Tree Search for step evaluation
+# - Graph of Thoughts: Non-linear reasoning with merging
+
+version: "1.0.0"
+
+# Global SLO defaults for exploration (expensive but high-value)
+slo_defaults:
+  expected_duration_ms: 15000
+  max_duration_ms: 60000
+  expected_cost_usd: 0.015
+  max_cost_usd: 0.05
+  expected_context_tokens: 5000
+  success_rate_target: 0.90
+  on_timeout:
+    action: "escalate"
+    message: "Exploration timed out - human guidance needed"
+
+synchronizations:
+  # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  # Complex Architecture Exploration
+  # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  - id: "arch-complexity-to-explore"
+    description: "Explore multiple approaches for complex architecture"
+    when:
+      concept: "architecture"
+      action: "design"
+      status: "starting"
+    where:
+      query: "story.complexity == 'high' OR story.acceptance_criteria.length > 5"
+    then:
+      - concept: "exploration"
+        action: "branch_explore"
+        model: "opus"  # Deep reasoning needed
+        inputs:
+          problem: "${story.description}"
+          constraints: "${story.acceptance_criteria}"
+          max_branches: 3
+          depth: 2
+          evaluation_criteria:
+            - "feasibility"
+            - "maintainability"
+            - "scalability"
+            - "security"
+
+    slo_expectations:
+      expected_duration_ms: 20000
+      max_duration_ms: 60000
+      expected_cost_usd: 0.02
+      max_cost_usd: 0.05
+      expected_context_tokens: 8000
+      on_timeout:
+        action: "skip"
+        fallback: "Proceed with default architecture approach"
+
+    provenance:
+      flow_id: "${flow.id}"
+      reason: "Complex story requires exploration of approaches"
+      category: "exploration"
+
+  - id: "explore-to-arch"
+    description: "Feed exploration results into architecture design"
+    when:
+      concept: "exploration"
+      action: "branch_explore"
+      status: "completed"
+    then:
+      - concept: "architecture"
+        action: "design"
+        model: "sonnet"
+        inputs:
+          exploration_result: "${exploration.selected_path}"
+          rejected_paths: "${exploration.rejected_paths_summary}"
+          confidence: "${exploration.confidence}"
+
+    slo_expectations:
+      expected_duration_ms: 5000
+      max_duration_ms: 20000
+      expected_cost_usd: 0.003
+      max_cost_usd: 0.01
+
+    provenance:
+      flow_id: "${flow.id}"
+      reason: "Architecture informed by exploration"
+      category: "design"
+
+  # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  # Debug Exploration
+  # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  - id: "debug-dead-end-to-explore"
+    description: "Explore alternatives when debugging approaches fail"
+    when:
+      concept: "execution-loop"
+      action: "self_debug"
+      status: "failed"
+    where:
+      query: "debug.attempts >= 2"
+    then:
+      - concept: "exploration"
+        action: "branch_explore"
+        model: "opus"
+        inputs:
+          problem: "Debug ${debug.error_type}: ${debug.error_message}"
+          constraints:
+            - "Must not break existing functionality"
+            - "Solution should be minimal"
+          max_branches: 3
+          depth: 2
+          evaluation_criteria:
+            - "likelihood_of_fix"
+            - "risk_of_regression"
+            - "implementation_effort"
+
+    slo_expectations:
+      expected_duration_ms: 15000
+      max_duration_ms: 45000
+      expected_cost_usd: 0.015
+      max_cost_usd: 0.04
+      on_timeout:
+        action: "escalate"
+        message: "Debug exploration timed out"
+
+    provenance:
+      flow_id: "${flow.id}"
+      reason: "Standard debugging failed - exploring alternatives"
+      category: "recovery"
+
+  # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  # Backtracking
+  # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  - id: "impl-blocked-to-backtrack"
+    description: "Backtrack to earlier decision when implementation is blocked"
+    when:
+      concept: "implementation"
+      action: "generate"
+      status: "blocked"
+    where:
+      query: "implementation.blocker_type == 'architectural'"
+    then:
+      - concept: "exploration"
+        action: "backtrack"
+        model: "sonnet"
+        inputs:
+          current_path: "${architecture.selected_approach}"
+          failure_reason: "${implementation.blocker_reason}"
+          backtrack_to: "architecture"
+
+    slo_expectations:
+      expected_duration_ms: 5000
+      max_duration_ms: 15000
+      expected_cost_usd: 0.003
+      max_cost_usd: 0.008
+      on_timeout:
+        action: "escalate"
+        message: "Backtracking timed out"
+
+    provenance:
+      flow_id: "${flow.id}"
+      reason: "Implementation blocked - backtracking to architecture"
+      category: "recovery"
+
+  # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  # Refactoring Exploration
+  # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  - id: "refactor-to-explore"
+    description: "Explore refactoring strategies before major changes"
+    when:
+      concept: "implementation"
+      action: "refactor"
+      status: "starting"
+    where:
+      query: "refactor.scope == 'major' OR refactor.files_affected > 5"
+    then:
+      - concept: "exploration"
+        action: "branch_explore"
+        model: "opus"
+        inputs:
+          problem: "Refactor ${refactor.target}: ${refactor.goal}"
+          constraints:
+            - "Maintain backwards compatibility"
+            - "Minimize test changes"
+          max_branches: 3
+          evaluation_criteria:
+            - "risk"
+            - "effort"
+            - "improvement"
+
+    slo_expectations:
+      expected_duration_ms: 20000
+      max_duration_ms: 60000
+      expected_cost_usd: 0.02
+      max_cost_usd: 0.05
+      on_timeout:
+        action: "skip"
+        fallback: "Proceed with incremental refactoring"
+
+    provenance:
+      flow_id: "${flow.id}"
+      reason: "Major refactor requires exploration"
+      category: "exploration"
+
+  # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  # Confidence-Based Evaluation
+  # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  - id: "low-confidence-to-evaluate"
+    description: "Evaluate path more deeply when confidence is low"
+    when:
+      concept: "exploration"
+      action: "branch_explore"
+      status: "completed"
+    where:
+      query: "exploration.confidence < 0.7"
+    then:
+      - concept: "exploration"
+        action: "evaluate_path"
+        model: "opus"
+        inputs:
+          path_id: "${exploration.selected_path.path_id}"
+          depth: 3
+          focus_areas:
+            - "unknowns"
+            - "risks"
+
+    slo_expectations:
+      expected_duration_ms: 10000
+      max_duration_ms: 30000
+      expected_cost_usd: 0.01
+      max_cost_usd: 0.03
+      on_timeout:
+        action: "proceed"
+        message: "Proceeding with low-confidence path"
+
+    provenance:
+      flow_id: "${flow.id}"
+      reason: "Low confidence - deeper evaluation needed"
+      category: "validation"
+
+  - id: "close-scores-to-merge"
+    description: "Consider hybrid approach when paths have similar scores"
+    when:
+      concept: "exploration"
+      action: "branch_explore"
+      status: "completed"
+    where:
+      query: "abs(exploration.branches[0].score - exploration.branches[1].score) < 1.0"
+    then:
+      - concept: "exploration"
+        action: "merge_paths"
+        model: "opus"
+        inputs:
+          paths:
+            - "${exploration.branches[0].path_id}"
+            - "${exploration.branches[1].path_id}"
+          merge_strategy: "best_of_each"
+
+    slo_expectations:
+      expected_duration_ms: 8000
+      max_duration_ms: 25000
+      expected_cost_usd: 0.008
+      max_cost_usd: 0.025
+      on_timeout:
+        action: "skip"
+        fallback: "Use highest-scoring path"
+
+    provenance:
+      flow_id: "${flow.id}"
+      reason: "Close scores suggest hybrid might be optimal"
+      category: "optimization"
+
+  # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  # Learning from Exploration
+  # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  - id: "exploration-to-memory"
+    description: "Store exploration learnings in semantic memory"
+    when:
+      concept: "exploration"
+      action: ["branch_explore", "backtrack"]
+      status: "completed"
+    then:
+      - concept: "retrospective"
+        action: "extract_pattern"
+        model: "sonnet"
+        inputs:
+          source: "exploration"
+          data: "${exploration}"
+          pattern_type: "decision_pattern"
+
+    slo_expectations:
+      expected_duration_ms: 3000
+      max_duration_ms: 10000
+      expected_cost_usd: 0.002
+      max_cost_usd: 0.005
+      on_timeout:
+        action: "skip"
+        fallback: "Learning deferred"
+
+    provenance:
+      flow_id: "${flow.id}"
+      reason: "Learn from exploration decisions"
+      category: "learning"
+
+  # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  # Escalation
+  # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  - id: "max-backtracks-escalate"
+    description: "Escalate to human if exploration keeps failing"
+    when:
+      concept: "exploration"
+      action: "backtrack"
+      status: "completed"
+    where:
+      query: "exploration.backtrack_count >= 3"
+    then:
+      - concept: "story"
+        action: "add_note"
+        model: "sonnet"
+        inputs:
+          note: |
+            ## Exploration Exhausted
+
+            Multiple approaches have been tried and abandoned:
+            ${exploration.abandoned_paths.map(p => '- ' + p.name + ': ' + p.failure_reason).join('\n')}
+
+            This may indicate:
+            - Requirements are conflicting
+            - Problem needs reframing
+            - Human domain expertise needed
+
+            Please review and provide guidance.
+          severity: "blocker"
+
+    slo_expectations:
+      expected_duration_ms: 2000
+      max_duration_ms: 5000
+      expected_cost_usd: 0.001
+      max_cost_usd: 0.003
+
+    provenance:
+      flow_id: "${flow.id}"
+      reason: "Max backtracks exceeded - human input needed"
+      category: "escalation"
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# Exploration Flow Summary
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+#
+# This synchronization file enables:
+# - Tree-of-Thoughts exploration for complex decisions
+# - Branch-and-bound search with evaluation criteria
+# - Backtracking when implementation hits blockers
+# - Hybrid path merging when scores are close
+# - Learning from exploration decisions
+# - Automatic escalation when exploration exhausted
+#
+# Uses Opus for deep reasoning (exploration, evaluation)
+# Uses Sonnet for routine operations (backtrack, learning)
+#
+# Expected exploration cost: $0.015-0.05 per complex decision