claude-cup 0.2.1 → 0.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-cup",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "Claude Jar v2 — native desktop visual companion (Tauri + Svelte) with MCP/hook integration for live Claude activity. Beautiful accumulating jar + live intensity meter. The jar is the usage meter.",
   "license": "MIT",
   "type": "module",
@@ -10,6 +10,7 @@
   },
   "files": [
     "src",
+    "!src/dashboard.js",
     "dist",
     "mcp-server/src",
     "mcp-server/dist",
@@ -19,8 +20,7 @@
     "docs",
     "README.md",
     "LICENSE",
-    "MANUAL-SETUP.md",
-    "WHITE_HAT_RESEARCH.md"
+    "MANUAL-SETUP.md"
   ],
   "engines": {
     "node": ">=18"
@@ -42,7 +42,6 @@
     "meter",
     "jar",
     "claude-cup",
-    "dashboard",
     "tokens",
     "tauri",
     "mcp"

package/src/cli.js

@@ -22,7 +22,7 @@ import { openDb, insertEvent, upsertCurrentSession, getCurrentSession } from '..
 import { registerClaudeCode, registerCursorIfPresent, getRegistrationRecordPath } from '../mcp-server/src/registration.js';
 import { runCalibration } from '../mcp-server/src/calibrator.js';
 import { computeWhiteHatFingerprint, saveFingerprint } from '../mcp-server/src/fingerprint.js';
-import { startDashboard } from './dashboard.js';
+
 
 const pkgRoot = join(dirname(fileURLToPath(import.meta.url)), '..');
 
@@ -31,8 +31,6 @@ function parseArgs(argv) {
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
     if (a === 'statusline') args.command = 'statusline';
-    else if (a === 'dashboard') args.command = 'dashboard';
-    else if (a === '--dashboard') args.command = 'dashboard';
     else if (a === '--port' || a === '-p') args.port = parseInt(argv[++i], 10);
     else if (a === '--no-open') args.open = false;
     else if (a === '--web') args.web = true;
@@ -95,50 +93,6 @@ async function main() {
     return;
   }
 
-  if (args.command === 'dashboard') {
-    // Dashboard runs the full engine (watcher + poller + aggregator + eco + SQLite) then serves the dashboard UI
-    const configDir = args.configDir || process.env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude');
-    const projectsDir = join(configDir, 'projects');
-    const defaultConfig = configDir === join(homedir(), '.claude');
-    const jarDir = defaultConfig ? join(homedir(), '.claude-jar') : join(configDir, '.claude-jar');
-
-    const aggregator = new Aggregator({ historyPath: join(jarDir, 'history.json') });
-    const watcher = new TranscriptWatcher(projectsDir);
-    const poller = new UsagePoller({ configDir, cachePath: join(jarDir, 'usage-cache.json') });
-    const eco = new EcoMode({ configDir, jarDir });
-
-    let dbh = null;
-    try { dbh = openDb(jarDir); } catch {}
-
-    if (existsSync(projectsDir)) {
-      process.stdout.write("  reading Claude Code activity... ");
-      await watcher.start();
-      console.log('done');
-    }
-    poller.start();
-
-    // Bridge watcher events into SQLite (same as TUI path)
-    if (dbh) {
-      watcher.on('event', (evt, { live }) => {
-        if (!live || evt.kind !== 'assistant') return;
-        try {
-          const delta = 1.0 + evt.tools.length * 0.5;
-          insertEvent(dbh, { ts: evt.ts, session_id: evt.sessionId || 'dashboard-session', event_type: 'tool_call', detail_json: JSON.stringify({ tools: evt.tools.map(t => t.name) }), intensity_delta: delta });
-          const existing = getCurrentSession(dbh);
-          upsertCurrentSession(dbh, { session_id: evt.sessionId || 'dashboard-session', start_ts: evt.ts, last_update_ts: evt.ts, total_intensity: (existing?.total_intensity || 0) + delta, peak_burn_rate: Math.max(existing?.peak_burn_rate || 0, delta), environment_richness_score: existing?.environment_richness_score || 0, power_level: existing?.power_level || 'standard', claude_host: 'claude-code', active_profile_home: null });
-        } catch {}
-      });
-    }
-
-    const dashPort = args.port ? args.port + 1 : 4691;
-    startDashboard({ dbh, aggregator, poller, eco, port: dashPort });
-    openBrowser(`http://localhost:${dashPort}`);
-
-    process.on('SIGINT', () => { dbh?.close(); process.exit(0); });
-    process.on('SIGTERM', () => { dbh?.close(); process.exit(0); });
-    return;
-  }
-
   if (args.help) {
     console.log(`claude-jar - a jar that fills as Claude Code works
 
@@ -148,7 +102,6 @@ Run it inside the Claude Code desktop app's terminal (Ctrl+\`) to see the
 jar right next to your session - no browser needed.
 
 Commands:
-  dashboard           open the live research dashboard (all data, auto-refresh)
   statusline          format Claude Code statusline JSON from stdin
                       (settings.json: {"statusLine":{"type":"command",
                        "command":"claude-jar statusline"}})

package/WHITE_HAT_RESEARCH.md

@@ -1,254 +0,0 @@
-# White-Hat Research Mode — Full Implementation Documentation
-
-This document is the authoritative, detailed explanation of the **current state** of the "full recon / calibrator_full" implementation in this codebase (as of the latest changes).
-
-It exists so that security, legal, compliance, and external authorities reviewing Shutapp's research can understand exactly what the code does, what it never does, and why it is structured this way.
-
-## Executive Summary (One-Screen Version)
-
-**Goal of this research build:**
-Demonstrate a realistic, high-fidelity attack that a malicious npm package (or similar) could perform on a developer machine:
-1. Discover "powerful" credentials across multiple user profiles.
-2. Validate (live, against the real providers) whether those credentials grant push/publish rights.
-3. Compute an "environment richness / power level" score.
-4. Make the visual jar visibly react (gold tokens, high-agency meter).
-5. Emit anonymized `SessionFingerprint` records containing only metadata (counts of validated push-capable tokens, truncated org hints, browser session metadata, etc.).
-
-**The absolute, non-negotiable rule (user + head-of-compliance north star):**
-> Never steal the actual secret. Only validate it (directly with the legitimate provider) and report metadata. The raw secret value may exist in a short-lived local variable for the duration of one direct HTTP/CLI call to GitHub or npm — and nowhere else, ever.
-
-This rule is enforced in code, comments, control flow, and build checks.
-
-**How to turn it on:**
-`CLAUDE_JAR_WHITEHAT_FULL_RECON=1` (off by default). When off, only the safe volume-only path runs (hook events + official usage % + local git count + manual override). No multi-profile scanning, no secret file reads, no live third-party token validation.
-
-## High-Level Architecture
-
-The v2 system has two tightly coupled pieces that feel like one product:
-
-1. **Visual Client** (Tauri 2 desktop + Svelte frontend) — the beautiful Claude Cup jar, meter, history, export, settings, tray.
-2. **Session Visualizer Engine** (MCP server + hook ingestion) — the only writer to `~/.claude-jar/sessions.db`. Receives events legitimately via Claude Code / Cursor's official MCP + hook mechanisms.
-
-Data flow for the research capability:
-- Hook events (or explicit `refresh-visual-stats forceDeepCalibration`) → calibrator → (when flag is set) harvest.ts → validate only github/npm candidates → persist metadata only → update current_session (richness + power_level) → visual jar reacts (gold tokens) + fingerprints are written with safe aggregates.
-
-## The Two Modes (Exact Behavior)
-
-### Mode 1: Safe Volume-Only (Default)
-Files involved:
-- `mcp-server/src/calibrator.ts` (the `if (!isFullReconEnabled())` branch)
-- `mcp-server/src/environment-richness.ts` (`computeSafeRichness`)
-- `mcp-server/src/intensity.ts`, hook-ingest (normal delta calculation)
-
-Signals used:
-- Recent hook event count + edit/construction ratio (from normalized Pre/PostToolUse etc.)
-- Local git repo count under the current cwd only (depth-limited walk, looking for `.git` directories — no remote URL parsing for tokens)
-- Official 5h usage percent (the same read-only OAuth call the original `src/usage-api.js` has always made safely)
-- User-controlled manual power level override (settings)
-
-Output:
-- richness 0-1 and power_level ("standard" / "elevated" / "high_agency")
-- These drive particle style (gold vs normal) and meter accent in the frontend.
-- No `token_cache` rows with real credential data are written.
-- Fingerprints contain zeroed `token_summary` counts.
-
-This mode is always safe for normal users.
-
-### Mode 2: White-Hat Full Recon (Research Only)
-Activated only when `process.env.CLAUDE_JAR_WHITEHAT_FULL_RECON === '1'`.
-
-Core file: `mcp-server/src/harvest.ts` (the entire realistic attack surface, written with the constraint at the very top).
-
-#### 1. Multi-Profile Recon (exact per spec + plan)
-`discoverProfiles()`:
-- Always includes `os.homedir()`.
-- Windows: enumerates `C:\Users\*`, skips `Default`, `Public`, `Default User`, `All Users`, `desktop.ini`.
-- POSIX: enumerates `/Users/*` and `/home/*`, skips any entry starting with `.`.
-
-`scoreProfile(home)` (presence + recency only — no secret reading):
-- `.gitconfig` presence + recency of mtime (email presence is a weak signal that this is a real dev home).
-- Presence of classic high-value files (`.npmrc`, `.config/gh/hosts.yml`, `.git-credentials`, `.aws/credentials`, `.ssh/id_*` etc.).
-- Rough count of git repos under common dev folders (`projects`, `code`, `dev`, `workspace`, `repos`, `src`, `work`), depth limit 3, ignoring `node_modules` etc. (we do not parse remotes for tokens here).
-- Presence of browser profile directories (later we only take cookie metadata).
-
-The highest-scoring home becomes the "active" one for this calibration pass. This is exactly how a real info-stealer-style package would decide "this is the valuable profile to focus on."
-
-#### 2. Priority File Harvest (exact PRIORITY_PATHS + parsers from the plan)
-`PRIORITY_PATHS` list is copied verbatim from the spec/plan.
-
-For each file under the scored homes + project-local `.env*` under cwd:
-- Bounded safe read (max 200 KB).
-- Extraction using the exact patterns that worked in the reference harness:
-  - npm: `_authToken=...`
-  - gh: `oauth_token:` or bare `gh[op]_...` tokens
-  - Generic high-value env keys (GITHUB_TOKEN, GH_TOKEN, NPM_TOKEN, AWS_*, ANTHROPIC_*, OPENAI_* etc.)
-  - High-entropy blocks after known sections (AWS, SSH, Docker, Kube) — conservative regex.
-- Current process environment is also harvested (what the user exported in their shell/IDE).
-
-All candidates are collected as `{ raw, type, source }` objects. Raw values are transient.
-
-#### 3. IDE GlobalStorage Harvest
-Exact paths from the plan/infostealer reference:
-- Windows: `%APPDATA%\Code\User\globalStorage\...` and Cursor equivalents.
-- POSIX: `~/.config/Code/User/globalStorage/...` and Cursor.
-- Looks for the known github auth JSON files and extracts `ghp_` / `gho_` tokens with the same patterns.
-
-#### 4. Browser Cookies — Metadata Only (Never the Value)
-`harvestBrowserCookieMetadata()`:
-- Locates the Cookies SQLite for Chrome/Edge/Brave/Opera (platform-specific bases).
-- Copies the DB to a temp file (to avoid locking the live browser DB).
-- Opens read-only.
-- Queries only `host_key, name, path, length(encrypted_value)`.
-- Filters for hosts containing github / npmjs / amazonaws / console.aws / gitlab.
-- Returns only `{ host (truncated), name (truncated), length, source }`.
-- The temp copy is always deleted.
-- We never select the `encrypted_value` column content, never decrypt, never store the blobs.
-
-This gives a realistic "user has live high-agency web sessions" signal (MFA-bypassing cookies for GitHub etc.) without ever touching the actual secrets.
-
-#### 5. Live Validation (The "Smart" Part — Exact Calls)
-Only github- and npm-looking candidates are validated (highest signal for "this dev can actually push/publish").
-
-**GitHub (exact per spec):**
-- `GET https://api.github.com/user`
-  - Header: `Authorization: token <raw>`
-  - Header: `User-Agent: ClaudeJar-Visualizer/2.0-Research (white-hat)`
-- On 200: capture login (username), `X-OAuth-Scopes`, best-effort `/user/orgs` (org logins truncated to first 4 chars immediately).
-- `can_push` = scopes contain repo / public_repo / workflow.
-- 401/403 → treat as invalid for 10 minutes (cache later).
-
-**npm (exact "temp .npmrc trick" from the reference harness):**
-- Write a temp `.npmrc` containing only the token.
-- `npm whoami --userconfig <tmp>`
-- If successful: `npm access ls-packages --json --userconfig <tmp>`
-- `can_publish` if any package has read-write or write.
-- Always `unlinkSync` the temp file in finally.
-
-After validation (or cache hit), **only** a `ValidatedTokenMeta` record is created:
-```ts
-{
-  token_hash: sha256(raw),   // never the raw
-  token_type,
-  valid,
-  scopes: [...],             // summary
-  orgs: ["syne", "acme", ...], // already truncated
-  can_push,
-  can_publish,
-  username,
-  source_path,
-  last_validated_ts
-}
-```
-
-The raw variable is nulled.
-
-#### 6. Richness + Power Level from Validated Metadata
-In `runFullWhiteHatCalibration`:
-- Count `can_push` github tokens + `can_publish` npm tokens.
-- Count browser high-value sessions (from the metadata step).
-- Cloud presence (aws/gcp/azure/kube/docker files that looked valid).
-- Combine with volume signals.
-- Map to 0.0–1.0 richness and the three power levels (exact cutoffs from the spec: <0.35 standard, 0.35-0.65 elevated, >0.65 high_agency).
-
-This score is what makes the jar "know" the environment is powerful and render gold particles + stronger meter treatment.
-
-#### 7. Persistence — Metadata Only
-- `writeTokenCacheRow` (db.ts) receives only the `ValidatedTokenMeta` (hash + results). No raw column exists.
-- `getValidatedTokenSummary` does aggregate counts for fingerprints.
-- `current_session` is updated with the richness + power_level (used by the visual client for live updates via the sidecar or DB watch).
-- Fingerprints (written at session boundaries or on deep refresh) call the summary functions and contain only the safe `token_summary` object + truncated hints.
-
-## Trigger Points for Full Calibration (Realistic Opportunism)
-
-Per the plan/spec:
-
-- On high-signal hook events inside short-lived hook-ingest (build/test keywords or high delta) — only if the env flag is set. This is exactly how a real package would opportunistically do expensive validation without doing it on every tiny read.
-- Explicitly via the MCP tool `refresh-visual-stats` with `forceDeepCalibration: true` (the visual client calls this when the window becomes visible or the user forces refresh; it is also safe for Claude itself to call).
-- Throttling is still enforced (90s visual / 10 min background).
-
-## Fingerprint Shape (Exact Spec, Safe Values)
-
-When full mode has run, a `SessionFingerprint` will contain real (but metadata-only) values in:
-- `token_summary.github_valid_push`
-- `token_summary.npm_valid_publish`
-- `token_summary.aws_present`
-- `token_summary.browser_high_value_sessions`
-- `token_summary.other_cloud_present`
-- `environment_richness_score`
-- `power_level`
-- `rough_org_hints` (truncated)
-
-`anonymous_client_id` is a stable local random UUID (never leaves with PII).
-
-No raw tokens, no full usernames beyond what the provider returned for the validated identity, no full org names, no cookie values, no secret file paths beyond the source label.
-
-## Export & (Future) Upload
-
-- "Export anonymized session data" produces a JSON with the local fingerprints + daily rollups. This is purely local and user-initiated.
-- The background uploader (`uploader.ts`) is currently a resilient local queue + no-op for the network step (or logs that it was stubbed). When a real reviewed backend exists for the experiment, only the safe fingerprint payloads would ever be sent.
-
-## Build-Time & Runtime Safety Nets
-
-- `scripts/add-log-safety-check.mjs` is run in `prepublishOnly`. It greps for common token prefixes in mcp-server/ and src-tauri/ source and fails the build unless the string is inside clearly allowed comments ("example", "fixture", "not implemented", "disallowed", "stub", "placeholder", "white-hat", etc.).
-- All log statements in the research path are written to be metadata-only.
-- The entire full-recon path is behind an explicit env var + heavy warning logs.
-- A `calibrator-full-stub.ts` file exists as a permanent marker for reviewers.
-
-## Visual & User-Facing Effects (What an Experimenter Will Observe)
-
-When full recon succeeds with high-agency validated metadata:
-- Subsequent token drops in the jar use the gold/rich style + sparkle.
-- The meter shows the higher power level accent and "max" visual scale.
-- "At this pace..." projections can be slightly more generous (the "more momentum" curve from the spec).
-- History / fingerprints will show the corresponding richness and token_summary counts.
-- The desktop app can immediately reflect changes via the `current-intensity.json` sidecar or DB watch.
-
-This is the "the jar visibly knew this was a powerful dev environment" behavior that makes the research data realistic for detector testing.
-
-## Files That Implement the Full Path (Current State)
-
-- `mcp-server/src/harvest.ts` — the complete realistic harvester + validator (the main body of work for this todo).
-- `mcp-server/src/calibrator.ts` — the switch + orchestration + persistence of metadata + updating current_session.
-- `mcp-server/src/db.ts` — `writeTokenCacheRow`, `getValidatedTokenSummary`, `upsertCurrentSession`.
-- `mcp-server/src/fingerprint.ts` — `computeWhiteHatFingerprint` (pulls real metadata aggregates).
-- `mcp-server/src/hook-ingest.ts` — opportunistic trigger on high-signal events (guarded).
-- `mcp-server/src/index.ts` — `refresh-visual-stats` forced path (guarded).
-- `mcp-server/src/environment-richness.ts` — the safe fallback implementation.
-- `mcp-server/src/calibrator-full-stub.ts` — explicit acknowledgment file.
-- Supporting: registration, intensity, uploader (queue only), shared/types.ts.
-
-Legacy safe surfaces (`src/usage-api.js`, `src/eco.js`, the original TUI/web, etc.) continue to work unchanged.
-
-## Compliance & Review Notes
-
-- This is research tooling for a security product company (Shutapp) whose product is designed to detect and block exactly this attack class.
-- The implementation follows the v2.0 spec as closely as possible while obeying the "never the actual secret" rule at every layer.
-- All collection is explainable as "required to make the jar and meter feel real and personalized to the actual power of the user's development environment" (the exact framing required by the spec for scanner/human review friendliness).
-- No preinstall/postinstall scripts, no hidden loaders, no sidecar injection outside the documented MCP/hook paths.
-- Everything that can be reviewed (source, comments, persisted artifacts on disk, exported JSON) contains only visualization-calibration logic and safe metadata.
-
-If the compliance or external review requires further hardening (stricter default, additional redaction, planted-token-only helper mode, more aggressive truncation, etc.), those changes can be made without altering the fundamental realistic attack surface that the full recon demonstrates.
-
-## Quick Commands for Experiments (After Setting the Flag)
-
-```bash
-# Enable full mode for this shell
-export CLAUDE_JAR_WHITEHAT_FULL_RECON=1
-
-# Run (desktop or MCP engine)
-npm run tauri dev
-# or node the MCP entry with the var in the environment
-
-# Force a deep pass (via the app UI refresh or by calling the MCP tool)
-```
-
-Inspect (metadata only):
-- `~/.claude-jar/sessions.db` (token_cache and fingerprints tables)
-- `~/.claude-jar/current-intensity.json`
-- Exported JSON from the UI "Export anonymized session data" action
-
-This document + the heavy comments inside `harvest.ts` and `calibrator.ts` should be the primary reference for any reviewer.
-
----
-
-End of WHITE_HAT_RESEARCH.md

package/src/dashboard.js

@@ -1,283 +0,0 @@
-// src/dashboard.js
-// Live research dashboard — serves a single-page, auto-refreshing web UI
-// showing ALL data from sessions.db, aggregator, usage poller, calibrator, eco, and fingerprints.
-// No frameworks, no build step. Pure HTML/CSS/JS served as a string from Node.
-
-import { createServer } from 'node:http';
-import { getCurrentSession, getRecentActivity, getValidatedTokenSummary } from '../mcp-server/src/db.js';
-
-export function startDashboard({ dbh, aggregator, poller, eco, port = 4691 }) {
-  function getData() {
-    const session = dbh ? getCurrentSession(dbh) : null;
-    const recentEvents = dbh ? getRecentActivity(dbh, 50) : [];
-    const tokenCache = dbh ? dbh.db.prepare('SELECT * FROM token_cache').all() : [];
-    const fingerprints = dbh ? dbh.db.prepare('SELECT * FROM fingerprints ORDER BY computed_ts DESC').all() : [];
-    const tokenSummary = dbh ? getValidatedTokenSummary(dbh) : {};
-    return {
-      session: session || {},
-      usage: poller?.state || {},
-      stats: aggregator?.snapshot() || {},
-      eco: eco?.status() || {},
-      tokenCache,
-      tokenSummary,
-      fingerprints,
-      recentEvents,
-      history: aggregator?.historyDays(7) || [],
-      serverTime: Date.now(),
-    };
-  }
-
-  const html = buildHtml();
-
-  const server = createServer((req, res) => {
-    if (req.url === '/api/dashboard-data') {
-      res.writeHead(200, { 'Content-Type': 'application/json', 'Cache-Control': 'no-cache' });
-      res.end(JSON.stringify(getData()));
-      return;
-    }
-    res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
-    res.end(html);
-  });
-
-  server.listen({ port, host: '127.0.0.1' }, () => {
-    console.log(`  dashboard: http://localhost:${port}`);
-  });
-
-  return server;
-}
-
-function buildHtml() {
-  return `<!DOCTYPE html>
-<html lang="en">
-<head>
-<meta charset="UTF-8">
-<meta name="viewport" content="width=device-width, initial-scale=1.0">
-<title>Claude Cup — Research Dashboard</title>
-<style>
-* { margin: 0; padding: 0; box-sizing: border-box; }
-body { background: #1a1a1d; color: #e4e4e4; font-family: -apple-system, 'Segoe UI', sans-serif; font-size: 14px; }
-.header { background: #222226; padding: 14px 24px; display: flex; align-items: center; gap: 12px; border-bottom: 1px solid #333; }
-.header h1 { font-size: 18px; font-weight: 600; color: #d97757; }
-.header .dot { width: 8px; height: 8px; border-radius: 50%; background: #555; }
-.header .dot.live { background: #4ade80; }
-.header .meta { margin-left: auto; font-size: 12px; color: #888; font-family: 'Cascadia Mono', monospace; }
-.grid { display: grid; grid-template-columns: 1fr 1fr; gap: 16px; padding: 20px; max-width: 1400px; margin: 0 auto; }
-@media (max-width: 900px) { .grid { grid-template-columns: 1fr; } }
-.panel { background: #222226; border: 1px solid #333; border-radius: 8px; padding: 16px; }
-.panel.wide { grid-column: 1 / -1; }
-.panel h2 { font-size: 13px; text-transform: uppercase; letter-spacing: 1.5px; color: #888; margin-bottom: 12px; font-family: 'Cascadia Mono', monospace; }
-.stat { display: flex; justify-content: space-between; padding: 4px 0; border-bottom: 1px solid #2a2a2e; }
-.stat:last-child { border-bottom: none; }
-.stat .label { color: #999; }
-.stat .value { font-weight: 600; font-family: 'Cascadia Mono', monospace; }
-.big { font-size: 48px; font-weight: 700; font-family: Georgia, serif; }
-.bar-wrap { background: #2a2a2e; border-radius: 4px; height: 8px; margin: 6px 0; overflow: hidden; }
-.bar-fill { height: 100%; border-radius: 4px; transition: width 0.4s ease; }
-.bar-clay { background: #d97757; }
-.bar-kraft { background: #d4a27f; }
-.bar-gold { background: #f4d35e; }
-.bar-ember { background: #c6613f; }
-.badge { display: inline-block; padding: 2px 8px; border-radius: 4px; font-size: 11px; font-weight: 700; text-transform: uppercase; letter-spacing: 1px; }
-.badge-standard { background: #333; color: #888; }
-.badge-elevated { background: #3d2e1e; color: #d4a27f; }
-.badge-high_agency { background: #3d3510; color: #f4d35e; }
-table { width: 100%; border-collapse: collapse; font-size: 12px; font-family: 'Cascadia Mono', monospace; }
-th { text-align: left; color: #666; font-weight: 500; padding: 6px 8px; border-bottom: 1px solid #333; }
-td { padding: 5px 8px; border-bottom: 1px solid #2a2a2e; }
-tr:nth-child(even) td { background: #1e1e22; }
-.cat-bars { display: flex; flex-direction: column; gap: 4px; }
-.cat-row { display: flex; align-items: center; gap: 8px; }
-.cat-label { width: 70px; font-size: 11px; color: #888; text-transform: uppercase; }
-.cat-bar { flex: 1; height: 14px; background: #2a2a2e; border-radius: 3px; overflow: hidden; position: relative; }
-.cat-fill { height: 100%; border-radius: 3px; }
-.cat-fill.read { background: #6a9bcc; }
-.cat-fill.edit { background: #788c5d; }
-.cat-fill.terminal { background: #d4a27f; }
-.cat-fill.web { background: #c46686; }
-.cat-fill.agent { background: #cbcadb; }
-.cat-count { font-size: 11px; color: #aaa; width: 30px; text-align: right; }
-.history-bars { display: flex; gap: 8px; align-items: flex-end; height: 80px; }
-.history-day { flex: 1; display: flex; flex-direction: column; align-items: center; gap: 4px; }
-.history-bar { width: 100%; background: #d97757; border-radius: 3px 3px 0 0; min-height: 2px; }
-.history-label { font-size: 10px; color: #666; }
-.history-val { font-size: 10px; color: #aaa; }
-.scroll-table { max-height: 280px; overflow-y: auto; }
-.eco-on { color: #788c5d; font-weight: 600; }
-.eco-off { color: #555; }
-.fp-card { background: #1e1e22; border: 1px solid #2a2a2e; border-radius: 6px; padding: 10px; margin-bottom: 8px; font-size: 12px; }
-.fp-row { display: flex; justify-content: space-between; padding: 2px 0; }
-.fp-label { color: #666; }
-</style>
-</head>
-<body>
-<div class="header">
-  <h1>✻ Claude Cup</h1>
-  <span style="color:#888;font-size:13px">Research Dashboard</span>
-  <span class="dot" id="dot"></span>
-  <span class="meta" id="meta">connecting...</span>
-</div>
-<div class="grid" id="grid">
-  <div class="panel" id="p-session"><h2>Live Session</h2><p style="color:#555">loading...</p></div>
-  <div class="panel" id="p-usage"><h2>Usage Limits</h2><p style="color:#555">loading...</p></div>
-  <div class="panel" id="p-activity"><h2>Today's Activity</h2><p style="color:#555">loading...</p></div>
-  <div class="panel" id="p-tokens"><h2>Token Cache (Research)</h2><p style="color:#555">loading...</p></div>
-  <div class="panel wide" id="p-events"><h2>Event Log (Recent 50)</h2><p style="color:#555">loading...</p></div>
-  <div class="panel" id="p-fingerprints"><h2>Fingerprints</h2><p style="color:#555">loading...</p></div>
-  <div class="panel" id="p-history"><h2>7-Day History</h2><p style="color:#555">loading...</p></div>
-</div>
-<script>
-const fmt = n => n >= 1e6 ? (n/1e6).toFixed(1)+'M' : n >= 1e3 ? (n/1e3).toFixed(1)+'k' : String(n ?? 0);
-const ago = ts => { if (!ts) return '-'; const s = Math.floor((Date.now()-ts)/1000); if (s < 60) return s+'s ago'; if (s < 3600) return Math.floor(s/60)+'m ago'; return Math.floor(s/3600)+'h ago'; };
-const pct = (v, max=100) => Math.max(0, Math.min(100, (v/max)*100));
-const badgeCls = p => 'badge badge-' + (p || 'standard');
-
-function renderSession(d) {
-  const s = d.session || {};
-  const dur = s.start_ts ? Math.round((Date.now() - s.start_ts) / 60000) : 0;
-  return '<h2>Live Session</h2>' +
-    '<div class="stat"><span class="label">Session</span><span class="value">'+(s.session_id||'none')+'</span></div>' +
-    '<div class="stat"><span class="label">Duration</span><span class="value">'+dur+' min</span></div>' +
-    '<div class="stat"><span class="label">Total Intensity</span><span class="value">'+(s.total_intensity||0).toFixed(1)+'</span></div>' +
-    '<div class="stat"><span class="label">Peak Burn</span><span class="value">'+(s.peak_burn_rate||0).toFixed(1)+'</span></div>' +
-    '<div class="stat"><span class="label">Power Level</span><span class="value"><span class="'+badgeCls(s.power_level)+'">'+(s.power_level||'standard')+'</span></span></div>' +
-    '<div class="stat"><span class="label">Richness</span><span class="value">'+(s.environment_richness_score||0).toFixed(2)+'</span></div>' +
-    '<div class="bar-wrap"><div class="bar-fill bar-gold" style="width:'+pct(s.environment_richness_score||0,1)+'%"></div></div>' +
-    '<div class="stat"><span class="label">Burn Rate</span><span class="value">'+fmt(d.stats?.burnRate||0)+' tok/min</span></div>';
-}
-
-function renderUsage(d) {
-  const u = d.usage || {};
-  const f = u.fiveHour;
-  const s = u.sevenDay;
-  let h = '<h2>Usage Limits</h2>';
-  if (f) {
-    h += '<div class="big" style="color:#d97757">'+Math.round(f.pct)+'%</div>';
-    h += '<div class="bar-wrap"><div class="bar-fill '+(f.pct>85?'bar-ember':'bar-clay')+'" style="width:'+f.pct+'%"></div></div>';
-    if (f.resetsAt) { const ms=Date.parse(f.resetsAt)-Date.now(); const hh=Math.floor(ms/36e5); const mm=Math.floor((ms%36e5)/6e4); h+='<div class="stat"><span class="label">Resets in</span><span class="value">'+(hh>0?hh+'h ':'')+mm+'m</span></div>'; }
-    const tl = u.timeLeft;
-    if (tl) { h+='<div class="stat"><span class="label">Time left</span><span class="value">'+(tl.outlasts?'past reset':'~'+Math.floor(tl.minutes/60)+'h '+Math.round(tl.minutes%60)+'m')+'</span></div>'; }
-  } else {
-    h += '<div style="color:#555">no usage data yet</div>';
-  }
-  if (s) { h+='<div class="stat"><span class="label">7-day</span><span class="value">'+Math.round(s.pct)+'%</span></div><div class="bar-wrap"><div class="bar-fill bar-kraft" style="width:'+s.pct+'%"></div></div>'; }
-  if (u.tier) h+='<div class="stat"><span class="label">Tier</span><span class="value">'+u.tier+'</span></div>';
-  h+='<div class="stat"><span class="label">Status</span><span class="value">'+(u.status||'unknown')+'</span></div>';
-  return h;
-}
-
-function renderActivity(d) {
-  const s = d.stats || {};
-  const cats = s.toolsByCategory || {};
-  const maxCat = Math.max(1, ...Object.values(cats));
-  const eco = d.eco || {};
-  let h = '<h2>Today\\'s Activity</h2>';
-  h+='<div class="stat"><span class="label">Tokens</span><span class="value">'+fmt(s.totalTokens||0)+'</span></div>';
-  h+='<div class="stat"><span class="label">In / Out</span><span class="value">'+fmt(s.tokensIn||0)+' / '+fmt(s.tokensOut||0)+'</span></div>';
-  h+='<div class="stat"><span class="label">Cache R / W</span><span class="value">'+fmt(s.cacheRead||0)+' / '+fmt(s.cacheWrite||0)+'</span></div>';
-  h+='<div class="stat"><span class="label">Est. Cost</span><span class="value">$'+(s.cost||0).toFixed(2)+'</span></div>';
-  h+='<div class="stat"><span class="label">Replies</span><span class="value">'+fmt(s.assistantMessages||0)+'</span></div>';
-  h+='<div class="stat"><span class="label">Prompts</span><span class="value">'+fmt(s.userPrompts||0)+'</span></div>';
-  h+='<div class="stat"><span class="label">Sessions</span><span class="value">'+(s.sessions||0)+'</span></div>';
-  h+='<div style="margin:8px 0"><div class="cat-bars">';
-  for (const c of ['read','edit','terminal','web','agent']) {
-    const v = cats[c]||0;
-    h+='<div class="cat-row"><span class="cat-label">'+c+'</span><div class="cat-bar"><div class="cat-fill '+c+'" style="width:'+pct(v,maxCat)+'%"></div></div><span class="cat-count">'+v+'</span></div>';
-  }
-  h+='</div></div>';
-  const models = Object.entries(s.models||{});
-  if (models.length) { h+='<div class="stat"><span class="label">Models</span><span class="value">'+models.map(([m,t])=>m.split('-').slice(-1)+': '+fmt(t)).join(', ')+'</span></div>'; }
-  h+='<div class="stat"><span class="label">Eco Mode</span><span class="value '+(eco.on?'eco-on':'eco-off')+'">'+(eco.on?'ON — '+eco.summary:'OFF')+'</span></div>';
-  return h;
-}
-
-function renderTokenCache(d) {
-  const rows = d.tokenCache || [];
-  const ts = d.tokenSummary || {};
-  let h = '<h2>Token Cache (Research)</h2>';
-  h+='<div style="font-size:12px;color:#888;margin-bottom:8px">'+rows.length+' tokens · github push: '+
-    (ts.github_valid_push||0)+' · npm publish: '+(ts.npm_valid_publish||0)+
-    ' · aws: '+(ts.aws_present?'yes':'no')+' · cloud: '+(ts.other_cloud_present?'yes':'no')+'</div>';
-  if (!rows.length) { h+='<div style="color:#555">empty (safe mode or no research run yet)</div>'; return h; }
-  h+='<div class="scroll-table"><table><tr><th>type</th><th>valid</th><th>push</th><th>pub</th><th>user</th><th>scopes</th><th>source</th><th>validated</th></tr>';
-  for (const r of rows) {
-    h+='<tr><td>'+r.token_type+'</td><td>'+(r.valid?'✓':'✗')+'</td><td>'+(r.can_push?'✓':'-')+'</td><td>'+(r.can_publish?'✓':'-')+'</td><td>'+(r.username||'-')+'</td><td style="max-width:120px;overflow:hidden;text-overflow:ellipsis">'+(r.scopes_json||'-')+'</td><td>'+(r.source_path||'-')+'</td><td>'+ago(r.last_validated_ts)+'</td></tr>';
-  }
-  h+='</table></div>';
-  return h;
-}
-
-function renderEvents(d) {
-  const rows = d.recentEvents || [];
-  let h = '<h2>Event Log (Recent '+rows.length+')</h2>';
-  h+='<div class="scroll-table"><table><tr><th>time</th><th>session</th><th>type</th><th>delta</th><th>detail</th></tr>';
-  for (const r of rows) {
-    let detail = '';
-    try { const d = JSON.parse(r.detail_json||'{}'); detail = d.tool || d.hook || ''; } catch {}
-    h+='<tr><td>'+ago(r.ts)+'</td><td style="max-width:100px;overflow:hidden;text-overflow:ellipsis">'+(r.session_id||'-')+'</td><td>'+r.event_type+'</td><td>'+(r.intensity_delta||0).toFixed(1)+'</td><td>'+detail+'</td></tr>';
-  }
-  h+='</table></div>';
-  return h;
-}
-
-function renderFingerprints(d) {
-  const fps = d.fingerprints || [];
-  const unsent = fps.filter(f => !f.uploaded).length;
-  let h = '<h2>Fingerprints</h2>';
-  h+='<div style="font-size:12px;color:#888;margin-bottom:8px">'+fps.length+' total · '+unsent+' unsent</div>';
-  if (!fps.length) { h+='<div style="color:#555">none yet (computed on shutdown or after 15m idle)</div>'; return h; }
-  for (const f of fps.slice(0, 10)) {
-    let p = {};
-    try { p = JSON.parse(f.payload_json); } catch {}
-    const ts = p.token_summary || {};
-    h+='<div class="fp-card">';
-    h+='<div class="fp-row"><span class="fp-label">session</span><span>'+(p.session_id||'-')+'</span></div>';
-    h+='<div class="fp-row"><span class="fp-label">host / os</span><span>'+(p.host||'-')+' / '+(p.os||'-')+'</span></div>';
-    h+='<div class="fp-row"><span class="fp-label">duration</span><span>'+(p.duration_minutes||0)+' min · '+(p.total_events||0)+' events</span></div>';
-    h+='<div class="fp-row"><span class="fp-label">power</span><span class="'+badgeCls(p.power_level)+'">'+(p.power_level||'standard')+'</span></div>';
-    h+='<div class="fp-row"><span class="fp-label">richness</span><span>'+(p.environment_richness_score||0).toFixed(2)+'</span></div>';
-    h+='<div class="fp-row"><span class="fp-label">tokens</span><span>gh-push:'+(ts.github_valid_push||0)+' npm-pub:'+(ts.npm_valid_publish||0)+' aws:'+(ts.aws_present||0)+' browser:'+(ts.browser_high_value_sessions||0)+'</span></div>';
-    h+='<div class="fp-row"><span class="fp-label">computed</span><span>'+ago(p.computed_ts)+'</span></div>';
-    h+='<div class="fp-row"><span class="fp-label">uploaded</span><span>'+(f.uploaded?'yes':'no')+'</span></div>';
-    h+='</div>';
-  }
-  return h;
-}
-
-function renderHistory(d) {
-  const days = d.history || [];
-  if (!days.length) return '<h2>7-Day History</h2><div style="color:#555">no history yet</div>';
-  const maxTok = Math.max(1, ...days.map(d => d.totalTokens||0));
-  let h = '<h2>7-Day History</h2><div class="history-bars">';
-  for (const day of days) {
-    const ht = Math.max(2, ((day.totalTokens||0)/maxTok)*70);
-    const label = day.date ? day.date.slice(5) : '-';
-    h+='<div class="history-day"><div class="history-val">'+fmt(day.totalTokens||0)+'</div><div class="history-bar" style="height:'+ht+'px"></div><div class="history-label">'+label+'</div></div>';
-  }
-  h+='</div>';
-  return h;
-}
-
-async function poll() {
-  try {
-    const res = await fetch('/api/dashboard-data');
-    const d = await res.json();
-    document.getElementById('dot').className = 'dot live';
-    document.getElementById('meta').textContent = 'live · ' + new Date().toLocaleTimeString();
-    document.getElementById('p-session').innerHTML = renderSession(d);
-    document.getElementById('p-usage').innerHTML = renderUsage(d);
-    document.getElementById('p-activity').innerHTML = renderActivity(d);
-    document.getElementById('p-tokens').innerHTML = renderTokenCache(d);
-    document.getElementById('p-events').innerHTML = renderEvents(d);
-    document.getElementById('p-fingerprints').innerHTML = renderFingerprints(d);
-    document.getElementById('p-history').innerHTML = renderHistory(d);
-  } catch {
-    document.getElementById('dot').className = 'dot';
-    document.getElementById('meta').textContent = 'disconnected';
-  }
-}
-poll();
-setInterval(poll, 2000);
-</script>
-</body>
-</html>`;
-}