Meta Cognition Parallel

# Meta-Cognition Parallel Analysis (Experimental)

> **Status:** Experimental | **Version:** 0.2.0 | **Last Updated:** 2025-01-27
>
> This skill tests parallel three-layer cognitive analysis.

## Concept

Instead of sequential analysis, this skill launches three parallel analyzers - one for each cognitive layer - then synthesizes their results.

```
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
```

## Usage

```
/meta-parallel <your Rust question>
```

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

## Execution Mode Detection

**CRITICAL: Check agent file availability first to determine execution mode.**

Try to read layer analyzer files:
- `../../agents/layer1-analyzer.md`
- `../../agents/layer2-analyzer.md`
- `../../agents/layer3-analyzer.md`

---

## Agent Mode (Plugin Install) - Parallel Execution

**When all layer analyzer files exist at `../../agents/`:**

### Step 1: Parse User Query

Extract from `$ARGUMENTS`:
- The original question
- Any code snippets
- Domain hints (trading, web, embedded, etc.)

### Step 2: Launch Three Parallel Agents

**CRITICAL: Launch all three Tasks in a SINGLE message to enable parallel execution.**

```
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
)
```

### Step 3: Collect Results

Wait for all three agents to complete. Each returns structured analysis.

### Step 4: Cross-Layer Synthesis

With all three results, perform synthesis per template below.

---

## Inline Mode (Skills-only Install) - Sequential Execution

**When layer analyzer files are NOT available, execute analysis directly:**

### Step 1: Parse User Query

Same as Agent Mode - extract question, code, and domain hints from `$ARGUMENTS`.

### Step 2: Execute Layer 1 - Language Mechanics

Analyze the Rust language mechanics involved:

```markdown
## 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]
```

**Focus areas:**
- Ownership rules (move, copy, borrow)
- Lifetime annotations
- Borrowing rules (shared vs mutable)
- Error codes and their meanings

### Step 3: Execute Layer 2 - Design Choices

Analyze the design patterns and trade-offs:

```mar