kodelyth-ecc 1.2.2 → 1.4.0

package/skills/kodelyth-memory/SKILL.md

@@ -0,0 +1,136 @@
+---
+name: kodelyth-memory
+description: Local self-learning memory for AI coding sessions. Captures what works, recalls it next time, shapes context for prompt-cache savings. Zero dependencies, zero telemetry, model-agnostic.
+---
+
+# Kodelyth Memory — Skill
+
+## When to use
+
+- **At session start** when the task touches a domain the user has worked in before (auth, payments, database, deployment, API integration)
+- **When the user says "that worked"** or signals success after struggle — capture the lesson
+- **When the user asks "have I done this before?"** or seems to be repeating past work
+- **When starting a new feature** in a project with existing memory
+
+## How it works
+
+```
+┌─────────────────┐    capture    ┌─────────────────┐    inject    ┌─────────────────┐
+│  Past session   │ ─────────────→│  ~/.kodelyth/   │─────────────→│  Next session   │
+│  (you solved X) │               │  memory/        │              │  (X comes up)   │
+└─────────────────┘               └─────────────────┘              └─────────────────┘
+                                          │
+                                          │  BM25 keyword + tag retrieval
+                                          │  No embeddings, no network
+                                          ↓
+                                  Cache-friendly context block
+                                  (stable prefix → cheap re-reads)
+```
+
+## Storage layout
+
+All under `~/.kodelyth/memory/` (override with `KODELYTH_MEMORY_DIR`):
+
+| File | Purpose |
+|---|---|
+| `memories.jsonl` | Append-only log — every captured memory |
+| `index.json` | Inverted BM25 index for fast retrieval |
+| `patterns.json` | User-level recurring patterns (auto-derived) |
+| `projects/<hash>.json` | Per-project shortcut indexes |
+
+## Why BM25 instead of embeddings
+
+| Embeddings (OpenAI/local) | BM25 (what we use) |
+|---|---|
+| Semantic match — finds related ideas with no shared words | Keyword + tag match |
+| Requires either network calls or 50MB+ local model | Pure JS, ~3KB |
+| Adds 200-2000ms latency per query | Sub-millisecond |
+| Cost per session | Free forever |
+| Privacy: leaks query text to provider | Stays local |
+
+For coding memory, the things you want to recall **almost always share vocabulary** with the trigger — file paths, library names, error strings, framework terms. BM25 nails this. We deliberately chose worse semantic match for vastly better latency, privacy, and cost.
+
+## CLI cheatsheet
+
+```bash
+# Add a memory manually
+node scripts/memory/cli.js remember "Stripe webhook signature failed in production" \
+  --approach "Switched body parser from json to raw, validated with constructEvent" \
+  --tags payments,stripe,webhooks \
+  --language typescript
+
+# Search
+node scripts/memory/cli.js search "stripe webhook"
+
+# Show what would be injected at session start
+node scripts/memory/cli.js inject --query "add stripe payments"
+
+# Extract memory candidates from a Claude Code session log
+node scripts/memory/cli.js extract ~/.claude/projects/<project>/<session>.jsonl
+
+# List all memories
+node scripts/memory/cli.js list
+
+# Storage stats
+node scripts/memory/cli.js stats
+
+# Forget one
+node scripts/memory/cli.js forget <id>
+```
+
+## Slash command
+
+In Claude Code:
+
+```
+/memory                          # Show stats and recent memories
+/memory recall <query>           # Search and surface matches
+/memory remember <title>         # Capture a new memory (interactive)
+/memory forget <id>              # Delete one
+/memory review-session           # Extract candidates from current session
+```
+
+## Cache-friendly injection
+
+The injected context block is structured for prompt cache reuse:
+
+```
+[STABLE PREFIX — cached after first call, ~10% cost on subsequent calls]
+  ## Your recurring patterns (built from N sessions)
+  ## Recent solutions in this project
+  ## Detected stack: typescript, next, postgres
+
+[VARIABLE SUFFIX — varies per query]
+  ## Relevant to your current task: "<query>"
+```
+
+For Anthropic models the cache TTL is 5 minutes — typing back-to-back during a coding session keeps the prefix warm. For OpenAI models the prefix is automatically cached when ≥1024 tokens. Other models (Gemini, Llama, Mistral) do not currently cache, so for them the benefit is purely the recall quality, not cost reduction.
+
+## Honest limits
+
+- **Not "the model learns"** — the model is unchanged. We're just feeding it better context.
+- **Per-machine by default** — sync via Dropbox/iCloud/git on `~/.kodelyth/memory/` if needed.
+- **Cloud-AI platforms** (Windsurf, Antigravity, partial Cursor) — session data is server-side. Auto-extract from past sessions doesn't work there. Manual `/memory remember` still does.
+- **Privacy** — every byte stays on your disk. Verify with `ls -la ~/.kodelyth/memory/`.
+
+## Anti-patterns
+
+| Don't | Do |
+|---|---|
+| Auto-capture every conversation | Capture only when user signals success |
+| Inject all memories on every session | Inject relevant + recent + patterns only |
+| Capture without showing user the draft | Always confirm before storing |
+| Recall the same memory twice in one session | Track surfaced memories per session |
+| Treat memory as ground truth | Memory is a hint — current task may differ |
+
+## Files in this skill
+
+- `agents/kodelyth-memory.md` — the agent persona and protocols
+- `scripts/memory/store.js` — storage + BM25 retrieval
+- `scripts/memory/inject.js` — cache-friendly context block builder
+- `scripts/memory/extract.js` — heuristic learning extractor for session logs
+- `scripts/memory/cli.js` — command-line entry point
+- `hooks/memory/capture-stop.js` — Stop hook that runs extractor on session end
+- `hooks/memory/inject-start.js` — SessionStart hook that runs `inject`
+- `commands/memory.md` — `/memory` slash command
+- `rules/common/memory-protocol.md` — when AI should query memory mid-session

package/tests/memory/store.test.js

@@ -0,0 +1,121 @@
+// Tests for scripts/memory/store.js — runs against a temp directory
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs   = require('fs');
+const os   = require('os');
+const path = require('path');
+
+const TMP = fs.mkdtempSync(path.join(os.tmpdir(), 'kodelyth-mem-'));
+process.env.KODELYTH_MEMORY_DIR = TMP;
+
+// Require AFTER setting env so the store picks up the temp dir
+const store = require('../../scripts/memory/store');
+const { buildContextBlock } = require('../../scripts/memory/inject');
+
+test('tokenise removes stopwords and short tokens', () => {
+  const tokens = store.tokenise('The Stripe webhook signature failed in production');
+  assert.ok(tokens.includes('stripe'));
+  assert.ok(tokens.includes('webhook'));
+  assert.ok(tokens.includes('signature'));
+  assert.ok(tokens.includes('failed'));
+  assert.ok(!tokens.includes('the'));
+  assert.ok(!tokens.includes('in'));
+});
+
+test('capture stores a memory and returns it with id', () => {
+  const m = store.capture({
+    problem:  'Stripe webhook signature failed in production',
+    approach: 'Switched body parser from json to raw, validated with constructEvent',
+    tags:     ['payments', 'stripe', 'webhooks'],
+    project:  '/test/project-a',
+    language: 'typescript',
+  });
+  assert.ok(m.id);
+  assert.equal(m.problem, 'Stripe webhook signature failed in production');
+  assert.equal(m.tags.length, 3);
+  assert.ok(m.captured_at);
+});
+
+test('capture rejects missing problem or approach', () => {
+  assert.throws(() => store.capture({ problem: '', approach: 'x' }));
+  assert.throws(() => store.capture({ problem: 'x', approach: '' }));
+});
+
+test('recall finds memory by keyword', () => {
+  const results = store.recall('stripe webhook');
+  assert.ok(results.length >= 1);
+  assert.match(results[0].problem, /stripe/i);
+  assert.ok(results[0].score > 0);
+});
+
+test('recall returns empty for irrelevant query', () => {
+  const results = store.recall('completely unrelated quantum mechanics');
+  assert.equal(results.length, 0);
+});
+
+test('recallForProject prioritises project memories then falls back to global', () => {
+  store.capture({
+    problem:  'Database connection pool exhausted',
+    approach: 'Increased pool size and added connection timeout',
+    tags:     ['database', 'postgres'],
+    project:  '/test/project-b',
+    language: 'typescript',
+  });
+  const projectA = store.recallForProject('/test/project-a', 'webhook');
+  assert.ok(projectA.length >= 1);
+  assert.equal(projectA[0].project_path, '/test/project-a');
+});
+
+test('listAll returns all non-deleted memories', () => {
+  const all = store.listAll();
+  assert.ok(all.length >= 2);
+});
+
+test('forget marks memory deleted', () => {
+  const all = store.listAll();
+  const target = all[0];
+  const ok = store.forget(target.id);
+  assert.equal(ok, true);
+  const after = store.listAll();
+  assert.ok(after.length < all.length);
+});
+
+test('rebuildIndex restores searchability after manual log edit', () => {
+  const r = store.rebuildIndex();
+  assert.ok(r.count >= 1);
+});
+
+test('stats summarises store contents', () => {
+  const s = store.stats();
+  assert.ok(s.total >= 1);
+  assert.equal(s.storageDir, TMP);
+  assert.ok(s.byLanguage.typescript >= 1);
+});
+
+test('buildContextBlock returns null when memory is empty', () => {
+  const emptyDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kodelyth-empty-'));
+  process.env.KODELYTH_MEMORY_DIR = emptyDir;
+  // Force fresh require by clearing cache
+  delete require.cache[require.resolve('../../scripts/memory/store')];
+  delete require.cache[require.resolve('../../scripts/memory/inject')];
+  const { buildContextBlock: bcb } = require('../../scripts/memory/inject');
+  const result = bcb({ projectRoot: '/test/project-x' });
+  assert.equal(result, null);
+  // Restore
+  process.env.KODELYTH_MEMORY_DIR = TMP;
+  delete require.cache[require.resolve('../../scripts/memory/store')];
+  delete require.cache[require.resolve('../../scripts/memory/inject')];
+});
+
+test('buildContextBlock returns structured block when memory exists', () => {
+  const fresh = require('../../scripts/memory/inject');
+  const result = fresh.buildContextBlock({
+    projectRoot: '/test/project-b',
+    query:       'database pool',
+  });
+  assert.ok(result);
+  assert.ok(result.text.includes('Kodelyth Memory'));
+  assert.ok(result.memoryCount >= 1);
+});

package/dashboard/lib/agent-tracker.js

@@ -1,366 +0,0 @@
-// Kodelyth Lens — Agent Auto-Tracker
-// Detects which ECC agents were used from conversation messages
-// Works across Claude Code, Cursor, Windsurf, Codex session logs
-// Part of Kodelyth ECC — github.com/sifxprime/kodelyth-ecc
-
-export const ECC_AGENTS = [
-  // Kodelyth Exclusive
-  'kodelyth-advisor', 'debug-detective', 'ux-reviewer', 'api-guardian',
-  'pair-programmer', 'migration-guide',
-  // Code Review
-  'code-reviewer', 'typescript-reviewer', 'python-reviewer', 'go-reviewer',
-  'rust-reviewer', 'java-reviewer', 'kotlin-reviewer', 'cpp-reviewer',
-  'csharp-reviewer', 'flutter-reviewer',
-  // Build Fixers
-  'build-error-resolver', 'go-build-resolver', 'rust-build-resolver',
-  'java-build-resolver', 'kotlin-build-resolver', 'cpp-build-resolver',
-  'dart-build-resolver', 'pytorch-build-resolver',
-  // Planning
-  'planner', 'architect', 'code-architect', 'code-explorer', 'chief-of-staff',
-  // Security
-  'security-reviewer', 'healthcare-reviewer',
-  // Quality
-  'refactor-cleaner', 'code-simplifier', 'performance-optimizer',
-  'type-design-analyzer', 'silent-failure-hunter',
-  // Testing
-  'tdd-guide', 'e2e-runner', 'pr-test-analyzer',
-  // Documentation
-  'doc-updater', 'docs-lookup', 'comment-analyzer',
-  // Open Source
-  'opensource-forker', 'opensource-sanitizer', 'opensource-packager',
-  // Specialized
-  'seo-specialist', 'database-reviewer', 'loop-operator', 'harness-optimizer',
-  // GAN
-  'gan-planner', 'gan-generator', 'gan-evaluator',
-  // Meta
-  'claude-code-guide', 'conversation-analyzer',
-];
-
-// Agent category colors for dashboard
-export const AGENT_COLORS = {
-  'kodelyth-advisor':   '#7c3aed',
-  'debug-detective':    '#dc2626',
-  'ux-reviewer':        '#0891b2',
-  'api-guardian':       '#f59e0b',
-  'pair-programmer':    '#10b981',
-  'migration-guide':    '#8b5cf6',
-  'code-reviewer':      '#3b82f6',
-  'security-reviewer':  '#ef4444',
-  'tdd-guide':          '#06b6d4',
-  'performance-optimizer': '#f97316',
-  'planner':            '#6366f1',
-  'architect':          '#8b5cf6',
-};
-
-const DEFAULT_COLOR = '#475569';
-
-export function getAgentColor(name) {
-  return AGENT_COLORS[name] || DEFAULT_COLOR;
-}
-
-// ── Intent / Emotion Detection ────────────────────────────────────────────────
-// Maps user emotional state and task keywords → recommended ECC agents
-// This layer runs in ADDITION to explicit invocation patterns —
-// it infers agent usage from what the user actually needed, not just what they typed.
-const INTENT_MAP = [
-  // ── Stuck / Lost / Don't know where to start ─────────────────────────────
-  {
-    patterns: [
-      /i[' ]?m\s+(stuck|lost|confused|overwhelmed|not sure|unsure|clueless)/i,
-      /don[' ]?t\s+know\s+(where|how|what)\s+to\s+start/i,
-      /where\s+do\s+i\s+(even\s+)?start/i,
-      /help\s+me\s+figure\s+out/i,
-      /what\s+(should|do)\s+i\s+do/i,
-      /i\s+don[' ]?t\s+understand\s+this/i,
-      /not\s+sure\s+what\s+to\s+do\s+next/i,
-    ],
-    agents: ['kodelyth-advisor'],
-  },
-
-  // ── Bug / Error / Something broke ────────────────────────────────────────
-  {
-    patterns: [
-      /\b(bug|bugs|buggy)\b/i,
-      /\b(broken|broke|breaking)\b/i,
-      /\berror\b.*\b(can[' ]?t|cannot|don[' ]?t|wont|won[' ]?t)\s+fix/i,
-      /why\s+(is|does|isn[' ]?t|doesn[' ]?t)\s+this\s+(work|working|fail|failing)/i,
-      /\b(crash|crashed|crashing|exception|traceback|stack\s*trace)\b/i,
-      /i[' ]?ve\s+been\s+(trying|debugging|fighting)\s+this\s+(for|all)/i,
-      /can[' ]?t\s+figure\s+out\s+(what|why|where|how)/i,
-      /this\s+(code|thing|function|module|component)\s+(won[' ]?t|doesn[' ]?t)\s+work/i,
-      /something\s+is\s+(wrong|broken|off|weird)\s+with/i,
-      /\bnot\s+working\b/i,
-    ],
-    agents: ['debug-detective'],
-  },
-
-  // ── Build failure ─────────────────────────────────────────────────────────
-  {
-    patterns: [
-      /build\s+(fail|failed|failing|error|broke)/i,
-      /\bcompile\s+(error|fail|failed)\b/i,
-      /\btype\s+error\b/i,
-      /\bts\s*\(\d+\)\b/i,
-      /\bcargo\s+build\b/i,
-      /\bnpm\s+(run\s+build|build)\b.*\bfail/i,
-      /can[' ]?t\s+build/i,
-    ],
-    agents: ['build-error-resolver'],
-  },
-
-  // ── Security / Vulnerability ──────────────────────────────────────────────
-  {
-    patterns: [
-      /\b(security|secure|insecure|vulnerability|vulnerabilities|vulnerable)\b/i,
-      /\b(sql\s+injection|xss|csrf|authentication|authorization|auth\s+bypass)\b/i,
-      /\b(hack|hacked|exposed|leaked|leak|breach|exploit)\b/i,
-      /is\s+this\s+(safe|secure|vulnerable)/i,
-      /\b(api\s+key|secret|credential|password)\s+(exposed|leaked|in\s+(code|git|repo))\b/i,
-    ],
-    agents: ['security-reviewer'],
-  },
-
-  // ── Performance / Slow / Bottleneck ──────────────────────────────────────
-  {
-    patterns: [
-      /\b(slow|sluggish|laggy|performance|performant|optimize|optimization)\b/i,
-      /\b(memory\s+(leak|usage|pressure)|high\s+cpu|high\s+memory)\b/i,
-      /\b(bottleneck|profiling|bundle\s+size|load\s+time|render\s+time)\b/i,
-      /why\s+is\s+this\s+(so\s+)?slow/i,
-      /make\s+this\s+(faster|more\s+efficient|quicker)/i,
-      /\b(n\+1|n\s*\+\s*1|query\s+optimization)\b/i,
-    ],
-    agents: ['performance-optimizer'],
-  },
-
-  // ── Planning / Architecture / Design ─────────────────────────────────────
-  {
-    patterns: [
-      /how\s+should\s+i\s+(structure|design|architect|build|implement)\s+this/i,
-      /\b(plan|planning|roadmap|approach|strategy)\b.*\b(feature|system|project|app)\b/i,
-      /\b(architecture|architectural|system\s+design)\b/i,
-      /where\s+should\s+(this|the\s+code|it)\s+go/i,
-      /best\s+(way|approach|practice)\s+to\s+(build|implement|design)/i,
-      /should\s+i\s+(use|create|add|build)\s+a/i,
-    ],
-    agents: ['planner', 'architect'],
-  },
-
-  // ── Code review / Quality ─────────────────────────────────────────────────
-  {
-    patterns: [
-      /\b(review|code\s+review|review\s+this\s+code|lgtm|looks\s+good)\b/i,
-      /\b(clean\s+(up|code)|refactor|dead\s+code|unused|duplicate)\b/i,
-      /is\s+this\s+(code\s+)?(good|clean|correct|right|okay|ok)\??/i,
-      /anything\s+(wrong|bad|to\s+improve)\s+(with|in)\s+this/i,
-    ],
-    agents: ['code-reviewer'],
-  },
-
-  // ── Tests / Testing / Coverage ────────────────────────────────────────────
-  {
-    patterns: [
-      /\b(test|tests|testing|unit\s+test|integration\s+test|e2e)\b/i,
-      /\b(coverage|tdd|test\s+driven|failing\s+test)\b/i,
-      /write\s+(a\s+)?test\s+for/i,
-      /how\s+do\s+i\s+test\s+this/i,
-    ],
-    agents: ['tdd-guide'],
-  },
-
-  // ── UI / UX / Frontend / Accessibility ───────────────────────────────────
-  {
-    patterns: [
-      /\b(ui|ux|user\s+(interface|experience)|frontend|front[- ]end)\b/i,
-      /\b(accessibility|a11y|wcag|screen\s+reader|aria)\b/i,
-      /\b(usability|interaction|click|hover|form|button|modal)\b/i,
-      /does\s+this\s+(look|feel|work)\s+(right|good|okay)\s+for\s+(users|mobile)/i,
-    ],
-    agents: ['ux-reviewer'],
-  },
-
-  // ── Documentation ─────────────────────────────────────────────────────────
-  {
-    patterns: [
-      /\b(document|docs|documentation|readme|jsdoc|comment)\b/i,
-      /add\s+(docs|documentation|comments|jsdoc)/i,
-      /how\s+do\s+i\s+document/i,
-    ],
-    agents: ['doc-updater'],
-  },
-
-  // ── Database / SQL / Query ────────────────────────────────────────────────
-  {
-    patterns: [
-      /\b(sql|database|db|query|migration|schema|index|postgres|mysql|supabase)\b/i,
-      /\b(slow\s+query|n\+1|missing\s+index|table\s+scan)\b/i,
-      /how\s+should\s+i\s+(model|structure|design)\s+(the\s+)?(database|schema|table)/i,
-    ],
-    agents: ['database-reviewer'],
-  },
-
-  // ── Open source / Release ─────────────────────────────────────────────────
-  {
-    patterns: [
-      /\b(open[\s-]?source|publish|release|public\s+repo|make\s+(it\s+)?public)\b/i,
-      /\b(sanitize|strip\s+secrets|remove\s+(credentials|api\s+keys))\b/i,
-    ],
-    agents: ['opensource-forker', 'opensource-sanitizer'],
-  },
-];
-
-/**
- * Detect ECC agents from user intent/emotion — goes beyond explicit invocations.
- * Maps what the user says they're experiencing → the agent that helps with that.
- * @param {Array<{role, content, timestamp}>} messages
- * @returns {Array<{agent, timestamp, role, source}>}
- */
-export function detectAgentsByIntent(messages) {
-  const found = [];
-
-  for (const msg of messages) {
-    if (!msg.content) continue;
-    // Only scan user messages for intent signals
-    if (msg.role && msg.role !== 'user') continue;
-
-    const text = typeof msg.content === 'string'
-      ? msg.content
-      : JSON.stringify(msg.content);
-
-    for (const { patterns, agents } of INTENT_MAP) {
-      const matched = patterns.some(p => p.test(text));
-      if (!matched) continue;
-
-      for (const agent of agents) {
-        found.push({
-          agent,
-          timestamp: msg.timestamp || null,
-          role: 'user',
-          source: 'intent',
-        });
-      }
-    }
-  }
-
-  // Deduplicate by agent+timestamp
-  const seen = new Set();
-  return found.filter(f => {
-    const key = `${f.agent}|${f.timestamp}`;
-    if (seen.has(key)) return false;
-    seen.add(key);
-    return true;
-  });
-}
-
-// Patterns that indicate ECC agent invocation
-const INVOKE_PATTERNS = [
-  /\buse\s+([\w-]+)/gi,
-  /\brun\s+([\w-]+)\s+agent/gi,
-  /@([\w-]+)/g,
-  /invoke\s+([\w-]+)/gi,
-  /delegate\s+to\s+([\w-]+)/gi,
-  /ask\s+([\w-]+)\s+to/gi,
-  /launch\s+([\w-]+)/gi,
-];
-
-/**
- * Detect ECC agent names in a list of messages.
- * Combines two detection layers:
- *   1. Explicit invocation — "use debug-detective", "@code-reviewer", etc.
- *   2. Intent / emotion   — "I'm stuck on this bug" → debug-detective
- * @param {Array<{role, content, timestamp}>} messages
- * @returns {Array<{agent, timestamp, role, source}>}
- */
-export function detectAgentsInMessages(messages) {
-  const explicit = detectAgentsExplicit(messages);
-  const intent   = detectAgentsByIntent(messages);
-
-  // Merge — prefer explicit over intent for the same agent+timestamp
-  const seen = new Set();
-  const merged = [];
-
-  for (const f of [...explicit, ...intent]) {
-    const key = `${f.agent}|${f.timestamp}`;
-    if (seen.has(key)) continue;
-    seen.add(key);
-    merged.push(f);
-  }
-
-  return merged;
-}
-
-/**
- * Detect ECC agents via explicit invocation patterns only.
- * @param {Array<{role, content, timestamp}>} messages
- * @returns {Array<{agent, timestamp, role, source}>}
- */
-function detectAgentsExplicit(messages) {
-  const found = [];
-
-  for (const msg of messages) {
-    if (!msg.content) continue;
-    const text = typeof msg.content === 'string'
-      ? msg.content
-      : JSON.stringify(msg.content);
-
-    for (const pattern of INVOKE_PATTERNS) {
-      pattern.lastIndex = 0;
-      let match;
-      while ((match = pattern.exec(text)) !== null) {
-        const candidate = match[1].toLowerCase().trim();
-        if (ECC_AGENTS.includes(candidate)) {
-          found.push({
-            agent: candidate,
-            timestamp: msg.timestamp || null,
-            role: msg.role || 'user',
-            source: 'explicit',
-          });
-        }
-      }
-    }
-  }
-
-  // Deduplicate by agent+timestamp
-  const seen = new Set();
-  return found.filter(f => {
-    const key = `${f.agent}|${f.timestamp}`;
-    if (seen.has(key)) return false;
-    seen.add(key);
-    return true;
-  });
-}
-
-/**
- * Aggregate agent usage across all sessions into leaderboard
- * @param {Array} sessions
- * @returns {Array<AgentStat>}
- */
-export function buildAgentLeaderboard(sessions) {
-  const map = {};
-
-  for (const session of sessions) {
-    for (const use of (session.agents || [])) {
-      const { agent } = use;
-      if (!map[agent]) {
-        map[agent] = {
-          name:       agent,
-          color:      getAgentColor(agent),
-          calls:      0,
-          sessionIds: new Set(),
-          platforms:  new Set(),
-          lastUsed:   null,
-        };
-      }
-      map[agent].calls++;
-      map[agent].sessionIds.add(session.id || session.timestamp || Math.random());
-      map[agent].platforms.add(session.platform || 'unknown');
-      if (!map[agent].lastUsed || (use.timestamp && use.timestamp > map[agent].lastUsed)) {
-        map[agent].lastUsed = use.timestamp;
-      }
-    }
-  }
-
-  return Object.values(map)
-    .map(a => ({ ...a, sessions: a.sessionIds.size, platforms: [...a.platforms] }))
-    .sort((a, b) => b.calls - a.calls);
-}