TrajectoryOS ↔ CC-TPO Integration Plan

-- Unified schema
CREATE TABLE life_events (
  id TEXT PRIMARY KEY,
  user_id TEXT,
  event_type TEXT, -- 'interview', 'journal', 'project_note', 'conversation'
  content TEXT,
  timestamp DATETIME,
  parent_event_id TEXT, -- Hierarchical structure

  -- TrajectoryOS fields
  evidence_type TEXT, -- 'skill', 'project', 'constraint', 'decision'
  skill_ids TEXT[], -- Related skills
  project_ids TEXT[],
  physics_impact JSONB, -- How this affects thrust/gravity/mass

  -- CC-TPO fields
  embedding BLOB, -- 384-dim vector
  x_coord REAL, -- Depth in life hierarchy
  y_coord REAL, -- Alternative path taken
  z_coord REAL, -- Coherence with other choices
  t_coord REAL, -- Temporal position
  n_coord INTEGER, -- Complexity
  ring_position INTEGER -- Position in recurring pattern ring
);

// InterviewAgent extracts evidence using LLM structured outputs
const evidence: SkillEvidence = await llm.chatStructured(prompt, "interview");

# 1. Semantic search through past conversations for skill evidence
def extract_skill_evidence_from_history(user_id: str, skill_id: str):
    """Find all mentions of a skill in past life events"""

    # Get skill name
    skill = db.get_skill(skill_id)

    # Search using IRCP
    query = f"times when I demonstrated {skill.name}"
    results = ircp_search(
        query=query,
        user_id=user_id,
        coordinate_filters={
            'x': [0, 5],  # Life decisions at various depths
            'z': lambda z: z > 0,  # Aligned with other skills (coherent)
            't': lambda t: recent(t, months=12)  # Last year
        }
    )

    # Extract evidence from results
    evidence_items = []
    for result in results:
        evidence_items.append({
            'skillId': skill_id,
            'levelEstimate': infer_level_from_context(result.content),
            'confidence': result.score,
            'utilization': estimate_utilization(result.coordinates),
            'source': 'conversation_analysis',
            'rawText': result.content,
            'timestamp': result.timestamp
        })

    return evidence_items

# Alignment = cosine similarity of project embeddings
alignment = compute_alignment(projects, skills, utilization_map)

def compute_topological_alignment(user_id: str) -> float:
    """
    Alignment using DLM coordinates:
    - High alignment: Projects cluster in (x,y,z) space
    - Low alignment: Projects scattered randomly
    """

    projects = db.get_active_projects(user_id)

    # Get coordinates for each project
    coords = [calculate_dlm_coordinates(p) for p in projects]

    # Measure clustering
    alignment_components = {
        'directional': clustering_in_z_dimension(coords),  # Semantic coherence
        'temporal': consistency_in_t(coords),  # Working on similar timescales
        'structural': variance_in_x_y(coords),  # Exploring vs. deepening
    }

    # Weighted combination
    return (
        0.4 * alignment_components['directional'] +
        0.3 * alignment_components['temporal'] +
        0.3 * alignment_components['structural']
    )

class LifePatternRing:
    """Detect recurring life patterns using ring topology"""

    def detect_rings(self, user_id: str, pattern_type: str):
        """
        Find circular patterns in life events

        Example:
        pattern_type = 'daily_routine'
        → Returns rings like: [wake, work, lunch, work, gym, dinner, sleep]

        pattern_type = 'creative_cycle'
        → Returns: [ideate, prototype, test, reflect, ideate...]
        """

        # Get events of this type
        events = db.get_events(user_id, type=pattern_type, limit=500)

        # Cluster events into pattern stages
        stages = cluster_events_by_embedding(events, n_clusters=5)

        # Find circular transitions: stage_i → stage_j → ... → stage_i
        transition_matrix = build_transition_matrix(events, stages)
        rings = detect_circular_paths(transition_matrix)

        return rings

    def map_to_ring_topology(self, events: List[LifeEvent], ring: Ring):
        """
        Map events onto ring structure for circular attention

        Enables queries like:
        - "What usually happens after I have a creative insight?" (ring position + 1)
        - "What are alternate paths I've taken at this stage?" (same position, different y)
        """

        positions = {}
        for event in events:
            # Find nearest ring stage
            stage = find_nearest_stage(event.embedding, ring.stages)

            # Assign position on ring
            positions[event.id] = {
                'ring_id': ring.id,
                'position': stage.position,
                'alternatives': find_alternatives(event, stage)  # Different y-coords
            }

        return positions

┌──────────────────────────────────────────────────────────┐
│  TrajectoryOS Navigator                                  │
├────────────────┬─────────────────────────────────────────┤
│ Life Tree      │  Physics Dashboard                       │
│                │                                          │
│ 📁 Career      │  Escape Index: η = 1.34 ✅              │
│   📁 BWB       │  Thrust: 6.2  Alignment: 0.73           │
│     💬 Pitch   │  Gravity: 0.4  Mass: 1.1               │
│     💬 MVP     │                                          │
│   📁 Upwork    │  🔥 Active Project: BWB                 │
│                │  📊 Skill Focus: React, TypeScript      │
│ 📁 Creative    │                                          │
│   📁 Music     │  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━     │
│   📁 Dance     │  Context: Career > BWB > Pitch          │
│                │                                          │
│ 📁 Learning    │  💬 Ask about your trajectory...        │
│   📁 ML        │                                          │
│   📁 TS        │  Q: "How has my React skill evolved?"   │
│                │                                          │
│ 📁 Life Events │  A: Based on your conversations, your   │
│   📁 2025-12   │  React skill has grown from 3.2 (Jan)   │
│   📁 2025-11   │  to 7.8 (Dec). Key evidence:            │
│                │  - Built 5 production apps (x=0 events) │
│                │  - Explored Next.js alternative (y>0)   │
│                │  - Consistent TypeScript alignment(z>0) │
└────────────────┴─────────────────────────────────────────┘

# 1. Semantic only (current vector search)
search("machine learning projects")
# Returns: Projects with ML in embeddings

# 2. Topological (CC-TPO)
search("divergent career decisions", coordinates={'z': lambda z: z < -1})
# Returns: Career decisions where you chose alternatives (low Z)

# 3. Physical (TrajectoryOS)
search("high-thrust moments", physics={'thrust': lambda t: t > 5})
# Returns: Life periods with high capability application

# 4. Combined
search(
    query="creative breakthroughs",
    coordinates={
        'x': [3, 10],  # Deep work, not surface
        't': recent(months=6),  # Last 6 months
        'n': lambda n: n > 3  # Complex entries (detailed)
    },
    physics={
        'alignment': lambda a: a > 0.7,  # Aligned with other work
        'escapeIndex': lambda e: e > 1.0  # During escape phase
    }
)
# Returns: Complex creative insights from last 6 months during high-alignment, escaping periods

def unified_search(
    query: str,
    user_id: str,
    coordinates: Dict = None,
    physics: Dict = None,
    top_k: int = 10
) -> List[LifeEvent]:
    """
    Search across semantic, topological, and physical dimensions
    """

    # 1. Semantic filtering (IRCP)
    embedding = model.encode(query)
    candidates = db.vector_search(embedding, user_id, k=100)

    # 2. Topological filtering (DLM coordinates)
    if coordinates:
        candidates = [
            c for c in candidates
            if matches_coordinate_filters(c.coordinates, coordinates)
        ]

    # 3. Physical filtering (TrajectoryOS)
    if physics:
        # Get life state at time of each event
        candidates = [
            c for c in candidates
            if matches_physics_filters(
                get_life_state_at(c.timestamp),
                physics
            )
        ]

    # 4. Multi-factor scoring
    scores = []
    for candidate in candidates:
        score = (
            0.4 * semantic_similarity(embedding, candidate.embedding) +
            0.3 * topological_relevance(candidate.coordinates) +
            0.3 * physical_relevance(candidate.physics_state)
        )
        scores.append((candidate, score))

    # 5. Return top K
    return sorted(scores, key=lambda x: x[1], reverse=True)[:top_k]

┌─────────────────────────────────────────────────────────────────────────┐
│                          USER INTERFACES                                 │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                          │
│  ┌────────────────────────────┐    ┌───────────────────────────────┐   │
│  │  TrajectoryOS Navigator    │    │  Mobile App (Future)          │   │
│  │  (Next.js Web UI)          │    │  - Quick skill logging        │   │
│  │                            │    │  - Life event capture         │   │
│  │  - Life Tree View          │    │  - Voice interview            │   │
│  │  - Physics Dashboard       │    └───────────────────────────────┘   │
│  │  - Context-Aware Chat      │                                         │
│  │  - Ring Topology View      │                                         │
│  │  - 4D Coordinate Space     │                                         │
│  │  - Escape Timeline         │                                         │
│  └────────────┬───────────────┘                                         │
└───────────────┼─────────────────────────────────────────────────────────┘
                │
                │ REST / WebSocket API
                ▼
┌─────────────────────────────────────────────────────────────────────────┐
│                       API GATEWAY (Enhanced)                             │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                          │
│  Endpoints:                                                              │
│  - /api/sessions/*          (Interview agent)                           │
│  - /api/search              (Unified search: semantic + topo + physics) │
│  - /api/chat                (Context-aware Q&A)                          │
│  - /api/hierarchy           (Life tree structure)                        │
│  - /api/physics/state       (Current life physics)                       │
│  - /api/physics/timeline    (Historical escape index)                    │
│  - /api/coordinates/calc    (Calculate DLM for event)                    │
│  - /api/rings/detect        (Find recurring patterns)                    │
│  └─────────────┬────────────────────────────────────────────────────────┘
                 │
                 │ Service Calls
                 ▼
┌─────────────────────────────────────────────────────────────────────────┐
│                     CORE SERVICES LAYER                                  │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                          │
│  ┌────────────────────────┐    ┌─────────────────────────────────────┐ │
│  │  Agent Orchestrator    │    │  Trajectory Core (Enhanced)         │ │
│  │                        │    │                                     │ │
│  │  - InterviewAgent      │───▶│  - LifeStateService                │ │
│  │  - PlannerAgent        │    │  - SkillGraphService (with IRCP)   │ │
│  │  - Evidence Extraction │    │  - PhysicsEngine                   │ │
│  └────────────────────────┘    │  - DLMCoordinateService (NEW)      │ │
│                                 │  - RingTopologyService (NEW)       │ │
│  ┌────────────────────────┐    │  - UnifiedSearchService (NEW)      │ │
│  │  IRCP Service (NEW)    │    └─────────────────────────────────────┘ │
│  │                        │                                             │
│  │  - SentenceTransformer │    ┌─────────────────────────────────────┐ │
│  │  - Ring Topology       │    │  Python ML Models                   │ │
│  │  - Coordinate Predict  │    │                                     │ │
│  │  - Inverse Attention   │───▶│  - Bayesian Skill Inference         │ │
│  └────────────────────────┘    │  - Alignment Scorer (with coords)   │ │
│                                 │  - Gravity/Mass Estimator           │ │
│                                 │  - Life State Dynamics              │ │
│                                 │  - Escape Timeline Predictor (NEW)  │ │
│                                 └─────────────────────────────────────┘ │
└─────────────────┬───────────────────────────────────────────────────────┘
                  │
                  │ Database Access
                  ▼
┌─────────────────────────────────────────────────────────────────────────┐
│                          DATA LAYER                                      │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                          │
│  ┌───────────────────────────────────────────────────────────────────┐  │
│  │  PostgreSQL / SQLite (Unified Schema)                             │  │
│  │                                                                   │  │
│  │  Core Tables:                                                     │  │
│  │  ┌─────────────────┬──────────────────┬─────────────────────┐   │  │
│  │  │  life_events    │  skill_beliefs   │  projects           │   │  │
│  │  │  - id           │  - user_id       │  - id               │   │  │
│  │  │  - user_id      │  - skill_id      │  - name             │   │  │
│  │  │  - content      │  - level         │  - embedding        │   │  │
│  │  │  - timestamp    │  - uncertainty   │  - x,y,z,t coords   │   │  │
│  │  │  - embedding    │  - last_updated  │  - alignment_score  │   │  │
│  │  │  - x,y,z,t,n    │  └──────────────┘│                     │   │  │
│  │  │  - ring_pos     │                   │                     │   │  │
│  │  │  - physics_snap │  ┌──────────────────┐                  │   │  │
│  │  └─────────────────┘  │  life_states     │                  │   │  │
│  │                       │  - id            │─────────────────┘   │  │
│  │  ┌─────────────────┐ │  - user_id       │                     │  │
│  │  │  skill_graph    │ │  - timestamp     │                     │  │
│  │  │  - from_skill   │ │  - latent_vector │                     │  │
│  │  │  - to_skill     │ │  - thrust        │                     │  │
│  │  │  - weight       │ │  - alignment     │                     │  │
│  │  │  - ring_connection│ - gravity        │                     │  │
│  │  └─────────────────┘ │  - mass          │                     │  │
│  │                       │  - escape_index  │                     │  │
│  │  ┌─────────────────┐ └──────────────────┘                     │  │
│  │  │  life_patterns  │                                           │  │
│  │  │  - id           │  ┌──────────────────┐                    │  │
│  │  │  - user_id      │  │  constraints     │                    │  │
│  │  │  - pattern_type │  │  - id            │                    │  │
│  │  │  - ring_stages  │  │  - user_id       │                    │  │
│  │  │  - transitions  │  │  - type          │                    │  │
│  │  └─────────────────┘  │  - intensity     │                    │  │
│  │                       │  - urgency       │                    │  │
│  │                       │  - t_coord (when)│                    │  │
│  │                       └──────────────────┘                    │  │
│  │                                                                   │  │
│  │  Imported from CC-TPO:                                           │  │
│  │  - 277 conversations → life_events (event_type='conversation')   │  │
│  │  - 9,572 messages → nested life_events                           │  │
│  │  - Existing DLM coordinates preserved                            │  │
│  └───────────────────────────────────────────────────────────────────┘  │
│                                                                          │
│  ┌───────────────────────────────────────────────────────────────────┐  │
│  │  Vector Store (Optional - for scale)                             │  │
│  │  - Pinecone / Weaviate / pgvector                                │  │
│  │  - Stores embeddings + metadata                                  │  │
│  │  - Enables fast k-NN search at scale                             │  │
│  └───────────────────────────────────────────────────────────────────┘  │
└─────────────────────────────────────────────────────────────────────────┘

   # Script: scripts/import_cc_tpo_data.py

   def import_conversations():
       # Read from cc-tpo/data/databases/conversations_fixed.db
       cc_tpo_db = sqlite3.connect('services/cc-tpo/data/databases/conversations_fixed.db')

       # Connect to TrajectoryOS database
       traj_db = prisma_client()

       # For each conversation
       for conv in cc_tpo_db.query("SELECT * FROM conversations"):
           # Create root life_event
           root_event = traj_db.life_events.create({
               'user_id': 'imported_user',
               'event_type': 'conversation',
               'content': conv['summary'],
               'timestamp': conv['create_time'],
               'parent_event_id': None,
               'evidence_type': 'conversation'
           })

           # For each message in conversation
           for msg in get_messages(conv['conversation_id']):
               # Create nested event
               child_event = traj_db.life_events.create({
                   'parent_event_id': root_event.id,
                   'content': msg['content'],
                   'timestamp': msg['create_time'],
                   'embedding': msg['embedding'],  # Already exists in CC-TPO
                   'x_coord': msg['x_coord'],
                   'y_coord': msg['y_coord'],
                   'z_coord': msg['z_coord'],
                   't_coord': msg['t_coord'],
                   'n_coord': msg['n_coord'] if exists else calculate_n(msg['content'])
               })

   // services/trajectory-core/src/services/DLMCoordinateService.ts

   class DLMCoordinateService {
     async calculateCoordinates(event: LifeEvent): Promise<DLMCoordinates> {
       // Call Python DLM calculator
       const coords = await pythonClient.calculateDLM({
         event_id: event.id,
         parent_id: event.parent_event_id,
         content: event.content,
         timestamp: event.timestamp,
         sibling_events: await this.getSiblings(event)
       });

       return coords;
     }
   }

   // services/trajectory-core/src/services/UnifiedSearchService.ts

   class UnifiedSearchService {
     async search(params: UnifiedSearchParams): Promise<SearchResult[]> {
       // 1. Semantic search (IRCP)
       const candidates = await ircpService.search(params.query, { k: 100 });

       // 2. Filter by coordinates
       let filtered = candidates;
       if (params.coordinates) {
         filtered = filtered.filter(c =>
           matchesCoordinateFilters(c.coordinates, params.coordinates)
         );
       }

       // 3. Filter by physics
       if (params.physics) {
         filtered = await this.filterByPhysics(filtered, params.physics);
       }

       // 4. Re-rank with multi-factor scoring
       return this.scoreAndRank(filtered, params);
     }
   }

   # services/agent-orchestrator/src/agents/HistoricalEvidenceAgent.ts

   class HistoricalEvidenceAgent {
     async extractSkillEvidence(userId: string, skillId: string): Promise<SkillEvidence[]> {
       const skill = await db.getSkill(skillId);

       // Search through imported conversations
       const results = await unifiedSearch({
         query: `demonstrations of ${skill.name} skill`,
         user_id: userId,
         coordinates: {
           'z': (z) => z > 0,  // Aligned work (coherent)
           't': (t) => recent(t, years: 5)  // Last 5 years
         },
         top_k: 20
       });

       // For each result, extract evidence
       const evidence = [];
       for (const result of results) {
         const level = await llm.inferSkillLevel(result.content, skill.name);
         evidence.push({
           skillId: skill.id,
           levelEstimate: level,
           confidence: result.score,
           source: 'conversation_analysis',
           rawText: result.content,
           timestamp: result.timestamp
         });
       }

       return evidence;
     }
   }

   # models/ring_topology/life_patterns.py

   class LifePatternDetector:
       def detect_patterns(self, user_id: str, pattern_type: str):
           """
           pattern_type examples:
           - 'daily_routine'
           - 'creative_cycle'
           - 'learning_pattern'
           - 'relationship_pattern'
           """

           # Get events tagged with this pattern type
           events = db.get_events(user_id, tags=[pattern_type])

           # Cluster into stages using embeddings
           embeddings = [e.embedding for e in events]
           stages = kmeans(embeddings, n_clusters=5)

           # Build transition graph
           transitions = {}
           for i in range(len(events) - 1):
               stage_from = stages[i]
               stage_to = stages[i + 1]
               transitions[(stage_from, stage_to)] = transitions.get(...) + 1

           # Find circular paths (rings)
           rings = find_cycles(transitions)

           return rings

   // components/RingTopologyView.tsx

   function RingTopologyView({ userId, patternType }) {
     const [rings, setRings] = useState([]);

     useEffect(() => {
       fetch(`/api/rings/detect?userId=${userId}&type=${patternType}`)
         .then(r => r.json())
         .then(data => setRings(data.rings));
     }, [userId, patternType]);

     return (
       <svg>
         {rings.map(ring => (
           <CircularLayout
             nodes={ring.stages}
             edges={ring.transitions}
             onClick={(stage) => showEventsAtStage(stage)}
           />
         ))}
       </svg>
     );
   }

   // Organize life events hierarchically
   {
     name: "Career",
     children: [
       { name: "BWB", children: [...project events...] },
       { name: "Upwork", children: [...] }
     ]
   },
   {
     name: "Creative",
     children: [
       { name: "Music", children: [...] },
       { name: "Dance", children: [...] }
     ]
   },
   {
     name: "Learning",
     children: [...]
   }

   # models/skill_graph/bayesian_model_with_rings.py

   class TopologicalSkillModel:
       def propagate_belief(self, skill_id: str, evidence: SkillEvidence):
           """
           Propagate skill belief through graph AND ring topology
           """

           # Standard graph propagation
           graph_updates = self.propagate_via_graph_edges(skill_id, evidence)

           # NEW: Ring propagation
           ring_updates = self.propagate_via_rings(skill_id, evidence)

           # Combine
           return merge_updates(graph_updates, ring_updates)

       def propagate_via_rings(self, skill_id: str, evidence: SkillEvidence):
           """
           If skills form a learning ring (e.g., Python → SQL → API Design → Python),
           propagate belief circularly
           """

           # Find rings containing this skill
           rings = db.get_skill_rings(skill_id)

           updates = []
           for ring in rings:
               # Get position of this skill in ring
               pos = ring.skills.index(skill_id)

               # Propagate to next skill in ring (with decay)
               next_skill = ring.skills[(pos + 1)
               updates.append({
                   'skill_id': next_skill,
                   'belief_delta': evidence.levelEstimate * 0.3  # 30
               })

           return updates

   # models/alignment/topological_scorer.py

   class TopologicalAlignmentScorer:
       def compute_alignment(self, user_id: str) -> float:
           projects = db.get_active_projects(user_id)

           # Get coordinates
           coords = [p.coordinates for p in projects]

           # Clustering in (x, y, z) space
           z_variance = np.var([c.z for c in coords])  # Lower = more aligned
           t_variance = np.var([c.t for c in coords])  # Lower = temporally consistent

           # Combine into alignment score
           alignment = 1.0 / (1.0 + z_variance + t_variance)

           return alignment