Confidence = initial_weight × decay_factor^(days_since_validation / half_life)

// 6 months ago: "Split by file type" worked great
// Today: Codebase restructured, pattern no longer applies

// Without decay: Old pattern dominates
// With decay: Old pattern fades, new patterns emerge

// Pattern used successfully
await semantic_memory_validate({ id: 'pattern-123' });
// Decay timer resets to 0

candidate → established → proven → deprecated

// New pattern starts as candidate
{
  pattern: "Split auth by layer (schema, service, routes)",
  maturity: "candidate",
  uses: 1,
  successes: 1,
  weight: 0.5
}

// After 3 successful uses → established
{
  pattern: "Split auth by layer (schema, service, routes)",
  maturity: "established",
  uses: 3,
  successes: 3,
  weight: 1.0
}

// After 10 successful uses → proven
{
  pattern: "Split auth by layer (schema, service, routes)",
  maturity: "proven",
  uses: 10,
  successes: 9,
  weight: 1.5
}

// Pattern keeps failing
{
  pattern: "Split by file extension",
  maturity: "deprecated",  // > 60% failure rate
  uses: 10,
  successes: 3,
  weight: 0.0  // Never suggested again
}

// Pattern fails repeatedly
"Split by file type" → 80% failure rate

// Auto-inverted to anti-pattern
"AVOID: Split by file type (80% failure rate)"

if (failureRate > 0.6 && uses >= 5) {
  invertToAntiPattern(pattern);
}

// Decomposition prompt includes:
"AVOID these patterns (historically problematic):
- Split by file type (80% failure rate)
- Over-decompose simple tasks (70% failure rate)
- Vague subtask descriptions (65% failure rate)"

score = baseScore
  × (1 - errorPenalty × errorCount)
  × (1 - retryPenalty × retryCount)
  × durationFactor(actualDuration, expectedDuration)
  × (success ? 1.0 : 0.0)

// After subtask completion
await swarm_record_outcome({
  bead_id: 'bd-123.2',
  duration_ms: 180000,  // 3 minutes
  success: true,
  error_count: 0,
  retry_count: 0,
  strategy: 'feature-based',
  files_touched: ['src/auth/service.ts']
});

// When decomposing a new task
const similarTasks = await cass_search({
  query: "authentication OAuth implementation",
  limit: 5,
  days: 90
});

// Extract successful patterns from similar tasks
const patterns = extractPatterns(similarTasks);

// Inject into decomposition prompt
"Similar past tasks used these patterns:
- Feature-based: schema → service → routes → tests
- 4-5 subtasks optimal for auth features
- Reserve src/auth/** early to prevent conflicts"

// After solving a tricky problem
await semantic_memory_store({
  information: "OAuth refresh tokens need 5min buffer before expiry to avoid race conditions",
  metadata: "auth, oauth, tokens, race-conditions"
});

// Before starting similar work
const memories = await semantic_memory_find({
  query: "OAuth token refresh",
  limit: 5
});

// Confirm memory is still accurate
await semantic_memory_validate({ id: 'mem-123' });

1. User requests: "Add OAuth authentication"

2. Query CASS for similar past tasks
   → Found 3 similar auth implementations

3. Extract patterns from successful tasks
   → Feature-based decomposition worked best
   → 4-5 subtasks optimal
   → Schema → Service → Routes → Tests order

4. Check anti-patterns
   → AVOID: "Split by file type" (80% failure)

5. Apply pattern maturity weights
   → "Feature-based" is proven (1.5x weight)
   → "Layer-based" is established (1.0x weight)

6. Generate decomposition prompt with context

7. Execute swarm

8. Record outcomes
   → Duration, errors, retries, success

9. Update pattern maturity
   → "Feature-based" gets another success

┌─────────────────────────────────────────────────────────────┐
│                     LEARNING LOOP                            │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  ┌─────────┐    ┌─────────┐    ┌─────────┐                 │
│  │  Task   │───▶│Decompose│───▶│ Execute │                 │
│  └─────────┘    └────┬────┘    └────┬────┘                 │
│                      │              │                       │
│                      │              ▼                       │
│                      │         ┌─────────┐                  │
│                      │         │ Outcome │                  │
│                      │         └────┬────┘                  │
│                      │              │                       │
│                      ▼              ▼                       │
│  ┌─────────────────────────────────────────┐               │
│  │           LEARNING SYSTEM                │               │
│  │                                          │               │
│  │  • Update pattern maturity               │               │
│  │  • Detect anti-patterns                  │               │
│  │  • Store in semantic memory              │               │
│  │  • Adjust confidence weights             │               │
│  └─────────────────────────────────────────┘               │
│                      │                                      │
│                      │ Improved patterns                    │
│                      ▼                                      │
│                 Next decomposition                          │
│                                                             │
└─────────────────────────────────────────────────────────────┘

// Default: 90-day half-life
const CONFIDENCE_HALF_LIFE_DAYS = 90;

// Adjust for faster/slower decay
// Faster decay = more responsive to recent data
// Slower decay = more stable, less reactive

const MATURITY_THRESHOLDS = {
  established: { minUses: 3, minSuccessRate: 0.6 },
  proven: { minUses: 10, minSuccessRate: 0.8 },
  deprecated: { minUses: 5, maxSuccessRate: 0.4 }
};

// Invert to anti-pattern when:
const ANTI_PATTERN_THRESHOLD = {
  minUses: 5,
  minFailureRate: 0.6
};