context-mode 1.0.107 → 1.0.109

package/build/session/analytics.js

@@ -332,6 +332,7 @@ export function getLifetimeStats(opts) {
         ?? join(homedir(), ".claude", "projects");
     let totalEvents = 0;
     let totalSessions = 0;
+    const categoryCounts = {};
     // ── SessionDB aggregation ──
     if (existsSync(sessionsDir)) {
         let dbFiles = [];
@@ -358,6 +359,20 @@ export function getLifetimeStats(opts) {
                             const ss = sdb.prepare("SELECT COUNT(*) AS cnt FROM session_meta").get();
                             totalEvents += ev?.cnt ?? 0;
                             totalSessions += ss?.cnt ?? 0;
+                            // Per-category aggregation across every sidecar so the
+                            // Persistent memory bars stay populated even when the
+                            // current project's local DB is fresh / empty.
+                            try {
+                                const catRows = sdb.prepare("SELECT category, COUNT(*) AS cnt FROM session_events GROUP BY category").all();
+                                for (const row of catRows) {
+                                    if (!row.category)
+                                        continue;
+                                    categoryCounts[row.category] = (categoryCounts[row.category] ?? 0) + (row.cnt ?? 0);
+                                }
+                            }
+                            catch {
+                                // older schema / no category column — ignore
+                            }
                         }
                         finally {
                             sdb.close();
@@ -414,6 +429,7 @@ export function getLifetimeStats(opts) {
         autoMemoryCount,
         autoMemoryProjects,
         autoMemoryByPrefix,
+        categoryCounts,
     };
 }
 // ─────────────────────────────────────────────────────────
@@ -477,21 +493,51 @@ function dataBar(bytes, maxBytes, width = 40) {
  * actual remaining count (Bug #5 — was hardcoded "9 more").
  */
 function renderProjectMemory(pm, opts) {
-    if (pm.total_events === 0 && (opts?.lifetime?.totalEvents ?? 0) === 0)
+    const sessionTokensSaved = opts?.sessionTokensSaved ?? 0;
+    // Render when EITHER disk has data OR current session has earnings.
+    if (pm.total_events === 0 &&
+        (opts?.lifetime?.totalEvents ?? 0) === 0 &&
+        sessionTokensSaved === 0) {
         return [];
+    }
     const topN = opts?.topN ?? 2;
     const out = [];
     out.push("");
     out.push("Persistent memory  ✓ preserved across compact, restart & upgrade");
-    // Lifetime line (Bug #3) — collapses to project-only when lifetime missing.
+    // Lifetime line — disk-aggregated lifetime PLUS current session's in-memory
+    // savings. Two separate accounting pipelines (server bytes vs hook events)
+    // get unified at the render edge so the user always sees a monotonic total
+    // (lifetime ≥ session). Without this, fresh users / pre-b8e11bf sidecars /
+    // not-yet-flushed events show $0 lifetime even when the session earned $X.
     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;
+    // Current session counts as 1 when no prior session has been recorded yet.
+    const effectiveSessions = lifeSessions === 0 && sessionTokensSaved > 0 ? 1 : lifeSessions;
+    const sessionLabel = effectiveSessions === 1 ? "1 session" : `${fmtNum(effectiveSessions)} sessions`;
+    // Estimate lifetime savings: ~1KB per event → ~256 tokens/event at Opus rates,
+    // plus current session's already-tracked token savings (in-memory).
+    const lifetimeTokens = lifeEvents * 256 + sessionTokensSaved;
     out.push(`  ${fmtNum(lifeEvents)} events · ${sessionLabel} · ~${tokensToUsd(lifetimeTokens)} saved lifetime`);
     out.push("");
-    const cats = pm.by_category;
+    // Prefer lifetime categoryCounts (aggregated across every SessionDB) so
+    // the bar block matches the lifetime header above. Falls back to the
+    // project-local pm.by_category when lifetime data is absent (tests, older
+    // callers) or when no sidecar has any events yet.
+    const lifetimeCats = opts?.lifetime?.categoryCounts;
+    let cats;
+    if (lifetimeCats && Object.keys(lifetimeCats).length > 0) {
+        cats = Object.entries(lifetimeCats)
+            .filter(([, c]) => c > 0)
+            .map(([category, count]) => ({
+            category,
+            count,
+            label: categoryLabels[category] || category,
+        }))
+            .sort((a, b) => b.count - a.count);
+    }
+    else {
+        cats = pm.by_category;
+    }
     const visible = cats.slice(0, topN);
     const maxCount = visible.length > 0 ? visible[0].count : 1;
     for (const cat of visible) {
@@ -517,8 +563,11 @@ function renderAutoMemory(lifetime) {
     const entries = Object.entries(lifetime.autoMemoryByPrefix)
         .sort((a, b) => b[1] - a[1])
         .slice(0, 6);
+    // Top entry sets the bar scale so the visual stays proportional even when
+    // the absolute counts are tiny. Entries are pre-sorted desc.
+    const maxCount = entries.length > 0 ? entries[0][1] : 1;
     for (const [prefix, count] of entries) {
-        out.push(`  ${prefix.padEnd(12)} ${String(count).padStart(2)}`);
+        out.push(`  ${prefix.padEnd(12)} ${String(count).padStart(2)}   ${dataBar(count, maxCount, 20)}`);
     }
     return out;
 }
@@ -526,8 +575,11 @@ function renderAutoMemory(lifetime) {
 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;
+    // Lifetime = disk-aggregated events × 256 tokens + current session's
+    // in-memory token savings. Two pipelines unified at the render edge so
+    // lifetime ≥ session always (never the surprising "$X session · $0 lifetime"
+    // a fresh user sees pre-flush).
+    const lifetimeTokens = (lifetime?.totalEvents ?? 0) * 256 + sessionTokensSaved;
     const lifetimeUsd = tokensToUsd(lifetimeTokens);
     out.push("");
     out.push("─".repeat(65));
@@ -572,7 +624,7 @@ export function formatReport(report, version, latestVersion, opts) {
             lines.push(`${kb(totalReturned)} entered context  |  0 tokens saved`);
         }
         // Project memory + auto-memory + bottom line
-        lines.push(...renderProjectMemory(report.projectMemory, { lifetime }));
+        lines.push(...renderProjectMemory(report.projectMemory, { lifetime, sessionTokensSaved: 0 }));
         lines.push(...renderAutoMemory(lifetime));
         lines.push(...renderBottomLine(0, lifetime));
         // Footer
@@ -627,15 +679,23 @@ export function formatReport(report, version, latestVersion, opts) {
             lines.push(`  ${name.padEnd(22)}  ${String(t.calls).padStart(4)} calls  ${kb(t.estimatedSaved).padStart(8)} saved`);
         }
     }
-    // ── MCP concurrency usage (only when batch tools recorded a concurrency) ──
+    // ── Parallel I/O — value-forward framing for concurrent batch tools.
+    // Suppressed when no tool ran with max_concurrency > 1 (don't claim
+    // parallelism we didn't deliver). Internal mcp__*__ namespace stripped
+    // for user-facing readability.
     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)`);
+        const concurrent = mcpUsage.filter((u) => u.median_concurrency != null && (u.max_concurrency ?? 1) > 1);
+        if (concurrent.length > 0) {
+            lines.push("");
+            lines.push("Parallel I/O  ✓ one call did the work of many — faster runs, lower bill, same answer.");
+            for (const u of concurrent) {
+                const name = u.tool_name.replace(/^mcp__.*?__/, "");
+                lines.push(`  ${name.padEnd(22)} ${u.calls} batches · ${u.median_concurrency} typical, ${u.max_concurrency} peak`);
+            }
         }
     }
     // ── Project memory — persistent across sessions (Bug #3 + #5) ──
-    lines.push(...renderProjectMemory(report.projectMemory, { lifetime }));
+    lines.push(...renderProjectMemory(report.projectMemory, { lifetime, sessionTokensSaved: tokensSaved }));
     // ── Auto-memory — Claude Code's preference learnings (Bug #4) ──
     lines.push(...renderAutoMemory(lifetime));
     // ── Bottom line — business value framing (Bug #8) ──

package/build/session/db.d.ts

@@ -77,7 +77,9 @@ export declare class SessionDB extends SQLiteBase {
      * Eviction: if session exceeds MAX_EVENTS_PER_SESSION, evicts the
      * lowest-priority (then oldest) event.
      */
-    insertEvent(sessionId: string, event: SessionEvent, sourceHook?: string, attribution?: Partial<ProjectAttribution>): void;
+    insertEvent(sessionId: string, event: Omit<SessionEvent, "data_hash"> & {
+        data_hash?: string;
+    }, sourceHook?: string, attribution?: Partial<ProjectAttribution>): void;
     /**
      * Bulk-insert N events in a SINGLE transaction.
      *

package/build/session/persist-tool-calls.d.ts

@@ -0,0 +1,54 @@
+/**
+ * persist-tool-calls — runtime glue between MCP server's in-memory
+ * `sessionStats` and the on-disk `tool_calls` SessionDB table.
+ *
+ * Why this module exists
+ * ──────────────────────
+ * Commit 4742160 (May 2 16:58) added the SessionDB write path so the
+ * statusline counters survived `npm update -g context-mode` and
+ * `claude --continue`. Commit b392c2f (May 2 21:43) — the concurrency
+ * refactor — silently dropped that wiring as collateral. Same-session
+ * `/ctx-upgrade` flips the statusline back to `0 calls / $0.00`
+ * because the new PID starts with an empty `sessionStats` and never
+ * looks at the table the old PID was writing to.
+ *
+ * This module re-introduces the write path AND adds the read-side
+ * restore that 4742160 never shipped — both pure helpers so the
+ * server.ts wiring is a one-liner and the unit tests don't need to
+ * boot the MCP server.
+ */
+/**
+ * Shape returned by {@link restoreSessionStats}. Subset of the in-memory
+ * `sessionStats` object the MCP server keeps — only the fields that can
+ * be recovered from SessionDB.
+ */
+export interface RestoredSessionStats {
+    /** Per-tool call counts. */
+    calls: Record<string, number>;
+    /** Per-tool returned bytes. */
+    bytesReturned: Record<string, number>;
+    /**
+     * Epoch-ms for `session_meta.started_at` of the latest session, so the
+     * statusline `uptime_ms` reflects the original session start instead of
+     * resetting to `Date.now()` on every PID change.
+     */
+    sessionStart: number;
+}
+/**
+ * Increment the persistent tool-call counter for `toolName` under whatever
+ * session_id `session_meta` currently treats as the most recent. This is
+ * called from {@link trackResponse} on every tool response and must be
+ * cheap, non-throwing, and best-effort — a stats failure must never break
+ * the MCP tool call.
+ */
+export declare function persistToolCallCounter(sessionDbPath: string, toolName: string, bytes: number): void;
+/**
+ * Read the latest session's tool-call totals back out of SessionDB so the
+ * MCP server can hydrate its in-memory `sessionStats` on startup. Returns
+ * `null` when the DB is missing or empty so the caller can keep the
+ * default zero-state without branching twice.
+ *
+ * Used during MCP server boot (BEFORE the heartbeat fires) so the
+ * statusline doesn't briefly flash `0 calls / $0.00` after upgrade.
+ */
+export declare function restoreSessionStats(sessionDbPath: string): RestoredSessionStats | null;

package/build/session/persist-tool-calls.js

@@ -0,0 +1,105 @@
+/**
+ * persist-tool-calls — runtime glue between MCP server's in-memory
+ * `sessionStats` and the on-disk `tool_calls` SessionDB table.
+ *
+ * Why this module exists
+ * ──────────────────────
+ * Commit 4742160 (May 2 16:58) added the SessionDB write path so the
+ * statusline counters survived `npm update -g context-mode` and
+ * `claude --continue`. Commit b392c2f (May 2 21:43) — the concurrency
+ * refactor — silently dropped that wiring as collateral. Same-session
+ * `/ctx-upgrade` flips the statusline back to `0 calls / $0.00`
+ * because the new PID starts with an empty `sessionStats` and never
+ * looks at the table the old PID was writing to.
+ *
+ * This module re-introduces the write path AND adds the read-side
+ * restore that 4742160 never shipped — both pure helpers so the
+ * server.ts wiring is a one-liner and the unit tests don't need to
+ * boot the MCP server.
+ */
+import { existsSync } from "node:fs";
+import { SessionDB } from "./db.js";
+/**
+ * Increment the persistent tool-call counter for `toolName` under whatever
+ * session_id `session_meta` currently treats as the most recent. This is
+ * called from {@link trackResponse} on every tool response and must be
+ * cheap, non-throwing, and best-effort — a stats failure must never break
+ * the MCP tool call.
+ */
+export function persistToolCallCounter(sessionDbPath, toolName, bytes) {
+    try {
+        if (!existsSync(sessionDbPath))
+            return;
+        const sdb = new SessionDB({ dbPath: sessionDbPath });
+        try {
+            const sid = sdb.getLatestSessionId();
+            if (!sid)
+                return;
+            sdb.incrementToolCall(sid, toolName, bytes);
+        }
+        finally {
+            sdb.close();
+        }
+    }
+    catch {
+        // Best-effort: counter must never throw and break the parent tool call.
+    }
+}
+/**
+ * Read the latest session's tool-call totals back out of SessionDB so the
+ * MCP server can hydrate its in-memory `sessionStats` on startup. Returns
+ * `null` when the DB is missing or empty so the caller can keep the
+ * default zero-state without branching twice.
+ *
+ * Used during MCP server boot (BEFORE the heartbeat fires) so the
+ * statusline doesn't briefly flash `0 calls / $0.00` after upgrade.
+ */
+export function restoreSessionStats(sessionDbPath) {
+    try {
+        if (!existsSync(sessionDbPath))
+            return null;
+        const sdb = new SessionDB({ dbPath: sessionDbPath });
+        try {
+            const sid = sdb.getLatestSessionId();
+            if (!sid)
+                return null;
+            const stats = sdb.getToolCallStats(sid);
+            const calls = {};
+            const bytesReturned = {};
+            for (const [tool, row] of Object.entries(stats.byTool)) {
+                calls[tool] = row.calls;
+                bytesReturned[tool] = row.bytesReturned;
+            }
+            // started_at is "YYYY-MM-DD HH:MM:SS" in UTC (SQLite datetime() default);
+            // append "Z" so Date.parse interprets it as UTC, matching how the
+            // session was actually persisted.
+            let sessionStart = Date.now();
+            try {
+                const meta = sdb.getSessionStats(sid);
+                if (meta?.started_at) {
+                    const parsed = Date.parse(`${meta.started_at}Z`);
+                    if (Number.isFinite(parsed) && parsed > 0)
+                        sessionStart = parsed;
+                }
+            }
+            catch {
+                // best-effort — keep `Date.now()` fallback
+            }
+            // Skip empty restores so callers can `if (restored)` and not stomp
+            // their already-zero default with another zero.
+            if (Object.keys(calls).length === 0 &&
+                Object.keys(bytesReturned).length === 0) {
+                // Still useful to return sessionStart so uptime_ms doesn't reset
+                // even when no tool calls were made — but only if we found a session.
+                return { calls, bytesReturned, sessionStart };
+            }
+            return { calls, bytesReturned, sessionStart };
+        }
+        finally {
+            sdb.close();
+        }
+    }
+    catch {
+        return null;
+    }
+}

package/build/session/project-attribution.d.ts

@@ -36,7 +36,7 @@ export declare const ATTRIBUTION_CONFIDENCE: {
     /** Fallback: session_origin without path signal */
     readonly FALLBACK_SESSION_ORIGIN: 0.35;
 };
-export type AttributionSource = "event_path" | "cwd_event" | "input_cwd" | "workspace_root" | "last_seen" | "session_origin" | "unknown";
+export type AttributionSource = "event_path" | "cwd_event" | "input_cwd" | "workspace_root" | "last_seen" | "session_origin" | "env" | "test" | "unknown";
 export interface ProjectAttribution {
     projectDir: string;
     source: AttributionSource;