@tokentop/ttop 0.6.0 → 0.7.0

package/README.md

@@ -1,5 +1,4 @@
- > [!CAUTION]
-> **tokentop is under active development and not yet ready for general use.** APIs and configuration may change without notice. If you're interested, star the repo and check back soon.
+ > **Early release** — tokentop is functional and actively developed. Please [report issues](https://github.com/tokentopapp/tokentop/issues)!
 
 <div align="center">
 
@@ -18,7 +17,9 @@ Real-time terminal monitoring of LLM token usage and spending across providers a
 [![Bun](https://img.shields.io/badge/Bun-runtime-f9f1e1?style=flat-square&logo=bun&logoColor=black)](https://bun.sh)
 [![Visitors](https://api.visitorbadge.io/api/visitors?path=https%3A%2F%2Fgithub.com%2Ftokentopapp%2Ftokentop&labelColor=%23697689&countColor=%23ba68c8&style=flat-square)](https://visitorbadge.io/status?path=https://github.com/tokentopapp/tokentop)
 
-[Features](#features) · [Install](#installation) · [Quick Start](#quick-start) · [Keyboard Shortcuts](#keyboard-shortcuts) · [Configuration](#configuration) · [Plugins](#plugin-system)
+[Features](#features) · [Install](#installation) · [Quick Start](#quick-start) · [Agents](#agents) · [Plugins](#plugin-system) · [Docs](https://tokentop.app/docs/getting-started/)
+
+**[tokentop.app](https://tokentop.app)**
 
 </div>
 
@@ -45,7 +46,7 @@ That's tokentop.
 
 - **Real-time dashboard** — Live token counts, costs, burn rate, and activity sparklines
 - **11 providers** — Anthropic, OpenAI, Google Gemini, GitHub Copilot, Codex, Perplexity, Antigravity, MiniMax, Zai, OpenCode Zen, Chutes
-- **Session tracking** — See every coding agent session with model, tokens, cost, and duration. Built-in support for Claude Code, OpenCode, Cursor, and Copilot CLI
+- **7 coding agents** — Claude Code, OpenCode, Cursor, Copilot CLI, Gemini CLI, Antigravity, and Windsurf. See every session with model, tokens, cost, and duration
 - **Budget guardrails** — Daily, weekly, and monthly limits with visual warnings at limit percentages you set
 - **Smart sidebar** — Adaptive panel that breaks down spending by model, project, or agent
 - **Efficiency insights** — Cache leverage, output verbosity, and cost-per-request analysis to help you spend less
@@ -53,11 +54,11 @@ That's tokentop.
 - **Projects view** — See which codebase is costing you the most
 - **Provider limits** — Visual gauges showing how close you are to rate limits
 - **Live pricing** — Fetches current model pricing from [models.dev](https://models.dev) with local caching
-- **15 built-in themes** — Dark: Tokyo Night (default), Dracula, Nord, Catppuccin Mocha, Gruvbox Dark, One Dark, Rosé Pine, Kanagawa, OpenCode, Claude Code · Light: Catppuccin Latte, Gruvbox Light, GitHub Light, Solarized Light, Rosé Pine Dawn
+- **[15 built-in themes](https://tokentop.app/docs/themes/built-in/)** — Tokyo Night, Dracula, Nord, Catppuccin, Gruvbox, Rosé Pine, Kanagawa, and more. Dark and light variants. Create your own with the [theme plugin API](https://tokentop.app/docs/themes/custom-themes/)
 - **Plugin system** — Extend with custom providers, agents, themes, and notifications
 - **Responsive layout** — Adapts to any terminal size; sidebar, KPI strip, header, and tables all reflow automatically from ultrawide to laptop-width
 - **Demo mode** — Explore the UI with synthetic data, no API keys needed
-- **Zero config** — Auto-discovers credentials from Claude Code, OpenCode, Cursor, Copilot CLI, environment variables, and CLI auth files
+- **Zero config** — Auto-discovers credentials from Claude Code, OpenCode, Cursor, Copilot CLI, Gemini CLI, environment variables, and CLI auth files
 
 ## Installation
 
@@ -141,9 +142,21 @@ tokentop has 4 main views, switchable with `1`–`4`:
 | `3` | **Trends** | ASCII step charts of cost over 7/30/90 days |
 | `4` | **Projects** | Cost and token breakdown by local project/repo |
 
-<!-- TODO: Add VHS recordings of each view
-> _Screenshots coming soon_
--->
+## Agents
+
+tokentop tracks sessions from 7 coding agents. Each agent is a standalone plugin — built-in agents ship with the app, community agents install from npm.
+
+| Agent | What it tracks | Plugin |
+|-------|---------------|--------|
+| [Claude Code](https://tokentop.app/docs/agents/claude-code/) | Sessions, OAuth tokens, multi-provider usage | [`@tokentop/agent-claude-code`](https://github.com/tokentopapp/agent-claude-code) |
+| [OpenCode](https://tokentop.app/docs/agents/opencode/) | Sessions, OAuth credentials, multi-provider support | [`@tokentop/agent-opencode`](https://github.com/tokentopapp/agent-opencode) |
+| [Cursor](https://tokentop.app/docs/agents/cursor/) | Sessions, CSV server log enrichment | [`@tokentop/agent-cursor`](https://github.com/tokentopapp/agent-cursor) |
+| [Copilot CLI](https://tokentop.app/docs/agents/copilot-cli/) | Sessions, GitHub token auth | [`@tokentop/agent-copilot-cli`](https://github.com/tokentopapp/agent-copilot-cli) |
+| [Gemini CLI](https://tokentop.app/docs/agents/gemini-cli/) | Sessions, Google OAuth | [`@tokentop/agent-gemini`](https://github.com/tokentopapp/agent-gemini) |
+| [Antigravity](https://tokentop.app/docs/agents/antigravity/) | Sessions, Google OAuth | [`@tokentop/agent-gemini`](https://github.com/tokentopapp/agent-gemini) |
+| [Windsurf](https://tokentop.app/docs/agents/windsurf/) | Sessions, Codeium auth | [`@tokentop/agent-windsurf`](https://github.com/tokentopapp/agent-windsurf) |
+
+All agents are auto-discovered — if you have the tool installed, tokentop finds it. See the [agent docs](https://tokentop.app/docs/agents/) for details.
 
 ## Keyboard Shortcuts
 
@@ -219,7 +232,7 @@ tokentop is built on a plugin architecture with four extension points:
 
 All plugins run in a **permission sandbox** — they must declare network, filesystem, and environment access upfront. Anyone can publish community plugins to npm — no org membership needed.
 
-See the [Plugin Guide](docs/plugins.md) for installation, configuration, and development details.
+See the [Plugin Guide](https://tokentop.app/docs/plugins/overview/) for installation, configuration, and development details.
 
 ## How It Works
 
@@ -232,6 +245,15 @@ Costs are calculated from token counts and live pricing data from [models.dev](h
 
 All data is stored in a **local SQLite database**. Nothing is sent anywhere. No telemetry, no analytics, no network calls except to the provider APIs you've already authenticated with.
 
+## Alternatives
+
+| Tool | Approach | Tokentop Difference |
+|------|----------|---------------------|
+| Provider dashboards | Web, hours behind | Real-time, in terminal |
+| [tokentap](https://github.com/nicholasgasior/tokentap) | MitM proxy (abandoned) | Native API polling, no proxy |
+| [toktop](https://github.com/jnsahaj/toktop) | Rust TUI, 2 providers | 11 providers, 7 agents, plugins |
+| [sniffly](https://github.com/chiphuyen/sniffly) | Python dashboard | Terminal-native, multi-agent |
+
 ## Development
 
 ```bash
@@ -239,7 +261,7 @@ bun install          # Install dependencies
 bun run dev          # Dev mode with hot reload
 bun test             # Run tests
 bun run typecheck    # TypeScript check
-bun run lint         # ESLint
+bun run lint         # Biome
 ```
 
 ### Demo mode for development

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tokentop/ttop",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Real-time AI token usage monitor - htop for your API costs",
   "author": "Nigel Bazzeghin <nbazzeghin@gmail.com>",
   "license": "MIT",
@@ -34,14 +34,14 @@
     "analytics": "bun .opencode/skills/analytics/scripts/analytics.ts"
   },
   "dependencies": {
-    "@opentui/core": "0.1.86",
-    "@opentui/react": "0.1.86",
+    "@opentui/core": "0.1.98",
+    "@opentui/react": "0.1.98",
     "@tokentop/agent-claude-code": "^1.1.0",
     "@tokentop/agent-copilot-cli": "^1.0.0",
     "@tokentop/agent-cursor": "^1.2.0",
     "@tokentop/agent-gemini": "^1.0.0",
     "@tokentop/agent-opencode": "^1.0.0",
-    "@tokentop/plugin-sdk": "^1.4.0",
+    "@tokentop/plugin-sdk": "^1.5.0",
     "react": "^19.0.0",
     "react-devtools-core": "^7.0.1",
     "zod": "^4.0.0"

package/src/agents/aggregator.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, test } from "bun:test";
+import type { SessionUsageData } from "@tokentop/plugin-sdk";
 import { aggregateSessionUsage, deduplicateAggregates } from "./aggregator.ts";
 import type { AgentSessionAggregate } from "./types.ts";
 
@@ -201,7 +202,40 @@ describe("deduplicateAggregates", () => {
 // aggregateSessionUsage — basic sanity
 // ---------------------------------------------------------------------------
 describe("aggregateSessionUsage", () => {
-  const NOW = Date.now();
+  const NOW = new Date(2026, 3, 15, 12, 0, 0, 0).getTime();
+
+  function makeUsageRow(
+    overrides: Partial<SessionUsageData> &
+      Pick<SessionUsageData, "sessionId" | "tokens" | "timestamp">,
+  ): SessionUsageData {
+    return {
+      providerId: "anthropic",
+      modelId: "claude-sonnet-4",
+      ...overrides,
+    };
+  }
+
+  function aggregateSingleSession(rows: SessionUsageData[]) {
+    const result = aggregateSessionUsage({
+      agentId: "test",
+      agentName: "Test",
+      now: NOW,
+      rows,
+    });
+
+    expect(result).toHaveLength(1);
+    return result[0]!;
+  }
+
+  function getOnlyStream(rows: SessionUsageData[]) {
+    const session = aggregateSingleSession(rows);
+    expect(session.streams).toHaveLength(1);
+    return {
+      session,
+      stream: session.streams[0]!,
+      windowed: session._streamWindowedTokens?.get("anthropic::claude-sonnet-4"),
+    };
+  }
 
   test("groups rows by sessionId", () => {
     const result = aggregateSessionUsage({
@@ -303,4 +337,238 @@ describe("aggregateSessionUsage", () => {
     expect(active!.status).toBe("active");
     expect(idle!.status).toBe("idle");
   });
+
+  test("keeps all requests in the base bucket when every request is at or under 200K context", () => {
+    const { stream, session, windowed } = getOnlyStream([
+      makeUsageRow({ sessionId: "s1", timestamp: NOW, tokens: { input: 120_000, output: 1_000 } }),
+      makeUsageRow({
+        sessionId: "s1",
+        timestamp: NOW - 1_000,
+        tokens: { input: 80_000, output: 2_000 },
+      }),
+      makeUsageRow({
+        sessionId: "s1",
+        timestamp: NOW - 2_000,
+        tokens: { input: 200_000, output: 3_000 },
+      }),
+    ]);
+
+    expect(stream.tokens).toEqual({ input: 400_000, output: 6_000 });
+    expect(stream.longContextTokens).toBeUndefined();
+    expect(stream.longContextRequestCount).toBeUndefined();
+    expect(stream.hasLongContext).toBeUndefined();
+    expect(session.totals).toEqual({ input: 400_000, output: 6_000 });
+    expect(windowed).toEqual({
+      dayTokens: 406_000,
+      weekTokens: 406_000,
+      monthTokens: 406_000,
+      totalTokens: 406_000,
+    });
+  });
+
+  test("moves all requests into long-context bucket when every request exceeds 200K context", () => {
+    const { stream, windowed } = getOnlyStream([
+      makeUsageRow({
+        sessionId: "s1",
+        timestamp: NOW,
+        tokens: { input: 210_000, output: 1_000, cacheRead: 5_000, cacheWrite: 2_000 },
+      }),
+      makeUsageRow({
+        sessionId: "s1",
+        timestamp: NOW - 1_000,
+        tokens: { input: 220_000, output: 2_000, cacheRead: 10_000, cacheWrite: 4_000 },
+      }),
+    ]);
+
+    expect(stream.tokens).toEqual({ input: 0, output: 0 });
+    expect(stream.requestCount).toBe(2);
+    expect(stream.longContextTokens).toEqual({
+      input: 430_000,
+      output: 3_000,
+      cacheRead: 15_000,
+      cacheWrite: 6_000,
+    });
+    expect(stream.longContextRequestCount).toBe(2);
+    expect(stream.hasLongContext).toBe(true);
+    expect(windowed).toEqual({
+      dayTokens: 454_000,
+      weekTokens: 454_000,
+      monthTokens: 454_000,
+      totalTokens: 454_000,
+      longContextDayTokens: 454_000,
+      longContextWeekTokens: 454_000,
+      longContextMonthTokens: 454_000,
+      longContextTotalTokens: 454_000,
+    });
+  });
+
+  test("splits mixed requests into base and long-context buckets", () => {
+    const { stream } = getOnlyStream([
+      makeUsageRow({ sessionId: "s1", timestamp: NOW, tokens: { input: 100_000, output: 1_000 } }),
+      makeUsageRow({
+        sessionId: "s1",
+        timestamp: NOW - 1_000,
+        tokens: { input: 120_000, output: 2_000 },
+      }),
+      makeUsageRow({
+        sessionId: "s1",
+        timestamp: NOW - 2_000,
+        tokens: { input: 180_000, output: 3_000 },
+      }),
+      makeUsageRow({
+        sessionId: "s1",
+        timestamp: NOW - 3_000,
+        tokens: { input: 210_000, output: 4_000 },
+      }),
+      makeUsageRow({
+        sessionId: "s1",
+        timestamp: NOW - 4_000,
+        tokens: { input: 190_000, output: 5_000, cacheRead: 20_000 },
+      }),
+    ]);
+
+    expect(stream.tokens).toEqual({ input: 400_000, output: 6_000 });
+    expect(stream.longContextTokens).toEqual({ input: 400_000, output: 9_000, cacheRead: 20_000 });
+    expect(stream.requestCount).toBe(5);
+    expect(stream.longContextRequestCount).toBe(2);
+    expect(stream.hasLongContext).toBe(true);
+  });
+
+  test("treats exactly 200,000 context tokens as base bucket", () => {
+    const { stream, windowed } = getOnlyStream([
+      makeUsageRow({
+        sessionId: "s1",
+        timestamp: NOW,
+        tokens: { input: 150_000, output: 7_000, cacheRead: 30_000, cacheWrite: 20_000 },
+      }),
+    ]);
+
+    expect(stream.tokens).toEqual({
+      input: 150_000,
+      output: 7_000,
+      cacheRead: 30_000,
+      cacheWrite: 20_000,
+    });
+    expect(stream.longContextTokens).toBeUndefined();
+    expect(stream.longContextRequestCount).toBeUndefined();
+    expect(stream.hasLongContext).toBeUndefined();
+    expect(windowed?.longContextTotalTokens).toBeUndefined();
+  });
+
+  test("moves 200,001 context tokens into long-context bucket", () => {
+    const { stream, windowed } = getOnlyStream([
+      makeUsageRow({
+        sessionId: "s1",
+        timestamp: NOW,
+        tokens: { input: 150_000, output: 7_000, cacheRead: 30_001, cacheWrite: 20_000 },
+      }),
+    ]);
+
+    expect(stream.tokens).toEqual({ input: 0, output: 0 });
+    expect(stream.longContextTokens).toEqual({
+      input: 150_000,
+      output: 7_000,
+      cacheRead: 30_001,
+      cacheWrite: 20_000,
+    });
+    expect(stream.longContextRequestCount).toBe(1);
+    expect(stream.hasLongContext).toBe(true);
+    expect(windowed?.longContextTotalTokens).toBe(207_001);
+  });
+
+  test("uses cache tokens when cache-only growth crosses the threshold", () => {
+    const { stream } = getOnlyStream([
+      makeUsageRow({
+        sessionId: "s1",
+        timestamp: NOW,
+        tokens: { input: 50_000, output: 1_000, cacheRead: 180_000 },
+      }),
+    ]);
+
+    expect(stream.tokens).toEqual({ input: 0, output: 0 });
+    expect(stream.longContextTokens).toEqual({ input: 50_000, output: 1_000, cacheRead: 180_000 });
+    expect(stream.longContextRequestCount).toBe(1);
+  });
+
+  test("treats missing cacheRead and cacheWrite as zero when computing context size", () => {
+    const { stream } = getOnlyStream([
+      makeUsageRow({ sessionId: "s1", timestamp: NOW, tokens: { input: 199_999, output: 1_000 } }),
+      makeUsageRow({
+        sessionId: "s1",
+        timestamp: NOW - 1_000,
+        tokens: { input: 200_001, output: 2_000 },
+      }),
+    ]);
+
+    expect(stream.tokens).toEqual({ input: 199_999, output: 1_000 });
+    expect(stream.longContextTokens).toEqual({ input: 200_001, output: 2_000 });
+    expect(stream.longContextRequestCount).toBe(1);
+  });
+
+  test("splits windowed tokens correctly between total and long-context buckets", () => {
+    const { windowed } = getOnlyStream([
+      makeUsageRow({
+        sessionId: "s1",
+        timestamp: NOW - 1_000,
+        tokens: { input: 210_000, output: 1_000 },
+      }),
+      makeUsageRow({
+        sessionId: "s1",
+        timestamp: NOW - 60 * 60 * 1000,
+        tokens: { input: 90_000, output: 2_000 },
+      }),
+      makeUsageRow({
+        sessionId: "s1",
+        timestamp: NOW - 2 * 24 * 60 * 60 * 1000,
+        tokens: { input: 205_000, output: 3_000 },
+      }),
+      makeUsageRow({
+        sessionId: "s1",
+        timestamp: NOW - 10 * 24 * 60 * 60 * 1000,
+        tokens: { input: 80_000, output: 4_000 },
+      }),
+      makeUsageRow({
+        sessionId: "s1",
+        timestamp: new Date(
+          new Date(NOW).getFullYear(),
+          new Date(NOW).getMonth() - 1,
+          15,
+        ).getTime(),
+        tokens: { input: 220_000, output: 5_000 },
+      }),
+    ]);
+
+    expect(windowed).toEqual({
+      dayTokens: 303_000,
+      weekTokens: 511_000,
+      monthTokens: 595_000,
+      totalTokens: 820_000,
+      longContextDayTokens: 211_000,
+      longContextWeekTokens: 419_000,
+      longContextMonthTokens: 419_000,
+      longContextTotalTokens: 644_000,
+    });
+  });
+
+  test("does not produce division-by-zero or NaN artifacts when every request is long-context", () => {
+    const { stream, session, windowed } = getOnlyStream([
+      makeUsageRow({ sessionId: "s1", timestamp: NOW, tokens: { input: 300_000, output: 5_000 } }),
+      makeUsageRow({
+        sessionId: "s1",
+        timestamp: NOW - 1_000,
+        tokens: { input: 250_000, output: 6_000 },
+      }),
+    ]);
+
+    expect(stream.tokens).toEqual({ input: 0, output: 0 });
+    expect(stream.longContextTokens).toEqual({ input: 550_000, output: 11_000 });
+    expect(stream.longContextRequestCount).toBe(2);
+    expect(stream.hasLongContext).toBe(true);
+    expect(Number.isNaN(stream.tokens.input)).toBe(false);
+    expect(Number.isNaN(stream.tokens.output)).toBe(false);
+    expect(Number.isNaN(session.totals.input)).toBe(false);
+    expect(Number.isNaN(session.totals.output)).toBe(false);
+    expect(Number.isNaN(windowed!.totalTokens)).toBe(false);
+    expect(Number.isNaN(windowed!.longContextTotalTokens!)).toBe(false);
+  });
 });

package/src/agents/aggregator.ts

@@ -1,4 +1,5 @@
 import type { SessionUsageData } from "@tokentop/plugin-sdk";
+import { LONG_CONTEXT_THRESHOLD } from "../pricing/estimator.ts";
 import {
   type AgentId,
   type AgentName,
@@ -64,9 +65,35 @@ interface StreamAccumulator {
   key: StreamKey;
   tokens: TokenCounts;
   requestCount: number;
+  longContextTokens?: TokenCounts;
+  longContextRequestCount?: number;
   windowed: StreamWindowedTokens;
 }
 
+function zeroTokens(): TokenCounts {
+  return { input: 0, output: 0 };
+}
+
+function normalizeTokens(tokens: TokenCounts): TokenCounts {
+  const normalized: TokenCounts = {
+    input: tokens.input,
+    output: tokens.output,
+  };
+
+  const cacheRead = tokens.cacheRead ?? 0;
+  const cacheWrite = tokens.cacheWrite ?? 0;
+
+  if (cacheRead > 0) normalized.cacheRead = cacheRead;
+  if (cacheWrite > 0) normalized.cacheWrite = cacheWrite;
+
+  return normalized;
+}
+
+function getContextSize(tokens: TokenCounts): number {
+  // contextSize = input + cacheRead + cacheWrite — the full prompt context sent to the model
+  return tokens.input + (tokens.cacheRead ?? 0) + (tokens.cacheWrite ?? 0);
+}
+
 export function aggregateSessionUsage(options: AggregateOptions): AgentSessionAggregate[] {
   const {
     agentId,
@@ -134,21 +161,52 @@ export function aggregateSessionUsage(options: AggregateOptions): AgentSessionAg
     if (!stream) {
       stream = {
         key: streamKey,
-        tokens: { input: 0, output: 0 },
+        tokens: zeroTokens(),
         requestCount: 0,
         windowed: { dayTokens: 0, weekTokens: 0, monthTokens: 0, totalTokens: 0 },
       };
       session.streamMap.set(streamKeyStr, stream);
     }
 
-    stream.tokens = sumTokens(stream.tokens, row.tokens);
+    const contextSize = getContextSize(row.tokens);
+    const bucketTokens = normalizeTokens(row.tokens);
+
+    if (contextSize > LONG_CONTEXT_THRESHOLD) {
+      stream.longContextTokens = sumTokens(stream.longContextTokens ?? zeroTokens(), bucketTokens);
+      stream.longContextRequestCount = (stream.longContextRequestCount ?? 0) + 1;
+    } else {
+      stream.tokens = sumTokens(stream.tokens, bucketTokens);
+    }
+
     stream.requestCount += 1;
 
     const msgTokens = totalTokenCount(row.tokens);
     stream.windowed.totalTokens += msgTokens;
-    if (row.timestamp >= startOfDay) stream.windowed.dayTokens += msgTokens;
-    if (row.timestamp >= startOfWeek) stream.windowed.weekTokens += msgTokens;
-    if (row.timestamp >= startOfMonth) stream.windowed.monthTokens += msgTokens;
+    if (contextSize > LONG_CONTEXT_THRESHOLD) {
+      stream.windowed.longContextTotalTokens =
+        (stream.windowed.longContextTotalTokens ?? 0) + msgTokens;
+    }
+    if (row.timestamp >= startOfDay) {
+      stream.windowed.dayTokens += msgTokens;
+      if (contextSize > LONG_CONTEXT_THRESHOLD) {
+        stream.windowed.longContextDayTokens =
+          (stream.windowed.longContextDayTokens ?? 0) + msgTokens;
+      }
+    }
+    if (row.timestamp >= startOfWeek) {
+      stream.windowed.weekTokens += msgTokens;
+      if (contextSize > LONG_CONTEXT_THRESHOLD) {
+        stream.windowed.longContextWeekTokens =
+          (stream.windowed.longContextWeekTokens ?? 0) + msgTokens;
+      }
+    }
+    if (row.timestamp >= startOfMonth) {
+      stream.windowed.monthTokens += msgTokens;
+      if (contextSize > LONG_CONTEXT_THRESHOLD) {
+        stream.windowed.longContextMonthTokens =
+          (stream.windowed.longContextMonthTokens ?? 0) + msgTokens;
+      }
+    }
     if ((row.metadata?.isEstimated as boolean) === true) {
       session.hasEstimated = true;
     }
@@ -168,13 +226,24 @@ export function aggregateSessionUsage(options: AggregateOptions): AgentSessionAg
     let totalRequestCount = 0;
 
     for (const [streamKeyStr, stream] of session.streamMap) {
-      streams.push({
+      const totalStreamTokens = sumTokens(stream.tokens, stream.longContextTokens ?? zeroTokens());
+      const streamAggregate: AgentSessionStream = {
         providerId: stream.key.providerId,
         modelId: stream.key.modelId,
         tokens: stream.tokens,
         requestCount: stream.requestCount,
-      });
-      totals = sumTokens(totals, stream.tokens);
+      };
+
+      if (stream.longContextTokens) {
+        streamAggregate.longContextTokens = stream.longContextTokens;
+      }
+      if (stream.longContextRequestCount) {
+        streamAggregate.longContextRequestCount = stream.longContextRequestCount;
+        streamAggregate.hasLongContext = true;
+      }
+
+      streams.push(streamAggregate);
+      totals = sumTokens(totals, totalStreamTokens);
       totalRequestCount += stream.requestCount;
       streamWindowedTokens.set(streamKeyStr, stream.windowed);
     }
@@ -236,3 +305,122 @@ export function deduplicateAggregates(
   }
   return Array.from(deduped.values());
 }
+
+export interface CrossAgentShadowMetadata {
+  kind: "cross-agent-shadow";
+  shadowOfAgentId: string;
+  shadowOfSessionId: string;
+  reason: "proxy-sdk-session-id" | "heuristic";
+}
+
+export function isCrossAgentShadow(session: AgentSessionAggregate): boolean {
+  const dedup = session.metadata?.dedup as { kind?: string } | undefined;
+  return dedup?.kind === "cross-agent-shadow";
+}
+
+export function selectEffectiveSessions(
+  sessions: AgentSessionAggregate[],
+): AgentSessionAggregate[] {
+  return sessions.filter((s) => !isCrossAgentShadow(s));
+}
+
+const CROSS_AGENT_TIMESTAMP_TOLERANCE_MS = 120_000;
+
+function normalizeProjectPath(p: string | undefined): string {
+  if (!p) return "";
+  return p.replace(/\/+$/, "");
+}
+
+export function markCrossAgentShadows(
+  aggregates: AgentSessionAggregate[],
+): AgentSessionAggregate[] {
+  const opencodeSessions: AgentSessionAggregate[] = [];
+  const claudeCodeById = new Map<string, AgentSessionAggregate>();
+  const claudeCodeByPath = new Map<string, AgentSessionAggregate[]>();
+  const ccStreamKeys = new Map<string, string[]>();
+
+  for (const agg of aggregates) {
+    if (agg.agentId === "opencode") {
+      opencodeSessions.push(agg);
+    } else if (agg.agentId === "claude-code") {
+      claudeCodeById.set(agg.sessionId, agg);
+      const path = normalizeProjectPath(agg.projectPath);
+      if (path) {
+        const bucket = claudeCodeByPath.get(path);
+        if (bucket) bucket.push(agg);
+        else claudeCodeByPath.set(path, [agg]);
+      }
+      const keys: string[] = new Array(agg.streams.length);
+      for (let i = 0; i < agg.streams.length; i++) {
+        const s = agg.streams[i]!;
+        keys[i] = `${s.providerId}::${s.modelId}`;
+      }
+      ccStreamKeys.set(agg.sessionId, keys);
+    }
+  }
+
+  if (opencodeSessions.length === 0 || claudeCodeById.size === 0) {
+    return aggregates;
+  }
+
+  const claimed = new Set<string>();
+
+  for (const oc of opencodeSessions) {
+    const proxy = oc.metadata?.proxy as { sdkSessionId?: string } | undefined;
+    if (!proxy?.sdkSessionId) continue;
+    const cc = claudeCodeById.get(proxy.sdkSessionId);
+    if (!cc || claimed.has(cc.sessionId)) continue;
+    cc.metadata = {
+      ...cc.metadata,
+      dedup: {
+        kind: "cross-agent-shadow",
+        shadowOfAgentId: "opencode",
+        shadowOfSessionId: oc.sessionId,
+        reason: "proxy-sdk-session-id",
+      } satisfies CrossAgentShadowMetadata,
+    };
+    claimed.add(cc.sessionId);
+  }
+
+  for (const oc of opencodeSessions) {
+    if (oc.streams.length === 0) continue;
+    const ocPath = normalizeProjectPath(oc.projectPath);
+    if (!ocPath) continue;
+    const bucket = claudeCodeByPath.get(ocPath);
+    if (!bucket) continue;
+
+    const ocKeys = new Set<string>();
+    for (const s of oc.streams) ocKeys.add(`${s.providerId}::${s.modelId}`);
+
+    for (const cc of bucket) {
+      if (claimed.has(cc.sessionId)) continue;
+      if (Math.abs(oc.lastActivityAt - cc.lastActivityAt) > CROSS_AGENT_TIMESTAMP_TOLERANCE_MS) {
+        continue;
+      }
+      const ccKeys = ccStreamKeys.get(cc.sessionId);
+      if (!ccKeys || ccKeys.length === 0) continue;
+      let overlap = false;
+      for (const k of ccKeys) {
+        if (ocKeys.has(k)) {
+          overlap = true;
+          break;
+        }
+      }
+      if (!overlap) continue;
+
+      cc.metadata = {
+        ...cc.metadata,
+        dedup: {
+          kind: "cross-agent-shadow",
+          shadowOfAgentId: "opencode",
+          shadowOfSessionId: oc.sessionId,
+          reason: "heuristic",
+        } satisfies CrossAgentShadowMetadata,
+      };
+      claimed.add(cc.sessionId);
+      break;
+    }
+  }
+
+  return aggregates;
+}