Hook（同步，必须快）          Worker（异步，可以慢）
┌──────────────────┐         ┌──────────────────────────┐
│ 读 stdin         │  HTTP   │ 接收观察数据              │
│ POST 到 Worker   │────────→│ 入队 pending_messages     │
│ 返回 success     │         │ 取出队列逐条处理          │
│ 耗时 < 30ms      │         │ 调用 Claude SDK 压缩      │
└──────────────────┘         │ 存入 observations 表      │
                             │ 同步 ChromaDB embedding   │
                             │ 耗时 5-30s / 条           │
                             └──────────────────────────┘

// src/services/worker-service.ts（简化）
// 端口计算：37700 + (uid % 100)
const port = getWorkerPort(); // 默认 37700
 
const server = new Server(app);
// 注册路由组
server.registerRoutes(new SessionRoutes(sessionManager, dbManager));
server.registerRoutes(new SearchRoutes(searchManager));
server.registerRoutes(new DataRoutes(dbManager));
server.registerRoutes(new ViewerRoutes());

// 简化的入队逻辑
// Worker 接收 POST /api/sessions/observations
async handleObservation(req, res) {
  const { contentSessionId, tool_name, tool_input, tool_response } = req.body;
 
  // 找到对应的数据库 session
  const session = this.dbManager.findSessionByContentId(contentSessionId);
 
  // 入队（写入 SQLite pending_messages 表）
  this.pendingStore.enqueue(session.id, {
    type: 'observation',
    tool_name,
    tool_input,
    tool_response,
  });
 
  // 立即返回（不等待处理完成）
  res.json({ status: 'queued' });
}

enqueue() → INSERT INTO pending_messages (status='pending')
    ↓
Worker 取出 → UPDATE status='processing'
    ↓
AI 压缩完成 → Parser 解析成功 → clearPendingForSession()
    ↓
如果解析失败 → 保留在队列中，等待下次尝试

// 简化的 Generator 循环
async function* processSession(session: ActiveSession) {
  while (true) {
    // 等待新的 pending messages
    const messages = await waitForPending(session.id);
    if (!messages.length) break; // session 结束
 
    // 构造 prompt，发送给 Claude SDK
    const prompt = buildCompressionPrompt(messages);
    const response = await claudeAgent.send(prompt);
 
    // 解析 AI 返回的结构化 Observation
    const parsed = parseResponse(response);
    if (parsed.valid) {
      yield parsed.observations; // 产出结构化 Observation
      clearPending(session.id);
    }
    // 无效响应：不清除队列，下次重试
  }
}

Generator 崩溃 → 等 1s → 重试 1
                → 等 2s → 重试 2
                → 等 4s → 重试 3
                → consecutiveRestarts > 3 → 放弃，让 Generator 自然结束

-- sdk_sessions 表
CREATE TABLE sdk_sessions (
  id INTEGER PRIMARY KEY,
  content_session_id TEXT NOT NULL,  -- 来自 Claude Code
  memory_session_id TEXT,            -- 来自 SDK Agent（可能变化）
  project TEXT,
  status TEXT DEFAULT 'active',
  created_at_epoch INTEGER
);

// 简化逻辑
async function ensureWorkerStarted(): Promise<void> {
  const pid = readPidFile();
  if (pid && isProcessAlive(pid)) {
    return; // Worker 已在运行
  }
  // 清理 stale PID file
  if (pid) removePidFile();
  // 启动新 Worker
  spawnDaemon();
  await waitForHealth(); // 等待 /health 端点可用
}

{
  "status": "healthy",
  "version": "12.6.2",
  "uptime": 3600,
  "sessions": { "active": 2, "total": 15 },
  "observations": { "total": 342, "pending": 3 }
}

// 每 5 分钟执行
function reapOrphans() {
  for (const [pid, process] of processRegistry) {
    if (!hasActiveSession(process.sessionId)) {
      kill(pid);
      processRegistry.delete(pid);
    }
  }
}

// src/services/infrastructure/GracefulShutdown.ts（简化）
async function performGracefulShutdown(): Promise<void> {
  // Step 1: 移除 PID 文件（防止新 Hook 连接进来）
  removePidFile();
 
  // Step 2: 停止接受新连接
  httpServer.close();
 
  // Step 3: 等待活跃请求完成（最多 5 秒）
  await drainConnections(5000);
 
  // Step 4: 通知所有活跃 Session 停止处理
  for (const session of activeSessions) {
    session.markCompleting();
  }
 
  // Step 5: 等待 pending messages 处理完毕（最多 10 秒）
  await drainPendingMessages(10000);
 
  // Step 6: 关闭 MCP 连接和 ChromaDB
  await chromaMcp.disconnect();
 
  // Step 7: 关闭 SQLite 数据库
  database.close();
 
  // 如果以上步骤超时，force kill 子进程
  killAllChildren();
}