context-mode 1.0.101 → 1.0.104

package/build/session/analytics.d.ts

@@ -41,6 +41,13 @@ export interface SandboxIO {
     inputBytes: number;
     outputBytes: number;
 }
+/** MCP tool usage row — concurrency stats for batch-style tools. */
+export interface McpToolUsageRow {
+    tool_name: string;
+    calls: number;
+    median_concurrency: number | null;
+    max_concurrency: number | null;
+}
 /** Runtime stats tracked by server.ts during a live session. */
 export interface RuntimeStats {
     bytesReturned: Record<string, number>;
@@ -150,6 +157,18 @@ export declare class AnalyticsEngine {
      * Stub: requires PolyglotExecutor byte counters.
      */
     static sandboxIO(inputBytes: number, outputBytes: number): SandboxIO;
+    /**
+     * MCP tool usage — call counts and concurrency stats per MCP tool.
+     *
+     * Reads `mcp_tool_call` events, parses the JSON payload, and aggregates:
+     *  - call count per tool_name
+     *  - median + max of `params.concurrency` (only for tools that take it,
+     *    e.g. ctx_batch_execute, ctx_fetch_and_index). Returns null when the
+     *    tool doesn't carry a concurrency param so callers can render N/A.
+     *
+     * Best-effort: malformed rows or truncated payloads are skipped silently.
+     */
+    getMcpToolUsage(): McpToolUsageRow[];
     /**
      * Build a FullReport by merging runtime stats (passed in)
      * with continuity data from the DB.
@@ -158,6 +177,32 @@ export declare class AnalyticsEngine {
      */
     queryAll(runtimeStats: RuntimeStats): FullReport;
 }
+/** Aggregated stats spanning every SessionDB + auto-memory under the user's profile. */
+export interface LifetimeStats {
+    totalEvents: number;
+    totalSessions: number;
+    autoMemoryCount: number;
+    autoMemoryProjects: number;
+    /** Per-prefix breakdown of auto-memory files (user/feedback/project/...). */
+    autoMemoryByPrefix: Record<string, number>;
+}
+/**
+ * Aggregate lifetime stats from all SessionDB files in `sessionsDir` and
+ * all auto-memory markdown files under `memoryRoot/<project>/memory/`.
+ *
+ * Best-effort: silently ignores missing/unreadable files so ctx_stats
+ * can never be broken by a corrupt sidecar.
+ */
+export declare function getLifetimeStats(opts?: {
+    sessionsDir?: string;
+    memoryRoot?: string;
+    /** Override for tests — defaults to db-base loadDatabase(). */
+    loadDatabase?: () => unknown;
+}): LifetimeStats;
+/** Opus 4 input price: $15 per 1M tokens. */
+export declare const OPUS_INPUT_PRICE_PER_TOKEN: number;
+/** Convert a token count to a USD string at the Opus input rate. */
+export declare function tokensToUsd(tokens: number): string;
 /**
  * Render a FullReport as a visual savings dashboard designed for screenshotting.
  *
@@ -168,4 +213,7 @@ export declare class AnalyticsEngine {
  * - Project memory: category bars showing persistent data across sessions
  * - No: Pct column, category tables, tips, jargon
  */
-export declare function formatReport(report: FullReport, version?: string, latestVersion?: string | null): string;
+export declare function formatReport(report: FullReport, version?: string, latestVersion?: string | null, opts?: {
+    lifetime?: LifetimeStats;
+    mcpUsage?: McpToolUsageRow[];
+}): string;

package/build/session/analytics.js

@@ -8,6 +8,10 @@
  *   const engine = new AnalyticsEngine(sessionDb);
  *   const report = engine.queryAll(runtimeStats);
  */
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { loadDatabase as loadDatabaseImpl } from "../db-base.js";
 function semverNewer(a, b) {
     const pa = a.split(".").map(Number);
     const pb = b.split(".").map(Number);
@@ -42,10 +46,10 @@ export const categoryLabels = {
 };
 /** Explains why each category matters for continuity. */
 export const categoryHints = {
-    file: "Restored after compact \u2014 no need to re-read",
+    file: "Restored after compact — no need to re-read",
     rule: "Your project instructions survive context resets",
     prompt: "Continues exactly where you left off",
-    decision: "Applied automatically \u2014 won\u2019t ask again",
+    decision: "Applied automatically — won’t ask again",
     task: "Picks up from where it stopped",
     error: "Tracked and monitored across compacts",
     git: "Branch, commit, and repo state preserved",
@@ -115,6 +119,73 @@ export class AnalyticsEngine {
     static sandboxIO(inputBytes, outputBytes) {
         return { inputBytes, outputBytes };
     }
+    /**
+     * MCP tool usage — call counts and concurrency stats per MCP tool.
+     *
+     * Reads `mcp_tool_call` events, parses the JSON payload, and aggregates:
+     *  - call count per tool_name
+     *  - median + max of `params.concurrency` (only for tools that take it,
+     *    e.g. ctx_batch_execute, ctx_fetch_and_index). Returns null when the
+     *    tool doesn't carry a concurrency param so callers can render N/A.
+     *
+     * Best-effort: malformed rows or truncated payloads are skipped silently.
+     */
+    getMcpToolUsage() {
+        let rows;
+        try {
+            rows = this.db.prepare("SELECT data FROM session_events WHERE category = 'mcp_tool_call'").all();
+        }
+        catch {
+            return [];
+        }
+        // toolName -> { calls, concurrencies }
+        const agg = new Map();
+        for (const row of rows) {
+            let parsed;
+            try {
+                parsed = JSON.parse(row.data);
+            }
+            catch {
+                continue;
+            }
+            const toolName = typeof parsed.tool_name === "string" ? parsed.tool_name : null;
+            if (!toolName)
+                continue;
+            const bucket = agg.get(toolName) ?? { calls: 0, concurrencies: [] };
+            bucket.calls += 1;
+            // Skip concurrency extraction when the row was truncated — the params
+            // blob is a substring of JSON that may not parse cleanly.
+            if (parsed.truncated !== true && parsed.params && typeof parsed.params === "object") {
+                const c = parsed.params.concurrency;
+                if (typeof c === "number" && Number.isFinite(c) && c > 0) {
+                    bucket.concurrencies.push(c);
+                }
+            }
+            agg.set(toolName, bucket);
+        }
+        const out = [];
+        for (const [tool_name, b] of agg) {
+            let median = null;
+            let max = null;
+            if (b.concurrencies.length > 0) {
+                const sorted = [...b.concurrencies].sort((a, c) => a - c);
+                const mid = Math.floor(sorted.length / 2);
+                median = sorted.length % 2 === 0
+                    ? (sorted[mid - 1] + sorted[mid]) / 2
+                    : sorted[mid];
+                max = sorted[sorted.length - 1];
+            }
+            out.push({
+                tool_name,
+                calls: b.calls,
+                median_concurrency: median,
+                max_concurrency: max,
+            });
+        }
+        // Stable sort: most-called first, then alphabetical
+        out.sort((a, c) => c.calls - a.calls || a.tool_name.localeCompare(c.tool_name));
+        return out;
+    }
     // ═══════════════════════════════════════════════════════
     // queryAll — single unified report from ONE source
     // ═══════════════════════════════════════════════════════
@@ -241,6 +312,110 @@ export class AnalyticsEngine {
         };
     }
 }
+/** Extract leading prefix from auto-memory filename: `feedback_push.md` → `feedback`. */
+function autoMemoryPrefix(filename) {
+    const base = filename.replace(/\.md$/i, "");
+    const m = base.match(/^([a-z]+)/i);
+    return m ? m[1].toLowerCase() : "other";
+}
+/**
+ * Aggregate lifetime stats from all SessionDB files in `sessionsDir` and
+ * all auto-memory markdown files under `memoryRoot/<project>/memory/`.
+ *
+ * Best-effort: silently ignores missing/unreadable files so ctx_stats
+ * can never be broken by a corrupt sidecar.
+ */
+export function getLifetimeStats(opts) {
+    const sessionsDir = opts?.sessionsDir
+        ?? join(homedir(), ".claude", "context-mode", "sessions");
+    const memoryRoot = opts?.memoryRoot
+        ?? join(homedir(), ".claude", "projects");
+    let totalEvents = 0;
+    let totalSessions = 0;
+    // ── SessionDB aggregation ──
+    if (existsSync(sessionsDir)) {
+        let dbFiles = [];
+        try {
+            dbFiles = readdirSync(sessionsDir).filter((f) => f.endsWith(".db"));
+        }
+        catch { /* unreadable */ }
+        if (dbFiles.length > 0) {
+            // Lazy-load better-sqlite3 / bun-sqlite via the same path the runtime uses.
+            let DatabaseCtor = null;
+            try {
+                DatabaseCtor = opts?.loadDatabase
+                    ? opts.loadDatabase()
+                    : loadDatabaseImpl();
+            }
+            catch { /* sqlite unavailable */ }
+            if (DatabaseCtor) {
+                for (const file of dbFiles) {
+                    const dbPath = join(sessionsDir, file);
+                    try {
+                        const sdb = new DatabaseCtor(dbPath, { readonly: true });
+                        try {
+                            const ev = sdb.prepare("SELECT COUNT(*) AS cnt FROM session_events").get();
+                            const ss = sdb.prepare("SELECT COUNT(*) AS cnt FROM session_meta").get();
+                            totalEvents += ev?.cnt ?? 0;
+                            totalSessions += ss?.cnt ?? 0;
+                        }
+                        finally {
+                            sdb.close();
+                        }
+                    }
+                    catch {
+                        // missing tables / corrupt file — skip
+                    }
+                }
+            }
+        }
+    }
+    // ── Auto-memory file scan ──
+    let autoMemoryCount = 0;
+    let autoMemoryProjects = 0;
+    const autoMemoryByPrefix = {};
+    if (existsSync(memoryRoot)) {
+        let projectDirs = [];
+        try {
+            projectDirs = readdirSync(memoryRoot).filter((entry) => {
+                try {
+                    return statSync(join(memoryRoot, entry)).isDirectory();
+                }
+                catch {
+                    return false;
+                }
+            });
+        }
+        catch { /* unreadable */ }
+        for (const proj of projectDirs) {
+            const memDir = join(memoryRoot, proj, "memory");
+            if (!existsSync(memDir))
+                continue;
+            let mdFiles = [];
+            try {
+                mdFiles = readdirSync(memDir).filter((f) => f.endsWith(".md"));
+            }
+            catch {
+                continue;
+            }
+            if (mdFiles.length === 0)
+                continue;
+            autoMemoryProjects++;
+            autoMemoryCount += mdFiles.length;
+            for (const f of mdFiles) {
+                const prefix = autoMemoryPrefix(f);
+                autoMemoryByPrefix[prefix] = (autoMemoryByPrefix[prefix] ?? 0) + 1;
+            }
+        }
+    }
+    return {
+        totalEvents,
+        totalSessions,
+        autoMemoryCount,
+        autoMemoryProjects,
+        autoMemoryByPrefix,
+    };
+}
 // ─────────────────────────────────────────────────────────
 // formatReport — renders FullReport as sales-grade savings dashboard
 // ─────────────────────────────────────────────────────────
@@ -271,6 +446,16 @@ function fmtNum(n) {
         return `${(n / 1_000).toFixed(1)}K`;
     return String(n);
 }
+// ─────────────────────────────────────────────────────────
+// Pricing (Bug #6) — Anthropic Opus input rate
+// ─────────────────────────────────────────────────────────
+/** Opus 4 input price: $15 per 1M tokens. */
+export const OPUS_INPUT_PRICE_PER_TOKEN = 15 / 1_000_000;
+/** Convert a token count to a USD string at the Opus input rate. */
+export function tokensToUsd(tokens) {
+    const safe = Number.isFinite(tokens) && tokens > 0 ? tokens : 0;
+    return `$${(safe * OPUS_INPUT_PRICE_PER_TOKEN).toFixed(2)}`;
+}
 /**
  * Build a proportional bar using █ chars, scaled to a fixed width.
  * Returns e.g. "████████████████████████████████████████" for full width.
@@ -283,20 +468,72 @@ function dataBar(bytes, maxBytes, width = 40) {
 }
 /**
  * Render project memory section with category bars.
- * Shows persistent event data across all sessions.
+ *
+ * Shows persistent event data, and — when supplied — lifetime totals
+ * across every project's SessionDB so users see the cumulative value
+ * (Bug #3).
+ *
+ * Caps the category list at `topN` and prints "N more categories" with the
+ * actual remaining count (Bug #5 — was hardcoded "9 more").
  */
-function renderProjectMemory(pm) {
-    if (pm.total_events === 0)
+function renderProjectMemory(pm, opts) {
+    if (pm.total_events === 0 && (opts?.lifetime?.totalEvents ?? 0) === 0)
         return [];
+    const topN = opts?.topN ?? 2;
     const out = [];
     out.push("");
-    const sessionLabel = pm.session_count === 1 ? "1 session" : `${pm.session_count} sessions`;
-    out.push(`${fmtNum(pm.total_events)} events remembered across ${sessionLabel} \u2014 searchable after compact & restart`);
+    out.push("Persistent memory  ✓ preserved across compact, restart & upgrade");
+    // Lifetime line (Bug #3) — collapses to project-only when lifetime missing.
+    const lifeEvents = opts?.lifetime?.totalEvents ?? pm.total_events;
+    const lifeSessions = opts?.lifetime?.totalSessions ?? pm.session_count;
+    const sessionLabel = lifeSessions === 1 ? "1 session" : `${fmtNum(lifeSessions)} sessions`;
+    // Estimate lifetime savings: ~1KB per event → ~256 tokens/event at Opus rates.
+    const lifetimeTokens = lifeEvents * 256;
+    out.push(`  ${fmtNum(lifeEvents)} events · ${sessionLabel} · ~${tokensToUsd(lifetimeTokens)} saved lifetime`);
     out.push("");
-    const maxCount = pm.by_category.length > 0 ? pm.by_category[0].count : 1;
-    for (const cat of pm.by_category) {
+    const cats = pm.by_category;
+    const visible = cats.slice(0, topN);
+    const maxCount = visible.length > 0 ? visible[0].count : 1;
+    for (const cat of visible) {
         out.push(`  ${cat.label.padEnd(18)} ${String(cat.count).padStart(5)}   ${dataBar(cat.count, maxCount, 30)}`);
     }
+    // Bug #5: real overflow count, not hardcoded.
+    const remaining = Math.max(0, cats.length - topN);
+    if (remaining > 0) {
+        out.push(`  ... ${remaining} more categor${remaining === 1 ? "y" : "ies"}`);
+    }
+    return out;
+}
+/**
+ * Render the auto-memory section (Bug #4) — files Claude Code captured
+ * under ~/.claude/projects/<project>/memory/ across the user's machine.
+ */
+function renderAutoMemory(lifetime) {
+    if (!lifetime || lifetime.autoMemoryCount === 0)
+        return [];
+    const out = [];
+    out.push("");
+    out.push(`Auto-memory  ✓ ${lifetime.autoMemoryCount} preference${lifetime.autoMemoryCount === 1 ? "" : "s"} learned across ${lifetime.autoMemoryProjects} project${lifetime.autoMemoryProjects === 1 ? "" : "s"}`);
+    const entries = Object.entries(lifetime.autoMemoryByPrefix)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 6);
+    for (const [prefix, count] of entries) {
+        out.push(`  ${prefix.padEnd(12)} ${String(count).padStart(2)}`);
+    }
+    return out;
+}
+/** Render the closing "Bottom line" footer (Bug #8). */
+function renderBottomLine(sessionTokensSaved, lifetime) {
+    const out = [];
+    const sessionUsd = tokensToUsd(sessionTokensSaved);
+    // Lifetime estimate: ~1KB/event ÷ 4 bytes/token = 256 tokens/event.
+    const lifetimeTokens = (lifetime?.totalEvents ?? 0) * 256;
+    const lifetimeUsd = tokensToUsd(lifetimeTokens);
+    out.push("");
+    out.push("─".repeat(65));
+    out.push("Your AI talks less, remembers more, costs less.");
+    out.push(`${sessionUsd} this session  ·  ${lifetimeUsd} lifetime`);
+    out.push("─".repeat(65));
     return out;
 }
 /**
@@ -309,9 +546,11 @@ function renderProjectMemory(pm) {
  * - Project memory: category bars showing persistent data across sessions
  * - No: Pct column, category tables, tips, jargon
  */
-export function formatReport(report, version, latestVersion) {
+export function formatReport(report, version, latestVersion, opts) {
     const lines = [];
     const duration = formatDuration(report.session.uptime_min);
+    const lifetime = opts?.lifetime;
+    const mcpUsage = opts?.mcpUsage;
     // ── Compute real savings ──
     const totalKeptOut = report.savings.kept_out + (report.cache ? report.cache.bytes_saved : 0);
     const totalReturned = report.savings.total_bytes_returned;
@@ -319,6 +558,9 @@ export function formatReport(report, version, latestVersion) {
     const grandTotal = totalKeptOut + totalReturned;
     const savingsPct = grandTotal > 0 ? (totalKeptOut / grandTotal) * 100 : 0;
     const tokensSaved = Math.round(totalKeptOut / 4);
+    const ratioMultiplier = totalReturned > 0
+        ? Math.max(1, Math.round(grandTotal / Math.max(totalReturned, 1)))
+        : 0;
     // ── Fresh session: no savings yet ──
     if (totalKeptOut === 0) {
         lines.push(`context-mode  ${duration}  ${totalCalls} calls`);
@@ -329,8 +571,10 @@ export function formatReport(report, version, latestVersion) {
         else {
             lines.push(`${kb(totalReturned)} entered context  |  0 tokens saved`);
         }
-        // Project memory
-        lines.push(...renderProjectMemory(report.projectMemory));
+        // Project memory + auto-memory + bottom line
+        lines.push(...renderProjectMemory(report.projectMemory, { lifetime }));
+        lines.push(...renderAutoMemory(lifetime));
+        lines.push(...renderBottomLine(0, lifetime));
         // Footer
         lines.push("");
         const versionStr = version ? `v${version}` : "context-mode";
@@ -342,14 +586,21 @@ export function formatReport(report, version, latestVersion) {
     }
     // ── Active session: visual savings dashboard ──
     // Line 1: Hero metric — the screenshottable number
-    lines.push(`${fmtNum(tokensSaved)} tokens saved  ·  ${savingsPct.toFixed(1)}% reduction  ·  ${duration}`);
+    // Bug #6: include Opus pricing on the hero line for credibility.
+    lines.push(`${fmtNum(tokensSaved)} tokens saved  ·  ${savingsPct.toFixed(1)}% reduction  ·  ${duration}  ·  ~${tokensToUsd(tokensSaved)} saved (Opus)`);
     lines.push("");
     // Lines 2-3: Before/After comparison bars — the visual proof
     lines.push(`Without context-mode  |${dataBar(grandTotal, grandTotal)}| ${kb(grandTotal)}`);
     lines.push(`With context-mode     |${dataBar(totalReturned, grandTotal)}| ${kb(totalReturned)}`);
     lines.push("");
     // Value statement — the line people share
-    lines.push(`${kb(totalKeptOut)} kept out of your conversation. Never entered context.`);
+    // Bug #7: replace meaningless "3.0x" ratio with "3× longer sessions".
+    if (ratioMultiplier >= 2) {
+        lines.push(`${kb(totalKeptOut)} kept out of your conversation — ${ratioMultiplier}× longer sessions before compact.`);
+    }
+    else {
+        lines.push(`${kb(totalKeptOut)} kept out of your conversation. Never entered context.`);
+    }
     lines.push("");
     // Compact stats row
     const statParts = [`${totalCalls} calls`];
@@ -376,8 +627,19 @@ export function formatReport(report, version, latestVersion) {
             lines.push(`  ${name.padEnd(22)}  ${String(t.calls).padStart(4)} calls  ${kb(t.estimatedSaved).padStart(8)} saved`);
         }
     }
-    // ── Project memory — persistent across sessions ──
-    lines.push(...renderProjectMemory(report.projectMemory));
+    // ── MCP concurrency usage (only when batch tools recorded a concurrency) ──
+    if (mcpUsage && mcpUsage.length > 0) {
+        const concurrent = mcpUsage.filter((u) => u.median_concurrency != null);
+        for (const u of concurrent) {
+            lines.push(`MCP concurrency usage: ${u.tool_name} median=${u.median_concurrency} max=${u.max_concurrency} (${u.calls} calls)`);
+        }
+    }
+    // ── Project memory — persistent across sessions (Bug #3 + #5) ──
+    lines.push(...renderProjectMemory(report.projectMemory, { lifetime }));
+    // ── Auto-memory — Claude Code's preference learnings (Bug #4) ──
+    lines.push(...renderAutoMemory(lifetime));
+    // ── Bottom line — business value framing (Bug #8) ──
+    lines.push(...renderBottomLine(tokensSaved, lifetime));
     // ── Footer ──
     lines.push("");
     const versionStr = version ? `v${version}` : "context-mode";

package/build/session/db.d.ts

@@ -8,15 +8,8 @@
 import { SQLiteBase } from "../db-base.js";
 import type { SessionEvent } from "../types.js";
 import type { ProjectAttribution } from "./project-attribution.js";
-/**
- * Returns the worktree suffix to append to session identifiers.
- * Returns empty string when running in the main working tree.
- *
- * Set CONTEXT_MODE_SESSION_SUFFIX to an explicit value to override
- * (useful in CI environments or when git is unavailable).
- * Set to empty string to disable isolation entirely.
- */
 export declare function getWorktreeSuffix(): string;
+export declare function _resetWorktreeSuffixCacheForTests(): void;
 /** A stored event row from the session_events table. */
 export interface StoredEvent {
     id: number;
@@ -47,6 +40,15 @@ export interface ResumeRow {
     event_count: number;
     consumed: number;
 }
+/** Aggregated tool-call stats for a single session. */
+export interface ToolCallStats {
+    totalCalls: number;
+    totalBytesReturned: number;
+    byTool: Record<string, {
+        calls: number;
+        bytesReturned: number;
+    }>;
+}
 export declare class SessionDB extends SQLiteBase {
     /**
      * Cached prepared statements. Stored in a Map to avoid the JS private-field
@@ -76,6 +78,18 @@ export declare class SessionDB extends SQLiteBase {
      * lowest-priority (then oldest) event.
      */
     insertEvent(sessionId: string, event: SessionEvent, sourceHook?: string, attribution?: Partial<ProjectAttribution>): void;
+    /**
+     * Bulk-insert N events in a SINGLE transaction.
+     *
+     * PostToolUse hooks emit 5–15 events per tool call. Calling insertEvent()
+     * in a loop runs N transactions = N WAL commits = N fsync candidates,
+     * which is painful on Windows NTFS where commit latency dominates.
+     * One transaction = one commit, dedup/evict checks reuse cached statements.
+     *
+     * Cross-platform: uses the same WAL-mode transaction primitive as
+     * insertEvent — behavior identical on macOS / Linux / Windows.
+     */
+    bulkInsertEvents(sessionId: string, events: SessionEvent[], sourceHook?: string, attributions?: Array<Partial<ProjectAttribution> | undefined>): void;
     /**
      * Retrieve events for a session with optional filtering.
      */
@@ -134,6 +148,23 @@ export declare class SessionDB extends SQLiteBase {
      * Mark the resume snapshot as consumed (already injected into conversation).
      */
     markResumeConsumed(sessionId: string): void;
+    /**
+     * Return the most recent session_id from session_meta, or null if none.
+     * Used by the runtime to attach persistent counters to the right session
+     * after a process restart.
+     */
+    getLatestSessionId(): string | null;
+    /**
+     * Increment the persistent tool-call counter for `tool` in `sessionId`.
+     * Adds `bytesReturned` to the cumulative total. Idempotent across
+     * SessionDB instances — counters survive process restart.
+     */
+    incrementToolCall(sessionId: string, tool: string, bytesReturned?: number): void;
+    /**
+     * Get aggregated tool-call stats for `sessionId`. Returns zero-stats
+     * when the session has no recorded calls.
+     */
+    getToolCallStats(sessionId: string): ToolCallStats;
     /**
      * Delete all data for a session (events, meta, resume).
      */