orbital-command 0.1.4 → 0.3.0

package/server/project-manager.ts

@@ -0,0 +1,369 @@
+import fs from 'fs';
+import { Router } from 'express';
+import type { Server } from 'socket.io';
+import { ProjectEmitter } from './project-emitter.js';
+import { createProjectContext } from './project-context.js';
+import type { ProjectContext, ProjectStatus } from './project-context.js';
+import {
+  loadGlobalConfig,
+  registerProject,
+  unregisterProject,
+  updateProject,
+  findProject,
+} from './global-config.js';
+import type { ProjectRegistration } from './global-config.js';
+import { createScopeRoutes } from './routes/scope-routes.js';
+import { createDataRoutes } from './routes/data-routes.js';
+import { createDispatchRoutes } from './routes/dispatch-routes.js';
+import { createSprintRoutes } from './routes/sprint-routes.js';
+import { createWorkflowRoutes } from './routes/workflow-routes.js';
+import { createConfigRoutes } from './routes/config-routes.js';
+import { createGitRoutes } from './routes/git-routes.js';
+import { createManifestRoutes } from './routes/manifest-routes.js';
+import { createTelemetryRoutes } from './services/telemetry-service.js';
+import { TEMPLATES_DIR } from './init.js';
+import { getPackageVersion } from './utils/package-info.js';
+import { resolveActiveDispatchesForScope } from './utils/dispatch-utils.js';
+import { createLogger } from './utils/logger.js';
+
+const log = createLogger('project-manager');
+
+// ─── Types ──────────────────────────────────────────────────
+
+export interface ProjectSummary {
+  id: string;
+  name: string;
+  path: string;
+  color: string;
+  status: ProjectStatus;
+  enabled: boolean;
+  scopeCount: number;
+  error?: string;
+}
+
+// ─── Manager ────────────────────────────────────────────────
+
+export class ProjectManager {
+  private contexts = new Map<string, ProjectContext>();
+  private routers = new Map<string, Router>();
+  private healthCheckInterval: ReturnType<typeof setInterval> | null = null;
+
+  constructor(private io: Server) {}
+
+  // ─── Initialization ─────────────────────────────────────
+
+  /** Initialize all enabled projects from the registry. */
+  async initializeAll(): Promise<void> {
+    const config = loadGlobalConfig();
+    const enabledProjects = config.projects.filter(p => p.enabled);
+
+    log.info('Initializing projects', { count: enabledProjects.length });
+
+    for (const reg of enabledProjects) {
+      try {
+        await this.initializeProject(reg);
+      } catch (err) {
+        log.error('Failed to initialize project', {
+          id: reg.id,
+          path: reg.path,
+          error: String(err),
+        });
+      }
+    }
+
+    // Start periodic health checks
+    this.healthCheckInterval = setInterval(() => this.checkHealth(), 60_000);
+  }
+
+  /** Initialize a single project from its registration. */
+  async initializeProject(reg: ProjectRegistration): Promise<ProjectContext | null> {
+    // Verify directory exists
+    if (!fs.existsSync(reg.path)) {
+      log.warn('Project directory not found, marking offline', { id: reg.id, path: reg.path });
+      // Store a placeholder context to track status
+      return null;
+    }
+
+    const emitter = new ProjectEmitter(this.io, reg.id);
+
+    try {
+      const ctx = await createProjectContext(reg.id, reg.path, emitter);
+      this.contexts.set(reg.id, ctx);
+
+      // Build and cache the project's router
+      const router = this.buildProjectRouter(ctx);
+      this.routers.set(reg.id, router);
+
+      log.info('Project initialized', {
+        id: reg.id,
+        name: reg.name,
+        scopeCount: ctx.scopeService.getAll().length,
+      });
+
+      return ctx;
+    } catch (err) {
+      log.error('Project initialization failed', { id: reg.id, error: String(err) });
+      return null;
+    }
+  }
+
+  // ─── Context Access ─────────────────────────────────────
+
+  /** Get a project context by ID. */
+  getContext(id: string): ProjectContext | undefined {
+    return this.contexts.get(id);
+  }
+
+  /** Get all active contexts. */
+  getAllContexts(): Map<string, ProjectContext> {
+    return this.contexts;
+  }
+
+  /** Get the router for a project. */
+  getRouter(id: string): Router | undefined {
+    return this.routers.get(id);
+  }
+
+  /** Get all project routers. */
+  getAllRouters(): Map<string, Router> {
+    return this.routers;
+  }
+
+  // ─── Project List ───────────────────────────────────────
+
+  /** Get summary of all registered projects with live status. */
+  getProjectList(options?: { includeWorkflow?: boolean }): (ProjectSummary & { workflow?: unknown })[] {
+    const config = loadGlobalConfig();
+    return config.projects.map(reg => {
+      const ctx = this.contexts.get(reg.id);
+      const summary: ProjectSummary & { workflow?: unknown } = {
+        id: reg.id,
+        name: reg.name,
+        path: reg.path,
+        color: reg.color,
+        status: ctx?.status ?? 'offline' as ProjectStatus,
+        enabled: reg.enabled,
+        scopeCount: ctx ? ctx.scopeService.getAll().length : 0,
+        error: ctx?.error,
+      };
+      if (options?.includeWorkflow && ctx) {
+        summary.workflow = ctx.workflowService.getActive();
+      }
+      return summary;
+    });
+  }
+
+  // ─── Registration ───────────────────────────────────────
+
+  /** Register and initialize a new project. */
+  async addProject(projectRoot: string, options?: { name?: string; color?: string }): Promise<ProjectSummary> {
+    const reg = registerProject(projectRoot, options);
+    const ctx = await this.initializeProject(reg);
+
+    // Notify all clients
+    this.io.emit('project:registered', {
+      id: reg.id,
+      name: reg.name,
+      path: reg.path,
+      color: reg.color,
+    });
+
+    return {
+      id: reg.id,
+      name: reg.name,
+      path: reg.path,
+      color: reg.color,
+      status: ctx?.status ?? 'offline',
+      enabled: reg.enabled,
+      scopeCount: ctx ? ctx.scopeService.getAll().length : 0,
+    };
+  }
+
+  /** Unregister a project and shut down its context. */
+  async removeProject(idOrPath: string): Promise<boolean> {
+    // Find the registration before removing
+    const config = loadGlobalConfig();
+    const reg = config.projects.find(p => p.id === idOrPath || p.path === idOrPath);
+    if (!reg) return false;
+
+    // Shut down context
+    await this.shutdownProject(reg.id);
+
+    // Remove from registry
+    unregisterProject(idOrPath);
+
+    // Notify clients
+    this.io.emit('project:unregistered', { id: reg.id });
+
+    return true;
+  }
+
+  /** Update project metadata (name, color, enabled). */
+  async updateProject(
+    id: string,
+    updates: Partial<Pick<ProjectRegistration, 'name' | 'color' | 'enabled'>>,
+  ): Promise<ProjectRegistration | null> {
+    const result = updateProject(id, updates);
+    if (!result) return null;
+
+    // If disabling, shut down the context
+    if (updates.enabled === false) {
+      await this.shutdownProject(id);
+    }
+
+    // If enabling, initialize the context
+    if (updates.enabled === true && !this.contexts.has(id)) {
+      const reg = findProject(id);
+      if (reg) await this.initializeProject(reg);
+    }
+
+    // Notify clients of metadata change
+    this.io.emit('project:updated', { id, ...updates });
+
+    return result;
+  }
+
+  // ─── Lifecycle ──────────────────────────────────────────
+
+  /** Shut down a single project's context. */
+  async shutdownProject(id: string): Promise<void> {
+    const ctx = this.contexts.get(id);
+    if (ctx) {
+      await ctx.shutdown();
+      this.contexts.delete(id);
+      this.routers.delete(id);
+      log.info('Project shut down', { id });
+    }
+  }
+
+  /** Shut down all projects and stop health checks. */
+  async shutdownAll(): Promise<void> {
+    if (this.healthCheckInterval) {
+      clearInterval(this.healthCheckInterval);
+      this.healthCheckInterval = null;
+    }
+
+    const shutdowns = [...this.contexts.entries()].map(([id, ctx]) =>
+      ctx.shutdown().catch(err =>
+        log.error('Error shutting down project', { id, error: String(err) }),
+      ),
+    );
+    await Promise.all(shutdowns);
+    this.contexts.clear();
+    this.routers.clear();
+    log.info('All projects shut down');
+  }
+
+  // ─── Health Checks ──────────────────────────────────────
+
+  /** Periodic health check — detect projects that have gone offline or come back. */
+  private async checkHealth(): Promise<void> {
+    const config = loadGlobalConfig();
+
+    for (const reg of config.projects) {
+      if (!reg.enabled) continue;
+
+      const ctx = this.contexts.get(reg.id);
+      const dirExists = fs.existsSync(reg.path);
+
+      if (ctx && !dirExists) {
+        // Project went offline
+        log.warn('Project directory disappeared', { id: reg.id, path: reg.path });
+        await this.shutdownProject(reg.id);
+        this.io.emit('project:status:changed', { id: reg.id, status: 'offline' });
+      } else if (!ctx && dirExists) {
+        // Project came back online (or failed to initialize previously — retry)
+        log.info('Attempting to initialize project', { id: reg.id, path: reg.path });
+        try {
+          await this.initializeProject(reg);
+          this.io.emit('project:status:changed', { id: reg.id, status: 'active' });
+        } catch (err) {
+          log.warn('Project initialization retry failed', { id: reg.id, error: String(err) });
+        }
+      }
+    }
+  }
+
+  // ─── Route Building ─────────────────────────────────────
+
+  /** Build an Express Router with all per-project routes for a context. */
+  /** Build an Express Router with all per-project routes.
+   *  Note: createVersionRoutes is intentionally omitted — version/update endpoints
+   *  are global (they update the Orbital Command package), not per-project. */
+  private buildProjectRouter(ctx: ProjectContext): Router {
+    const router = Router();
+    const { db, emitter, config, scopeService, eventService, gateService, deployService,
+            sprintService, sprintOrchestrator, batchOrchestrator,
+            readinessService, workflowService, workflowEngine,
+            gitService, githubService, telemetryService } = ctx;
+
+    // Scope status inference function (same logic as index.ts)
+    function inferScopeStatus(
+      eventType: string,
+      scopeId: unknown,
+      data: Record<string, unknown>,
+    ): void {
+      if (scopeId == null) return;
+      const id = Number(scopeId);
+      if (isNaN(id) || id <= 0) return;
+      const current = scopeService.getById(id);
+      if (current?.status === 'icebox') return;
+      const currentStatus = current?.status ?? '';
+      const result = workflowEngine.inferStatus(eventType, currentStatus, data);
+      if (result === null) return;
+      if (typeof result === 'object' && 'dispatchResolution' in result) {
+        resolveActiveDispatchesForScope(db, emitter, id, result.resolution as 'completed' | 'failed');
+        return;
+      }
+      scopeService.updateStatus(id, result, 'event');
+    }
+
+    // Project config endpoint
+    router.get('/config', (_req, res) => {
+      res.json({
+        projectName: config.projectName,
+        categories: config.categories,
+        agents: config.agents,
+        serverPort: config.serverPort,
+        clientPort: config.clientPort,
+      });
+    });
+
+    // Mount all route groups
+    router.use(createScopeRoutes({
+      db, io: emitter, scopeService, readinessService,
+      projectRoot: config.projectRoot, projectName: config.projectName,
+      engine: workflowEngine,
+    }));
+    router.use(createDataRoutes({
+      db, io: emitter, eventService, gateService, deployService, gitService,
+      engine: workflowEngine, projectRoot: config.projectRoot,
+      inferScopeStatus,
+    }));
+    router.use(createDispatchRoutes({
+      db, io: emitter, scopeService,
+      projectRoot: config.projectRoot, engine: workflowEngine,
+    }));
+    router.use(createSprintRoutes({
+      sprintService, sprintOrchestrator, batchOrchestrator,
+    }));
+    router.use(createWorkflowRoutes({
+      workflowService, projectRoot: config.projectRoot,
+    }));
+    router.use(createConfigRoutes({
+      projectRoot: config.projectRoot, workflowService, io: emitter,
+    }));
+    router.use(createGitRoutes({
+      gitService, githubService, engine: workflowEngine,
+    }));
+    router.use(createManifestRoutes({
+      projectRoot: config.projectRoot,
+      templatesDir: TEMPLATES_DIR,
+      packageVersion: getPackageVersion(),
+      io: emitter,
+    }));
+    router.use(createTelemetryRoutes({ telemetryService }));
+
+    return router;
+  }
+}

package/server/routes/config-routes.ts

@@ -1,13 +1,14 @@
 import { Router } from 'express';
-import type { Server } from 'socket.io';
+import type { Emitter } from '../project-emitter.js';
 import { ConfigService, isValidPrimitiveType } from '../services/config-service.js';
 import type { ConfigPrimitiveType } from '../services/config-service.js';
 import type { WorkflowService } from '../services/workflow-service.js';
+import { errMsg } from '../utils/route-helpers.js';
 
 interface ConfigRouteDeps {
   projectRoot: string;
   workflowService: WorkflowService;
-  io: Server;
+  io: Emitter;
 }
 
 export function createConfigRoutes({ projectRoot, workflowService: _workflowService, io }: ConfigRouteDeps): Router {
@@ -177,6 +178,3 @@ export function createConfigRoutes({ projectRoot, workflowService: _workflowServ
   return router;
 }
 
-function errMsg(err: unknown): string {
-  return err instanceof Error ? err.message : String(err);
-}

package/server/routes/data-routes.ts

@@ -3,25 +3,20 @@ import { execFile } from 'child_process';
 import path from 'path';
 import { promisify } from 'util';
 import type Database from 'better-sqlite3';
-import type { Server } from 'socket.io';
+import type { Emitter } from '../project-emitter.js';
+import type { EventService } from '../services/event-service.js';
 import type { GateService } from '../services/gate-service.js';
 import type { DeployService } from '../services/deploy-service.js';
+import type { GitService } from '../services/git-service.js';
 import type { WorkflowEngine } from '../../shared/workflow-engine.js';
 import { getHookEnforcement } from '../../shared/workflow-config.js';
 import { getClaudeSessions, getSessionStats, type SessionStats } from '../services/claude-session-service.js';
 import { launchInTerminal } from '../utils/terminal-launcher.js';
+import { createLogger } from '../utils/logger.js';
 
-const execFileAsync = promisify(execFile);
-
-// ─── Types & Helpers ────────────────────────────────────────
+const log = createLogger('server');
 
-interface DriftCommit { sha: string; message: string; author: string; date: string }
-interface BranchHead { sha: string; date: string; message: string }
-interface PipelineDriftData {
-  devToStaging: { count: number; commits: DriftCommit[]; oldestDate: string | null };
-  stagingToMain: { count: number; commits: DriftCommit[]; oldestDate: string | null };
-  heads: { dev: BranchHead; staging: BranchHead; main: BranchHead };
-}
+const execFileAsync = promisify(execFile);
 
 const JSON_FIELDS = ['tags', 'blocked_by', 'blocks', 'data', 'discoveries', 'next_steps', 'details'];
 
@@ -37,100 +32,32 @@ function parseJsonFields(row: Row): Row {
   return parsed;
 }
 
-function parseDriftCommits(raw: string): DriftCommit[] {
-  if (!raw) return [];
-  return raw.split('\n').map((line) => {
-    const [sha, date, message, author] = line.split('|');
-    return { sha, date, message: message ?? '', author: author ?? '' };
-  });
-}
-
-function parseHead(raw: string): BranchHead {
-  const [sha, date, message] = raw.split('|');
-  return { sha: sha ?? '', date: date ?? '', message: message ?? '' };
-}
-
 // ─── Route Factory ──────────────────────────────────────────
 
 interface DataRouteDeps {
   db: Database.Database;
-  io: Server;
+  io: Emitter;
+  eventService: EventService;
   gateService: GateService;
   deployService: DeployService;
+  gitService: GitService;
   engine: WorkflowEngine;
   projectRoot: string;
   inferScopeStatus: (type: string, scopeId: unknown, data: Record<string, unknown>) => void;
 }
 
 export function createDataRoutes({
-  db, io, gateService, deployService, engine, projectRoot, inferScopeStatus,
+  db, io, eventService, gateService, deployService, gitService, engine, projectRoot, inferScopeStatus,
 }: DataRouteDeps): Router {
   const router = Router();
 
-  // ─── Pipeline Drift (cached) ─────────────────────────────
-
-  let driftCache: { data: PipelineDriftData; ts: number } | null = null;
-  const DRIFT_CACHE_MS = 60_000;
-
-  async function gitLog(args: string[]): Promise<string> {
-    const { stdout } = await execFileAsync('git', args, { cwd: projectRoot });
-    return stdout.trim();
-  }
-
-  async function computeDrift(): Promise<PipelineDriftData> {
-    if (driftCache && Date.now() - driftCache.ts < DRIFT_CACHE_MS) return driftCache.data;
-
-    const [devToStagingRaw, stagingToMainRaw, devHead, stagingHead, mainHead] =
-      await Promise.all([
-        gitLog(['log', 'origin/dev', '--not', 'origin/staging', '--reverse', '--format=%H|%aI|%s|%an']),
-        gitLog(['log', 'origin/staging', '--not', 'origin/main', '--reverse', '--format=%H|%aI|%s|%an']),
-        gitLog(['log', 'origin/dev', '-1', '--format=%H|%aI|%s']),
-        gitLog(['log', 'origin/staging', '-1', '--format=%H|%aI|%s']),
-        gitLog(['log', 'origin/main', '-1', '--format=%H|%aI|%s']),
-      ]);
-
-    const devToStaging = parseDriftCommits(devToStagingRaw);
-    const stagingToMain = parseDriftCommits(stagingToMainRaw);
-
-    const data: PipelineDriftData = {
-      devToStaging: {
-        count: devToStaging.length,
-        commits: devToStaging,
-        oldestDate: devToStaging[0]?.date ?? null,
-      },
-      stagingToMain: {
-        count: stagingToMain.length,
-        commits: stagingToMain,
-        oldestDate: stagingToMain[0]?.date ?? null,
-      },
-      heads: {
-        dev: parseHead(devHead),
-        staging: parseHead(stagingHead),
-        main: parseHead(mainHead),
-      },
-    };
-
-    driftCache = { data, ts: Date.now() };
-    return data;
-  }
-
   // ─── Event Routes ──────────────────────────────────────────
 
   router.get('/events', (req, res) => {
     const limit = Number(req.query.limit) || 50;
     const type = req.query.type as string | undefined;
-    const scopeId = req.query.scope_id as string | undefined;
-
-    let query = 'SELECT * FROM events WHERE 1=1';
-    const params: unknown[] = [];
-
-    if (type) { query += ' AND type = ?'; params.push(type); }
-    if (scopeId) { query += ' AND scope_id = ?'; params.push(Number(scopeId)); }
-
-    query += ' ORDER BY timestamp DESC LIMIT ?';
-    params.push(limit);
-
-    const events = db.prepare(query).all(...params) as Row[];
+    const scopeId = req.query.scope_id ? Number(req.query.scope_id) : undefined;
+    const events = eventService.getFiltered({ limit, type, scopeId }) as unknown as Row[];
     res.json(events.map(parseJsonFields));
   });
 
@@ -167,23 +94,9 @@ export function createDataRoutes({
 
   router.get('/events/violations/summary', (_req, res) => {
     try {
-      const byRule = db.prepare(
-        `SELECT JSON_EXTRACT(data, '$.rule') as rule, COUNT(*) as count, MAX(timestamp) as last_seen
-         FROM events WHERE type = 'VIOLATION' GROUP BY rule ORDER BY count DESC`
-      ).all();
-      const byFile = db.prepare(
-        `SELECT JSON_EXTRACT(data, '$.file') as file, COUNT(*) as count FROM events
-         WHERE type = 'VIOLATION' AND JSON_EXTRACT(data, '$.file') IS NOT NULL AND JSON_EXTRACT(data, '$.file') != ''
-         GROUP BY file ORDER BY count DESC LIMIT 20`
-      ).all();
-      const overrides = db.prepare(
-        `SELECT JSON_EXTRACT(data, '$.rule') as rule, JSON_EXTRACT(data, '$.reason') as reason, timestamp as date
-         FROM events WHERE type = 'OVERRIDE' ORDER BY timestamp DESC LIMIT 50`
-      ).all();
-      const totalViolations = db.prepare(`SELECT COUNT(*) as count FROM events WHERE type = 'VIOLATION'`).get() as { count: number };
-      const totalOverrides = db.prepare(`SELECT COUNT(*) as count FROM events WHERE type = 'OVERRIDE'`).get() as { count: number };
-      res.json({ byRule, byFile, overrides, totalViolations: totalViolations.count, totalOverrides: totalOverrides.count });
-    } catch {
+      res.json(eventService.getViolationSummary());
+    } catch (err) {
+      log.error('Violations summary failed', { error: String(err) });
       res.status(500).json({ error: 'Failed to query violations summary' });
     }
   });
@@ -204,19 +117,7 @@ export function createDataRoutes({
         }
       }
 
-      // Query violation and override stats per rule
-      const violationStats = db.prepare(
-        `SELECT JSON_EXTRACT(data, '$.rule') as rule, COUNT(*) as count, MAX(timestamp) as last_seen
-         FROM events WHERE type = 'VIOLATION' GROUP BY rule`
-      ).all() as Array<{ rule: string; count: number; last_seen: string }>;
-
-      const overrideStats = db.prepare(
-        `SELECT JSON_EXTRACT(data, '$.rule') as rule, COUNT(*) as count
-         FROM events WHERE type = 'OVERRIDE' GROUP BY rule`
-      ).all() as Array<{ rule: string; count: number }>;
-
-      const violationMap = new Map(violationStats.map((v) => [v.rule, v]));
-      const overrideMap = new Map(overrideStats.map((o) => [o.rule, o]));
+      const { violations: violationMap, overrides: overrideMap } = eventService.getViolationStatsByRule();
 
       // Build summary counts
       const summary = { guards: 0, gates: 0, lifecycle: 0, observers: 0 };
@@ -239,7 +140,8 @@ export function createDataRoutes({
       }));
 
       res.json({ summary, rules, totalEdges: allEdges.length });
-    } catch {
+    } catch (err) {
+      log.error('Enforcement rules failed', { error: String(err) });
       res.status(500).json({ error: 'Failed to query enforcement rules' });
     }
   });
@@ -248,14 +150,10 @@ export function createDataRoutes({
 
   router.get('/events/violations/trend', (req, res) => {
     try {
-      const days = Number(req.query.days) || 30;
-      const trend = db.prepare(
-        `SELECT date(timestamp) as day, JSON_EXTRACT(data, '$.rule') as rule, COUNT(*) as count
-         FROM events WHERE type = 'VIOLATION' AND timestamp >= datetime('now', ? || ' days')
-         GROUP BY day, rule ORDER BY day ASC`
-      ).all(`-${days}`) as Array<{ day: string; rule: string; count: number }>;
-      res.json(trend);
-    } catch {
+      const days = Math.max(1, Math.min(365, Number(req.query.days) || 30));
+      res.json(eventService.getViolationTrend(days));
+    } catch (err) {
+      log.error('Violation trends failed', { error: String(err) });
       res.status(500).json({ error: 'Failed to query violation trends' });
     }
   });
@@ -330,8 +228,7 @@ export function createDataRoutes({
 
   router.get('/pipeline/drift', async (_req, res) => {
     try {
-      const drift = await computeDrift();
-      res.json(drift);
+      res.json(await gitService.getPipelineDrift());
     } catch (err) {
       res.status(500).json({ error: 'Failed to compute drift', details: String(err) });
     }
@@ -339,19 +236,9 @@ export function createDataRoutes({
 
   router.get('/deployments/frequency', (_req, res) => {
     try {
-      const rows = db.prepare(
-        `SELECT environment, strftime('%Y-W%W', started_at) as week, COUNT(*) as count
-         FROM deployments WHERE started_at > datetime('now', '-56 days') GROUP BY environment, week ORDER BY week ASC`
-      ).all() as Array<{ environment: string; week: string; count: number }>;
-      const weekMap = new Map<string, { week: string; staging: number; production: number }>();
-      for (const row of rows) {
-        if (!weekMap.has(row.week)) weekMap.set(row.week, { week: row.week, staging: 0, production: 0 });
-        const entry = weekMap.get(row.week)!;
-        if (row.environment === 'staging') entry.staging = row.count;
-        if (row.environment === 'production') entry.production = row.count;
-      }
-      res.json([...weekMap.values()]);
-    } catch {
+      res.json(eventService.getDeployFrequency());
+    } catch (err) {
+      log.error('Deploy frequency query failed', { error: String(err) });
       res.status(500).json({ error: 'Failed to query deployment frequency' });
     }
   });
@@ -417,7 +304,7 @@ export function createDataRoutes({
     let stats: SessionStats | null = null;
 
     if (parsed.claude_session_id && typeof parsed.claude_session_id === 'string') {
-      const claudeSessions = await getClaudeSessions();
+      const claudeSessions = await getClaudeSessions(undefined, projectRoot);
       const match = claudeSessions.find(s => s.id === parsed.claude_session_id);
       if (match) {
         meta = {
@@ -429,7 +316,7 @@ export function createDataRoutes({
           lastActiveAt: match.lastActiveAt,
         };
       }
-      stats = getSessionStats(parsed.claude_session_id as string);
+      stats = getSessionStats(parsed.claude_session_id as string, projectRoot);
     }
 
     if (!content) {