cross-task-learning

# Cross-Task Learning Skill

Pattern for maintaining aggregated insights across all completed tasks.

## When to Load This Skill

- Reflector: After writing individual reflection
- Evolver: Before analyzing reflections (to get aggregated view)

## Core Concept

Individual reflections capture task-specific learnings. Cross-task learning aggregates these to identify:

- **Patterns that keep appearing** → Skill candidates
- **Strategies that consistently work** → Best practices
- **Strategies that keep failing** → Anti-patterns
- **Bottlenecks that recur** → System weaknesses
- **Proposals that keep emerging** → Priority improvements

## Aggregate File

Location: `memory/reflections/_aggregate.json`

Example structure (compact JSON):

```json
{"last_updated":"ISO-8601","tasks_analyzed":15,"strategy_effectiveness":[{"strategy":"Spawn parallel explorers for context","uses":12,"successes":10,"effectiveness_score":0.83,"notes":"Works well for unfamiliar codebases"}],"failure_patterns":[{"pattern":"Contract conflicts in parallel implementation","occurrences":4,"severity":"high","status":"active"}],"skill_candidates":[{"pattern":"Read → Explore → Implement → Test → Verify","frequency":8,"effectiveness":"high","proposed_skill_name":"implementation-cycle"}]}
```

## Update Protocol (for Reflector)

After writing individual reflection, update aggregate:

```
1. Read current _aggregate.json
2. Read the reflection just written

3. Update task_history:
   - Add new entry with task_id, timestamp, outcome
   - Keep last 20 entries (trim oldest)

4. Update strategy_effectiveness:
   FOR each strategy in reflection.patterns.effective_strategies:
     IF strategy exists in aggregate:
       → Increment uses and successes
       → Recalculate effectiveness_score
     ELSE:
       → Add new entry with uses=1, successes=1

   FOR each strategy in reflection.patterns.ineffective_strategies:
     IF strategy exists in aggregate:
       → Increment uses and failures
       → Recalculate effectiveness_score
     ELSE:
       → Add new entry with uses=1, failures=1

5. Update failure_patterns:
   FOR each issue in reflection.process_analysis.phases[].issues:
     IF similar pattern exists (fuzzy match):
       → Increment occurrences
       → Update last_seen
     ELSE:
       → Add new pattern

6. Update bottleneck_hotspots:
   FOR each bottleneck in reflection.process_analysis.bottlenecks:
     IF location exists:
       → Increment frequency
       → Add cause if new
     ELSE:
       → Add new hotspot

7. Update skill_candidates:
   FOR each sequence in reflection.patterns.repeated_sequences:
     IF sequence.skill_candidate == true:
       IF similar pattern exists:
         → Increment frequency
       ELSE:
         → Add new candidate

8. Update recurring_discoveries:
   FOR each finding in reflection.knowledge_discovered:
     IF similar finding exists:
       → Increment discovery_count
       → Set should_be_documented = true if count >= 3
     ELSE:
       → Add new entry

9. Update recurring_proposals:
   FOR each proposal in reflection.evolution_proposals:
     IF similar proposal exists:
       → Increment occurrence_count
     ELSE:
       → Add new entry

10. Update retry_analysis:
    FOR each retry in reflection.process_analysis.retries:
      → Increment total_retries
      → Update by_strategy counts

11. Increment tasks_analyzed
12. Update last_updated
13. Write updated _aggregate.json (compact JSON)
```

## Similarity Matching

When checking if patterns are "similar":

```
Normalize both strings:
  - Lowercase
  - Remove punctuation
  - Remove common words (the, a, an, is, are)

Compare using:
  - Exact match after normalization
  - OR: >70% word overlap
  - OR: Same key terms present
```

## Thresholds for Action

| Metric | Threshold | Action |
|--------|-----------|--------|
| Strategy effectiveness < 0.3 | After 5 uses | Flag as anti-pattern |
| Strategy effectiveness > 0.8 | After 5 uses | Flag as best practice |
| Failure pattern occurrences | >= 3 | Flag for urgent fix |
| Skill candidate frequency | >= 5 | Propose as new skill |
| Recurring discovery count | >= 3 | Add to knowledge base |
| Recurring proposal count | >= 3 | Prioritize for evolution |

## Query Patterns (for Evolver)

**Get top issues to fix:**
```
failure_patterns
  WHERE status == "active"
  ORDER BY occurrences * severity_weight DESC
  LIMIT 5
```

**Get best practices to document:**
```
strategy_effectiveness
  WHERE effectiveness_score > 0.8
  AND uses >= 5
```

**Get skill candidates ready for implementation:**
```
skill_candidates
  WHERE frequency >= 5
  AND effectiveness == "high"
  AND status == "candidate"
```

**Get knowledge gaps:**
```
recurring_discoveries
  WHERE should_be_documented == true
  AND NOT in knowledge_base
```

## Integration with Evolver

The evolver should:

1. Read `_aggregate.json` FIRST (not individual reflections)
2. Use aggregated data for proposal prioritization:
   - High-occurrence failure patterns → High priority
   - High-frequency skill candidates → Medium priority
   - Recurring proposals → Already validated ideas
3. Reference individual reflections only for details
4. Update `recurring_proposals[].status` after evolution

## Principles

1. **Aggregate, don't duplicate** - Summary stats, not copies
2. **Track trends** - First seen, last seen, frequency
3. **Enable queries** - Structure for easy filtering
4. **Threshold-based actions** - Clear criteria for when to act
5. **Fuzzy matching** - Similar patterns should merge, not duplicate