meta-cognition-parallel

User Question
     │
     ▼
┌─────────────────────────────────────────────────────┐
│            meta-cognition-parallel                   │
│                  (Coordinator)                       │
└─────────────────────────────────────────────────────┘
     │
     ├─── Layer 1 ──► Language Mechanics ──► L1 Result
     │
     ├─── Layer 2 ──► Design Choices     ──► L2 Result
     │                                            ├── Parallel (Agent Mode)
     │                                            │   or Sequential (Inline)
     └─── Layer 3 ──► Domain Constraints ──► L3 Result
     │
     ▼
┌─────────────────────────────────────────────────────┐
│              Cross-Layer Synthesis                   │
│         (In main context with all results)          │
└─────────────────────────────────────────────────────┘
     │
     ▼
Domain-Correct Architectural Solution

/meta-parallel <your Rust question>

/meta-parallel 我的交易系统报 E0382 错误，应该用 clone 吗？

Read agent files, then launch in parallel:

Task(
  subagent_type: "general-purpose",
  run_in_background: true,
  prompt: <content of ../../agents/layer1-analyzer.md>
          + "\n\n## User Query\n" + $ARGUMENTS
)

Task(
  subagent_type: "general-purpose",
  run_in_background: true,
  prompt: <content of ../../agents/layer2-analyzer.md>
          + "\n\n## User Query\n" + $ARGUMENTS
)

Task(
  subagent_type: "general-purpose",
  run_in_background: true,
  prompt: <content of ../../agents/layer3-analyzer.md>
          + "\n\n## User Query\n" + $ARGUMENTS
)

## Layer 1: Language Mechanics
 
**Error/Pattern Identified:**
- Error code: E0XXX (if applicable)
- Pattern: ownership/borrowing/lifetime/etc.
 
**Root Cause:**
[Explain why this error occurs in terms of Rust's ownership model]
 
**Language-Level Solutions:**
1. [Solution 1]: description
2. [Solution 2]: description
 
**Confidence:** HIGH | MEDIUM | LOW
**Reasoning:** [Why this confidence level]

## Layer 2: Design Choices
 
**Design Pattern Context:**
- Current approach: [What pattern is being used]
- Problem: [Why it conflicts with Rust's rules]
 
**Design Alternatives:**
| Pattern | Pros | Cons | When to Use |
|---------|------|------|-------------|
| Pattern A | ... | ... | ... |
| Pattern B | ... | ... | ... |
 
**Recommended Pattern:**
[Which pattern fits best and why]
 
**Confidence:** HIGH | MEDIUM | LOW
**Reasoning:** [Why this confidence level]

## Layer 3: Domain Constraints
 
**Domain Identified:** [trading/fintech | web | CLI | embedded | etc.]
 
**Domain-Specific Requirements:**
- [ ] Performance: [requirements]
- [ ] Safety: [requirements]
- [ ] Concurrency: [requirements]
- [ ] Auditability: [requirements]
 
**Domain Best Practices:**
1. [Best practice 1]
2. [Best practice 2]
 
**Constraints on Solution:**
- MUST: [hard requirements]
- SHOULD: [soft requirements]
- AVOID: [anti-patterns for this domain]
 
**Confidence:** HIGH | MEDIUM | LOW
**Reasoning:** [Why this confidence level]

## Cross-Layer Synthesis
 
### Layer Results Summary
 
| Layer | Key Finding | Confidence |
|-------|-------------|------------|
| L1 (Mechanics) | [Summary] | [Level] |
| L2 (Design) | [Summary] | [Level] |
| L3 (Domain) | [Summary] | [Level] |
 
### Cross-Layer Reasoning
 
1. **L3 → L2:** [How domain constraints affect design choice]
2. **L2 → L1:** [How design choice determines mechanism]
3. **L1 ← L3:** [Direct domain impact on language features]
 
### Synthesized Recommendation
 
**Problem:** [Restated with full context]
 
**Solution:** [Domain-correct architectural solution]
 
**Rationale:**
- Domain requires: [L3 constraint]
- Design pattern: [L2 pattern]
- Mechanism: [L1 implementation]
 
### Confidence Assessment
 
- **Overall:** HIGH | MEDIUM | LOW
- **Limiting Factor:** [Which layer had lowest confidence]

# Three-Layer Meta-Cognition Analysis
 
> Query: [User's question]
 
---
 
## Layer 1: Language Mechanics
[L1 analysis result]
 
---
 
## Layer 2: Design Choices
[L2 analysis result]
 
---
 
## Layer 3: Domain Constraints
[L3 analysis result]
 
---
 
## Cross-Layer Synthesis
 
### Reasoning Chain

 
### Final Recommendation
 
**Do:** [Recommended approach]
 
**Don't:** [What to avoid]
 
**Code Pattern:**
```rust
// Recommended implementation

 
---
 
## Test Scenarios
 
### Test 1: Trading System E0382

 
Expected: L3 identifies FinTech constraints → L2 suggests shared immutable → L1 recommends Arc<T>
 
### Test 2: Web API Concurrency

 
Expected: L3 identifies Web constraints → L2 suggests connection pooling → L1 recommends Arc<Pool>
 
### Test 3: CLI Tool Config

 
Expected: L3 identifies CLI constraints → L2 suggests config precedence pattern → L1 recommends builder pattern
 
---
 
## Error Handling
 
| Error | Cause | Solution |
|-------|-------|----------|
| Agent files not found | Skills-only install | Use inline mode (sequential) |
| Agent timeout | Complex analysis | Wait longer or use inline mode |
| Incomplete layer result | Agent issue | Fill in with inline analysis |
 
## Limitations
 
- **Agent Mode:** Parallel execution, faster but requires plugin install
- **Inline Mode:** Sequential execution, slower but works everywhere
- Cross-layer synthesis quality depends on result structure
- May have higher latency than simple single-layer analysis
 
## Feedback
 
This is experimental. Please report issues and suggestions to improve the three-layer analysis approach.