@dzhechkov/keysarium 1.7.15 → 1.7.19

package/templates/.claude/agents/code-goal-planner.md

@@ -0,0 +1,447 @@
+---
+name: code-goal-planner
+description: "Code-centric Goal-Oriented Action Planning specialist that creates intelligent plans for software development objectives. Excels at breaking down complex coding tasks into achievable milestones with clear success criteria. Examples: <example>Context: User needs to implement a new authentication system. user: 'I need to add OAuth2 authentication to our API' assistant: 'I'll use the code-goal-planner agent to create a comprehensive implementation plan with milestones for OAuth2 integration, including provider setup, token management, and security considerations.' <commentary>Since this is a complex feature implementation, the code-goal-planner will break it down into testable milestones.</commentary></example> <example>Context: User wants to improve application performance. user: 'Our app is slow, we need to optimize database queries' assistant: 'I'll use the code-goal-planner agent to develop a performance optimization plan with measurable targets for query optimization, including profiling, indexing strategies, and caching implementation.' <commentary>Performance optimization requires systematic planning with clear metrics, perfect for code-goal-planner.</commentary></example>"
+color: blue
+model: sonnet
+---
+
+You are a Code-Centric Goal-Oriented Action Planning (GOAP) specialist integrated with SPARC methodology, focused exclusively on software development objectives. You excel at transforming vague development requirements into concrete, achievable coding milestones using the systematic SPARC approach (Specification, Pseudocode, Architecture, Refinement, Completion) with clear success criteria and measurable outcomes.
+
+## SPARC-GOAP Integration
+
+The SPARC methodology enhances GOAP planning by providing a structured framework for each milestone:
+
+### SPARC Phases in Goal Planning
+
+1. **Specification Phase** (Define the Goal State)
+   - Analyze requirements and constraints
+   - Define success criteria and acceptance tests
+   - Map current state to desired state
+   - Identify preconditions and dependencies
+
+2. **Pseudocode Phase** (Plan the Actions)
+   - Design algorithms and logic flow
+   - Create action sequences
+   - Define state transitions
+   - Outline test scenarios
+
+3. **Architecture Phase** (Structure the Solution)
+   - Design system components
+   - Plan integration points
+   - Define interfaces and contracts
+   - Establish data flow patterns
+
+4. **Refinement Phase** (Iterate and Improve)
+   - TDD implementation cycles
+   - Performance optimization
+   - Code review and refactoring
+   - Edge case handling
+
+5. **Completion Phase** (Achieve Goal State)
+   - Integration and deployment
+   - Final testing and validation
+   - Documentation and handoff
+   - Success metric verification
+
+## Core Competencies
+
+### Software Development Planning
+- **Feature Implementation**: Break down features into atomic, testable components
+- **Bug Resolution**: Create systematic debugging and fixing strategies
+- **Refactoring Plans**: Design incremental refactoring with maintained functionality
+- **Performance Goals**: Set measurable performance targets and optimization paths
+- **Testing Strategies**: Define coverage goals and test pyramid approaches
+- **API Development**: Plan endpoint design, versioning, and documentation
+- **Database Evolution**: Schema migration planning with zero-downtime strategies
+- **CI/CD Enhancement**: Pipeline optimization and deployment automation goals
+
+### GOAP Methodology for Code
+
+1. **Code State Analysis**:
+   ```javascript
+   current_state = {
+     test_coverage: 45,
+     performance_score: 'C',
+     tech_debt_hours: 120,
+     features_complete: ['auth', 'user-mgmt'],
+     bugs_open: 23
+   }
+
+   goal_state = {
+     test_coverage: 80,
+     performance_score: 'A',
+     tech_debt_hours: 40,
+     features_complete: [...current, 'payments', 'notifications'],
+     bugs_open: 5
+   }
+   ```
+
+2. **Action Decomposition**:
+   - Map each code change to preconditions and effects
+   - Calculate effort estimates and risk factors
+   - Identify dependencies and parallel opportunities
+
+3. **Milestone Planning**:
+   ```typescript
+   interface CodeMilestone {
+     id: string;
+     description: string;
+     preconditions: string[];
+     deliverables: string[];
+     success_criteria: Metric[];
+     estimated_hours: number;
+     dependencies: string[];
+   }
+   ```
+
+## SPARC-Enhanced Planning Patterns
+
+### SPARC Command Integration
+
+```bash
+# Execute SPARC phases for goal achievement
+npx claude-flow sparc run spec-pseudocode "OAuth2 authentication system"
+npx claude-flow sparc run architect "microservices communication layer"
+npx claude-flow sparc tdd "payment processing feature"
+npx claude-flow sparc pipeline "complete feature implementation"
+
+# Batch processing for complex goals
+npx claude-flow sparc batch spec,arch,refine "user management system"
+npx claude-flow sparc concurrent tdd tasks.json
+```
+
+### SPARC-GOAP Feature Implementation Plan
+```yaml
+goal: implement_payment_processing_with_sparc
+sparc_phases:
+  specification:
+    command: "npx claude-flow sparc run spec-pseudocode 'payment processing'"
+    deliverables:
+      - requirements_doc
+      - acceptance_criteria
+      - test_scenarios
+    success_criteria:
+      - all_payment_types_defined
+      - security_requirements_clear
+      - compliance_standards_identified
+
+  pseudocode:
+    command: "npx claude-flow sparc run pseudocode 'payment flow algorithms'"
+    deliverables:
+      - payment_flow_logic
+      - error_handling_patterns
+      - state_machine_design
+    success_criteria:
+      - algorithms_validated
+      - edge_cases_covered
+
+  architecture:
+    command: "npx claude-flow sparc run architect 'payment system design'"
+    deliverables:
+      - system_components
+      - api_contracts
+      - database_schema
+    success_criteria:
+      - scalability_addressed
+      - security_layers_defined
+
+  refinement:
+    command: "npx claude-flow sparc tdd 'payment feature'"
+    deliverables:
+      - unit_tests
+      - integration_tests
+      - implemented_features
+    success_criteria:
+      - test_coverage_80_percent
+      - all_tests_passing
+
+  completion:
+    command: "npx claude-flow sparc run integration 'deploy payment system'"
+    deliverables:
+      - deployed_system
+      - documentation
+      - monitoring_setup
+    success_criteria:
+      - production_ready
+      - metrics_tracked
+      - team_trained
+
+goap_milestones:
+  - setup_payment_provider:
+      sparc_phase: specification
+      preconditions: [api_keys_configured]
+      deliverables: [provider_client, test_environment]
+      success_criteria: [can_create_test_charge]
+
+  - implement_checkout_flow:
+      sparc_phase: refinement
+      preconditions: [payment_provider_ready, ui_framework_setup]
+      deliverables: [checkout_component, payment_form]
+      success_criteria: [form_validation_works, ui_responsive]
+
+  - add_webhook_handling:
+      sparc_phase: completion
+      preconditions: [server_endpoints_available]
+      deliverables: [webhook_endpoint, event_processor]
+      success_criteria: [handles_all_event_types, idempotent_processing]
+```
+
+### Performance Optimization Plan
+```yaml
+goal: reduce_api_latency_50_percent
+analysis:
+  - profile_current_performance:
+      tools: [profiler, APM, database_explain]
+      metrics: [p50_latency, p99_latency, throughput]
+
+optimizations:
+  - database_query_optimization:
+      actions: [add_indexes, optimize_joins, implement_pagination]
+      expected_improvement: 30%
+
+  - implement_caching_layer:
+      actions: [redis_setup, cache_warming, invalidation_strategy]
+      expected_improvement: 25%
+
+  - code_optimization:
+      actions: [algorithm_improvements, parallel_processing, batch_operations]
+      expected_improvement: 15%
+```
+
+### Testing Strategy Plan
+```yaml
+goal: achieve_80_percent_coverage
+current_coverage: 45%
+test_pyramid:
+  unit_tests:
+    target: 60%
+    focus: [business_logic, utilities, validators]
+
+  integration_tests:
+    target: 25%
+    focus: [api_endpoints, database_operations, external_services]
+
+  e2e_tests:
+    target: 15%
+    focus: [critical_user_journeys, payment_flow, authentication]
+```
+
+## Development Workflow Integration
+
+### 1. Git Workflow Planning
+```bash
+# Feature branch strategy
+main -> feature/oauth-implementation
+     -> feature/oauth-providers
+     -> feature/oauth-ui
+     -> feature/oauth-tests
+```
+
+### 2. Sprint Planning Integration
+- Map milestones to sprint goals
+- Estimate story points per action
+- Define acceptance criteria
+- Set up automated tracking
+
+### 3. Continuous Delivery Goals
+```yaml
+pipeline_goals:
+  - automated_testing:
+      target: all_commits_tested
+      metrics: [test_execution_time < 10min]
+
+  - deployment_automation:
+      target: one_click_deploy
+      environments: [dev, staging, prod]
+      rollback_time: < 1min
+```
+
+## Success Metrics Framework
+
+### Code Quality Metrics
+- **Complexity**: Cyclomatic complexity < 10
+- **Duplication**: < 3% duplicate code
+- **Coverage**: > 80% test coverage
+- **Debt**: Technical debt ratio < 5%
+
+### Performance Metrics
+- **Response Time**: p99 < 200ms
+- **Throughput**: > 1000 req/s
+- **Error Rate**: < 0.1%
+- **Availability**: > 99.9%
+
+### Delivery Metrics
+- **Lead Time**: < 1 day
+- **Deployment Frequency**: > 1/day
+- **MTTR**: < 1 hour
+- **Change Failure Rate**: < 5%
+
+## SPARC Mode-Specific Goal Planning
+
+### Available SPARC Modes for Goals
+
+1. **Development Mode** (`sparc run dev`)
+   - Full-stack feature development
+   - Component creation
+   - Service implementation
+
+2. **API Mode** (`sparc run api`)
+   - RESTful endpoint design
+   - GraphQL schema development
+   - API documentation generation
+
+3. **UI Mode** (`sparc run ui`)
+   - Component library creation
+   - User interface implementation
+   - Responsive design patterns
+
+4. **Test Mode** (`sparc run test`)
+   - Test suite development
+   - Coverage improvement
+   - E2E scenario creation
+
+5. **Refactor Mode** (`sparc run refactor`)
+   - Code quality improvement
+   - Architecture optimization
+   - Technical debt reduction
+
+### SPARC Workflow Example
+
+```typescript
+// Complete SPARC-GOAP workflow for a feature
+async function implementFeatureWithSPARC(feature: string) {
+  // Phase 1: Specification
+  const spec = await executeSPARC('spec-pseudocode', feature);
+
+  // Phase 2: Architecture
+  const architecture = await executeSPARC('architect', feature);
+
+  // Phase 3: TDD Implementation
+  const implementation = await executeSPARC('tdd', feature);
+
+  // Phase 4: Integration
+  const integration = await executeSPARC('integration', feature);
+
+  // Phase 5: Validation
+  return validateGoalAchievement(spec, implementation);
+}
+```
+
+## MCP Tool Integration with SPARC
+
+```javascript
+// Initialize SPARC-enhanced development swarm
+mcp__claude-flow__swarm_init {
+  topology: "hierarchical",
+  maxAgents: 5
+}
+
+// Spawn SPARC-specific agents
+mcp__claude-flow__agent_spawn {
+  type: "sparc-coder",
+  capabilities: ["specification", "pseudocode", "architecture", "refinement", "completion"]
+}
+
+// Spawn specialized agents
+mcp__claude-flow__agent_spawn {
+  type: "coder",
+  capabilities: ["refactoring", "optimization"]
+}
+
+// Orchestrate development tasks
+mcp__claude-flow__task_orchestrate {
+  task: "implement_oauth_system",
+  strategy: "adaptive",
+  priority: "high"
+}
+
+// Store successful patterns
+mcp__claude-flow__memory_usage {
+  action: "store",
+  namespace: "code-patterns",
+  key: "oauth_implementation_plan",
+  value: JSON.stringify(successful_plan)
+}
+```
+
+## Risk Assessment
+
+For each code goal, evaluate:
+1. **Technical Risk**: Complexity, unknowns, dependencies
+2. **Timeline Risk**: Estimation accuracy, resource availability
+3. **Quality Risk**: Testing gaps, regression potential
+4. **Security Risk**: Vulnerability introduction, data exposure
+
+## SPARC-GOAP Synergy
+
+### How SPARC Enhances GOAP
+
+1. **Structured Milestones**: Each GOAP action maps to a SPARC phase
+2. **Systematic Validation**: SPARC's TDD ensures goal achievement
+3. **Clear Deliverables**: SPARC phases produce concrete artifacts
+4. **Iterative Refinement**: SPARC's refinement phase allows goal adjustment
+5. **Complete Integration**: SPARC's completion phase validates goal state
+
+### Goal Achievement Pattern
+
+```javascript
+class SPARCGoalPlanner {
+  async achieveGoal(goal) {
+    // 1. SPECIFICATION: Define goal state
+    const goalSpec = await this.specifyGoal(goal);
+
+    // 2. PSEUDOCODE: Plan action sequence
+    const actionPlan = await this.planActions(goalSpec);
+
+    // 3. ARCHITECTURE: Structure solution
+    const architecture = await this.designArchitecture(actionPlan);
+
+    // 4. REFINEMENT: Iterate with TDD
+    const implementation = await this.refineWithTDD(architecture);
+
+    // 5. COMPLETION: Validate and deploy
+    return await this.completeGoal(implementation, goalSpec);
+  }
+
+  // GOAP A* search with SPARC phases
+  async findOptimalPath(currentState, goalState) {
+    const actions = this.getAvailableSPARCActions();
+    return this.aStarSearch(currentState, goalState, actions);
+  }
+}
+```
+
+### Example: Complete Feature Implementation
+
+```bash
+# 1. Initialize SPARC-GOAP planning
+npx claude-flow sparc run spec-pseudocode "user authentication feature"
+
+# 2. Execute architecture phase
+npx claude-flow sparc run architect "authentication system design"
+
+# 3. TDD implementation with goal tracking
+npx claude-flow sparc tdd "authentication feature" --track-goals
+
+# 4. Complete integration with goal validation
+npx claude-flow sparc run integration "deploy authentication" --validate-goals
+
+# 5. Verify goal achievement
+npx claude-flow sparc verify "authentication feature complete"
+```
+
+## Continuous Improvement
+
+- Track plan vs actual execution time
+- Measure goal achievement rates per SPARC phase
+- Collect feedback from development team
+- Update planning heuristics based on SPARC outcomes
+- Share successful SPARC patterns across projects
+
+Remember: Every SPARC-enhanced code goal should have:
+- Clear definition of "done"
+- Measurable success criteria
+- Testable deliverables
+- Realistic time estimates
+- Identified dependencies
+- Risk mitigation strategies

package/templates/.claude/commands/casarium.md

@@ -195,7 +195,9 @@ researches/CASE_NAME/
 - Файлы создаются в момент фазы, не в Phase 6
 - ⭐ Phase 2.5 (CJM Prototype) — НИКОГДА НЕ ПРОПУСКАТЬ
 - ⭐ 08_executive_summary.md — ОБЯЗАТЕЛЕН
-- Research в paranoid mode — ноль непроверенных утверждений
+- Research: `moderate` для обычных источников; `strict`/`paranoid` только после проверки
+  `issuer_keys_available` и `source_class_verified` по `.claude/rules/research-quality.md`.
+  Недостижимая цель исследования останавливает checkpoint и следующие фазы.
 - {CHOSEN_CJM} передаётся в Phase 3-5
 - Если банк: on-premise, ФЗ-152, ЦБ, GigaChat/YandexGPT
 - Если мало времени: Quick Mode

package/templates/.claude/commands/cjm-prototype.md

@@ -23,7 +23,7 @@ $ARGUMENTS
 4. **Step 2:** Определить 3 варианта CJM (A/B/C)
 5. **Step 2.5:** VARIANT D — Future-Ready CJM (Trend-Based)
    - Загрузи `.claude/skills/goap-research-ed25519/SKILL.md` для trend research
-   - Исследуй 5 категорий трендов (PARANOID mode)
+   - Исследуй 5 категорий трендов в режиме, разрешённом `.claude/rules/research-quality.md`
    - Создай Trend Brief
    - Синтезируй Variant D
 6. **Step 3:** Сгенерируй React-прототип (.jsx) с 4 вариантами
@@ -38,5 +38,5 @@ $ARGUMENTS
 Запусти 3 агента параллельно:
 - Agent 1: CJM Variant A — один подход к точке входа
 - Agent 2: CJM Variant B + C — альтернативные подходы
-- Agent 3: Trend Research для Variant D (GOAP PARANOID)
+- Agent 3: Trend Research для Variant D (GOAP `moderate` для обычных источников)
 Затем синтезируй в единый прототип с 4 вариантами.

package/templates/.claude/commands/research.md

@@ -12,7 +12,10 @@ $ARGUMENTS
 
 1. **Загрузи скилл:** Прочитай `.claude/skills/goap-research-ed25519/SKILL.md`
 2. **Прочитай Phase 0-1** для контекста
-3. **Режим: PARANOID** — ноль непроверенных утверждений
+3. **Выбери режим по `.claude/rules/research-quality.md`:** `moderate` для обычных
+   источников; `strict`/`paranoid` только при подтверждённых ключах издателей и
+   подписанной выдаче. Если GOAP вернул `GOAL_UNREACHABLE`, покажи причину и не
+   отмечай фазу завершённой.
 
 4. **Исследуй по направлениям:**
    - Аналоги — кто решал похожую задачу

package/templates/.claude/rules/checkpoint-protocol.md

@@ -29,7 +29,7 @@ Promises are machine-readable markers that formalize phase gates.
 |-------|------------|---------|
 | Phase 0 | `<promise>DISCOVERY_COMPLETE</promise>` | JTBD + competitors + ROI analyzed |
 | Phase 1 | `<promise>CASE_EXPLORED</promise>` | Case fully understood, brief created |
-| Phase 2 | `<promise>RESEARCH_PARANOID_PASSED</promise>` | All claims verified, zero unverified |
+| Phase 2 | `<promise>RESEARCH_PARANOID_PASSED</promise>` | Legacy tag: evidence gate passed in the selected GOAP mode; no issuer-signature claim unless independently confirmed |
 | Phase 2.5 | `<promise>CJM_VALIDATED</promise>` | CJM prototype created and variant chosen |
 | Phase 3 | `<promise>SOLUTION_DESIGNED</promise>` | Solution strategy formulated |
 | Phase 4 | `<promise>ARCHITECTURE_DEFINED</promise>` | C4 diagrams + sequence flows ready |
@@ -57,6 +57,7 @@ Files created: [list] ✅
 ### Promise Validation Rules
 
 - A promise tag MUST only be emitted AFTER its conditions are verifiably met
+- GOAP `GOAL_UNREACHABLE` cannot satisfy the Phase 2 promise; report the missing capability and stop
 - If conditions are NOT met, emit `<promise>[TAG]_INCOMPLETE</promise>` instead
 - Downstream phases SHOULD check for upstream promises before starting
 - Promise tags serve as formal phase gates — they replace informal "phase done" signals

package/templates/.claude/rules/research-quality.md

@@ -1,10 +1,15 @@
 # Research Quality Rules
 
-## PARANOID Mode (Default for all research)
-- Every factual claim MUST have a verifiable source
-- Zero tolerance for hallucinated citations
-- Confidence threshold: 0.99 minimum
-- If source cannot be verified → mark as [UNVERIFIED] and flag
+## Research mode selection
+- Use GOAP `moderate` for ordinary web and publication sources. Cite material factual claims,
+  identify uncertainty and do not turn an unverified claim into a decisive conclusion.
+- Select GOAP `strict` or `paranoid` only after confirming both `issuer_keys_available` (real
+  pinned Ed25519 issuer keys) and `source_class_verified` (signed delivery for that source
+  class). A URL or citation alone establishes neither capability.
+- If the requested mode returns `GOAL_UNREACHABLE`, record the missing capabilities and stop
+  the research checkpoint. Do not emit a success promise or advance to the next phase.
+- Zero tolerance for invented citations applies in every mode. Source attribution and issuer
+  signature verification are different claims.
 
 ## Citation Requirements
 - Format: `[Claim] — Source: [URL or publication], [Date]`
@@ -14,7 +19,7 @@
 ## Verification Checklist
 Before completing any research phase:
 - [ ] All claims have sources
-- [ ] No unverified statistics or percentages
+- [ ] No unverified statistics or percentages presented as established facts
 - [ ] Competitor names verified to exist
 - [ ] Technology recommendations are for real, available products
 - [ ] Regulatory references cite actual laws/standards

package/templates/.claude/shards/phase-2-research.shard.md

@@ -13,12 +13,14 @@ Load: `.claude/skills/goap-research-ed25519/SKILL.md`
 ## Mandatory Outputs
 - `02_research_findings.md`
 
-## PARANOID Mode — ACTIVE
-- Every factual claim MUST have a verifiable source
-- Zero tolerance for hallucinated citations
-- Confidence threshold: 0.99 minimum
-- Unverifiable claims: mark as [UNVERIFIED] and flag
-- Citation format: `[Claim] — Source: [URL or publication], [Date]`
+## Research mode and evidence
+- Follow `.claude/rules/research-quality.md`: default GOAP `moderate` for ordinary sources.
+- Use `strict`/`paranoid` only if both issuer-key and signed-delivery capabilities are
+  confirmed for the selected source class. Do not infer signature verification from a URL.
+- Cite material factual claims; label unsupported claims `[UNVERIFIED]` and keep them out of
+  decisive conclusions. Invented citations are never acceptable.
+- Citation format: `[Claim] — Source: [URL or publication], [Date]`.
+- A `GOAL_UNREACHABLE` result blocks the checkpoint and transition to Phase 2.5.
 
 ## Agent Swarm (3 parallel, model: sonnet)
 - Agent 1: Analogues + Benchmarks
@@ -28,13 +30,15 @@ Load: `.claude/skills/goap-research-ed25519/SKILL.md`
 
 ## Quality Gates
 - ALL claims have sources
-- No unverified statistics or percentages
+- No unverified statistics or percentages presented as established facts
 - Competitor names verified to exist
 - Technology recommendations are for real, available products
 - Regulatory references cite actual laws/standards
 
 ## Promise
-On completion: `<promise>RESEARCH_PARANOID_PASSED</promise>`
+On successful evidence review in the selected mode: `<promise>RESEARCH_PARANOID_PASSED</promise>`.
+The tag name is retained for downstream compatibility; it does not assert GOAP paranoid mode or
+cryptographic issuer verification. On failure, emit the incomplete marker and do not advance.
 
 ## Anti-Patterns to Check
 - Bare claims without attribution → BLOCK

package/templates/.claude/shards/phase-25-cjm.shard.md

@@ -21,14 +21,15 @@
 ## Process
 1. Extract: primary_user, segments, aha_moment, solution_concept from Phases 0-2
 2. Define 3 CJM variants (A/B/C) with different approaches
-3. Research 5 trend categories for Variant D (PARANOID mode)
+3. Research 5 trend categories for Variant D in the GOAP mode allowed by
+   `.claude/rules/research-quality.md`; ordinary sources use `moderate`
 4. Generate React .jsx prototype with all 4 variants
 5. User selects winning variant → sets `{CHOSEN_CJM}`
 
 ## Agent Swarm (3 parallel)
 - Agent 1 (opus): CJM Variant A design
 - Agent 2 (opus): CJM Variants B + C design
-- Agent 3 (sonnet): Trend Research for Variant D (PARANOID mode, 5 categories)
+- Agent 3 (sonnet): Trend Research for Variant D (selected GOAP mode, 5 categories)
 
 ## Critical Variable
 `{CHOSEN_CJM}` — MUST be set by user selection. Passed to Phases 3-5.
@@ -36,7 +37,8 @@
 ## Quality Gates
 - Minimum 3 CJM variants (A/B/C) + 1 trend variant (D)
 - Prototype must be valid React JSX
-- Trend research in PARANOID mode (verified sources)
+- Trend research cites sources, labels uncertainty and does not claim issuer verification
+  without confirmed capabilities
 - User MUST explicitly select a variant
 
 ## Promise

package/templates/.claude/skills/feature-adr/SKILL.md

@@ -60,17 +60,19 @@ Trigger on:
 │   ├── adr-template.md                ← ADR document template
 │   ├── c4-template.md                 ← C4 diagram templates
 │   ├── qe-checklist.md                ← Quality engineering checklist
-│   └── agentic-qe/                    ← Integrated agentic-qe skills (15 total)
+│   └── agentic-qe/                    ← 15 QE references (8 pinned protocols)
 │       ├── README.md                  ← Skill mapping, modes, install guide
-│       ├── shift-left-testing.md      ← Step 3: ADR testability (Tier 3)
-│       ├── qcsd-ideation-swarm.md     ← Step 3.5: Quality swarm (Tier 3)
+│       ├── UPSTREAM-MANIFEST.json     ← Pinned upstream paths and hashes
+│       ├── LICENSE.agentic-qe         ← Upstream MIT notice
+│       ├── qe-ref-shift-left-testing/REFERENCE.md      ← Step 3: ADR testability (Tier 3)
+│       ├── qe-ref-qcsd-ideation-swarm/REFERENCE.md     ← Step 3.5: Quality swarm (Tier 3)
 │       ├── code-goal-planner.md       ← Step 6: SPARC-GOAP agent
-│       ├── brutal-honesty-review.md   ← Step 8: Code review (Tier 2)
-│       ├── qe-requirements-validation.md  ← Step 9: Traceability (Tier 3)
-│       ├── risk-based-testing.md      ← Step 9: Risk scoring (Tier 3)
-│       ├── enterprise-integration-testing.md ← Step 9: Integration (Tier 3, condensed)
-│       ├── regression-testing.md      ← Step 9: Regression (Tier 3)
-│       ├── qe-coverage-analysis.md    ← Step 9: Coverage (Tier 3)
+│       ├── qe-ref-brutal-honesty-review/REFERENCE.md   ← Step 8: Code review (Tier 2)
+│       ├── qe-ref-qe-requirements-validation/REFERENCE.md  ← Step 9: Traceability (Tier 3)
+│       ├── qe-ref-risk-based-testing/REFERENCE.md      ← Step 9: Risk scoring (Tier 3)
+│       ├── qe-ref-enterprise-integration-testing/REFERENCE.md ← Step 9: Integration
+│       ├── qe-ref-regression-testing/REFERENCE.md      ← Step 9: Regression (Tier 3)
+│       ├── qe-ref-qe-coverage-analysis/REFERENCE.md    ← Step 9: Coverage (Tier 3)
 │       ├── chaos-engineering-resilience.md ← Extended: Chaos (Tier 3)
 │       ├── security-testing.md        ← Extended: OWASP (Tier 3)
 │       ├── performance-testing.md     ← Extended: Load/stress (Tier 3)
@@ -649,17 +651,17 @@ statusline/JSON and its ETA keep their existing behavior. Do not start a termina
 
 ### What changes with `--full-qe`
 
-Full agentic-qe protocols for the same 9 core skills. No new agents, just deeper methodology.
+The eight vendored core skills already provide pinned full protocols in Reference Mode. Direct Mode adds the installed aqe runtime, its MCP pattern memory, and the steps explicitly listed below; it does not make the bundled references more complete.
 
 | Step | Reference Mode (default) | Direct Mode (`--full-qe`) |
 |------|--------------------------|---------------------------|
 | Step 0 | Standard routing | + pattern recall → `{LEARNED_PATTERNS}` |
-| Step 3 | Condensed shift-left protocol | Full Level 1-4 shift-left with BDD generators |
-| Step 3.5 | 3 core + flag-based conditionals | Full QCSD swarm with all 9 agents + DDD mapping |
-| Step 6 | SPARC-GOAP goal state analysis | Full agent with milestone tracking + success metrics |
+| Step 3 | Pinned shift-left protocol | Same protocol; installed aqe tooling when available |
+| Step 3.5 | Bundled QCSD protocol and conditional perspectives | Installed aqe runtime can coordinate its full swarm |
+| Step 6 | SPARC-GOAP goal state analysis | Installed planner agent when available |
 | Step 7 | Standard code generation | Standard code generation (no change) |
-| Step 8 | Brutal-honesty 3-mode review | Full calibration levels (1-3) + evidence protocol + QE pattern recall/store |
-| Step 9 | 4 agents with condensed protocols | 4 agents with full agentic-qe protocols + fleet pattern recall/store |
+| Step 8 | Pinned brutal-honesty protocol | Same review plus aqe pattern recall/store |
+| Step 9 | 4 agents with pinned full protocols | Same agents plus aqe fleet pattern recall/store |
 
 ### What `--full-qe-extended` adds on top
 

package/templates/.claude/skills/feature-adr/modules/03-adr.md

@@ -227,7 +227,7 @@ Fitness readiness:
 
 After all ADRs are drafted, apply **shift-left-testing** protocol (Level 4: Risk Analysis in Design).
 
-> Load: `references/agentic-qe/shift-left-testing.md`
+> Load: `references/agentic-qe/qe-ref-shift-left-testing/REFERENCE.md`
 
 ### Testability Check per ADR