kodelyth-ecc 1.7.3 → 1.7.4

package/README.md

@@ -2,13 +2,16 @@
 
 <img src="social/readme-hero.svg" alt="Kodelyth ECC — AI Agent Toolkit" width="900"/>
 
+[![npm version](https://img.shields.io/npm/v/kodelyth-ecc.svg)](https://www.npmjs.com/package/kodelyth-ecc)
+[![npm downloads](https://img.shields.io/npm/dm/kodelyth-ecc.svg)](https://www.npmjs.com/package/kodelyth-ecc)
+[![GitHub Stars](https://img.shields.io/github/stars/sifxprime/kodelyth-ecc?style=social)](https://github.com/sifxprime/kodelyth-ecc/stargazers)
 [![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+![Tests](https://img.shields.io/badge/tests-336%20passing-brightgreen)
 ![Claude Code](https://img.shields.io/badge/Claude%20Code-Ready-8A2BE2)
 ![Windsurf](https://img.shields.io/badge/Windsurf-Ready-06b6d4)
 ![Antigravity](https://img.shields.io/badge/Antigravity-Ready-00ADD8)
 ![Cursor](https://img.shields.io/badge/Cursor-Ready-3b82f6)
 ![Codex](https://img.shields.io/badge/Codex-Ready-10b981)
-![Version](https://img.shields.io/badge/version-1.7.0-orange)
 ![Agents](https://img.shields.io/badge/Agents-70-brightgreen)
 ![Devil Mode](https://img.shields.io/badge/Devil%20Mode-new-red)
 ![Skills](https://img.shields.io/badge/Skills-194-brightgreen)
@@ -74,7 +77,7 @@ You never typed `use debug-detective`. You didn't have to. The toolkit read the
 | Quality hooks | ✅ 22+ | Some | ❌ | ❌ |
 | IDE platforms | **11** (Claude Code, Windsurf, Cursor, Codex, Antigravity, OpenCode, Cline, Roo Code, Aider, Kimi, Gemini CLI) | 1-2 | 1 | Varies |
 | Telemetry | ❌ none | Varies | ❌ | Varies |
-| Test coverage | ✅ 336 tests | ❌ | ❌ | ❌ |
+| Test coverage | ✅ 348 tests | ❌ | ❌ | ❌ |
 | Distributed via | `npx`, curl, clone | Manual | Manual | Manual |
 
 ---
@@ -125,6 +128,30 @@ Feature depth varies by platform — hooks are a Claude Code native format, and
 
 Hooks use Claude Code's JSON settings format — no equivalent exists on other platforms. Cursor reads rules and skills from `.cursor/`; its agent system uses a different format not yet compatible with ECC agents.
 
+### Memory & dashboard reality per IDE
+
+Memory storage is a single shared file at `~/.kodelyth/memory/memories.jsonl` — every IDE on the same machine reads and writes the **same** memories. The only thing that varies is *how* memories surface:
+
+| Platform | Auto-recall on every prompt | Auto-capture on success | Manual recall via MCP tool | Dashboard "Live IDE activity" |
+|---|---|---|---|---|
+| **Claude Code** | ✓ (hook) | ✓ (hook) | ✓ | ✓ Claude session files |
+| **Windsurf** | — | — | ✓ `recall_memory` | ✓ Windsurf + Windsurf-Next state |
+| **Cursor** | — | — | ✓ `recall_memory` | ✓ workspace storage dirs |
+| **Codex CLI** | — | — | ✓ `recall_memory` | — |
+| **Antigravity** | — | — | ✓ `recall_memory` | ✓ `.agent/` in cwd |
+| **Roo Code / Aider / Kimi / Cline / Gemini CLI / OpenCode** | — | — | ✓ if MCP-capable | — |
+
+What this means in practice:
+- A memory captured in **Claude Code** is recall-able from every other IDE the same day — the file is shared.
+- In **Windsurf / Cursor / Codex / Antigravity**, the AI does NOT auto-fire memory recall; the `rules/common/memory-protocol.md` rule (installed automatically) tells the AI to call the `recall_memory` MCP tool proactively at the start of substantive prompts.
+- The dashboard's **Sessions → Live IDE activity** tab surfaces session files for Claude Code, Windsurf, Windsurf-Next, Cursor, and Antigravity. Add custom paths via the `KODELYTH_EXTRA_IDE_WATCH` env var (comma-separated).
+
+```bash
+# Watch additional paths in the dashboard
+export KODELYTH_EXTRA_IDE_WATCH="$HOME/my-agent-logs,$HOME/other-tool/state"
+npx kodelyth-ecc dashboard
+```
+
 ### Option 2 — npx from GitHub (always latest commit)
 
 ```bash
@@ -352,7 +379,13 @@ What's inside:
 | **Memory** | Browse, search, and manage your local BM25 memory store |
 | **Evolve** | Self-improving memory — review AI-proposed refinements |
 | **Catalog** | Full searchable index of all 70 agents, 194 skills, 97 commands |
-| **Sessions** | Browse past session excerpts and exported bundles |
+| **Sessions** | **Live IDE activity** (Claude Code, Windsurf, Windsurf-Next, Cursor, Antigravity) + orchestration/swarm sessions |
+
+Real-time:
+- SSE push every 3 seconds, only when at least one browser tab is connected (zero CPU otherwise)
+- Watches memory writes, evolve signals, token-budget changes, and IDE session files
+- "Last activity" auto-updates without a page refresh
+- Set `KODELYTH_EXTRA_IDE_WATCH=path1,path2` to watch additional paths
 
 Security design:
 - **GET-only** — no write endpoints accessible from the UI
@@ -752,12 +785,24 @@ See [CONTRIBUTING.md](CONTRIBUTING.md) for templates, checklists, and the full K
 
 ## Changelog
 
-See [CHANGELOG.md](CHANGELOG.md). v1.7.0 highlights:
+See [CHANGELOG.md](CHANGELOG.md). v1.7.4 highlights:
+
+- **Real-time IDE-aware dashboard** — Sessions tab now surfaces live Claude Code / Windsurf / Windsurf-Next / Cursor / Antigravity activity; SSE poll 10 s → 3 s; new `/api/ide-sessions` endpoint
+- **Cross-IDE memory protocol** — `rules/common/memory-protocol.md` now explicitly instructs non-Claude IDEs (Windsurf, Cursor, Codex, Antigravity) to call the `recall_memory` and `capture_memory` MCP tools proactively
+- **`KODELYTH_EXTRA_IDE_WATCH` env var** — add custom watch paths to the dashboard (comma/semicolon/colon-separated)
+- **Watch-path fixes** — broken `proposals.jsonl`-only watch now also watches `routing-misses.jsonl` and the `token-budget/` directory
+- **+12 dashboard tests** for IDE platform coverage and cross-platform path resolution
+
+v1.7.3 highlights:
+
+- **Social hype pack** — 5 X/Twitter SVG cards + 5 thread scripts, full SVG version sync, GitHub issue templates, repo polish
+
+v1.7.0 highlights:
 
-- **MCP Server** — 16 tools, 6 prompts, 365 resources; stdio JSON-RPC; zero telemetry; works with Claude Desktop, LangGraph, AutoGen, CrewAI, OpenAI Agents SDK
+- **MCP Server** — 16 tools, 6 prompts, 377 resources; stdio JSON-RPC; zero telemetry; works with Claude Desktop, LangGraph, AutoGen, CrewAI, OpenAI Agents SDK
 - **Dashboard hardening** — DNS rebinding protection, shell injection fix (`execFileSync`), CSP on all responses, SSE client cap (max 10), TOCTOU fixes
 - **Devil Mode** — 8 adversarial agents, `--pre-public` / `--pre-launch` / `--all` flags, real bash-grep patterns and remediation playbooks
-- **336 tests** passing across 24 test files
+- **336 tests** passing across 24 test files (now 348 at v1.7.4)
 
 v1.5.8 highlights:
 

package/VERSION

@@ -1 +1 @@
-1.7.3
+1.7.4

package/actions/ecc-review/README.md

@@ -29,7 +29,7 @@ jobs:
         with:
           fetch-depth: 0
 
-      - uses: sifxprime/kodelyth-ecc/actions/ecc-review@v1.6.0
+      - uses: sifxprime/kodelyth-ecc/actions/ecc-review@v1.7.3
         with:
           bundle: red-team
           fail-on: critical
@@ -75,7 +75,7 @@ That's it. Every PR now gets reviewed by ECC's adversarial crew and the findings
 To run a custom set, use `agents:` instead:
 
 ```yaml
-- uses: sifxprime/kodelyth-ecc/actions/ecc-review@v1.6.0
+- uses: sifxprime/kodelyth-ecc/actions/ecc-review@v1.7.3
   with:
     agents: secret-hunter,license-violation-finder,jailbreak-tester
 ```
@@ -87,7 +87,7 @@ To run a custom set, use `agents:` instead:
 ### 1. Indie Hacker — fast feedback, never block
 
 ```yaml
-- uses: sifxprime/kodelyth-ecc/actions/ecc-review@v1.6.0
+- uses: sifxprime/kodelyth-ecc/actions/ecc-review@v1.7.3
   with:
     bundle: indie-hacker
     fail-on: none
@@ -99,7 +99,7 @@ PR gets a comment, but CI never fails. You decide what to address.
 ### 2. Red Team — full adversarial sweep, block on critical
 
 ```yaml
-- uses: sifxprime/kodelyth-ecc/actions/ecc-review@v1.6.0
+- uses: sifxprime/kodelyth-ecc/actions/ecc-review@v1.7.3
   with:
     bundle: red-team
     fail-on: critical
@@ -111,7 +111,7 @@ Default. Recommended for any user-facing product.
 ### 3. Enterprise — strict, block on high
 
 ```yaml
-- uses: sifxprime/kodelyth-ecc/actions/ecc-review@v1.6.0
+- uses: sifxprime/kodelyth-ecc/actions/ecc-review@v1.7.3
   with:
     bundle: enterprise
     fail-on: high
@@ -121,7 +121,7 @@ Default. Recommended for any user-facing product.
 ### 4. Pre-public-release — secret + license + AI safety only
 
 ```yaml
-- uses: sifxprime/kodelyth-ecc/actions/ecc-review@v1.6.0
+- uses: sifxprime/kodelyth-ecc/actions/ecc-review@v1.7.3
   with:
     agents: secret-hunter,license-violation-finder,prompt-injection-hunter
     fail-on: critical
@@ -236,7 +236,7 @@ Reduce findings by tightening `agents:` or `max-files:`. The action caps to firs
 
 - [Kodelyth ECC repo](https://github.com/sifxprime/kodelyth-ecc) — the toolkit this action runs
 - [`/devil-mode` command](../../commands/devil-mode.md) — same agents, run locally
-- [Devil Roadmap](../../) — the broader v1.6.0 → v2.0.0 plan
+- [Devil Roadmap](../../) — the broader v1.7.3 → v2.0.0 plan
 
 ---
 

package/bundles/enterprise.md

@@ -169,4 +169,4 @@ These provide additional audit playbooks on top of the enterprise baseline.
 
 ---
 
-**Powered by Kodelyth ECC v1.6.0+ · Enterprise bundle**
+**Powered by Kodelyth ECC v1.7.4 · Enterprise bundle**

package/bundles/indie-hacker.md

@@ -103,4 +103,4 @@ Run `/devil-mode --all` or `use <agent-name>` any time to access the full crew.
 
 ---
 
-**Powered by Kodelyth ECC v1.6.0+ · Indie Hacker bundle**
+**Powered by Kodelyth ECC v1.7.4 · Indie Hacker bundle**

package/bundles/red-team.md

@@ -135,4 +135,4 @@ Each ~300 lines of real audit logic, not theatrical persona.
 
 ---
 
-**Powered by Kodelyth ECC v1.6.0+ · Red Team bundle**
+**Powered by Kodelyth ECC v1.7.4 · Red Team bundle**

package/docs/supply-chain.md

@@ -102,7 +102,7 @@ Exits `0` on `ok=true`, `1` otherwise. With `--json`, prints the full report:
 
 ```bash
 # 1) Download the manifest from the GitHub release that matches your installed version.
-gh release download v1.7.0 -p kodelyth-ecc-manifest.json -O /tmp/manifest.json
+gh release download v1.7.3 -p kodelyth-ecc-manifest.json -O /tmp/manifest.json
 
 # 2) Run verify against your installed copy.
 npx kodelyth-ecc verify --root "$(npm root -g)/kodelyth-ecc" --manifest /tmp/manifest.json

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kodelyth-ecc",
-  "version": "1.7.3",
+  "version": "1.7.4",
   "description": "Production-grade AI coding toolkit — 70 agents (incl. devil-mode adversarial crew), 194 skills, 97 commands, parallel multi-agent commands, semantic intent routing, self-learning memory, and a built-in MCP server (16 tools / 6 prompts / 377 resources) that bridges to Claude Desktop, LangGraph, AutoGen, CrewAI, and OpenAI Agents SDK. Works with Claude Code, Windsurf, Cursor, Codex, Antigravity, OpenCode, Cline, RooCode, Aider, Kimi, and Gemini CLI.",
   "author": "Kodelyth <github.com/sifxprime>",
   "license": "MIT",
@@ -9,6 +9,9 @@
     "url": "https://github.com/sifxprime/kodelyth-ecc.git"
   },
   "homepage": "https://github.com/sifxprime/kodelyth-ecc",
+  "bugs": {
+    "url": "https://github.com/sifxprime/kodelyth-ecc/issues"
+  },
   "keywords": [
     "claude-code",
     "windsurf",

package/rules/common/memory-protocol.md

@@ -6,19 +6,37 @@
 
 A local file at `~/.kodelyth/memory/memories.jsonl` storing solutions, patterns, and gotchas extracted from past sessions. Retrieval is BM25 (keyword + tag matching). It is **not** a learned model — it is a retrieval store that gives you better context.
 
-If the SessionStart hook ran, you have already received a memory block in your initial context with:
+**Cross-IDE: the same file is read/written by every IDE on this machine.** A memory captured in Claude Code is recall-able from Windsurf, Cursor, Antigravity, Codex, and any other MCP-capable client. There is one shared store.
+
+If the SessionStart hook ran (Claude Code only — other IDEs do not have a hook system), you have already received a memory block in your initial context with:
 - The user's recurring patterns (tags seen across multiple sessions)
 - Recent solutions in this project
 - Their detected stack
 
+If you are NOT in Claude Code (Windsurf / Cursor / Antigravity / Codex / etc.) you must proactively call the MCP tools below — no hook will surface memories for you automatically.
+
+## How to recall memory (works in EVERY IDE)
+
+Call the Kodelyth MCP tool **`recall_memory`** with:
+- `query`: the user's task or topic in their own words
+- `project_root` (optional): the absolute path of the current project — scopes recall to that project's memories first
+- `limit` (optional, default 5)
+
+Equivalent CLIs (any terminal):
+- `npx kodelyth-ecc mcp-call kodelyth recall_memory --query "<text>"`
+- `node scripts/memory/cli.js search "<query>"` (if running from the repo)
+
 ## When to recall memory mid-session
 
-Trigger a memory recall (run the `kodelyth-memory` agent or `node scripts/memory/cli.js search "<query>"`) when **any** of these is true:
+Trigger `recall_memory` when **any** of these is true:
 
-1. The user describes a task in a domain that matches a tag in their memory (`payments`, `auth`, `database`, `deployment`, etc.)
+1. The user describes a task in a domain that likely matches a tag in their memory (`payments`, `auth`, `database`, `deployment`, `tailwind`, `prisma`, etc.)
 2. The user asks "have I done this before?" or "how did I solve X last time?"
-3. The user mentions a library, framework, or service by name that appears in past memories
+3. The user mentions a library, framework, or service by name
 4. You're about to commit to an architectural decision and want to check past precedent
+5. **First substantive prompt of a non-Claude-Code session** — always recall once at the start so you don't miss prior context
+
+Skip recall on trivial prompts (`ok`, `yes`, `thanks`), agent invocations (`use <agent>`, `@<agent>`), and meta-questions about ECC itself.
 
 ## How to surface a recalled memory
 
@@ -37,6 +55,19 @@ Capture when **all** are true:
 
 Show the user the draft memory before storing. Never silently capture.
 
+### How to capture (works in EVERY IDE)
+
+Call the Kodelyth MCP tool **`capture_memory`** with:
+- `problem`: short statement of what was hard (required)
+- `approach`: the solution that worked, with the key insight (required)
+- `tags`: array of short keywords (`['tailwind', 'css', 'v4']`) — these power recall
+- `language` (optional): primary language of the fix
+- `project_root` (optional): absolute path of the project
+- `files` (optional): files touched
+- `gotchas` (optional): array of pitfalls future-you should avoid
+
+Equivalent CLI: `npx kodelyth-ecc mcp-call kodelyth capture_memory --problem "..." --approach "..."`
+
 ## What you must not do
 
 - **Never** auto-recall the same memory twice in one session (the user has seen it)

package/scripts/dashboard/data.js

@@ -1,6 +1,6 @@
 // scripts/dashboard/data.js
 //
-// Local observability dashboard: pure aggregators (v1.7.0).
+// Local observability dashboard: pure aggregators (v1.7.4).
 //
 // All data the dashboard renders comes from:
 //   - The MCP catalog (filesystem reads of agents/, skills/, commands/, rules/, bundles/)
@@ -8,6 +8,7 @@
 //   - The evolve signal streams (~/.kodelyth/evolve/)
 //   - The token-budget hook state (${KODELYTH_TOKEN_BUDGET_DIR})
 //   - The orchestration session dirs (.orchestration/<session>/)
+//   - Live IDE session activity (Claude Code, Windsurf, Antigravity)
 //
 // Every aggregator is pure: takes its inputs explicitly OR uses well-defined
 // env-overridable defaults. No global mutable state. Errors are swallowed
@@ -45,6 +46,35 @@ function defaultBudgetDir() {
 function defaultCoordRoot() {
   return process.env.KODELYTH_COORDINATION_ROOT || path.join(process.cwd(), '.orchestration');
 }
+function defaultClaudeProjectsDir() {
+  return process.env.KODELYTH_CLAUDE_PROJECTS_DIR || path.join(os.homedir(), '.claude', 'projects');
+}
+function defaultWindsurfStateDir() {
+  return process.env.KODELYTH_WINDSURF_DIR || path.join(os.homedir(), '.codeium', 'windsurf');
+}
+function defaultWindsurfNextStateDir() {
+  // Windsurf Next (newer Codeium release) uses a separate state dir.
+  return process.env.KODELYTH_WINDSURF_NEXT_DIR || path.join(os.homedir(), '.codeium', 'windsurf-next');
+}
+function defaultCursorWorkspaceDir() {
+  if (process.env.KODELYTH_CURSOR_DIR) return process.env.KODELYTH_CURSOR_DIR;
+  const home = os.homedir();
+  switch (process.platform) {
+    case 'darwin': return path.join(home, 'Library', 'Application Support', 'Cursor', 'User', 'workspaceStorage');
+    case 'win32':  return path.join(home, 'AppData', 'Roaming', 'Cursor', 'User', 'workspaceStorage');
+    default:       return path.join(home, '.config', 'Cursor', 'User', 'workspaceStorage');
+  }
+}
+function defaultAntigravityStateDir() {
+  // Best-effort — Google Antigravity is in early access and the canonical session
+  // path is not yet documented. Users can override via KODELYTH_ANTIGRAVITY_DIR.
+  return process.env.KODELYTH_ANTIGRAVITY_DIR || path.join(os.homedir(), '.antigravity');
+}
+// Comma-separated extra dirs from env. Each path's mtime contributes to SSE.
+function extraIdeWatchDirs() {
+  const raw = process.env.KODELYTH_EXTRA_IDE_WATCH || '';
+  return raw.split(/[,;:]/).map(s => s.trim()).filter(Boolean);
+}
 
 function safeReadDir(p) {
   try { return fs.readdirSync(p, { withFileTypes: true }); } catch { return []; }
@@ -308,6 +338,225 @@ function safeReadExcerpt(p, max = 800) {
   } catch { return null; }
 }
 
+// ── IDE sessions (Claude Code / Windsurf / Antigravity) ──────────────────────
+//
+// Surfaces the AI coding sessions the user is actually running RIGHT NOW.
+// Read-only filesystem stats — never reads JSONL contents (could be 27MB+).
+// Caps the walk to keep watcher latency predictable.
+
+const IDE_WALK_FILE_CAP = 500; // hard ceiling so a runaway dir can't hang the watcher
+
+function decodeClaudeProjectName(name) {
+  // Claude Code encodes the project's absolute path by replacing '/' with '-'.
+  // Best-effort decode for display only — original separators are unrecoverable.
+  if (!name) return null;
+  return '/' + name.replace(/^-+/, '').replace(/-/g, '/');
+}
+
+function pushTopLevelFiles(sessions, dir, platform, cap, scannedRef) {
+  if (!fs.existsSync(dir)) return;
+  for (const entry of safeReadDir(dir)) {
+    if (scannedRef.value++ > cap) break;
+    if (!entry.isFile()) continue;
+    const fp = path.join(dir, entry.name);
+    const st = safeStat(fp);
+    if (!st) continue;
+    sessions.push({
+      platform,
+      session_id: entry.name,
+      project:    null,
+      path:       fp,
+      size_bytes: st.size,
+      modified:   st.mtime.toISOString(),
+    });
+  }
+}
+
+function ideSessionsList({
+  claudeProjectsDir = defaultClaudeProjectsDir(),
+  windsurfDir       = defaultWindsurfStateDir(),
+  windsurfNextDir   = defaultWindsurfNextStateDir(),
+  cursorDir         = defaultCursorWorkspaceDir(),
+  antigravityDir    = defaultAntigravityStateDir(),
+  extraDirs         = extraIdeWatchDirs(),
+  cwd               = process.cwd(),
+  limit             = 15,
+} = {}) {
+  const sessions = [];
+  const scannedRef = { value: 0 };
+
+  // Claude Code: ~/.claude/projects/<encoded-path>/<uuid>.jsonl
+  if (fs.existsSync(claudeProjectsDir)) {
+    for (const proj of safeReadDir(claudeProjectsDir)) {
+      if (!proj.isDirectory()) continue;
+      const projDir = path.join(claudeProjectsDir, proj.name);
+      for (const f of safeReadDir(projDir)) {
+        if (scannedRef.value++ > IDE_WALK_FILE_CAP) break;
+        if (!f.isFile() || !f.name.endsWith('.jsonl')) continue;
+        const fp = path.join(projDir, f.name);
+        const st = safeStat(fp);
+        if (!st) continue;
+        sessions.push({
+          platform:    'claude-code',
+          session_id:  f.name.replace(/\.jsonl$/, ''),
+          project:     decodeClaudeProjectName(proj.name),
+          path:        fp,
+          size_bytes:  st.size,
+          modified:    st.mtime.toISOString(),
+        });
+      }
+      if (scannedRef.value > IDE_WALK_FILE_CAP) break;
+    }
+  }
+
+  // Windsurf (legacy) + Windsurf-Next: top-level state files only.
+  pushTopLevelFiles(sessions, windsurfDir,     'windsurf',      IDE_WALK_FILE_CAP, scannedRef);
+  pushTopLevelFiles(sessions, windsurfNextDir, 'windsurf-next', IDE_WALK_FILE_CAP, scannedRef);
+
+  // Cursor: ~/Library/Application Support/Cursor/User/workspaceStorage/<hash>/
+  // Each workspace is a directory containing .vscdb sqlite files; we surface
+  // the directory mtime (proxies for last open) without reading SQLite.
+  if (fs.existsSync(cursorDir)) {
+    for (const ws of safeReadDir(cursorDir)) {
+      if (scannedRef.value++ > IDE_WALK_FILE_CAP) break;
+      if (!ws.isDirectory()) continue;
+      const wsDir = path.join(cursorDir, ws.name);
+      const st = safeStat(wsDir);
+      if (!st) continue;
+      sessions.push({
+        platform:    'cursor',
+        session_id:  ws.name,
+        project:     null,
+        path:        wsDir,
+        size_bytes:  0,
+        modified:    st.mtime.toISOString(),
+      });
+    }
+  }
+
+  // Antigravity (home dir, best-effort) + per-workspace .agent/ in cwd.
+  if (fs.existsSync(antigravityDir)) {
+    const st = safeStat(antigravityDir);
+    if (st) {
+      sessions.push({
+        platform:    'antigravity',
+        session_id:  'home',
+        project:     null,
+        path:        antigravityDir,
+        size_bytes:  0,
+        modified:    st.mtime.toISOString(),
+      });
+    }
+  }
+  const agentDir = path.join(cwd, '.agent');
+  if (fs.existsSync(agentDir)) {
+    const st = safeStat(agentDir);
+    if (st) {
+      sessions.push({
+        platform:    'antigravity',
+        session_id:  path.basename(cwd) || 'workspace',
+        project:     cwd,
+        path:        agentDir,
+        size_bytes:  0,
+        modified:    st.mtime.toISOString(),
+      });
+    }
+  }
+
+  // User-supplied extra paths (KODELYTH_EXTRA_IDE_WATCH).
+  // We only record an entry when the path exists; otherwise we silently skip.
+  for (const extra of extraDirs) {
+    if (!fs.existsSync(extra)) continue;
+    const st = safeStat(extra);
+    if (!st) continue;
+    sessions.push({
+      platform:    'custom',
+      session_id:  path.basename(extra) || 'extra',
+      project:     extra,
+      path:        extra,
+      size_bytes:  st.isFile() ? st.size : 0,
+      modified:    st.mtime.toISOString(),
+    });
+  }
+
+  sessions.sort((a, b) => b.modified.localeCompare(a.modified));
+  return sessions.slice(0, Math.max(1, Math.min(100, limit)));
+}
+
+// Cheap mtime aggregator used by the SSE file-watcher tick.
+// Returns the largest mtimeMs across IDE session files. 0 if nothing found.
+function getMaxIdeMtime({
+  claudeProjectsDir = defaultClaudeProjectsDir(),
+  windsurfDir       = defaultWindsurfStateDir(),
+  windsurfNextDir   = defaultWindsurfNextStateDir(),
+  cursorDir         = defaultCursorWorkspaceDir(),
+  antigravityDir    = defaultAntigravityStateDir(),
+  extraDirs         = extraIdeWatchDirs(),
+  cwd               = process.cwd(),
+} = {}) {
+  let maxMs = 0;
+  let scanned = 0;
+
+  // Claude Code
+  if (fs.existsSync(claudeProjectsDir)) {
+    for (const proj of safeReadDir(claudeProjectsDir)) {
+      if (!proj.isDirectory()) continue;
+      const projDir = path.join(claudeProjectsDir, proj.name);
+      for (const f of safeReadDir(projDir)) {
+        if (scanned++ > IDE_WALK_FILE_CAP) break;
+        if (!f.isFile() || !f.name.endsWith('.jsonl')) continue;
+        const st = safeStat(path.join(projDir, f.name));
+        if (st && st.mtimeMs > maxMs) maxMs = st.mtimeMs;
+      }
+      if (scanned > IDE_WALK_FILE_CAP) break;
+    }
+  }
+
+  // Windsurf (legacy + next) — dir mtime + one level of files.
+  for (const dir of [windsurfDir, windsurfNextDir]) {
+    if (!fs.existsSync(dir)) continue;
+    const st = safeStat(dir);
+    if (st && st.mtimeMs > maxMs) maxMs = st.mtimeMs;
+    for (const entry of safeReadDir(dir)) {
+      if (scanned++ > IDE_WALK_FILE_CAP) break;
+      if (!entry.isFile()) continue;
+      const fst = safeStat(path.join(dir, entry.name));
+      if (fst && fst.mtimeMs > maxMs) maxMs = fst.mtimeMs;
+    }
+  }
+
+  // Cursor workspace dirs
+  if (fs.existsSync(cursorDir)) {
+    for (const ws of safeReadDir(cursorDir)) {
+      if (scanned++ > IDE_WALK_FILE_CAP) break;
+      if (!ws.isDirectory()) continue;
+      const st = safeStat(path.join(cursorDir, ws.name));
+      if (st && st.mtimeMs > maxMs) maxMs = st.mtimeMs;
+    }
+  }
+
+  // Antigravity
+  if (fs.existsSync(antigravityDir)) {
+    const st = safeStat(antigravityDir);
+    if (st && st.mtimeMs > maxMs) maxMs = st.mtimeMs;
+  }
+  const agentDir = path.join(cwd, '.agent');
+  if (fs.existsSync(agentDir)) {
+    const st = safeStat(agentDir);
+    if (st && st.mtimeMs > maxMs) maxMs = st.mtimeMs;
+  }
+
+  // Extra user-supplied watch paths (KODELYTH_EXTRA_IDE_WATCH).
+  for (const extra of extraDirs) {
+    if (scanned++ > IDE_WALK_FILE_CAP) break;
+    if (!fs.existsSync(extra)) continue;
+    const st = safeStat(extra);
+    if (st && st.mtimeMs > maxMs) maxMs = st.mtimeMs;
+  }
+
+  return maxMs;
+}
+
 // ── token budget snapshot ────────────────────────────────────────────────────
 
 function tokenBudgetSnapshot({ budgetDir = defaultBudgetDir() } = {}) {
@@ -343,11 +592,19 @@ module.exports = {
   // catalog
   catalogList,
   catalogCounts,
-  // sessions
+  // sessions (orchestration)
   sessionsList,
   sessionDetail,
+  // ide sessions (claude code / windsurf / antigravity)
+  ideSessionsList,
   // token budget
   tokenBudgetSnapshot,
-  // exposed for tests
-  _internals: { defaultMemoryDir, defaultEvolveDir, defaultBudgetDir, defaultCoordRoot, safeReadDir, safeReadJson, safeReadExcerpt },
+  // exposed for tests + the file-watcher tick
+  _internals: {
+    defaultMemoryDir, defaultEvolveDir, defaultBudgetDir, defaultCoordRoot,
+    defaultClaudeProjectsDir, defaultWindsurfStateDir, defaultWindsurfNextStateDir,
+    defaultCursorWorkspaceDir, defaultAntigravityStateDir, extraIdeWatchDirs,
+    safeReadDir, safeReadJson, safeReadExcerpt,
+    getMaxIdeMtime,
+  },
 };

package/scripts/dashboard/server.js

@@ -1,6 +1,6 @@
 // scripts/dashboard/server.js
 //
-// Local observability dashboard server (v1.7.0).
+// Local observability dashboard server (v1.7.4).
 //
 // HTTP server using ONLY Node.js built-ins. Serves:
 //   GET  /                        → static index.html
@@ -11,7 +11,9 @@
 //   GET  /api/catalog?kind=…&q=…  → agents | skills | commands | rules | bundles
 //   GET  /api/sessions            → orchestration session list
 //   GET  /api/sessions/:name      → single session detail
+//   GET  /api/ide-sessions        → live Claude Code / Windsurf / Antigravity activity
 //   GET  /api/token-budget        → per-session token usage
+//   GET  /api/events              → SSE stream of data-changed events
 //   GET  /api/health              → tiny liveness probe
 //
 // Default bind: 127.0.0.1 (localhost ONLY). Refuses to bind 0.0.0.0 unless
@@ -32,13 +34,18 @@ const sseClients = new Set();
 const MAX_SSE_CLIENTS = 10;
 
 // Key files that signal data changes when their mtime moves.
+// IMPORTANT: include both `routing-misses.jsonl` (always present once evolve sees
+// any miss) AND `proposals.jsonl` (created later, after `evolve analyze` runs).
 const WATCH_PATHS = [
-  path.join(os.homedir(), '.kodelyth', 'memory', 'memories.jsonl'),
+  path.join(os.homedir(), '.kodelyth', 'memory',  'memories.jsonl'),
   path.join(os.homedir(), '.kodelyth', 'evolve',  'reuse.json'),
+  path.join(os.homedir(), '.kodelyth', 'evolve',  'routing-misses.jsonl'),
   path.join(os.homedir(), '.kodelyth', 'evolve',  'proposals.jsonl'),
+  path.join(os.homedir(), '.kodelyth', 'token-budget'), // dir mtime — changes when budget files appear
 ];
 const lastMtimes    = new Map();
-const FILE_CHECK_MS = 10000; // check every 10 s
+let   lastIdeMtime  = 0; // max mtime across Claude Code / Windsurf / Antigravity sessions
+const FILE_CHECK_MS = 3000; // poll every 3 s — "feels live" without burning CPU
 
 function broadcastSSE(obj) {
   const msg = `data: ${JSON.stringify(obj)}\n\n`;
@@ -55,15 +62,27 @@ function startFileWatcher() {
   for (const p of WATCH_PATHS) {
     try { lastMtimes.set(p, fs.statSync(p).mtimeMs); } catch { /* file not yet present */ }
   }
+  try { lastIdeMtime = data._internals.getMaxIdeMtime(); } catch { lastIdeMtime = 0; }
+
   _fileWatchTimer = setInterval(() => {
     if (sseClients.size === 0) return; // no connected browsers — skip stat I/O
     let changed = false;
+
+    // Static watched files (memory, evolve, token-budget).
     for (const p of WATCH_PATHS) {
       try {
         const m = fs.statSync(p).mtimeMs;
         if (lastMtimes.get(p) !== m) { changed = true; lastMtimes.set(p, m); }
       } catch { /* file doesn't exist yet — that's fine */ }
     }
+
+    // Live IDE activity — Claude Code / Windsurf / Antigravity.
+    // Cheap: only stats jsonl files in known dirs, capped at 500 files per tick.
+    try {
+      const m = data._internals.getMaxIdeMtime();
+      if (m > lastIdeMtime) { changed = true; lastIdeMtime = m; }
+    } catch { /* swallow — IDE watch must never break the heartbeat */ }
+
     broadcastSSE({ type: changed ? 'data-changed' : 'heartbeat', time: new Date().toISOString() });
   }, FILE_CHECK_MS);
 }
@@ -241,6 +260,12 @@ function handleRequest(req, res) {
       });
     }
 
+    if (p === '/api/ide-sessions') {
+      return jsonResponse(res, 200, {
+        sessions: data.ideSessionsList({ limit: Number(q.get('limit')) || 15 }),
+      });
+    }
+
     const sessMatch = p.match(/^\/api\/sessions\/([A-Za-z0-9._-]+)$/);
     if (sessMatch) {
       const sessionName = sessMatch[1];