@bahulam/code 0.1.1

package/pulse/app/api/benchmarks/route.ts

@@ -0,0 +1,195 @@
+import { NextResponse } from 'next/server'
+import fs from 'fs'
+import path from 'path'
+
+export const dynamic = 'force-dynamic'
+
+interface BenchmarkResult {
+  instance_id: string
+  repo: string
+  model: string
+  timestamp: string
+  kepler: {
+    status: string
+    exit_code: number
+    duration_seconds: number
+    tokens_used: number
+    cost: number
+    tool_calls: number
+    sub_agents: string[]
+  }
+  patch_lines: number
+  model_patch: string
+  status: string
+}
+
+interface BenchmarkStats {
+  total_runs: number
+  passed: number
+  failed: number
+  error: number
+  success_rate: number
+  avg_duration: number
+  total_cost: number
+  total_tokens: number
+  avg_tokens_per_run: number
+  by_status: Record<string, number>
+  by_repo: Record<string, { count: number; passed: number; success_rate: number }>
+  by_model: Record<string, { count: number; passed: number; success_rate: number }>
+}
+
+async function loadBenchmarkResults(): Promise<BenchmarkResult[]> {
+  try {
+    const resultsPath = path.join(
+      process.cwd(),
+      'benchmark/results/runs/swebench-v4-flash-300/harness-results.json'
+    )
+
+    if (!fs.existsSync(resultsPath)) {
+      return []
+    }
+
+    const data = JSON.parse(fs.readFileSync(resultsPath, 'utf-8'))
+    return data.results || []
+  } catch (error) {
+    console.error('Error loading benchmark results:', error)
+    return []
+  }
+}
+
+function calculateStats(results: BenchmarkResult[]): BenchmarkStats {
+  if (results.length === 0) {
+    return {
+      total_runs: 0,
+      passed: 0,
+      failed: 0,
+      error: 0,
+      success_rate: 0,
+      avg_duration: 0,
+      total_cost: 0,
+      total_tokens: 0,
+      avg_tokens_per_run: 0,
+      by_status: {},
+      by_repo: {},
+      by_model: {},
+    }
+  }
+
+  const by_status: Record<string, number> = {}
+  const by_repo: Record<string, { count: number; passed: number }> = {}
+  const by_model: Record<string, { count: number; passed: number }> = {}
+
+  let total_cost = 0
+  let total_tokens = 0
+  let total_duration = 0
+  let passed = 0
+
+  results.forEach((result) => {
+    // Count by status
+    by_status[result.status] = (by_status[result.status] || 0) + 1
+
+    // Count by repo
+    if (!by_repo[result.repo]) {
+      by_repo[result.repo] = { count: 0, passed: 0 }
+    }
+    by_repo[result.repo].count++
+
+    // Count by model
+    if (!by_model[result.model]) {
+      by_model[result.model] = { count: 0, passed: 0 }
+    }
+    by_model[result.model].count++
+
+    // Aggregate metrics
+    if (result.kepler) {
+      total_cost += result.kepler.cost || 0
+      total_tokens += result.kepler.tokens_used || 0
+      total_duration += result.kepler.duration_seconds || 0
+
+      if (result.kepler.status === 'success') {
+        passed++
+        by_repo[result.repo].passed++
+        by_model[result.model].passed++
+      }
+    }
+  })
+
+  // Calculate success rates
+  const by_repo_with_rates = Object.entries(by_repo).reduce(
+    (acc, [repo, data]) => {
+      acc[repo] = {
+        ...data,
+        success_rate: data.count > 0 ? (data.passed / data.count) * 100 : 0,
+      }
+      return acc
+    },
+    {} as Record<string, { count: number; passed: number; success_rate: number }>
+  )
+
+  const by_model_with_rates = Object.entries(by_model).reduce(
+    (acc, [model, data]) => {
+      acc[model] = {
+        ...data,
+        success_rate: data.count > 0 ? (data.passed / data.count) * 100 : 0,
+      }
+      return acc
+    },
+    {} as Record<string, { count: number; passed: number; success_rate: number }>
+  )
+
+  return {
+    total_runs: results.length,
+    passed,
+    failed: by_status['failed'] || 0,
+    error: by_status['error'] || 0,
+    success_rate: (passed / results.length) * 100,
+    avg_duration: total_duration / results.length,
+    total_cost,
+    total_tokens,
+    avg_tokens_per_run: total_tokens / results.length,
+    by_status,
+    by_repo: by_repo_with_rates,
+    by_model: by_model_with_rates,
+  }
+}
+
+export async function GET(request: Request) {
+  const { searchParams } = new URL(request.url)
+  const format = searchParams.get('format') || 'summary'
+  const repo = searchParams.get('repo')
+  const model = searchParams.get('model')
+  const status = searchParams.get('status')
+
+  const results = await loadBenchmarkResults()
+
+  // Filter results
+  let filtered = results
+  if (repo) {
+    filtered = filtered.filter((r) => r.repo === repo)
+  }
+  if (model) {
+    filtered = filtered.filter((r) => r.model === model)
+  }
+  if (status) {
+    filtered = filtered.filter((r) => r.status === status)
+  }
+
+  if (format === 'detailed') {
+    return NextResponse.json({
+      results: filtered,
+      count: filtered.length,
+    })
+  }
+
+  // Default: summary format
+  const stats = calculateStats(filtered)
+
+  return NextResponse.json({
+    stats,
+    filters: {
+      repo: repo || null,
+      model: model || null,
+      status: status || null,
+    },
+  })
+}

package/pulse/app/api/costs/route.ts

@@ -0,0 +1,88 @@
+import { NextResponse } from 'next/server'
+import { readStatsCache, getSessions } from '@/lib/claude-reader'
+import { estimateTotalCostFromModel, cacheEfficiency, getPricing, PRICING } from '@/lib/pricing'
+import { projectDisplayName } from '@/lib/decode'
+import type { CostAnalytics, ModelCostBreakdown, DailyCost, ProjectCost } from '@/types/claude'
+
+export const dynamic = 'force-dynamic'
+
+export async function GET() {
+  const [stats, sessions] = await Promise.all([readStatsCache(), getSessions()])
+
+  if (!stats) {
+    return NextResponse.json({ error: 'stats-cache.json not found' }, { status: 404 })
+  }
+
+  // ── Per-model breakdown ────────────────────────────────────────────────────
+  let totalCost = 0
+  let totalSavings = 0
+  const models: ModelCostBreakdown[] = Object.entries(stats.modelUsage ?? {}).map(([model, usage]) => {
+    const cost = estimateTotalCostFromModel(model, usage)
+    const eff = cacheEfficiency(model, usage)
+    totalCost += cost
+    totalSavings += eff.savedUSD
+    return {
+      model,
+      input_tokens: usage.inputTokens ?? 0,
+      output_tokens: usage.outputTokens ?? 0,
+      cache_write_tokens: usage.cacheCreationInputTokens ?? 0,
+      cache_read_tokens: usage.cacheReadInputTokens ?? 0,
+      estimated_cost: cost,
+      cache_savings: eff.savedUSD ?? 0,
+      cache_hit_rate: eff.hitRate ?? 0,
+    }
+  }).sort((a, b) => b.estimated_cost - a.estimated_cost)
+
+  // ── Daily cost by model ────────────────────────────────────────────────────
+  // stats-cache.json uses "dailyModelTokens" in newer CC versions; "tokensByDate" in older ones
+  const daily: DailyCost[] = (stats.dailyModelTokens ?? stats.tokensByDate ?? []).map(d => {
+    const costs: Record<string, number> = {}
+    let dayTotal = 0
+    for (const [model, tokens] of Object.entries(d.tokensByModel ?? {})) {
+      const p = getPricing(model)
+      // tokensByDate only has total tokens, approximate as input+output split 50/50
+      const cost = tokens * p.input * 0.5 + tokens * p.output * 0.5
+      costs[model] = cost
+      dayTotal += cost
+    }
+    return { date: d.date, costs, total: dayTotal }
+  })
+
+  // ── Cost by project ────────────────────────────────────────────────────────
+  const projectMap = new Map<string, { cost: number; input: number; output: number }>()
+  for (const s of sessions) {
+    const pp = s.project_path ?? ''
+    const slug = pp
+    const existing = projectMap.get(slug) ?? { cost: 0, input: 0, output: 0 }
+    const cost = estimateTotalCostFromModel('claude-opus-4-6', {
+      inputTokens: s.input_tokens ?? 0,
+      outputTokens: s.output_tokens ?? 0,
+      cacheCreationInputTokens: s.cache_creation_input_tokens ?? 0,
+      cacheReadInputTokens: s.cache_read_input_tokens ?? 0,
+      costUSD: 0,
+      webSearchRequests: 0,
+    })
+    projectMap.set(slug, {
+      cost: existing.cost + cost,
+      input: existing.input + (s.input_tokens ?? 0),
+      output: existing.output + (s.output_tokens ?? 0),
+    })
+  }
+
+  const by_project: ProjectCost[] = [...projectMap.entries()]
+    .map(([slug, data]) => {
+      const projectPath = slug
+      return {
+        slug,
+        display_name: projectDisplayName(projectPath),
+        estimated_cost: data.cost,
+        input_tokens: data.input,
+        output_tokens: data.output,
+      }
+    })
+    .sort((a, b) => b.estimated_cost - a.estimated_cost)
+    .slice(0, 20)
+
+  const result: CostAnalytics = { total_cost: totalCost, total_savings: totalSavings, models, daily, by_project }
+  return NextResponse.json(result)
+}

package/pulse/app/api/export/route.ts

@@ -0,0 +1,77 @@
+import { NextResponse } from 'next/server'
+import { readStatsCache, getSessions, readAllFacets, readHistory } from '@/lib/claude-reader'
+import type { ExportPayload, Facet, SessionMeta } from '@/types/claude'
+
+export const dynamic = 'force-dynamic'
+
+function filterSessionsByDateRange(
+  sessions: SessionMeta[],
+  dateRange?: { from?: string; to?: string }
+) {
+  const fromMs = dateRange?.from ? new Date(dateRange.from).getTime() : null
+  const toMs = dateRange?.to ? new Date(dateRange.to + 'T23:59:59.999Z').getTime() : null
+  return sessions.filter(s => {
+    if (!s.start_time) return true
+    const t = new Date(s.start_time).getTime()
+    if (fromMs !== null && t < fromMs) return false
+    if (toMs !== null && t > toMs) return false
+    return true
+  })
+}
+
+function facetsForSessions(facets: Facet[], sessions: SessionMeta[]) {
+  const sessionIds = new Set(sessions.map(s => s.session_id))
+  return facets.filter(f => sessionIds.has(f.session_id))
+}
+
+/** Preview counts for the export UI (optional date filter via query params). */
+export async function GET(req: Request) {
+  const url = new URL(req.url)
+  const from = url.searchParams.get('from') || undefined
+  const to = url.searchParams.get('to') || undefined
+  const dateRange = from || to ? { from, to } : undefined
+
+  const [stats, sessions, facets, history] = await Promise.all([
+    readStatsCache(),
+    getSessions(),
+    readAllFacets(),
+    readHistory(10_000),
+  ])
+
+  const filteredSessions = filterSessionsByDateRange(sessions, dateRange)
+  const filteredFacets = facetsForSessions(facets, filteredSessions)
+
+  return NextResponse.json({
+    sessionCount: filteredSessions.length,
+    facetCount: filteredFacets.length,
+    historyEntries: history.length,
+    hasStatsCache: stats !== null,
+    totalSessionsIndexed: sessions.length,
+  })
+}
+
+export async function POST(req: Request) {
+  const body = await req.json().catch(() => ({}))
+  const { dateRange } = body as { dateRange?: { from?: string; to?: string } }
+
+  const [stats, sessions, facets, history] = await Promise.all([
+    readStatsCache(),
+    getSessions(),
+    readAllFacets(),
+    readHistory(10_000),
+  ])
+
+  const filteredSessions = filterSessionsByDateRange(sessions, dateRange)
+  const filteredFacets = facetsForSessions(facets, filteredSessions)
+
+  const payload: ExportPayload = {
+    exportedAt: new Date().toISOString(),
+    version: '1.0.0',
+    stats,
+    sessions: filteredSessions,
+    facets: filteredFacets,
+    history,
+  }
+
+  return NextResponse.json(payload)
+}

package/pulse/app/api/history/route.ts

@@ -0,0 +1,11 @@
+import { NextResponse } from 'next/server'
+import { readHistory } from '@/lib/claude-reader'
+
+export const dynamic = 'force-dynamic'
+
+export async function GET(req: Request) {
+  const { searchParams } = new URL(req.url)
+  const limit = Math.min(parseInt(searchParams.get('limit') ?? '200', 10), 10_000)
+  const history = await readHistory(limit)
+  return NextResponse.json({ history })
+}

package/pulse/app/api/import/route.ts

@@ -0,0 +1,31 @@
+import { NextResponse } from 'next/server'
+import { getSessions } from '@/lib/claude-reader'
+import type { ExportPayload, ImportDiff } from '@/types/claude'
+
+export const dynamic = 'force-dynamic'
+
+export async function POST(req: Request) {
+  const payload = await req.json().catch(() => null) as ExportPayload | null
+
+  if (!payload || !payload.sessions) {
+    return NextResponse.json({ error: 'Invalid import payload' }, { status: 400 })
+  }
+
+  const existing = await getSessions()
+  const existingIds = new Set(existing.map(s => s.session_id))
+
+  const sessions_to_add = payload.sessions.filter(s => !existingIds.has(s.session_id))
+
+  const diff: ImportDiff = {
+    total_in_export: payload.sessions.length,
+    already_present: payload.sessions.length - sessions_to_add.length,
+    new_sessions: sessions_to_add.length,
+    sessions_to_add,
+  }
+
+  // Note: actual file writing is intentionally not implemented here
+  // to prevent accidental corruption of ~/.bahulam/ live data.
+  // The import feature shows a diff preview only.
+
+  return NextResponse.json(diff)
+}

package/pulse/app/api/memory/route.ts

@@ -0,0 +1,50 @@
+import { NextResponse } from 'next/server'
+import fs from 'fs/promises'
+import path from 'path'
+import { readMemories } from '@/lib/claude-reader'
+import { bahulamPath } from '@/lib/bahulam-paths'
+
+export const dynamic = 'force-dynamic'
+
+export async function GET() {
+  const memories = await readMemories()
+  return NextResponse.json({ memories })
+}
+
+export async function PATCH(req: Request) {
+  try {
+    const { projectSlug, file, content } = await req.json() as {
+      projectSlug?: string
+      file?: string
+      content?: string
+    }
+
+    if (!projectSlug || !file || typeof content !== 'string') {
+      return NextResponse.json({ error: 'Missing required fields' }, { status: 400 })
+    }
+
+    // Only allow .md files
+    if (!file.endsWith('.md')) {
+      return NextResponse.json({ error: 'Only .md files allowed' }, { status: 400 })
+    }
+
+    // Prevent path traversal — slug and file must be plain names (no slashes or dots)
+    if (/[/\\]/.test(projectSlug) || /[/\\]/.test(file)) {
+      return NextResponse.json({ error: 'Invalid path' }, { status: 400 })
+    }
+
+    const filePath = bahulamPath('projects', projectSlug, 'memory', file)
+
+    // Ensure the resolved path stays within ~/.bahulam/projects/ (or the configured legacy dir).
+    const allowedRoot = bahulamPath('projects')
+    if (!filePath.startsWith(allowedRoot + path.sep)) {
+      return NextResponse.json({ error: 'Path outside allowed directory' }, { status: 403 })
+    }
+
+    await fs.mkdir(path.dirname(filePath), { recursive: true })
+    await fs.writeFile(filePath, content, 'utf-8')
+    return NextResponse.json({ ok: true })
+  } catch (err) {
+    return NextResponse.json({ error: String(err) }, { status: 500 })
+  }
+}

package/pulse/app/api/plans/route.ts

@@ -0,0 +1,9 @@
+import { NextResponse } from 'next/server'
+import { readPlans } from '@/lib/claude-reader'
+
+export const dynamic = 'force-dynamic'
+
+export async function GET() {
+  const plans = await readPlans()
+  return NextResponse.json({ plans })
+}

package/pulse/app/api/projects/[slug]/route.ts

@@ -0,0 +1,96 @@
+import path from 'path'
+import { NextResponse } from 'next/server'
+import { getSessions, listProjectJSONLFiles, readJSONLLines, resolveProjectPath } from '@/lib/claude-reader'
+import { estimateCostFromUsage } from '@/lib/pricing'
+import { projectDisplayName } from '@/lib/decode'
+import type { SessionWithFacet } from '@/types/claude'
+
+export const dynamic = 'force-dynamic'
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type AnyLine = Record<string, any>
+
+export async function GET(
+  _req: Request,
+  { params }: { params: Promise<{ slug: string }> }
+) {
+  const { slug } = await params
+  const projectPath = await resolveProjectPath(slug)
+  const allSessions = await getSessions()
+  let sessions = allSessions.filter(s => s.project_path === projectPath)
+
+  if (sessions.length === 0) {
+    const lastSegment = projectPath.split('/').filter(Boolean).pop() ?? ''
+    sessions = allSessions.filter(s =>
+      s.project_path?.endsWith('/' + lastSegment)
+    )
+  }
+
+  // Gather per-session branch data from JSONL
+  const files = await listProjectJSONLFiles(slug)
+  const branchTurns = new Map<string, number>()
+  const sessionMeta = new Map<string, { slug?: string; version?: string; has_compaction?: boolean }>()
+
+  await Promise.all(
+    files.map(async (f) => {
+      const sessionId = path.basename(f, '.jsonl')
+      const meta: { slug?: string; version?: string; has_compaction?: boolean } = {}
+
+      await readJSONLLines(f, (line: AnyLine) => {
+        if (!meta.slug && line.slug) meta.slug = line.slug
+        if (!meta.version && line.version) meta.version = line.version
+        if (line.type === 'system' && line.subtype === 'compact_boundary') meta.has_compaction = true
+        if (line.gitBranch && line.gitBranch !== 'HEAD') {
+          branchTurns.set(line.gitBranch, (branchTurns.get(line.gitBranch) ?? 0) + 1)
+        }
+      })
+
+      sessionMeta.set(sessionId, meta)
+    })
+  )
+
+  const enrichedSessions: SessionWithFacet[] = sessions.map(s => {
+    const enrich = sessionMeta.get(s.session_id) ?? {}
+    return {
+      ...s,
+      estimated_cost: estimateCostFromUsage('claude-opus-4-6', {
+        input_tokens: s.input_tokens ?? 0,
+        output_tokens: s.output_tokens ?? 0,
+        cache_creation_input_tokens: s.cache_creation_input_tokens ?? 0,
+        cache_read_input_tokens: s.cache_read_input_tokens ?? 0,
+      }),
+      slug: enrich.slug,
+      version: enrich.version,
+      has_compaction: enrich.has_compaction,
+    }
+  })
+
+  // Aggregate tools
+  const toolCounts: Record<string, number> = {}
+  for (const s of sessions) {
+    for (const [t, c] of Object.entries(s.tool_counts ?? {})) {
+      toolCounts[t] = (toolCounts[t] ?? 0) + c
+    }
+  }
+
+  // Cost per session (for chart)
+  const costBySession = enrichedSessions.map(s => ({
+    session_id: s.session_id,
+    start_time: s.start_time,
+    cost: s.estimated_cost,
+    messages: (s.user_message_count ?? 0) + (s.assistant_message_count ?? 0),
+  }))
+
+  const branches = [...branchTurns.entries()]
+    .map(([branch, turns]) => ({ branch, turns }))
+    .sort((a, b) => b.turns - a.turns)
+
+  return NextResponse.json({
+    project_path: projectPath,
+    display_name: projectDisplayName(projectPath),
+    sessions: enrichedSessions.sort((a, b) => b.start_time.localeCompare(a.start_time)),
+    tool_counts: toolCounts,
+    cost_by_session: costBySession,
+    branches,
+  })
+}

package/pulse/app/api/projects/route.ts

@@ -0,0 +1,121 @@
+import { NextResponse } from 'next/server'
+import { getSessions, listProjectSlugs, listProjectJSONLFiles, readJSONLLines, resolveProjectPath } from '@/lib/claude-reader'
+import { estimateCostFromUsage } from '@/lib/pricing'
+import { projectDisplayName } from '@/lib/decode'
+import type { ProjectSummary } from '@/types/claude'
+
+export const dynamic = 'force-dynamic'
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type AnyLine = Record<string, any>
+
+export async function GET() {
+  const [sessions, slugDirs] = await Promise.all([getSessions(), listProjectSlugs()])
+
+  // Build path→slug lookup from actual project directories
+  const pathToSlugMap = new Map<string, string>()
+  await Promise.all(
+    slugDirs.map(async (slug) => {
+      const resolved = await resolveProjectPath(slug)
+      pathToSlugMap.set(resolved, slug)
+    })
+  )
+
+  // Group sessions by project_path
+  const byPath = new Map<string, typeof sessions>()
+  for (const s of sessions) {
+    const pp = s.project_path ?? ''
+    if (!byPath.has(pp)) byPath.set(pp, [])
+    byPath.get(pp)!.push(s)
+  }
+
+  // Gather branches per slug from JSONL
+  const slugBranches = new Map<string, Set<string>>()
+  await Promise.all(
+    slugDirs.map(async (slug) => {
+      const files = await listProjectJSONLFiles(slug)
+      const branches = new Set<string>()
+      await Promise.all(
+        files.map(async (f) => {
+          await readJSONLLines(f, (line: AnyLine) => {
+            if (line.gitBranch && line.gitBranch !== 'HEAD') {
+              branches.add(line.gitBranch)
+            }
+          })
+        })
+      )
+      slugBranches.set(slug, branches)
+    })
+  )
+
+  const projects: ProjectSummary[] = []
+
+  for (const [projectPath, sessionList] of byPath.entries()) {
+    const slug = pathToSlugMap.get(projectPath) ?? projectPath.replace(/\//g, '-')
+
+    const totalMessages = sessionList.reduce(
+      (s, m) => s + (m.user_message_count ?? 0) + (m.assistant_message_count ?? 0), 0
+    )
+    const totalDuration = sessionList.reduce((s, m) => s + (m.duration_minutes ?? 0), 0)
+    const totalLinesAdded = sessionList.reduce((s, m) => s + (m.lines_added ?? 0), 0)
+    const totalLinesRemoved = sessionList.reduce((s, m) => s + (m.lines_removed ?? 0), 0)
+    const totalFilesModified = sessionList.reduce((s, m) => s + (m.files_modified ?? 0), 0)
+    const gitCommits = sessionList.reduce((s, m) => s + (m.git_commits ?? 0), 0)
+    const gitPushes = sessionList.reduce((s, m) => s + (m.git_pushes ?? 0), 0)
+    const inputTokens = sessionList.reduce((s, m) => s + (m.input_tokens ?? 0), 0)
+    const outputTokens = sessionList.reduce((s, m) => s + (m.output_tokens ?? 0), 0)
+
+    const estimatedCost = sessionList.reduce((sum, s) => {
+      return sum + estimateCostFromUsage('claude-opus-4-6', {
+        input_tokens: s.input_tokens ?? 0,
+        output_tokens: s.output_tokens ?? 0,
+        cache_creation_input_tokens: s.cache_creation_input_tokens ?? 0,
+        cache_read_input_tokens: s.cache_read_input_tokens ?? 0,
+      })
+    }, 0)
+
+    const languages: Record<string, number> = {}
+    for (const s of sessionList) {
+      for (const [lang, count] of Object.entries(s.languages ?? {})) {
+        languages[lang] = (languages[lang] ?? 0) + count
+      }
+    }
+
+    const toolCounts: Record<string, number> = {}
+    for (const s of sessionList) {
+      for (const [tool, count] of Object.entries(s.tool_counts ?? {})) {
+        toolCounts[tool] = (toolCounts[tool] ?? 0) + count
+      }
+    }
+
+    const sortedDates = sessionList.map(s => s.start_time).sort()
+
+    projects.push({
+      slug,
+      project_path: projectPath,
+      display_name: projectDisplayName(projectPath),
+      session_count: sessionList.length,
+      total_messages: totalMessages,
+      total_duration_minutes: totalDuration,
+      total_lines_added: totalLinesAdded,
+      total_lines_removed: totalLinesRemoved,
+      total_files_modified: totalFilesModified,
+      git_commits: gitCommits,
+      git_pushes: gitPushes,
+      estimated_cost: estimatedCost,
+      input_tokens: inputTokens,
+      output_tokens: outputTokens,
+      languages,
+      tool_counts: toolCounts,
+      last_active: sortedDates[sortedDates.length - 1] ?? '',
+      first_active: sortedDates[0] ?? '',
+      uses_mcp: sessionList.some(s => s.uses_mcp),
+      uses_task_agent: sessionList.some(s => s.uses_task_agent),
+      branches: [...(slugBranches.get(slug) ?? new Set())].slice(0, 10),
+    })
+  }
+
+  return NextResponse.json({
+    projects: projects.sort((a, b) => b.last_active.localeCompare(a.last_active)),
+  })
+}