TrajectoryOS + CC-TPO Unification Plan

cc-trajectory/
├── apps/
│   ├── api-gateway/           # TrajectoryOS API gateway (NEW)
│   └── web-dashboard/         # TrajectoryOS Next.js UI (NEW)
│
├── services/
│   ├── agent-orchestrator/    # TrajectoryOS LLM agents (NEW)
│   ├── background-worker/     # TrajectoryOS background processing (NEW)
│   ├── trajectory-core/       # TrajectoryOS physics engine (NEW)
│   ├── echelon-bridge/        # TrajectoryOS Echelon integration (NEW)
│   └── cc-tpo/               # ENTIRE CC-TPO PROJECT (LEGACY)
│       ├── apps/
│       │   ├── liquid-chat-ui/
│       │   ├── ircp-search-app/
│       │   └── liquid-chat-backend/
│       ├── services/
│       │   └── [9 search API services]
│       ├── packages/
│       │   ├── ircp/          # Core IRCP implementation ← KEEP
│       │   ├── tpo/           # DLM coordinates ← KEEP
│       │   ├── rcp/           # Ring propagation ← KEEP
│       │   ├── dlm/           # Liquid motion ← KEEP
│       │   └── ctsc/          # Topology search ← KEEP
│       ├── cc-navigator/      # Hierarchical knowledge browser ← ADAPT
│       ├── data/
│       │   └── databases/
│       │       ├── conversations_fixed.db ← MIGRATE
│       │       └── claude_full_embeddings_dlm_fixed.db ← MIGRATE
│       ├── training/          # IRCP model training ← KEEP
│       ├── scripts/           # Utility scripts
│       └── docs/              # Documentation

cc-trajectory/
│
├── packages/                  # Shared Python libraries (from cc-tpo)
│   ├── ircp/                 # Inverse Ring Contextual Propagation
│   ├── tpo/                  # Temporal Positional Optimization (DLM coords)
│   ├── rcp/                  # Ring Contextual Propagation
│   ├── dlm/                  # Dynamic Liquid Motion
│   └── ctsc/                 # Computational Topology Search Coordinates
│
├── services/
│   ├── ircp-service/         # Python FastAPI - IRCP inference & embedding
│   │   ├── main.py
│   │   ├── routes/
│   │   │   ├── embed.py      # POST /embed - text → embedding + coords
│   │   │   ├── search.py     # POST /search - topological search
│   │   │   └── coordinates.py # POST /calculate-coords - DLM coords
│   │   ├── models/
│   │   │   ├── ircp_model.py # SentenceTransformerICP wrapper
│   │   │   └── dlm_calculator.py # DLM coordinate computation
│   │   └── requirements.txt
│   │
│   ├── trajectory-core/      # TypeScript - Life physics & state management
│   │   ├── src/
│   │   │   ├── services/
│   │   │   │   ├── LifeStateService.ts
│   │   │   │   ├── SkillGraphService.ts # Bayesian updates + IRCP calls
│   │   │   │   ├── PhysicsEngine.ts
│   │   │   │   ├── DLMCoordinateService.ts # Wraps Python IRCP service
│   │   │   │   └── RingPatternDetector.ts
│   │   │   ├── routes/
│   │   │   │   ├── skills.ts
│   │   │   │   ├── projects.ts
│   │   │   │   ├── state.ts
│   │   │   │   ├── interviews.ts
│   │   │   │   └── search.ts # Unified search endpoint
│   │   │   ├── domain/
│   │   │   │   ├── types.ts
│   │   │   │   ├── physics.ts
│   │   │   │   └── coordinates.ts # DLM coordinate types
│   │   │   └── prisma/
│   │   │       └── schema.prisma # Unified schema
│   │   └── package.json
│   │
│   ├── agent-orchestrator/   # TypeScript - LLM agents
│   │   ├── src/
│   │   │   ├── agents/
│   │   │   │   ├── InterviewAgent.ts
│   │   │   │   ├── PlannerAgent.ts
│   │   │   │   └── EvidenceExtractor.ts # Uses IRCP search for historical evidence
│   │   │   ├── llm/
│   │   │   │   └── client.ts
│   │   │   └── adapters/
│   │   │       ├── TrajectoryCoreClient.ts
│   │   │       └── IRCPClient.ts # Calls Python IRCP service
│   │   └── package.json
│   │
│   ├── api-gateway/          # TypeScript - Unified REST + WebSocket API
│   │   ├── src/
│   │   │   ├── routes/
│   │   │   │   ├── sessions.ts # Interview sessions
│   │   │   │   ├── search.ts   # Unified search (semantic + topo + physics)
│   │   │   │   ├── state.ts    # Life state queries
│   │   │   │   ├── coordinates.ts # Coordinate calculations
│   │   │   │   └── patterns.ts # Ring pattern queries
│   │   │   ├── middleware/
│   │   │   │   └── auth.ts
│   │   │   └── websocket/
│   │   │       └── broadcaster.ts
│   │   └── package.json
│   │
│   └── background-worker/    # TypeScript - Scheduled jobs
│       ├── src/
│       │   ├── jobs/
│       │   │   ├── pattern-detector.ts
│       │   │   ├── state-updater.ts
│       │   │   └── planner.ts
│       │   └── scheduler.ts
│       └── package.json
│
├── apps/
│   └── web/                  # Next.js - Unified Navigator
│       ├── app/
│       │   ├── page.tsx      # Main navigation (tree + dashboard)
│       │   ├── layout.tsx
│       │   └── api/          # Next.js API routes (optional, proxy to gateway)
│       ├── components/
│       │   ├── LifeTree.tsx  # Hierarchical event browser (from cc-navigator)
│       │   ├── CoordinateSpace.tsx # 3D DLM visualization
│       │   ├── RingTopology.tsx # Ring pattern visualization
│       │   ├── PhysicsDashboard.tsx # Escape index, thrust, etc.
│       │   ├── ChatInterface.tsx # Context-aware Q&A
│       │   └── SearchInterface.tsx # Multi-dimensional search
│       ├── lib/
│       │   ├── api-client.ts # Gateway API wrapper
│       │   └── types.ts
│       └── package.json
│
├── data/
│   ├── databases/
│   │   └── trajectoryos.db   # Unified SQLite database
│   ├── models/
│   │   └── ircp_best_model.pt # Trained IRCP model
│   └── migrations/           # Data migration scripts
│       └── import_cc_tpo_conversations.py
│
├── training/                 # Model training (from cc-tpo)
│   ├── ircp/
│   │   ├── train.py
│   │   ├── evaluate.py
│   │   └── config.yaml
│   └── notebooks/
│
├── scripts/
│   ├── setup/
│   │   ├── init-database.sh
│   │   └── download-model.sh
│   ├── migration/
│   │   ├── migrate-cc-tpo-data.py
│   │   └── validate-migration.py
│   └── dev/
│       └── start-all-services.sh
│
├── docs/
│   ├── architecture/
│   │   ├── UNIFIED_ARCHITECTURE.md
│   │   ├── SERVICE_BOUNDARIES.md
│   │   └── DATA_MODEL.md
│   ├── guides/
│   │   ├── GETTING_STARTED.md
│   │   ├── DEPLOYMENT.md
│   │   └── DEVELOPMENT.md
│   ├── research/
│   │   ├── RESEARCH_PAPER_TOPOLOGICAL_LIFE_MODELING.md
│   │   ├── TOPOLOGICAL_SEARCH_VISUALIZATION.md
│   │   └── EXAMPLE_TOPOLOGICAL_QUERIES.md
│   └── integration/
│       ├── TRAJECTORY_TPO_INTEGRATION.md
│       └── MIGRATION_GUIDE.md
│
├── docker/
│   ├── docker-compose.yml    # All services orchestrated
│   ├── Dockerfile.ircp       # Python IRCP service
│   ├── Dockerfile.trajectory # TypeScript services
│   └── Dockerfile.web        # Next.js app
│
├── .env.example
├── package.json              # Root workspace config (pnpm)
├── pnpm-workspace.yaml
├── tsconfig.json             # Root TypeScript config
└── README.md

// Unified Prisma Schema

model User {
  id        String   @id @default(uuid())
  email     String?  @unique
  name      String?
  createdAt DateTime @default(now())

  lifeEvents     LifeEvent[]
  skillBeliefs   SkillBelief[]
  projects       Project[]
  constraints    Constraint[]
  lifeStates     LifeState[]
  patterns       LifePattern[]
}

model LifeEvent {
  id              String   @id @default(uuid())
  userId          String
  user            User     @relation(fields: [userId], references: [id])

  eventType       String   // 'conversation', 'interview', 'journal', 'project_note', 'decision'
  content         String   // Full text content
  parentEventId   String?  // Hierarchical nesting
  parentEvent     LifeEvent? @relation("EventHierarchy", fields: [parentEventId], references: [id])
  childEvents     LifeEvent[] @relation("EventHierarchy")

  timestamp       DateTime

  // Semantic embedding
  embedding       Bytes?   // 384-dim float array (serialized)

  // DLM coordinates
  xCoord          Float?   // Hierarchical depth
  yCoord          Float?   // Sibling position
  zCoord          Float?   // Semantic homogeneity
  tCoord          Float?   // Temporal position
  nCoord          Int?     // Structural complexity

  // Ring topology
  ringId          String?
  ringPosition    Int?
  pattern         LifePattern? @relation(fields: [ringId], references: [id])

  // Physics context
  physicsSnapshotId String?
  physicsSnapshot LifeState? @relation(fields: [physicsSnapshotId], references: [id])

  // Extracted evidence
  skillEvidence   SkillEvidence[]

  // Flexible metadata
  metadata        Json?

  createdAt       DateTime @default(now())
  updatedAt       DateTime @updatedAt

  @@index([userId, timestamp])
  @@index([userId, eventType])
  @@index([xCoord, yCoord, zCoord])
}

model Skill {
  id          String  @id @default(uuid())
  name        String
  domain      String
  description String?

  beliefs     SkillBelief[]
  edgesFrom   SkillEdge[] @relation("FromSkill")
  edgesTo     SkillEdge[] @relation("ToSkill")
  evidence    SkillEvidence[]

  @@unique([name, domain])
}

model SkillEdge {
  id           String @id @default(uuid())
  fromSkillId  String
  toSkillId    String
  fromSkill    Skill  @relation("FromSkill", fields: [fromSkillId], references: [id])
  toSkill      Skill  @relation("ToSkill", fields: [toSkillId], references: [id])

  weight       Float  // Transfer strength (0-1)
  description  String?

  @@unique([fromSkillId, toSkillId])
}

model SkillBelief {
  id            String   @id @default(uuid())
  userId        String
  skillId       String
  user          User     @relation(fields: [userId], references: [id])
  skill         Skill    @relation(fields: [skillId], references: [id])

  level         Float    // 0-10 scale (mean of posterior)
  uncertainty   Float    // Standard deviation
  lastUpdated   DateTime

  // Full posterior params (Beta distribution)
  posteriorParams Json?

  @@unique([userId, skillId])
  @@index([userId, level])
}

model SkillEvidence {
  id        String   @id @default(uuid())
  userId    String
  skillId   String
  skill     Skill    @relation(fields: [skillId], references: [id])

  eventId   String?
  event     LifeEvent? @relation(fields: [eventId], references: [id])

  timestamp DateTime
  level     Float    // Observed level (0-10)
  confidence Float   // Confidence in observation (0-1)
  source    String   // 'interview', 'artifact', 'echelon_flow', 'self_report'
  sourceRef String?  // Reference to source
  notes     String?

  @@index([userId, skillId, timestamp])
}

model Project {
  id              String   @id @default(uuid())
  userId          String
  user            User     @relation(fields: [userId], references: [id])

  name            String
  description     String?
  status          String   // 'active', 'paused', 'completed', 'archived'

  embedding       Bytes?   // Semantic vector
  importance      Float?   // 0-1
  timeAllocation  Float?   // 0-1

  // DLM coordinates for project as a whole
  xCoord          Float?
  yCoord          Float?
  zCoord          Float?

  metadata        Json?

  createdAt       DateTime @default(now())
  updatedAt       DateTime @updatedAt

  @@index([userId, status])
}

model Constraint {
  id          String    @id @default(uuid())
  userId      String
  user        User      @relation(fields: [userId], references: [id])

  type        String    // 'financial', 'time', 'health', 'social', 'other'
  description String
  intensity   Float     // 0-1
  urgency     Float     // 0-1

  startDate   DateTime
  endDate     DateTime?
  decayFunction String? // 'constant', 'exponential', 'linear'

  @@index([userId, endDate])
}

model LifeState {
  id            String   @id @default(uuid())
  userId        String
  user          User     @relation(fields: [userId], references: [id])

  timestamp     DateTime

  latentVector  Bytes    // z_t encoded

  // Physics variables
  thrust        Float
  alignment     Float
  gravity       Float
  mass          Float
  escapeIndex   Float

  notes         String?

  events        LifeEvent[]

  @@index([userId, timestamp])
  @@index([userId, escapeIndex])
}

model LifePattern {
  id            String   @id @default(uuid())
  userId        String
  user          User     @relation(fields: [userId], references: [id])

  patternType   String   // 'daily_routine', 'creative_cycle', 'learning_cycle', 'work_cycle'
  stages        Json     // Array of stage labels
  transitions   Json     // Transition matrix
  cycleDuration Float?   // Average period in days
  confidence    Float    // Detection confidence

  detectedAt    DateTime @default(now())
  status        String   // 'active', 'archived'

  events        LifeEvent[]

  @@index([userId, patternType])
}

# 1. Backup current state
cp -r services/cc-tpo services/cc-tpo.backup

# 2. Move packages to root
mv services/cc-tpo/packages ./packages

# 3. Create IRCP service structure
mkdir -p services/ircp-service/{routes,models}
# Copy relevant Python code from cc-tpo/apps/liquid-chat-backend
# Adapt to match new API spec

# 4. Update workspace config
cat > pnpm-workspace.yaml << EOF
packages:
  - 'apps/*'
  - 'services/*'
  - 'packages/*'
EOF

# 5. Create unified Next.js app
mv apps/web-dashboard apps/web
# Integrate cc-navigator components

import sqlite3
import json
from prisma import Prisma

async def migrate_conversations():
    # Source: CC-TPO database
    cc_tpo_db = sqlite3.connect('services/cc-tpo.backup/data/databases/conversations_fixed.db')

    # Target: Unified database
    prisma = Prisma()
    await prisma.connect()

    # Get all conversations
    cursor = cc_tpo_db.execute("SELECT * FROM conversations")

    for conv in cursor:
        # Create root life event
        root_event = await prisma.lifeevent.create({
            'data': {
                'userId': 'migrated_user',  # Set actual user ID
                'eventType': 'conversation',
                'content': conv['summary'] or '',
                'timestamp': conv['create_time'],
                'metadata': json.dumps({
                    'source': 'cc-tpo',
                    'original_id': conv['conversation_id']
                })
            }
        })

        # Get messages for this conversation
        msg_cursor = cc_tpo_db.execute(
            "SELECT * FROM messages WHERE conversation_id = ?",
            (conv['conversation_id'],)
        )

        for msg in msg_cursor:
            # Get DLM coordinates
            coords = cc_tpo_db.execute(
                "SELECT * FROM dlm_coordinates WHERE message_id = ?",
                (msg['message_id'],)
            ).fetchone()

            # Get embedding
            emb = cc_tpo_db.execute(
                "SELECT embedding_vector FROM embeddings WHERE message_id = ?",
                (msg['message_id'],)
            ).fetchone()

            # Create child event
            await prisma.lifeevent.create({
                'data': {
                    'userId': 'migrated_user',
                    'eventType': 'conversation',
                    'content': msg['content'],
                    'parentEventId': root_event.id,
                    'timestamp': msg['create_time'],
                    'xCoord': coords['x_coord'] if coords else None,
                    'yCoord': coords['y_coord'] if coords else None,
                    'zCoord': coords['z_coord'] if coords else None,
                    'tCoord': coords['t_coord'] if coords else None,
                    'nCoord': calculate_n(msg['content']),
                    'embedding': emb['embedding_vector'] if emb else None
                }
            })

    await prisma.disconnect()

def calculate_n(content: str) -> int:
    return len(content.split('\n\n'))

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import torch
from typing import List, Optional
import sys
from pathlib import Path

# Add packages to path
sys.path.append(str(Path(__file__).parent.parent.parent / "packages" / "ircp"))
sys.path.append(str(Path(__file__).parent.parent.parent / "packages" / "tpo"))

from ircp.models.sentence_transformer_icp import SentenceTransformerICP
from tpo.core.dlm_coordinates import DLMCalculator

app = FastAPI(title="IRCP Service")

# Load model at startup
model_path = "../../data/models/ircp_best_model.pt"
model = SentenceTransformerICP.load(model_path)
dlm_calculator = DLMCalculator()

class EmbedRequest(BaseModel):
    text: str

class EmbedResponse(BaseModel):
    embedding: List[float]
    coordinates: dict

class SearchRequest(BaseModel):
    query: str
    filters: Optional[dict] = None
    top_k: int = 10

@app.post("/embed", response_model=EmbedResponse)
async def embed_text(request: EmbedRequest):
    embedding = model.encode(request.text)

    # Predict coordinates (simplified - needs event context for full calc)
    coords_pred = model.predict_coordinates(embedding)

    return EmbedResponse(
        embedding=embedding.tolist(),
        coordinates={
            'x': coords_pred[0],
            'y': coords_pred[1],
            'z': coords_pred[2],
            't': coords_pred[3],
            'n': coords_pred[4]
        }
    )

@app.post("/calculate-coords")
async def calculate_coordinates(event: dict):
    # Full DLM calculation with graph structure
    coords = dlm_calculator.calculate(
        event_id=event['id'],
        parent_id=event.get('parentId'),
        siblings=event.get('siblings', []),
        timestamp=event['timestamp'],
        content=event['content']
    )

    return coords

@app.get("/health")
async def health():
    return {"status": "ok", "model_loaded": model is not None}

// apps/web/app/page.tsx

import LifeTree from '@/components/LifeTree';
import PhysicsDashboard from '@/components/PhysicsDashboard';
import CoordinateSpace from '@/components/CoordinateSpace';
import RingTopology from '@/components/RingTopology';
import SearchInterface from '@/components/SearchInterface';

export default function Home() {
  const [view, setView] = useState<'tree' | 'coords' | 'rings'>('tree');
  const [currentContext, setCurrentContext] = useState(null);

  return (
    <div className="grid grid-cols-12 h-screen">
      {/* Left sidebar: Navigation */}
      <div className="col-span-3 border-r">
        <LifeTree onNodeSelect={setCurrentContext} />
      </div>

      {/* Main content: View selection */}
      <div className="col-span-6">
        <ViewTabs value={view} onChange={setView} />

        {view === 'tree' && <EventDetail context={currentContext} />}
        {view === 'coords' && <CoordinateSpace />}
        {view === 'rings' && <RingTopology />}
      </div>

      {/* Right sidebar: Physics + Search */}
      <div className="col-span-3 border-l flex flex-col">
        <PhysicsDashboard className="flex-shrink-0" />
        <SearchInterface context={currentContext} className="flex-1" />
      </div>
    </div>
  );
}

# Remove redundant apps
rm -rf services/cc-tpo/apps/liquid-chat-ui
rm -rf services/cc-tpo/apps/ircp-search-app
rm -rf services/cc-tpo/apps/liquid-chat-backend

# Remove redundant services
rm -rf services/cc-tpo/services/

# Keep only essential CC-TPO structure
# services/cc-tpo/
#   ├── data/databases/ (as backup)
#   ├── training/ (model training code)
#   └── docs/ (research documentation)

# Archive
mkdir archive/
mv services/cc-tpo.backup archive/

# docker/docker-compose.yml

version: '3.8'

services:
  ircp:
    build:
      context: ..
      dockerfile: docker/Dockerfile.ircp
    ports:
      - "3005:3005"
    volumes:
      - ../data:/app/data
    environment:
      - MODEL_PATH=/app/data/models/ircp_best_model.pt

  trajectory-core:
    build:
      context: ..
      dockerfile: docker/Dockerfile.trajectory
    ports:
      - "3003:3003"
    depends_on:
      - ircp
    environment:
      - DATABASE_URL=file:/app/data/databases/trajectoryos.db
      - IRCP_SERVICE_URL=http://ircp:3005

  agent-orchestrator:
    build:
      context: ..
      dockerfile: docker/Dockerfile.trajectory
    ports:
      - "3004:3004"
    depends_on:
      - trajectory-core
      - ircp
    environment:
      - TRAJECTORY_CORE_URL=http://trajectory-core:3003
      - IRCP_SERVICE_URL=http://ircp:3005
      - OPENAI_API_KEY=${OPENAI_API_KEY}

  api-gateway:
    build:
      context: ..
      dockerfile: docker/Dockerfile.trajectory
    ports:
      - "8080:8080"
    depends_on:
      - trajectory-core
      - agent-orchestrator
      - ircp
    environment:
      - TRAJECTORY_CORE_URL=http://trajectory-core:3003
      - AGENT_ORCHESTRATOR_URL=http://agent-orchestrator:3004
      - IRCP_SERVICE_URL=http://ircp:3005

  web:
    build:
      context: ..
      dockerfile: docker/Dockerfile.web
    ports:
      - "3000:3000"
    depends_on:
      - api-gateway
    environment:
      - NEXT_PUBLIC_API_URL=http://api-gateway:8080

  background-worker:
    build:
      context: ..
      dockerfile: docker/Dockerfile.trajectory
    depends_on:
      - trajectory-core
      - ircp
    environment:
      - TRAJECTORY_CORE_URL=http://trajectory-core:3003
      - IRCP_SERVICE_URL=http://ircp:3005