@yamo/memory-mesh 3.0.3 → 3.1.0

package/skills/foundational/yamo-unified-foundation.yamo

@@ -0,0 +1,77 @@
+---
+name: YamoUnifiedFoundation
+version: 3.0.0
+description: The "Global Protocol" for the YAMO Unified Development OS.
+author: Soverane Labs
+license: MIT
+tags: foundation, protocol, yamo, unified, llm-first
+module_type: foundation
+---
+🎯 YAMO Unified Foundation v3.0.0 - The Global Semantic Protocol
+
+**Purpose**: Defines the universal state structure that bridges Macro-level Specifications and Micro-level Implementation.
+
+**Zero JSON Compliance**: Mandatory.
+
+---
+concept: GlobalProjectContext;
+description: The persistent context chain for the entire project lifecycle.
+structure:
+  macro_state:
+    feature_description;raw_input;
+    specification_path;docs/specs/prd.md;
+    architectural_design;docs/specs/architecture.md;
+    constitutional_assessment;docs/audits/macro_compliance.yamo;
+    
+  micro_state:
+    active_worktree;path;
+    current_branch;string;
+    implementation_plan;docs/plans/roadmap.md;
+    active_task_id;string;
+    tdd_status;red|green|refactor;
+
+  subconscious_state:
+    oversights;list_of_past_failures;
+    lessons;list_of_lesson_learned_blocks;
+    active_constraints;derived_from_memory;
+    
+  semantic_heritage:
+    intent_chain;list_of_intents;
+    hypotheses;list_of_macro_and_micro_hypotheses;
+    rationales;justifications_for_design_and_impl;
+    confidence_score;average_of_all_agents;
+
+---
+concept: LessonLearned;
+description: A high-fidelity memory entry containing an oversight and its resolution.
+required_fields:
+  context;situation_description;
+  oversight;what_was_missed;
+  fix;how_it_was_resolved;
+  constraint;preventative_rule_for_future;
+  tags;["#lesson_learned"];
+
+---
+protocol: UnifiedHandoff;
+mode: llm_first;
+constraints:
+  - use_canonical_yamo_format;required;
+  - include_semantic_metadata;hypothesis;rationale;confidence;
+  - ensure_unbroken_chain;from_macro_to_micro;
+  - NO_JSON_OUTPUT;critical;
+
+---
+concept: QualityGates;
+definitions:
+  specification_gate;completeness_and_testability;
+  compliance_gate;article_vii_and_viii_verification;
+  implementation_gate;test_pass_and_contract_adherence;
+  unified_gate;alignment_between_spec_and_code;
+
+---
+agent: UnifiedProtocolProvider;
+intent: synchronize_state_across_macro_and_micro_modules;
+context:
+  protocol_active;true;
+  version;3.0.0;
+handoff: caller;

package/skills/macro/planning-workflow.yamo

@@ -0,0 +1,176 @@
+---
+name: PlanningWorkflow
+version: 1.0.0
+description: Converts PRD specifications into detailed implementation plans with constitutional compliance, technology choices, and test-first structure. Enforces phase gates and architectural discipline.
+author: Soverane Labs
+license: MIT
+tags:
+  - sdd
+  - planning
+  - implementation-plan
+  - constitutional-compliance
+  - architecture
+module_type: workflow
+dependencies:
+  - ../foundational/yamo-unified-foundation.yamo
+---
+🏗️ Planning Workflow - PRD to Constitutional Implementation Plan
+
+**Purpose**: Transform business requirements into technically sound, constitutionally compliant implementation plans
+
+---
+agent: PlanningInitiator;
+intent: initialize_planning_from_finalized_specification;
+context:
+  received_specification;finalized_specification_context.yamo;
+  foundation;../foundational/yamo-unified-foundation.yamo;
+constraints:
+  - receive_finalized_specification;required;
+  - validate_specification_completeness;required;
+  - load_constitutional_framework;required;
+  - initialize_planning_context;required;
+  - prepare_output_structure;required;
+
+priority: critical;
+output: planning_initialization_context.yamo;
+log: planning_initiated;timestamp;2026-02-14;
+
+meta: hypothesis;Planning requires complete specification and constitutional framework;
+meta: rationale;Initialization loads all necessary context for technical translation;
+meta: confidence;0.97;
+
+handoff: ResearchAgent;
+---
+agent: ResearchAgent;
+intent: investigate_technical_options_and_gather_context;
+context:
+  received_planning;planning_initialization_context.yamo;
+constraints:
+  - identify_all_technical_decisions;required;
+  - investigate_options_thoroughly;required;
+  - gather_performance_data;where_applicable;
+  - consider_organizational_constraints;required;
+  - document_findings;research_md;
+  - provide_recommendations;with_rationale;
+
+priority: high;
+output: research_findings_context.yamo;
+log: research_completed;timestamp;2026-02-14;
+
+meta: hypothesis;Research-driven context produces better technical decisions;
+meta: confidence;0.94;
+
+handoff: TechnicalTranslator;
+---
+agent: TechnicalTranslator;
+intent: translate_business_requirements_to_technical_architecture;
+context:
+  received_planning;planning_initialization_context.yamo;
+  received_research;research_findings_context.yamo;
+constraints:
+  - translate_all_requirements;to_technical_decisions;
+  - reference_research_findings;for_technology_choices;
+  - align_with_constitutional_principles;required;
+  - document_rationale;for_each_decision;
+  - create_data_model;entities_schemas;
+  - design_api_contracts;specifications;
+  - define_testing_strategy;test_first;
+
+priority: critical;
+output: technical_architecture_context.yamo;
+log: requirements_translated;timestamp;2026-02-14;
+
+meta: hypothesis;Systematic translation produces comprehensive technical architecture;
+meta: confidence;0.95;
+
+handoff: PhaseGateValidator;
+---
+agent: PhaseGateValidator;
+intent: validate_architecture_against_constitutional_phase_gates;
+context:
+  received_architecture;technical_architecture_context.yamo;
+constraints:
+  - validate_all_three_gates;required;
+  - check_simplicity_gate;project_count;future_proofing;
+  - check_anti_abstraction_gate;framework_usage;wrappers;
+  - check_integration_first_gate;contracts;mocking;
+  - require_justification_for_failures;documented_exceptions;
+  - determine_pass_fail;based_on_gate_criteria;
+
+priority: critical;
+output: gate_validation_results_context.yamo;
+log: phase_gates_validated;timestamp;2026-02-14;
+
+meta: hypothesis;Phase gates prevent over-engineering and ensure quality;
+meta: confidence;0.96;
+
+handoff: ComplexityTracker;
+---
+agent: ComplexityTracker;
+intent: document_justified_exceptions_to_constitutional_gates;
+context:
+  received_validation;gate_validation_results_context.yamo;
+  received_architecture;technical_architecture_context.yamo;
+constraints:
+  - check_gate_results;required;
+  - document_justified_exceptions;if_any;
+  - require_justification;for_all_failures;
+  - create_complexity_tracking_section;in_plan;
+  - skip_if_all_passed;efficient;
+
+priority: high;
+output: complexity_tracking_context.yamo;
+log: complexity_documented;timestamp;2026-02-14;
+
+meta: hypothesis;Documented exceptions create accountability for complexity;
+meta: confidence;0.93;
+
+handoff: PlanAssembler;
+---
+agent: PlanAssembler;
+intent: assemble_complete_implementation_plan_with_all_components;
+context:
+  received_architecture;technical_architecture_context.yamo;
+  received_research;research_findings_context.yamo;
+  received_gates;gate_validation_results_context.yamo;
+  received_complexity;complexity_tracking_context.yamo;
+constraints:
+  - assemble_all_plan_components;required;
+  - structure_in_phases;minus_1_through_4;
+  - include_pre_implementation_gates;phase_minus_1;
+  - document_file_creation_order;contracts_first;
+  - keep_plan_high_level;extract_details_to_separate_files;
+  - generate_data_model;entities_schemas;
+  - generate_api_contracts;specifications;
+  - generate_quickstart;validation_scenarios;
+  - write_all_documents;to_specs_branch_directory;
+
+priority: critical;
+output: assembled_plan_context.yamo;
+log: plan_assembled;timestamp;2026-02-14;
+
+meta: hypothesis;Complete plan provides all information needed for execution;
+meta: confidence;0.97;
+
+handoff: PlanValidator;
+---
+agent: PlanValidator;
+intent: validate_plan_completeness_and_constitutional_compliance;
+context:
+  received_plan;assembled_plan_context.yamo;
+constraints:
+  - validate_all_criteria;comprehensively;
+  - check_constitutional_compliance;critical;
+  - verify_technology_rationale;documented;
+  - verify_test_first_approach;required;
+  - verify_supporting_documents;all_present;
+  - determine_pass_fail;based_on_criteria;
+
+priority: critical;
+output: plan_validation_results_context.yamo;
+log: plan_validated;timestamp;2026-02-14;
+
+meta: hypothesis;Plan validation ensures execution readiness;
+meta: confidence;0.96;
+
+handoff: Orchestrator;

package/skills/macro/specification-workflow.yamo

@@ -0,0 +1,154 @@
+---
+name: SpecificationWorkflow
+version: 1.0.0
+description: Transforms vague ideas into comprehensive, executable PRDs through iterative AI-assisted dialogue. Enforces template-driven quality constraints and constitutional compliance.
+author: Soverane Labs
+license: MIT
+tags:
+  - sdd
+  - specification
+  - prd
+  - requirements
+  - feature-spec
+module_type: workflow
+dependencies:
+  - ../foundational/yamo-unified-foundation.yamo
+---
+🎯 Specification Workflow - Idea to Executable PRD
+
+**Purpose**: Convert vague feature ideas into comprehensive, template-constrained PRDs
+
+**Philosophy**: What and Why, never How. Specifications drive code, not serve it.
+
+---
+agent: IdeaCaptureAgent;
+intent: capture_initial_feature_idea_from_user;
+context:
+  user_input;vague_incomplete_idea;natural_language_description;
+  foundation;../foundational/yamo-unified-foundation.yamo;
+constraints:
+  - accept_user_input;any_form;any_completeness_level;
+  - perform_basic_sanity_check;required;
+  - avoid_premature_technical_translation;no_how_yet;
+  - capture_raw_intent;preserve_user_language;
+  - identify_obvious_gaps;for_clarification;
+
+priority: high;
+output: raw_idea_context.yamo;
+log: idea_captured;timestamp;2026-02-14;
+
+meta: hypothesis;Raw ideas contain enough signal to begin refinement process;
+meta: rationale;Capturing raw ideas enables iterative clarification dialogue;
+meta: confidence;0.92;
+
+handoff: TemplateInitializer;
+---
+agent: TemplateInitializer;
+intent: initialize_feature_specification_template;
+context:
+  received_idea;raw_idea_context.yamo;
+constraints:
+  - initialize_template;required;
+  - apply_template_constraints;from_foundation;
+  - determine_feature_number;auto_increment;
+  - generate_branch_name;semantic;
+  - create_directory;specs_directory;
+  - preserve_what_and_why_focus;critical;
+
+priority: critical;
+output: initialized_template_context.yamo;
+log: template_initialized;feature_number_assigned;branch_created;timestamp;2026-02-14;
+
+meta: hypothesis;Template initialization structures subsequent refinement process;
+meta: rationale;Template provides scaffolding for complete specification;
+meta: confidence;0.95;
+
+handoff: ClarificationDialogueAgent;
+---
+agent: ClarificationDialogueAgent;
+intent: conduct_iterative_dialogue_to_refine_specification;
+context:
+  received_template;initialized_template_context.yamo;
+constraints:
+  - conduct_iterative_dialogue;required;
+  - ask_clarifying_questions;targeted_specific;
+  - identify_all_edge_cases;required;
+  - define_measurable_acceptance_criteria;required;
+  - enforce_what_and_why_constraint;no_how_discussion;
+  - use_needs_clarification_markers;for_unknowns;
+  - iterate_until_complete;or_user_satisfied;
+
+priority: critical;
+output: refined_specification_context.yamo;
+log: clarification_dialogue_completed;iterations_count;timestamp;2026-02-14;
+
+meta: hypothesis;Iterative dialogue produces more complete specifications than single-pass;
+meta: rationale;Dialogue enables collaborative specification refinement;
+meta: confidence;0.96;
+
+handoff: CompletenessValidator;
+---
+agent: CompletenessValidator;
+intent: validate_specification_completeness_against_criteria;
+context:
+  received_specification;refined_specification_context.yamo;
+constraints:
+  - validate_all_criteria;comprehensively;
+  - check_for_clarification_markers;must_be_zero;
+  - verify_testability;all_requirements;
+  - verify_measurability;acceptance_criteria;
+  - identify_all_gaps;explicitly;
+  - determine_pass_fail;based_on_criteria;
+
+priority: critical;
+output: validation_results_context.yamo;
+log: completeness_validated;result;gaps_found;timestamp;2026-02-14;
+
+meta: hypothesis;Explicit validation prevents incomplete specifications from proceeding;
+meta: rationale;Validation gate ensures quality before handoff to planning;
+meta: confidence;0.97;
+
+handoff: GapResolver;
+---
+agent: GapResolver;
+intent: resolve_identified_gaps_in_specification;
+context:
+  received_validation;validation_results_context.yamo;
+  received_specification;refined_specification_context.yamo;
+constraints:
+  - check_validation_results;required;
+  - route_based_on_gaps;conditional;
+  - provide_gap_context;if_returning_to_dialogue;
+  - proceed_if_complete;validation_passed;
+
+priority: high;
+output: gap_resolution_decision_context.yamo;
+log: gaps_assessed;resolution_path_determined;timestamp;2026-02-14;
+
+meta: hypothesis;Iterative gap resolution produces higher quality specifications;
+meta: confidence;0.93;
+
+handoff: SpecificationFinalizer;
+---
+agent: SpecificationFinalizer;
+intent: finalize_and_persist_complete_specification;
+context:
+  received_specification;refined_specification_context.yamo;
+  received_validation;validation_results_context.yamo;
+constraints:
+  - generate_final_document;markdown_format;
+  - write_to_correct_directory;specs_branch_name;
+  - include_all_metadata;required;
+  - validate_final_output;against_template;
+  - prepare_for_git;required;
+  - ensure_template_compliance;documented;
+
+priority: critical;
+output: finalized_specification_context.yamo;
+log: specification_finalized;written_to_file;ready_for_planning;timestamp;2026-02-14;
+
+meta: hypothesis;Finalized specification serves as immutable input to planning workflow;
+meta: rationale;Finalization creates clear boundary between specification and planning;
+meta: confidence;0.98;
+
+handoff: Orchestrator;

package/skills/micro/debugging-verification.yamo

@@ -0,0 +1,70 @@
+---
+name: YamoSuperDebugging
+version: 3.0.0
+description: Debugging and verification workflow for YamoSuper v3. Systematic root-cause analysis.
+author: Soverane Labs
+license: MIT
+tags: debugging, verification, root-cause, yamo-v3
+module_type: workflow
+dependencies:
+  - ../foundational/yamo-unified-foundation.yamo
+---
+🎯 Debugging & Verification Workflow v3.0.0 - Systematic Root-Cause Analysis
+
+**Purpose**: Resolves bugs by identifying the underlying cause and verifying the fix through TDD.
+
+---
+agent: DebuggingInitiator;
+intent: identify_and_reproduce_bug;
+context:
+  symptoms;from_orchestrator;
+  foundation;../foundational/yamo-unified-foundation.yamo;
+constraints:
+  - define_symptoms_precisely;
+  - create_minimal_reproduction_case;critical;
+  - verify_bug_exists_in_current_state;
+priority: critical;
+output: reproduction_context.yamo;
+
+meta: hypothesis;Reliable reproduction is 90% of the fix;
+meta: rationale;If you cannot see it fail, you cannot know if you fixed it;
+meta: confidence;0.98;
+
+handoff: RootCauseAnalyzer;
+
+---
+agent: RootCauseAnalyzer;
+intent: isolate_the_underlying_failure;
+context:
+  reproduction;from_DebuggingInitiator;
+constraints:
+  - trace_execution_flow;
+  - use_binary_search_to_isolate_culprit;
+  - identify_the_exact_line_or_logic_failure;
+  - avoid_bandage_fixes;look_for_systemic_cause;
+priority: high;
+output: root_cause_context.yamo;
+
+meta: observation;Bugs often cluster around edge cases and state transitions;
+meta: rationale;Treating the symptom without the cause leads to regression loops;
+meta: confidence;0.95;
+
+handoff: FixVerifier;
+
+---
+agent: FixVerifier;
+intent: apply_fix_and_ensure_zero_regressions;
+context:
+  cause;from_RootCauseAnalyzer;
+constraints:
+  - apply_tdd_cycle_to_fix;
+  - run_full_regression_suite;
+  - verify_fix_on_original_symptoms;
+priority: high;
+output: debugging_results_context.yamo;
+
+meta: hypothesis;Regression suites prevent fixing one thing by breaking another;
+meta: rationale;Production stability depends on holistic verification;
+meta: confidence;0.97;
+
+handoff: Orchestrator;

package/skills/micro/discovery-analysis.yamo

@@ -0,0 +1,72 @@
+---
+name: YamoSuperDiscovery
+version: 3.0.0
+description: Discovery and analysis workflow for YamoSuper v3. Handles brainstorming and design refinement.
+author: Soverane Labs
+license: MIT
+tags: discovery, brainstorming, design, yamo-v3
+module_type: workflow
+dependencies:
+  - ../foundational/yamo-unified-foundation.yamo
+---
+🎯 Discovery & Analysis Workflow v3.0.0 - Semantic Intent Extraction
+
+**Purpose**: Refines the user's idea into a validated design through socratic dialogue and architectural analysis.
+
+---
+agent: DiscoveryInitiator;
+intent: start_discovery_phase;
+context:
+  initialization;from_orchestrator;
+  foundation;../foundational/yamo-unified-foundation.yamo;
+  memory_search;search_similar_patterns;
+constraints:
+  - scan_codebase_for_context;files;docs;recent_changes;
+  - ask_socratic_questions;limit_one_at_a_time;
+  - identify_stakeholders_and_impact;
+priority: high;
+output: discovery_intent_context.yamo;
+
+meta: hypothesis;Socratic questioning reveals hidden requirements;
+meta: rationale;Direct implementation often misses edge cases identified during dialogue;
+meta: confidence;0.95;
+
+handoff: DesignRefiner;
+
+---
+agent: DesignRefiner;
+intent: iteratively_refine_architecture;
+context:
+  intent;from_DiscoveryInitiator;
+constraints:
+  - propose_alternatives;at_least_two;
+  - document_tradeoffs;complexity_vs_performance_vs_maintainability;
+  - segment_design;architecture;data_flow;interface;testing;
+  - validate_each_segment_with_user;
+priority: high;
+output: refined_design_context.yamo;
+
+meta: hypothesis;Segmented validation prevents cognitive overload;
+meta: rationale;User can provide higher quality feedback on smaller design blocks;
+meta: confidence;0.96;
+
+handoff: BaselineVerifier;
+
+---
+agent: BaselineVerifier;
+intent: verify_project_health_before_coding;
+context:
+  design;from_DesignRefiner;
+constraints:
+  - run_current_test_suite;
+  - verify_clean_git_state;
+  - identify_dependency_conflicts;
+  - if_baseline_fails;require_fix_before_proceeding;
+priority: critical;
+output: discovery_results_context.yamo;
+
+meta: observation;Baseline health is the foundation of reliable TDD;
+meta: rationale;Starting from a failing baseline leads to "false red" TDD cycles;
+meta: confidence;0.98;
+
+handoff: Orchestrator;

package/skills/micro/implementation-tdd.yamo

@@ -0,0 +1,73 @@
+---
+name: YamoSuperExecution
+version: 3.0.0
+description: Implementation TDD workflow for YamoSuper v3. Enforces Red-Green-Refactor cycles.
+author: Soverane Labs
+license: MIT
+tags: implementation, tdd, coding, yamo-v3
+module_type: workflow
+dependencies:
+  - ../foundational/yamo-unified-foundation.yamo
+---
+🎯 Implementation TDD Workflow v3.0.0 - Red-Green-Refactor Execution
+
+**Purpose**: Executes the implementation plan through a series of verified TDD cycles.
+
+---
+agent: TDDOrchestrator;
+intent: manage_execution_cycle;
+context:
+  micro_plan;from_planning;
+  foundation;../foundational/yamo-unified-foundation.yamo;
+constraints:
+  - execute_tasks_sequentially;
+  - for_each_task;trigger_tdd_cycle;
+  - maintain_state_in_yamo_context;
+  - stop_on_any_test_failure;
+priority: critical;
+output: execution_progress_context.yamo;
+
+meta: hypothesis;Sequential execution with immediate verification prevents error compounding;
+meta: rationale;Fixing a bug in the moment it is introduced is the most efficient path;
+meta: confidence;0.96;
+
+handoff: TDDCycleAgent;
+
+---
+agent: TDDCycleAgent;
+intent: execute_single_red_green_refactor_loop;
+context:
+  task;from_TDDOrchestrator;
+constraints:
+  - step_1_red;write_minimal_failing_test;verify_fail;
+  - step_2_green;write_minimal_code_to_pass;verify_pass;
+  - step_3_refactor;clean_code_on_green;verify_pass;
+  - NO_CODE_WITHOUT_TEST;iron_law;
+  - use_real_code_avoid_excessive_mocking;
+priority: critical;
+output: cycle_results_context.yamo;
+
+meta: observation;The Red phase proves that the test is actually testing the requirement;
+meta: rationale;Without seeing a test fail, you have no proof that it will catch a future regression;
+meta: confidence;0.99;
+
+handoff: ImplementationReviewer;
+
+---
+agent: ImplementationReviewer;
+intent: perform_task_level_code_review;
+context:
+  results;from_TDDCycleAgent;
+constraints:
+  - check_against_spec;inherit_macro_intent;
+  - verify_test_coverage_and_quality;
+  - check_code_style_and_conventions;
+  - if_review_fails;return_to_tdd_cycle;
+priority: high;
+output: execution_results_context.yamo;
+
+meta: hypothesis;Peer review catches subtle logic errors;
+meta: rationale;A second set of semantic eyes ensures code isn't just "passing" but "correct";
+meta: confidence;0.95;
+
+handoff: Orchestrator;

package/skills/micro/planning-logic.yamo

@@ -0,0 +1,72 @@
+---
+name: YamoSuperPlanning
+version: 3.0.0
+description: Planning logic workflow for YamoSuper v3. Translates Macro designs into TDD-ready task lists.
+author: Soverane Labs
+license: MIT
+tags: planning, tasks, tdd, yamo-v3
+module_type: workflow
+dependencies:
+  - ../foundational/yamo-unified-foundation.yamo
+---
+🎯 Planning Logic Workflow v3.0.0 - Micro Task Derivation
+
+**Purpose**: Breaks down a Macro-level design into granular, TDD-compliant tasks for implementation.
+
+---
+agent: PlanningInitiator;
+intent: derive_tdd_tasks_from_macro_design;
+context:
+  macro_results;from_orchestrator; // This is macro_results_context.yamo
+  foundation;../foundational/yamo-unified-foundation.yamo;
+constraints:
+  - receive_macro_plan;docs/plans/roadmap.md_or_similar;
+  - break_into_bite_sized_tasks;target_5_15_minutes_per_task;
+  - each_task_must_have_test_first_step;
+  - include_exact_file_paths;
+  - define_explicit_success_criteria_per_task;
+priority: critical;
+output: micro_tasks_context.yamo;
+
+meta: hypothesis;Granular micro-tasks minimize cognitive load during coding;
+meta: rationale;Inheriting the Macro rationale ensures architectural alignment;
+meta: confidence;0.97;
+
+handoff: MicroConstitutionalGate;
+
+---
+agent: MicroConstitutionalGate;
+intent: validate_micro_tasks_against_yamo_constitution;
+context:
+  tasks;from_PlanningInitiator;
+constraints:
+  - check_article_vii;simplicity;detect_over_engineering_in_tasks;
+  - check_article_viii;anti_abstraction;detect_redundant_wrappers;
+  - check_article_ix;integration_first;verify_contracts_defined;
+  - if_violation_found;require_justification_or_redesign;
+priority: critical;
+output: micro_gated_tasks_context.yamo;
+
+meta: observation;Constitutional gating at the task level prevents implementation-drift;
+meta: rationale;Enforcing simplicity during coding is the last line of defense;
+meta: confidence;0.94;
+
+handoff: WorkspacePreparer;
+
+---
+agent: WorkspacePreparer;
+intent: setup_isolated_workspace;
+context:
+  gated_tasks;from_MicroConstitutionalGate;
+constraints:
+  - create_isolated_worktree;if_supported;
+  - initialize_feature_branch;
+  - persist_plan_to_docs;docs/plans/v3_micro_plan.md;
+priority: high;
+output: micro_implementation_plan_context.yamo;
+
+meta: hypothesis;Isolation prevents environmental contamination;
+meta: rationale;Dedicated worktrees ensure that experiments don't break the main workspace;
+meta: confidence;0.98;
+
+handoff: Orchestrator;