---
description: Handles processing, scoring and promotion of contextual information between memory tiers with time-based decay
globs: **/context/*.js,**/working-memory/*.js,**/processor.js
alwaysApply: false
---


# context-processing

The context processing system implements a multi-tiered architecture for managing contextual information across three memory layers:

Core Relevance Scoring (Importance: 95)
- Weighted context evaluation using multi-factor calculations:
  - Term-based relevance with predefined context weights
  - Time decay using 24-hour half-life formula
  - Frequency boosting (10% per occurrence, max 50%)
  - Priority multipliers for discrepancies (1.2x) and needed context (1.1x)

Memory Layer Promotion Rules (Importance: 90)
- Working to medium-term memory: stability score > 0.8
- Medium to long-term memory: stability score > 0.9
- Stability scoring components:
  - Type presence (0.2)
  - Content presence (0.2)
  - Metadata presence (0.2)
  - Relationships presence (0.2)
  - Tags presence (0.2)

Context Enrichment Pipeline (Importance: 85)
- Input validation through processor checks
- Pattern analysis for relationship detection
- Discrepancy tracking integration
- Tag-based categorization 

Relevant Files:
- /working-memory/processor.js
- /context/checker.js

$END$

---
description: Documents how data flows between components, including synchronization, processing pipelines and memory transitions
globs: **/*.js,**/*.vbs
alwaysApply: false
---


# data-flow

The system implements a three-tiered memory architecture with distinct data flows:

## Memory Tier Transitions
Score: 95
File: examples/car-knowledge.js

Data flows through three memory layers with strict promotion criteria:
1. Short-term → Medium-term
- Requires stability score > 0.8
- Must have multiple stable examples
- Pattern consistency validation

2. Medium-term → Long-term 
- Requires stability score > 0.9
- Conflict resolution completion
- Knowledge inheritance verification

## Node Synchronization
Score: 85
Files:
- sync.js
- tailscale.js

Three-node mesh network synchronization:
1. Core Node (Local)
- Receives pattern updates
- Sends training requests
- Maintains state consistency

2. Server Node (Training)
- Processes pattern batches
- Returns trained models
- Manages GPU resources

3. Control Node (Mobile)
- Monitors system state
- Triggers training cycles
- Reviews pattern conflicts

## Pattern Processing Pipeline
Score: 90
Files:
- working-memory/processor.js
- context/checker.js

Sequential data processing stages:
1. Input Processing
- Context scoring with weighted factors
- Time-decay adjustments
- Frequency-based boosting

2. Memory Evolution
- Pattern conflict detection
- Relationship impact analysis
- Context stability scoring

3. Knowledge Integration
- Concept promotion between tiers
- Example diversity tracking
- Weight rebalancing

## Storage Area Synchronization
Score: 75
File: sync.js

Bi-directional sync between storage areas:
1. Droplet Storage
- Trained model persistence
- Snapshot management
- Version control

2. Pattern Storage
- Analysis results
- Recognition metrics
- Evolution tracking

3. Content Repositories
- Public/private separation
- Implementation details
- Shareable artifacts

$END$

---
description: Documents the three-tiered memory system implementation, knowledge promotion rules, and pattern stability scoring.
globs: '**/memory/**','**/brain.js','**/processor.js','**/context/**'
alwaysApply: false
---


# memory-architecture

## Core Memory Tiers
The system implements a three-tiered memory architecture:

1. Short-term (Working) Memory
- Active pattern tracking with weighted context scoring 
- Time-decay relevance using 24-hour half-life formula
- Frequency-based boosting up to 50%
- Priority multipliers for discrepancies (1.2x) and needed context (1.1x)

2. Medium-term Memory 
- Requires stability score > 0.8 for promotion from working memory
- Pattern relationship tracking and contextual tagging
- Example diversity tracking for concept validation

3. Long-term Memory
- Requires stability score > 0.9 for promotion from medium-term
- Inheritance-based knowledge evolution
- Pattern conflict detection and resolution

## Stability Scoring Components
Each memory element receives a stability score based on:
- Type presence: 0.2
- Content presence: 0.2  
- Metadata presence: 0.2
- Relationships presence: 0.2
- Tags presence: 0.2

## Knowledge Evolution Rules
- Concepts require multiple stable examples before promotion
- Pattern conflicts trigger high-severity discrepancy resolution
- Implementation conflicts handled as medium-severity issues
- Frequency weights capped at 0.5 (100 occurrences)
- Example diversity weights capped at 0.5 (10 unique examples)

Key Files:
- `/working-memory/processor.js`
- `/context/checker.js` 
- `/examples/car-knowledge.js`
- `/brain.js`

Importance Scores:
- Memory Tier Implementation: 95
- Stability Scoring System: 90
- Knowledge Evolution Rules: 85
- Pattern Conflict Resolution: 80

$END$

---
description: Technical specification for an adaptive pattern recognition system with multi-tiered memory architecture and weighted context processing
globs: **/pattern/**,**/memory/**,**/weights/**,**/context/**
alwaysApply: false
---


# pattern-recognition

Core Pattern Recognition Components:

1. Weight-Based Pattern Scoring (weights/tracker.js)
Importance: 95
- Dual-weighted pattern recognition system:
  - Frequency weights (capped at 0.5 for 100 occurrences)
  - Example diversity weights (capped at 0.5 for 10 unique examples)
- Automatic flagging of pattern imbalances between frequency/examples
- Pattern conflict severity classification (high/medium/low)

2. Memory-Tiered Pattern Processing (examples/car-knowledge.js)
Importance: 90
- Three-tiered pattern storage architecture:
  - Short-term: Initial pattern recognition
  - Medium-term: Validated patterns with stability >0.8
  - Long-term: Established patterns with stability >0.9
- Inheritance-based pattern evolution system
- Pattern promotion based on stability scoring

3. Context-Aware Pattern Analysis (working-memory/processor.js)
Importance: 85
- Weighted context scoring with multi-factor analysis:
  - Term-based pattern relevance
  - Time-decay adjustments (24-hour half-life)
  - Frequency boosting (10% per occurrence, max 50%)
  - Priority multipliers for pattern discrepancies (1.2x)

4. Pattern Stability Evaluation (context/checker.js)
Importance: 80
- Pattern stability scoring criteria:
  - Type presence: 0.2
  - Content presence: 0.2
  - Metadata presence: 0.2
  - Relationship presence: 0.2
  - Tags presence: 0.2

Key Business Rules:
- Critical pattern conflicts block task execution
- Patterns require multiple stable examples for tier promotion
- Pattern conflicts trigger high-severity resolution workflows
- Automatic deduplication of similar patterns with context awareness

Pattern Processing Pipeline:
```
Input -> Pattern Detection -> Stability Scoring -> Memory Tier Assignment -> Evolution Tracking
```

Relevant File Paths:
- /weights/tracker.js
- /examples/car-knowledge.js
- /working-memory/processor.js
- /context/checker.js

$END$