@axplusb/kepler 0.0.1 → 1.0.1

package/README.md

@@ -0,0 +1,82 @@
+# @devtarang/orca
+
+Orca — AI coding agent that plans, builds, and ships software from your terminal. Multi-agent orchestration with explore, review, and architect sub-agents.
+
+## Install
+
+```bash
+npm install -g @devtarang/orca
+```
+
+## Quick Start
+
+```bash
+orca login                          # Sign in via browser (GitHub/Google)
+orca                                # Start interactive REPL
+orca "add user authentication"      # Run a single instruction
+```
+
+## Commands
+
+```
+orca                    Start interactive REPL
+orca "instruction"      Run a single instruction and exit
+orca login              Sign in via browser
+orca dashboard          Open Orca Pulse analytics dashboard
+orca sessions           List recent local sessions
+orca stats              Aggregate session stats (tokens, cost, tools)
+orca history            Recent prompt history
+orca version            Show version
+```
+
+## REPL Commands
+
+```
+/help                   Show available commands
+/stats                  Session metrics (tokens, cost, tools)
+/cost                   Detailed cost breakdown by model
+/history                Conversation history
+/clear                  Clear conversation history
+/explore <query>        Spawn read-only codebase explorer
+/review <query>         Spawn code review agent
+/architect <query>      Spawn architecture planning agent
+/safety                 Show safety guardrail status
+/revoke                 Revoke auto-approvals
+/exit                   Exit the REPL
+```
+
+## Keyboard
+
+```
+Esc                     Cancel current execution
+Space                   Pause / resume execution
+Ctrl+C                  Exit
+```
+
+## Configuration
+
+Settings are managed via the web dashboard at [devtarang.ai/dashboard/settings](https://devtarang.ai/dashboard/settings) and synced to the CLI automatically.
+
+- **API Key**: Add your OpenRouter/Anthropic/OpenAI key in Settings
+- **Model**: Choose your preferred model (40+ supported)
+- **Gateway**: Select provider (OpenRouter, Anthropic, OpenAI, Bedrock, Google AI, etc.)
+
+Config directory: `~/.orca/`
+
+## Environment Variables
+
+```
+TARANG_ENV              Set backend (local, development, production)
+ANTHROPIC_API_KEY       Direct Anthropic API key
+OPENROUTER_API_KEY      OpenRouter API key
+ORCA_CONFIG_DIR         Override config directory (default: ~/.orca)
+```
+
+## Links
+
+- [Tarang Platform](https://devtarang.ai)
+- [Documentation](https://devtarang.ai/docs)
+
+## License
+
+MIT

package/package.json

@@ -1,7 +1,39 @@
 {
   "name": "@axplusb/kepler",
-  "version": "0.0.1",
-  "description": "CodeKepler — AI coding agent by axplusb.tech",
-  "main": "index.js",
-  "license": "MIT"
+  "version": "1.0.1",
+  "description": "Kepler — AI coding agent CLI. 30.7% on SWE-bench Lite. Powered by axplusb.tech",
+  "type": "module",
+  "bin": {
+    "kepler": "src/terminal/main.mjs"
+  },
+  "files": [
+    "src/",
+    "pulse/"
+  ],
+  "scripts": {
+    "start": "node src/terminal/main.mjs",
+    "test": "node test/test-sse-client.mjs && node test/test-tool-executor.mjs && node test/test-callback.mjs && node test/test-formatter.mjs && node test/test-terminal-rendering.mjs && node test/test-slash-commands.mjs && node test/test-approval.mjs && node test/test-session-manager.mjs && node test/test-safety.mjs && node test/test-jsonl-writer.mjs && node test/test-analytics.mjs && node test/test-stagnation.mjs"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "kepler",
+    "codekepler",
+    "ai",
+    "coding-agent",
+    "swe-bench",
+    "cli",
+    "code-generation",
+    "deepseek",
+    "axplusb"
+  ],
+  "license": "MIT",
+  "author": "axplusb.tech <hello@axplusb.tech>",
+  "homepage": "https://codekepler.ai",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/axplusb/kepler.git"
+  },
+  "dependencies": {}
 }

package/pulse/app/activity/page.tsx

@@ -0,0 +1,190 @@
+'use client'
+
+import useSWR from 'swr'
+import { TopBar } from '@/components/layout/top-bar'
+import { ActivityHeatmap } from '@/components/overview/activity-heatmap'
+import { PeakHoursChart } from '@/components/overview/peak-hours-chart'
+import { DayOfWeekChart } from '@/components/activity/day-of-week-chart'
+import { UsageOverTimeChart } from '@/components/overview/usage-over-time-chart'
+import type { DailyActivity } from '@/types/claude'
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
+import { Skeleton } from '@/components/ui/skeleton'
+import { Alert, AlertDescription } from '@/components/ui/alert'
+import { AlertTriangle, Flame, CalendarDays, BarChart3, Clock, Zap, TrendingUp, Star } from 'lucide-react'
+
+const fetcher = (url: string) =>
+  fetch(url).then(r => { if (!r.ok) throw new Error(`API error ${r.status}`); return r.json() })
+
+interface ActivityData {
+  daily_activity: DailyActivity[]
+  hour_counts: Array<{ hour: number; count: number }>
+  dow_counts: Array<{ day: string; count: number }>
+  streaks: { current: number; longest: number }
+  most_active_day: string
+  most_active_day_msgs: number
+  total_active_days: number
+}
+
+function StatTile({
+  label,
+  value,
+  sub,
+  icon: Icon,
+  color,
+}: {
+  label: string
+  value: string | number
+  sub: string
+  icon: React.ElementType
+  color: string
+}) {
+  return (
+    <Card className="gap-0">
+      <CardHeader className="pb-2">
+        <CardDescription className="flex items-center gap-2 text-sm font-medium">
+          <Icon className="h-4 w-4 shrink-0 text-muted-foreground" />
+          {label}
+        </CardDescription>
+        <CardTitle className="text-3xl font-bold tabular-nums leading-none" style={{ color }}>
+          {value}
+        </CardTitle>
+      </CardHeader>
+      <CardContent className="pt-0">
+        <p className="text-xs text-muted-foreground">{sub}</p>
+      </CardContent>
+    </Card>
+  )
+}
+
+export default function ActivityPage() {
+  const { data, error, isLoading } = useSWR<ActivityData>('/api/activity', fetcher, { refreshInterval: 5_000 })
+
+  const hourCounts = data
+    ? Object.fromEntries(data.hour_counts.map(h => [String(h.hour), h.count]))
+    : {}
+
+  return (
+    <div className="flex flex-col min-h-screen">
+      <TopBar title="Activity" subtitle="Patterns, streaks, and peak hours" />
+      <div className="w-full space-y-4 p-4 md:p-6">
+
+        {error && (
+          <Alert variant="destructive">
+            <AlertTriangle className="h-4 w-4" />
+            <AlertDescription>Error loading data: {String(error)}</AlertDescription>
+          </Alert>
+        )}
+
+        {isLoading && (
+          <>
+            <div className="grid grid-cols-2 md:grid-cols-4 gap-4">
+              {Array.from({ length: 4 }).map((_, i) => <Skeleton key={i} className="h-28 rounded-xl" />)}
+            </div>
+            <div className="grid grid-cols-1 gap-4 md:grid-cols-2 md:items-stretch">
+              <Skeleton className="h-72 min-h-72 rounded-xl md:min-h-80" />
+              <Skeleton className="h-56 min-h-56 rounded-xl md:min-h-80" />
+            </div>
+            <div className="grid grid-cols-1 gap-4 md:grid-cols-2 md:items-stretch">
+              <Skeleton className="h-64 rounded-xl md:min-h-72" />
+              <Skeleton className="h-56 rounded-xl md:min-h-72" />
+            </div>
+          </>
+        )}
+
+        {data && (
+          <>
+            {/* Stat tiles */}
+            <div className="grid grid-cols-2 md:grid-cols-4 gap-4">
+              <StatTile
+                label="Current Streak"
+                value={data.streaks.current}
+                sub="consecutive days"
+                icon={Flame}
+                color="#f97316"
+              />
+              <StatTile
+                label="Longest Streak"
+                value={data.streaks.longest}
+                sub="personal best"
+                icon={Zap}
+                color="var(--viz-sky)"
+              />
+              <StatTile
+                label="Active Days"
+                value={data.total_active_days}
+                sub="total days with activity"
+                icon={TrendingUp}
+                color="#a78bfa"
+              />
+              <StatTile
+                label="Most Active Day"
+                value={data.most_active_day ? data.most_active_day.slice(5) : '—'}
+                sub={data.most_active_day_msgs ? `${data.most_active_day_msgs.toLocaleString()} messages` : 'no data'}
+                icon={Star}
+                color="#34d399"
+              />
+            </div>
+
+            {/* Row 1: Activity calendar | Peak hours */}
+            <div className="grid grid-cols-1 gap-4 md:grid-cols-2 md:items-stretch">
+              <Card className="flex h-full min-h-0 min-w-0 flex-col gap-2 py-4">
+                <CardHeader className="space-y-1 pb-0">
+                  <CardTitle className="flex items-center gap-2 text-base font-semibold">
+                    <CalendarDays className="h-4 w-4 shrink-0 text-muted-foreground" />
+                    Activity Calendar
+                  </CardTitle>
+                  <CardDescription>GitHub-style contribution heatmap</CardDescription>
+                </CardHeader>
+                <CardContent className="flex flex-1 flex-col pt-3 pb-0">
+                  <ActivityHeatmap data={data.daily_activity} />
+                </CardContent>
+              </Card>
+
+              <Card className="flex h-full min-h-0 min-w-0 flex-col gap-2 py-4">
+                <CardHeader className="space-y-1 pb-0">
+                  <CardTitle className="flex items-center gap-2 text-base font-semibold">
+                    <Clock className="h-4 w-4 shrink-0 text-muted-foreground" />
+                    Peak Hours
+                  </CardTitle>
+                  <CardDescription>Activity by hour of day</CardDescription>
+                </CardHeader>
+                <CardContent className="flex flex-1 flex-col justify-between pt-3 pb-0">
+                  <PeakHoursChart hourCounts={hourCounts} />
+                </CardContent>
+              </Card>
+            </div>
+
+            {/* Row 2: Usage over time | Day of week */}
+            <div className="grid grid-cols-1 gap-4 md:grid-cols-2 md:items-stretch">
+              <Card className="flex h-full min-h-0 min-w-0 flex-col gap-2 py-4">
+                <CardHeader className="space-y-1 pb-0">
+                  <CardTitle className="flex items-center gap-2 text-base font-semibold">
+                    <BarChart3 className="h-4 w-4 shrink-0 text-muted-foreground" />
+                    Usage Over Time
+                  </CardTitle>
+                  <CardDescription>Messages and sessions over the last 90 days</CardDescription>
+                </CardHeader>
+                <CardContent className="flex flex-1 flex-col pt-3 pb-0">
+                  <UsageOverTimeChart data={data.daily_activity} days={90} />
+                </CardContent>
+              </Card>
+
+              <Card className="flex h-full min-h-0 min-w-0 flex-col gap-2 py-4">
+                <CardHeader className="space-y-1 pb-0">
+                  <CardTitle className="flex items-center gap-2 text-base font-semibold">
+                    <CalendarDays className="h-4 w-4 shrink-0 text-muted-foreground" />
+                    Day of Week
+                  </CardTitle>
+                  <CardDescription>Which days you use Orca most</CardDescription>
+                </CardHeader>
+                <CardContent className="flex flex-1 flex-col justify-between pt-3 pb-0">
+                  <DayOfWeekChart data={data.dow_counts} />
+                </CardContent>
+              </Card>
+            </div>
+          </>
+        )}
+      </div>
+    </div>
+  )
+}

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

@@ -0,0 +1,138 @@
+import { NextResponse } from 'next/server'
+import { getSessions, readStatsCache } from '@/lib/claude-reader'
+import type { DailyActivity, SessionMeta } from '@/types/claude'
+
+export const dynamic = 'force-dynamic'
+
+function computeStreaks(dates: Set<string>): { current: number; longest: number } {
+  const sorted = [...dates].sort()
+  if (sorted.length === 0) return { current: 0, longest: 0 }
+
+  let longest = 1
+  let streak = 1
+  for (let i = 1; i < sorted.length; i++) {
+    const prev = new Date(sorted[i - 1])
+    const curr = new Date(sorted[i])
+    const diff = (curr.getTime() - prev.getTime()) / 86_400_000
+    if (diff === 1) {
+      streak++
+      if (streak > longest) longest = streak
+    } else {
+      streak = 1
+    }
+  }
+
+  // Current streak (from today backwards)
+  const today = new Date().toISOString().slice(0, 10)
+  let current = 0
+  const d = new Date(today)
+  while (dates.has(d.toISOString().slice(0, 10))) {
+    current++
+    d.setDate(d.getDate() - 1)
+  }
+
+  return { current, longest }
+}
+
+function computeDailyActivityFromSessions(sessions: SessionMeta[]): DailyActivity[] {
+  const byDate = new Map<string, { messages: number; sessions: number; tools: number }>()
+
+  for (const s of sessions) {
+    if (!s.start_time) continue
+    const date = s.start_time.slice(0, 10)
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) continue
+
+    const existing = byDate.get(date) ?? { messages: 0, sessions: 0, tools: 0 }
+    existing.messages += (s.user_message_count ?? 0) + (s.assistant_message_count ?? 0)
+    existing.sessions += 1
+    existing.tools += Object.values(s.tool_counts ?? {}).reduce((sum, count) => sum + count, 0)
+    byDate.set(date, existing)
+  }
+
+  return Array.from(byDate.entries())
+    .map(([date, { messages, sessions: sessionCount, tools }]) => ({
+      date,
+      messageCount: messages,
+      sessionCount,
+      toolCallCount: tools,
+    }))
+    .sort((a, b) => a.date.localeCompare(b.date))
+}
+
+function mergeDailyActivity(fromStats: DailyActivity[], fromSessions: DailyActivity[]): DailyActivity[] {
+  const byDate = new Map<string, DailyActivity>()
+  for (const d of fromStats) byDate.set(d.date, d)
+  for (const d of fromSessions) byDate.set(d.date, d)
+  return Array.from(byDate.values()).sort((a, b) => a.date.localeCompare(b.date))
+}
+
+function computeHourCounts(sessions: SessionMeta[]): Array<{ hour: number; count: number }> {
+  const hourCounts = Array.from({ length: 24 }, () => 0)
+
+  for (const s of sessions) {
+    if (s.user_message_timestamps?.length) {
+      for (const ts of s.user_message_timestamps) {
+        const d = new Date(ts)
+        if (!isNaN(d.getTime())) hourCounts[d.getHours()]++
+      }
+      continue
+    }
+
+    if (s.message_hours?.length) {
+      for (const hour of s.message_hours) {
+        if (Number.isInteger(hour) && hour >= 0 && hour < 24) hourCounts[hour]++
+      }
+      continue
+    }
+
+    const d = new Date(s.start_time)
+    if (!isNaN(d.getTime())) hourCounts[d.getHours()]++
+  }
+
+  return hourCounts.map((count, hour) => ({ hour, count }))
+}
+
+export async function GET() {
+  const [stats, sessions] = await Promise.all([readStatsCache(), getSessions()])
+  const dailyFromSessions = computeDailyActivityFromSessions(sessions)
+  const dailyActivity = stats
+    ? mergeDailyActivity(stats.dailyActivity ?? [], dailyFromSessions)
+    : dailyFromSessions
+
+  // Day-of-week counts from session timestamps
+  const dowCounts: number[] = [0, 0, 0, 0, 0, 0, 0] // Sun=0..Sat=6
+  const activeDates = new Set<string>()
+
+  for (const s of sessions) {
+    if (!s.start_time) continue
+    const d = new Date(s.start_time)
+    if (isNaN(d.getTime())) continue
+    dowCounts[d.getDay()]++
+    activeDates.add(s.start_time.slice(0, 10))
+  }
+
+  const streaks = computeStreaks(activeDates)
+
+  // Most active day
+  let mostActiveDay = ''
+  let mostActiveMsgs = 0
+  for (const da of dailyActivity) {
+    if (da.messageCount > mostActiveMsgs) {
+      mostActiveMsgs = da.messageCount
+      mostActiveDay = da.date
+    }
+  }
+
+  return NextResponse.json({
+    daily_activity: dailyActivity,
+    hour_counts: computeHourCounts(sessions),
+    dow_counts: dowCounts.map((count, i) => ({
+      day: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'][i],
+      count,
+    })),
+    streaks,
+    most_active_day: mostActiveDay,
+    most_active_day_msgs: mostActiveMsgs,
+    total_active_days: activeDates.size,
+  })
+}

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 ~/.orca/ live data.
+  // The import feature shows a diff preview only.
+
+  return NextResponse.json(diff)
+}