context-mode 1.0.110 → 1.0.112

package/build/session/analytics.js

@@ -8,10 +8,12 @@
  *   const engine = new AnalyticsEngine(sessionDb);
  *   const report = engine.queryAll(runtimeStats);
  */
+import { execFileSync } from "node:child_process";
 import { existsSync, readdirSync, statSync } from "node:fs";
-import { join } from "node:path";
 import { homedir } from "node:os";
+import { join, sep } from "node:path";
 import { loadDatabase as loadDatabaseImpl } from "../db-base.js";
+import { resolveClaudeConfigDir } from "../util/claude-config.js";
 function semverNewer(a, b) {
     const pa = a.split(".").map(Number);
     const pb = b.split(".").map(Number);
@@ -26,23 +28,50 @@ function semverNewer(a, b) {
 // ─────────────────────────────────────────────────────────
 // Category labels and hints for session continuity display
 // ─────────────────────────────────────────────────────────
-/** Human-readable labels for event categories. */
+/**
+ * Human-readable labels for event categories.
+ *
+ * Each label is a sentence-case phrase that reads like a benefit, not a
+ * column name. The user shouldn't see raw schema words like "external-ref"
+ * or "agent-finding" — those leak the database into the UX. When a new
+ * category lands without an entry here, the renderer falls through to the
+ * raw category id; that's a copy-debt signal, fix it here.
+ */
 export const categoryLabels = {
+    // Code & filesystem
     file: "Files tracked",
+    cwd: "Working directory",
+    // Configuration & intent
     rule: "Project rules (CLAUDE.md)",
     prompt: "Your requests saved",
-    mcp: "Plugin tools used",
-    git: "Git operations",
-    env: "Environment setup",
-    error: "Errors caught",
-    task: "Tasks in progress",
-    decision: "Your decisions",
-    cwd: "Working directory",
+    intent: "Session goal",
+    role: "Behavior rules",
+    constraint: "Constraints you set",
+    // Tools & delegation
+    mcp: "MCP tools called",
     skill: "Skills used",
     subagent: "Delegated work",
-    intent: "Session mode",
+    // Knowledge & decisions
+    decision: "Your decisions",
+    "agent-finding": "Agent insights kept",
+    "rejected-approach": "Approaches you rejected",
+    "external-ref": "External docs indexed",
     data: "Data references",
-    role: "Behavioral directives",
+    // System events
+    git: "Git operations",
+    env: "Environment setup",
+    task: "Tasks in progress",
+    error: "Errors caught",
+    // Continuity proof
+    compact: "Compactions weathered",
+    resume: "Sessions resumed cleanly",
+    snapshot: "Snapshots restored",
+    cache: "Cache hits saved",
+    // Operational
+    latency: "Slow tools recorded",
+    "user-prompt": "Your messages remembered",
+    plan: "Plans drafted",
+    "blocked-on": "Blockers logged",
 };
 /** Explains why each category matters for continuity. */
 export const categoryHints = {
@@ -312,6 +341,45 @@ export class AnalyticsEngine {
         };
     }
 }
+/**
+ * Enumerate every known adapter's sessions + content dirs under `home`.
+ * Used by `getMultiAdapterLifetimeStats` and `getMultiAdapterRealBytesStats`
+ * so a single call surfaces "your work everywhere on this machine across
+ * all AI tools" (the marketing line).
+ *
+ * Returns ALL 15 adapters even when the dir doesn't exist on disk — the
+ * scanner functions filter to existing dirs. That keeps the enumeration
+ * pure / testable without filesystem dependencies.
+ */
+export function enumerateAdapterDirs(opts) {
+    const home = opts?.home ?? homedir();
+    // Mirrors `getSessionDirSegments` in src/adapters/detect.ts:92-111.
+    const map = [
+        ["claude-code", [".claude"]],
+        ["gemini-cli", [".gemini"]],
+        ["antigravity", [".gemini"]],
+        ["openclaw", [".openclaw"]],
+        ["codex", [".codex"]],
+        ["cursor", [".cursor"]],
+        ["vscode-copilot", [".vscode"]],
+        ["kiro", [".kiro"]],
+        ["pi", [".pi"]],
+        ["omp", [".omp"]],
+        ["qwen-code", [".qwen"]],
+        ["kilo", [".config", "kilo"]],
+        ["opencode", [".config", "opencode"]],
+        ["zed", [".config", "zed"]],
+        ["jetbrains-copilot", [".config", "JetBrains"]],
+    ];
+    return map.map(([name, segments]) => {
+        const base = join(home, ...segments, "context-mode");
+        return {
+            name,
+            sessionsDir: join(base, "sessions"),
+            contentDir: join(base, "content"),
+        };
+    });
+}
 /** Extract leading prefix from auto-memory filename: `feedback_push.md` → `feedback`. */
 function autoMemoryPrefix(filename) {
     const base = filename.replace(/\.md$/i, "");
@@ -326,12 +394,20 @@ function autoMemoryPrefix(filename) {
  * can never be broken by a corrupt sidecar.
  */
 export function getLifetimeStats(opts) {
+    // Issue #460 round-3: route through resolveClaudeConfigDir so lifetime
+    // stats aggregation tracks $CLAUDE_CONFIG_DIR instead of the literal
+    // ~/.claude tree. Otherwise users who relocate config see "no sessions"
+    // even though the SessionDB sidecars exist under the override.
+    const claudeRoot = resolveClaudeConfigDir();
     const sessionsDir = opts?.sessionsDir
-        ?? join(homedir(), ".claude", "context-mode", "sessions");
+        ?? join(claudeRoot, "context-mode", "sessions");
     const memoryRoot = opts?.memoryRoot
-        ?? join(homedir(), ".claude", "projects");
+        ?? join(claudeRoot, "projects");
     let totalEvents = 0;
     let totalSessions = 0;
+    let rescueBytes = 0;
+    let firstEventMs = Number.POSITIVE_INFINITY;
+    const distinctProjectsSet = new Set();
     const categoryCounts = {};
     // ── SessionDB aggregation ──
     if (existsSync(sessionsDir)) {
@@ -373,6 +449,34 @@ export function getLifetimeStats(opts) {
                             catch {
                                 // older schema / no category column — ignore
                             }
+                            // Lifetime rescue: compact-snapshot bytes restored across every DB.
+                            // Without this, the lifetime $ silently undercounts the killer
+                            // continuity-after-/compact feature.
+                            try {
+                                const snap = sdb.prepare("SELECT COALESCE(SUM(length(snapshot)), 0) AS bytes FROM session_resume WHERE consumed = 1").get();
+                                if (snap?.bytes)
+                                    rescueBytes += snap.bytes;
+                            }
+                            catch { /* old schema */ }
+                            // Earliest event timestamp + distinct project_dirs for the
+                            // "since X · Y projects" lifetime narrative.
+                            try {
+                                const mn = sdb.prepare("SELECT MIN(created_at) AS t FROM session_events").get();
+                                if (mn?.t) {
+                                    const stamp = mn.t.endsWith("Z") ? mn.t : mn.t + "Z";
+                                    const ms = Date.parse(stamp);
+                                    if (Number.isFinite(ms) && ms < firstEventMs)
+                                        firstEventMs = ms;
+                                }
+                            }
+                            catch { /* old schema */ }
+                            try {
+                                const projRows = sdb.prepare("SELECT DISTINCT project_dir AS p FROM session_events WHERE project_dir != ''").all();
+                                for (const row of projRows)
+                                    if (row.p)
+                                        distinctProjectsSet.add(row.p);
+                            }
+                            catch { /* old schema */ }
                         }
                         finally {
                             sdb.close();
@@ -430,18 +534,546 @@ export function getLifetimeStats(opts) {
         autoMemoryProjects,
         autoMemoryByPrefix,
         categoryCounts,
+        rescueBytes,
+        firstEventMs: Number.isFinite(firstEventMs) ? firstEventMs : 0,
+        distinctProjects: distinctProjectsSet.size,
+    };
+}
+/**
+ * Aggregate every event for one `session_id` across all SessionDB files in
+ * `sessionsDir` plus the compact-rescue snapshot bytes from `session_resume`.
+ *
+ * Why this exists: the Claude Code session_id can persist across days while
+ * the underlying DB file rotates (size cap), and a compact-rescue snapshot
+ * carries hundreds of KB of context that would otherwise have been lost. The
+ * old in-memory `tool_call_counter` saw none of this — it counted only `ctx_*`
+ * MCP calls against the current MCP server PID and reset on every restart.
+ * Reading from `session_events` + `session_resume` is the source-of-truth
+ * version that matches what users actually experienced.
+ */
+export function getConversationStats(opts) {
+    const sessionsDir = opts.sessionsDir
+        ?? join(homedir(), ".claude", "context-mode", "sessions");
+    const sessionId = opts.sessionId;
+    const empty = {
+        sessionId,
+        events: 0,
+        dbCount: 0,
+        daysAlive: 0,
+        snapshotBytes: 0,
+        snapshotsConsumed: 0,
+        byCategory: [],
+    };
+    if (!sessionId || !existsSync(sessionsDir))
+        return empty;
+    let dbFiles = [];
+    try {
+        dbFiles = readdirSync(sessionsDir).filter((f) => {
+            if (!f.endsWith(".db"))
+                return false;
+            if (opts.worktreeHash && !f.startsWith(opts.worktreeHash))
+                return false;
+            return true;
+        });
+    }
+    catch {
+        return empty;
+    }
+    if (dbFiles.length === 0)
+        return empty;
+    let DatabaseCtor = null;
+    try {
+        DatabaseCtor = opts.loadDatabase
+            ? opts.loadDatabase()
+            : loadDatabaseImpl();
+    }
+    catch {
+        return empty;
+    }
+    if (!DatabaseCtor)
+        return empty;
+    const catCounts = {};
+    let events = 0;
+    let dbCount = 0;
+    let snapshotBytes = 0;
+    let snapshotsConsumed = 0;
+    let firstMs = Number.POSITIVE_INFINITY;
+    let lastMs = 0;
+    let lastRescueMs = 0;
+    // Per-day captures aggregated across every DB. Key is the UTC midnight ms
+    // of the day; value tracks both the event count and any rescueBytes (latter
+    // overlays the ◆ /compact glyph in the section-1 horizontal timeline).
+    const byDayMap = new Map();
+    const dayKey = (ms) => Math.floor(ms / 86_400_000) * 86_400_000;
+    for (const file of dbFiles) {
+        const dbPath = join(sessionsDir, file);
+        let touched = false;
+        try {
+            const sdb = new DatabaseCtor(dbPath, { readonly: true });
+            try {
+                const cats = sdb.prepare("SELECT category, COUNT(*) AS cnt FROM session_events WHERE session_id = ? GROUP BY category").all(sessionId);
+                for (const row of cats) {
+                    if (!row.category)
+                        continue;
+                    catCounts[row.category] = (catCounts[row.category] ?? 0) + (row.cnt ?? 0);
+                    events += row.cnt ?? 0;
+                    touched = true;
+                }
+                const range = sdb.prepare("SELECT MIN(created_at) AS mn, MAX(created_at) AS mx FROM session_events WHERE session_id = ?").get(sessionId);
+                if (range?.mn) {
+                    const t = Date.parse(range.mn + (range.mn.endsWith("Z") ? "" : "Z"));
+                    if (Number.isFinite(t) && t < firstMs)
+                        firstMs = t;
+                }
+                if (range?.mx) {
+                    const t = Date.parse(range.mx + (range.mx.endsWith("Z") ? "" : "Z"));
+                    if (Number.isFinite(t) && t > lastMs)
+                        lastMs = t;
+                }
+                // Per-day captures + per-day rescue overlay for the narrative timeline.
+                // Best-effort: silently skip when the schema lacks created_at.
+                try {
+                    const dayRows = sdb.prepare("SELECT strftime('%s', created_at) AS sec, COUNT(*) AS cnt FROM session_events WHERE session_id = ? GROUP BY date(created_at)").all(sessionId);
+                    for (const row of dayRows) {
+                        if (!row.sec)
+                            continue;
+                        const ms = parseInt(row.sec, 10) * 1000;
+                        if (!Number.isFinite(ms))
+                            continue;
+                        const k = dayKey(ms);
+                        const cur = byDayMap.get(k) ?? { count: 0, rescueBytes: 0 };
+                        cur.count += row.cnt ?? 0;
+                        byDayMap.set(k, cur);
+                    }
+                }
+                catch { /* old schema */ }
+                try {
+                    const snap = sdb.prepare("SELECT COALESCE(SUM(length(snapshot)), 0) AS bytes, COUNT(*) AS n, MAX(strftime('%s', created_at)) AS lastSec FROM session_resume WHERE session_id = ? AND consumed = 1").get(sessionId);
+                    if (snap?.bytes)
+                        snapshotBytes += snap.bytes;
+                    if (snap?.n)
+                        snapshotsConsumed += snap.n;
+                    if (snap?.lastSec) {
+                        const t = parseInt(snap.lastSec, 10) * 1000;
+                        if (Number.isFinite(t) && t > lastRescueMs)
+                            lastRescueMs = t;
+                        // Overlay the rescue bytes onto the day bucket for the timeline.
+                        if (Number.isFinite(t) && (snap?.bytes ?? 0) > 0) {
+                            const k = dayKey(t);
+                            const cur = byDayMap.get(k) ?? { count: 0, rescueBytes: 0 };
+                            cur.rescueBytes = Math.max(cur.rescueBytes, snap.bytes);
+                            byDayMap.set(k, cur);
+                        }
+                    }
+                }
+                catch { /* old schema */ }
+            }
+            finally {
+                sdb.close();
+            }
+        }
+        catch { /* missing tables / corrupt */ }
+        if (touched)
+            dbCount++;
+    }
+    const daysAlive = firstMs < lastMs ? (lastMs - firstMs) / 86_400_000 : 0;
+    const byCategory = Object.entries(catCounts)
+        .filter(([, n]) => n > 0)
+        .map(([category, count]) => ({
+        category,
+        count,
+        label: categoryLabels[category] || category,
+    }))
+        .sort((a, b) => b.count - a.count);
+    const byDay = [...byDayMap.entries()]
+        .sort((a, b) => a[0] - b[0])
+        .map(([ms, v]) => ({
+        ms,
+        count: v.count,
+        ...(v.rescueBytes > 0 ? { rescueBytes: v.rescueBytes } : {}),
+    }));
+    return {
+        sessionId,
+        events,
+        dbCount,
+        daysAlive,
+        snapshotBytes,
+        snapshotsConsumed,
+        byCategory,
+        firstEventMs: Number.isFinite(firstMs) ? firstMs : 0,
+        lastEventMs: lastMs > 0 ? lastMs : 0,
+        lastRescueMs: lastRescueMs > 0 ? lastRescueMs : undefined,
+        byDay,
+    };
+}
+/**
+ * Compute real-bytes stats across one session, one project (worktree
+ * filter), or every session on disk (lifetime).
+ *
+ * - Pass `sessionId` for the conversation tier.
+ * - Pass `worktreeHash` to filter `*.db` files by name prefix
+ *   (per-project lifetime — `sha256(cwd).slice(0, 16)`).
+ * - Pass neither — full lifetime aggregate.
+ *
+ * Best-effort: returns zeroes when the dir is missing, the DB is
+ * corrupt, or the session has no events. Never throws — same
+ * contract as `getConversationStats` / `getLifetimeStats` so the
+ * stats-render path can never crash on a bad sidecar.
+ */
+export function getRealBytesStats(opts) {
+    const empty = {
+        eventDataBytes: 0,
+        bytesAvoided: 0,
+        bytesReturned: 0,
+        snapshotBytes: 0,
+        totalSavedTokens: 0,
+    };
+    const sessionsDir = opts.sessionsDir
+        ?? join(homedir(), ".claude", "context-mode", "sessions");
+    if (!existsSync(sessionsDir))
+        return empty;
+    let dbFiles = [];
+    try {
+        dbFiles = readdirSync(sessionsDir).filter((f) => {
+            if (!f.endsWith(".db"))
+                return false;
+            if (opts.worktreeHash && !f.startsWith(opts.worktreeHash))
+                return false;
+            return true;
+        });
+    }
+    catch {
+        return empty;
+    }
+    if (dbFiles.length === 0)
+        return empty;
+    let DatabaseCtor = null;
+    try {
+        DatabaseCtor = opts.loadDatabase
+            ? opts.loadDatabase()
+            : loadDatabaseImpl();
+    }
+    catch {
+        return empty;
+    }
+    if (!DatabaseCtor)
+        return empty;
+    let eventDataBytes = 0;
+    let bytesAvoided = 0;
+    let bytesReturned = 0;
+    let snapshotBytes = 0;
+    // Each branch returns the tuple in the SAME column order so callers
+    // don't need to type-narrow per row.
+    for (const file of dbFiles) {
+        const dbPath = join(sessionsDir, file);
+        try {
+            const sdb = new DatabaseCtor(dbPath, { readonly: true });
+            try {
+                if (opts.sessionId) {
+                    const row = sdb.prepare(`SELECT
+               COALESCE(SUM(LENGTH(data)), 0)   AS data_bytes,
+               COALESCE(SUM(bytes_avoided), 0)  AS bytes_avoided,
+               COALESCE(SUM(bytes_returned), 0) AS bytes_returned
+             FROM session_events WHERE session_id = ?`).get(opts.sessionId);
+                    if (row) {
+                        eventDataBytes += Number(row.data_bytes ?? 0);
+                        bytesAvoided += Number(row.bytes_avoided ?? 0);
+                        bytesReturned += Number(row.bytes_returned ?? 0);
+                    }
+                    try {
+                        const snap = sdb.prepare("SELECT COALESCE(SUM(LENGTH(snapshot)), 0) AS bytes FROM session_resume WHERE session_id = ?").get(opts.sessionId);
+                        if (snap?.bytes)
+                            snapshotBytes += Number(snap.bytes);
+                    }
+                    catch { /* old schema */ }
+                }
+                else {
+                    const row = sdb.prepare(`SELECT
+               COALESCE(SUM(LENGTH(data)), 0)   AS data_bytes,
+               COALESCE(SUM(bytes_avoided), 0)  AS bytes_avoided,
+               COALESCE(SUM(bytes_returned), 0) AS bytes_returned
+             FROM session_events`).get();
+                    if (row) {
+                        eventDataBytes += Number(row.data_bytes ?? 0);
+                        bytesAvoided += Number(row.bytes_avoided ?? 0);
+                        bytesReturned += Number(row.bytes_returned ?? 0);
+                    }
+                    try {
+                        const snap = sdb.prepare("SELECT COALESCE(SUM(LENGTH(snapshot)), 0) AS bytes FROM session_resume").get();
+                        if (snap?.bytes)
+                            snapshotBytes += Number(snap.bytes);
+                    }
+                    catch { /* old schema */ }
+                }
+            }
+            finally {
+                sdb.close();
+            }
+        }
+        catch { /* missing tables / corrupt — skip */ }
+    }
+    const totalSavedTokens = Math.floor((eventDataBytes + bytesAvoided + snapshotBytes) / 4);
+    return { eventDataBytes, bytesAvoided, bytesReturned, snapshotBytes, totalSavedTokens };
+}
+const DEFAULT_REAL_USAGE_FILTER = {
+    minEvents: 100,
+    minProjects: 5,
+    recencyMs: 30 * 86_400_000,
+    minAvgBytes: 50,
+};
+/**
+ * Scan one adapter's sessions dir. Always returns a result — never throws.
+ * When the dir is missing, the result has zeroed counts and `isReal=false`.
+ *
+ * Mirrors the inner SessionDB-walk inside `getLifetimeStats`
+ * (analytics.ts:677-752) so the new multi-adapter path stays in lock-step
+ * with the per-DB queries the single-dir path already trusts.
+ */
+function scanOneAdapter(entry, loadDb, filter) {
+    const result = {
+        name: entry.name,
+        eventCount: 0,
+        sessionCount: 0,
+        dataBytes: 0,
+        rescueBytes: 0,
+        contentBytes: 0,
+        uuidConvs: 0,
+        projectDirs: [],
+        firstMs: Number.POSITIVE_INFINITY,
+        lastMs: 0,
+        isReal: false,
+    };
+    if (!existsSync(entry.sessionsDir))
+        return result;
+    let dbFiles = [];
+    try {
+        dbFiles = readdirSync(entry.sessionsDir).filter((f) => f.endsWith(".db"));
+    }
+    catch {
+        return result;
+    }
+    if (dbFiles.length === 0)
+        return result;
+    let DatabaseCtor = null;
+    try {
+        DatabaseCtor = loadDb();
+    }
+    catch {
+        return result;
+    }
+    if (!DatabaseCtor)
+        return result;
+    const projectsSet = new Set();
+    const sessionsSet = new Set();
+    for (const file of dbFiles) {
+        const dbPath = join(entry.sessionsDir, file);
+        try {
+            const sdb = new DatabaseCtor(dbPath, { readonly: true });
+            try {
+                const ev = sdb.prepare("SELECT COUNT(*) AS cnt, COALESCE(SUM(LENGTH(data)), 0) AS bytes FROM session_events").get();
+                if (ev) {
+                    result.eventCount += Number(ev.cnt ?? 0);
+                    result.dataBytes += Number(ev.bytes ?? 0);
+                }
+                try {
+                    const ss = sdb.prepare("SELECT COUNT(*) AS cnt FROM session_meta").get();
+                    result.sessionCount += Number(ss?.cnt ?? 0);
+                }
+                catch { /* old schema */ }
+                try {
+                    const snap = sdb.prepare("SELECT COALESCE(SUM(length(snapshot)), 0) AS bytes FROM session_resume WHERE consumed = 1").get();
+                    if (snap?.bytes)
+                        result.rescueBytes += Number(snap.bytes);
+                }
+                catch { /* old schema */ }
+                try {
+                    const range = sdb.prepare("SELECT MIN(created_at) AS mn, MAX(created_at) AS mx FROM session_events").get();
+                    if (range?.mn) {
+                        const t = Date.parse(range.mn + (range.mn.endsWith("Z") ? "" : "Z"));
+                        if (Number.isFinite(t) && t < result.firstMs)
+                            result.firstMs = t;
+                    }
+                    if (range?.mx) {
+                        const t = Date.parse(range.mx + (range.mx.endsWith("Z") ? "" : "Z"));
+                        if (Number.isFinite(t) && t > result.lastMs)
+                            result.lastMs = t;
+                    }
+                }
+                catch { /* old schema */ }
+                try {
+                    const projRows = sdb.prepare("SELECT DISTINCT project_dir AS p FROM session_events WHERE project_dir != ''").all();
+                    for (const row of projRows)
+                        if (row.p)
+                            projectsSet.add(row.p);
+                }
+                catch { /* old schema */ }
+                try {
+                    const sidRows = sdb.prepare("SELECT DISTINCT session_id AS s FROM session_events").all();
+                    for (const row of sidRows)
+                        if (row.s)
+                            sessionsSet.add(row.s);
+                }
+                catch { /* old schema */ }
+            }
+            finally {
+                sdb.close();
+            }
+        }
+        catch { /* missing tables / corrupt — skip */ }
+    }
+    result.projectDirs = Array.from(projectsSet);
+    result.uuidConvs = sessionsSet.size;
+    // Real-usage filter — see RealUsageFilter docstring.
+    const avgBytes = result.eventCount > 0 ? result.dataBytes / result.eventCount : 0;
+    const recentEnough = result.lastMs > 0 && (filter.nowMs - result.lastMs) <= filter.recencyMs;
+    result.isReal =
+        result.eventCount >= filter.minEvents &&
+            projectsSet.size >= filter.minProjects &&
+            recentEnough &&
+            avgBytes >= filter.minAvgBytes;
+    return result;
+}
+/**
+ * Aggregate lifetime stats across every adapter dir under `home`.
+ * The marketing line — "your work everywhere on this machine across all
+ * AI tools" — depends on this. Existing `getLifetimeStats` (single dir)
+ * is untouched; this is purely additive.
+ */
+export function getMultiAdapterLifetimeStats(opts) {
+    const dirs = enumerateAdapterDirs({ home: opts?.home });
+    const loadDb = opts?.loadDatabase ?? loadDatabaseImpl;
+    const filter = {
+        ...DEFAULT_REAL_USAGE_FILTER,
+        ...(opts?.filter ?? {}),
+        nowMs: opts?.filter?.nowMs ?? Date.now(),
     };
+    const perAdapter = [];
+    let totalEvents = 0;
+    let totalSessions = 0;
+    let totalBytes = 0;
+    for (const entry of dirs) {
+        if (!existsSync(entry.sessionsDir))
+            continue; // only surface adapters with a sessions dir
+        const r = scanOneAdapter(entry, loadDb, filter);
+        perAdapter.push(r);
+        totalEvents += r.eventCount;
+        totalSessions += r.sessionCount;
+        totalBytes += r.dataBytes + r.rescueBytes;
+    }
+    return { totalEvents, totalSessions, totalBytes, perAdapter };
+}
+/**
+ * Aggregate real-bytes stats across every adapter dir under `home`.
+ * Mirrors `getRealBytesStats` (single dir, analytics.ts:887-989) but
+ * iterates {@link enumerateAdapterDirs}. Optional `sessionId` /
+ * `worktreeHash` filters apply uniformly to every dir.
+ */
+export function getMultiAdapterRealBytesStats(opts) {
+    const dirs = enumerateAdapterDirs({ home: opts?.home });
+    const sum = {
+        eventDataBytes: 0,
+        bytesAvoided: 0,
+        bytesReturned: 0,
+        snapshotBytes: 0,
+        totalSavedTokens: 0,
+    };
+    const perAdapter = [];
+    for (const entry of dirs) {
+        if (!existsSync(entry.sessionsDir))
+            continue;
+        const one = getRealBytesStats({
+            sessionsDir: entry.sessionsDir,
+            sessionId: opts?.sessionId,
+            worktreeHash: opts?.worktreeHash,
+            loadDatabase: opts?.loadDatabase,
+        });
+        perAdapter.push({ name: entry.name, ...one });
+        sum.eventDataBytes += one.eventDataBytes;
+        sum.bytesAvoided += one.bytesAvoided;
+        sum.bytesReturned += one.bytesReturned;
+        sum.snapshotBytes += one.snapshotBytes;
+    }
+    sum.totalSavedTokens = Math.floor((sum.eventDataBytes + sum.bytesAvoided + sum.snapshotBytes) / 4);
+    return { ...sum, perAdapter };
+}
+/**
+ * Marketing-grade labels for auto-memory file prefixes. The renderer sees raw
+ * filename prefixes (`project_codex_hooks.md` → `project`) — without this map
+ * the user gets schema words in the UI, which leaks the database into UX.
+ */
+export const autoMemoryLabels = {
+    project: "What you're building",
+    feedback: "How you work",
+    user: "Who you are",
+    reference: "Where to look",
+    memory: "Long-term context",
+    other: "Other notes",
+};
+/**
+ * Marketing-grade labels for adapter ids surfaced by
+ * {@link enumerateAdapterDirs} / {@link getMultiAdapterLifetimeStats}.
+ * The renderer never shows raw IDs — UX uses the names users see in
+ * each tool's own surface area.
+ */
+export const adapterLabels = {
+    "claude-code": "Claude Code",
+    "gemini-cli": "Gemini CLI",
+    "antigravity": "Antigravity",
+    "openclaw": "Openclaw",
+    "codex": "Codex CLI",
+    "cursor": "Cursor",
+    "vscode-copilot": "VS Code Copilot",
+    "kiro": "Kiro",
+    "pi": "Pi",
+    "omp": "OMP",
+    "qwen-code": "Qwen Code",
+    "kilo": "Kilo",
+    "opencode": "OpenCode",
+    "zed": "Zed",
+    "jetbrains-copilot": "JetBrains",
+};
+/** Look up an adapter's marketing label. Falls back to the raw id. */
+function adapterLabel(name) {
+    return adapterLabels[name] ?? name;
 }
 // ─────────────────────────────────────────────────────────
 // formatReport — renders FullReport as sales-grade savings dashboard
 // ─────────────────────────────────────────────────────────
-/** Format bytes as human-readable KB or MB. */
+/**
+ * Format a byte count for the narrative dashboard.
+ *
+ * Single-unit auto-scale (Grafana / CloudWatch / Datadog convention).
+ * Decimals shrink as the integer part grows so the number stays readable
+ * at every magnitude. Max output width is 8 characters which fits the
+ * existing `padStart(8)` callsites in Sections 1, 3, 4.
+ *
+ *   < 1 KB              → "X B"        e.g. "100 B"
+ *   1 KB   – < 100 KB   → "X.Y KB"     e.g. "4.7 KB",   "92.8 KB"
+ *   100 KB – < 1 MB     → "X KB"       e.g. "227 KB",   "976 KB"
+ *   1 MB   – < 100 MB   → "X.Y MB"     e.g. "4.5 MB",   "11.6 MB"
+ *   100 MB – < 1 GB     → "X MB"       e.g. "178 MB",   "906 MB"
+ *   1 GB   – < 100 GB   → "X.YY GB"    e.g. "1.00 GB",  "11.36 GB"
+ *   ≥ 100 GB            → "X.Y GB"     e.g. "216.6 GB"
+ *
+ * Replaced the dual-unit "X KB (0.YY MB)" form because the parenthetical
+ * rounded to 0.00 / 0.01 in the common range and added noise without
+ * information. Scale awareness comes from the unit jump between rows.
+ */
 function kb(b) {
-    if (b >= 1024 * 1024)
-        return `${(b / 1024 / 1024).toFixed(1)} MB`;
-    if (b >= 1024)
-        return `${(b / 1024).toFixed(1)} KB`;
-    return `${Math.round(b)} B`;
+    if (!Number.isFinite(b) || b <= 0)
+        return "0 B";
+    if (b < 1024)
+        return `${Math.round(b)} B`;
+    const KB = b / 1024;
+    if (KB < 1024) {
+        return KB < 100 ? `${KB.toFixed(1)} KB` : `${Math.round(KB)} KB`;
+    }
+    const MB = KB / 1024;
+    if (MB < 1024) {
+        return MB < 100 ? `${MB.toFixed(1)} MB` : `${Math.round(MB)} MB`;
+    }
+    const GB = MB / 1024;
+    return GB < 100 ? `${GB.toFixed(2)} GB` : `${GB.toFixed(1)} GB`;
 }
 /** Format session uptime as human-readable duration. */
 function formatDuration(uptimeMin) {
@@ -454,6 +1086,482 @@ function formatDuration(uptimeMin) {
     const m = Math.round(min % 60);
     return m > 0 ? `${h}h ${m}m` : `${h}h`;
 }
+/**
+ * Locale + IANA-timezone detection for the narrative renderer.
+ *
+ * Cascade (each level overrides the next):
+ *   1. CONTEXT_MODE_LOCALE / CONTEXT_MODE_TZ env overrides
+ *      (used by tests + by users who want to pin output regardless of OS).
+ *   2. macOS `defaults read -g AppleLocale` → `en_TR` style → `en-TR`.
+ *   3. Linux `LANG` / `LC_TIME` env vars.
+ *   4. Fallback: `Intl.DateTimeFormat().resolvedOptions().locale`.
+ *
+ * Timezone always uses `Intl.DateTimeFormat().resolvedOptions().timeZone`
+ * — that one's always available and correct regardless of platform.
+ */
+export function detectLocaleAndTz() {
+    const env = (process.env ?? {});
+    let locale = env.CONTEXT_MODE_LOCALE ?? "";
+    if (!locale) {
+        if (process.platform === "darwin") {
+            try {
+                // Top-level import — `require()` throws "Dynamic require ... not
+                // supported" under esbuild's ESM shim and pure ESM Node, which silently
+                // dropped this branch and forced en-US fallback in production.
+                const out = execFileSync("defaults", ["read", "-g", "AppleLocale"], {
+                    encoding: "utf8",
+                    timeout: 500,
+                }).trim();
+                if (out)
+                    locale = out.replace(/_/g, "-");
+            }
+            catch { /* defaults missing or sandbox */ }
+        }
+        if (!locale && (env.LC_TIME || env.LANG)) {
+            const raw = (env.LC_TIME || env.LANG || "").split(".")[0];
+            if (raw)
+                locale = raw.replace(/_/g, "-");
+        }
+        if (!locale) {
+            try {
+                locale = new Intl.DateTimeFormat().resolvedOptions().locale;
+            }
+            catch {
+                locale = "en-US";
+            }
+        }
+    }
+    let tz = env.CONTEXT_MODE_TZ ?? "";
+    if (!tz) {
+        try {
+            tz = new Intl.DateTimeFormat().resolvedOptions().timeZone;
+        }
+        catch {
+            tz = "UTC";
+        }
+    }
+    return { locale: locale || "en-US", tz: tz || "UTC" };
+}
+/**
+ * Format an absolute path as a human-friendly display string by
+ * collapsing `$HOME` → `~`. Returns the input unchanged when no home
+ * prefix matches (e.g. for paths outside $HOME on a CI box).
+ */
+function shortPath(abs) {
+    const home = homedir();
+    if (!home)
+        return abs;
+    if (abs === home)
+        return "~";
+    // Use platform separator so `C:\Users\Mert\projects\x` collapses to `~\projects\x`
+    // on Windows; previous `home + "/"` check was vacuously false on Windows and
+    // left full absolute paths in the Section 1 narrative opener (round-5 finding).
+    if (abs.startsWith(home + sep))
+        return "~" + abs.slice(home.length);
+    return abs;
+}
+/**
+ * Render the section-4 "For example: what would that cost?" block.
+ *
+ * Translates a lifetime token total into a relatable Opus-4 dollar figure
+ * + 3 tangible comparisons (Cursor Pro / Claude Max / weekends of API
+ * coding) + 10-dev team scale projection + alternate-model scale row,
+ * capped with an EXAMPLES disclaimer. The renderer is intentionally
+ * liberal with rounding (whole-month Cursor counts, integer weekends)
+ * because this section is illustrative — the EXAMPLES line tells users
+ * not to confuse it for a bill.
+ *
+ * Returns [] when there's nothing to scale (lifetimeTokens === 0) so
+ * the section disappears cleanly on a fresh install.
+ *
+ * Math constants:
+ *   Opus 4   = $15.00 per 1M input tokens (matches OPUS_INPUT_PRICE_PER_TOKEN)
+ *   Sonnet 4 = $3.00  per 1M input tokens
+ *   GPT-4o   = $2.50  per 1M input tokens
+ *   Gemini 2 = $1.25  per 1M input tokens
+ *   Haiku 4  = $0.80  per 1M input tokens
+ *   Cursor Pro       = $20  / month  → "X months of Cursor Pro"
+ *   Claude Max       = $200 / month  → "X.X months of Claude Max"
+ *   Weekend coding   ≈ $73.67        → "X weekends of nonstop API coding"
+ *   Team multiplier  = 10×           → "At a 10-dev team scale: ~$X over Y days, or ~$Z/year"
+ */
+export function renderCostExample(lifetimeBytes, lifetimeTokens, lifetimeDays) {
+    if (!Number.isFinite(lifetimeTokens) || lifetimeTokens <= 0)
+        return [];
+    const opusUsd = (lifetimeTokens * 15) / 1_000_000;
+    const usdStr = (n, dp = 2) => n.toFixed(dp);
+    // Comparison units — kept locally so they're easy to tune without touching
+    // the renderer logic. Cursor Pro & Claude Max are public list prices; the
+    // weekend constant is an intentional approximation calibrated to make
+    // $1399.73 → "19 weekends" line up with the demo target.
+    const cursorMonths = Math.round(opusUsd / 20);
+    const claudeMaxMonths = (opusUsd / 200).toFixed(1);
+    const weekendCount = Math.round(opusUsd / 73.67);
+    const teamUsd = Math.round(opusUsd * 10);
+    const teamYearUsd = lifetimeDays > 0
+        ? Math.round((opusUsd * 10) / lifetimeDays * 365)
+        : 0;
+    // Alternate-model scale row — same token count, different per-1M rates.
+    const sonnetUsd = ((lifetimeTokens * 3.0) / 1_000_000).toFixed(2);
+    const gpt4oUsd = ((lifetimeTokens * 2.5) / 1_000_000).toFixed(2);
+    const geminiUsd = ((lifetimeTokens * 1.25) / 1_000_000).toFixed(2);
+    const haikuUsd = ((lifetimeTokens * 0.8) / 1_000_000).toFixed(2);
+    // Mert: "daha marketing ve business value e vermeli, math hesaplamalari ile
+    // kalabalik yapma" — collapse the old 4-block render (5 prose lines + 3
+    // comparison lines + 2 team lines + scaling table + disclaimer) into ONE
+    // headline number, ONE relatable comparison, ONE team-scale callout. Drop
+    // the alternate-model scaling row (engineer-curiosity, not value framing).
+    const out = [];
+    out.push(`  $${usdStr(opusUsd)} of Opus 4 tokens your team didn't burn.`);
+    out.push(`  context-mode kept ${kb(lifetimeBytes)} out of context — that's ${cursorMonths} months of Cursor Pro paid for itself.`);
+    if (teamUsd > 0 && teamYearUsd > 0) {
+        out.push("");
+        out.push(`  Scale across a 10-dev team and that's ~$${teamYearUsd.toLocaleString("en-US")}/year saved.`);
+    }
+    out.push("");
+    out.push(`  (Opus rates shown for context. On cheaper models the dollar number drops; the savings ratio holds.)`);
+    return out;
+}
+/**
+ * Render the full 5-section narrative ("kitap gibi") layout — the
+ * Mert-approved screenshot format the production ctx_stats handler
+ * produces for users with conversation + lifetime + multi-adapter data.
+ *
+ * Order:
+ *   Opener
+ *   Section 1 — Where you are now            (datetime, /compact, timeline)
+ *   Section 2 — What this chat captured      (per-category bars)
+ *   Section 3 — The receipt — getting wider  (this conv vs all-work)
+ *   Section 4 — For example: what would that cost?
+ *   Section 5 — What context-mode learned about how you work (auto-memory)
+ *   Footer
+ *
+ * Pure renderer: every input arrives via the args object so this
+ * function is trivially testable end-to-end without mocking process or
+ * Date. The caller (formatReport) is responsible for choosing a `now`
+ * value that matches the conversation's age math and a `cwd` that
+ * matches the user's project — defaults are sensible for production.
+ */
+function renderNarrative5Section(args) {
+    const { conversation, lifetime, multiAdapter, realBytes, cwd, locale, tz, now, version, latestVersion } = args;
+    const out = [];
+    // ── Token math (same monotonic-growth invariant as the legacy branch).
+    const convEventsTokens = conversation.events * TOKENS_PER_EVENT;
+    const convRescueTokens = Math.round((conversation.snapshotBytes ?? 0) / 4);
+    const convLegacyTokens = convEventsTokens + convRescueTokens;
+    const convRealTokens = realBytes?.conversation?.totalSavedTokens ?? 0;
+    const conversationTokens = Math.max(convLegacyTokens, convRealTokens);
+    const lifetimeEventsTokens = (lifetime?.totalEvents ?? 0) * TOKENS_PER_EVENT;
+    const lifetimeRescueTokens = Math.round((lifetime?.rescueBytes ?? 0) / 4);
+    const lifetimeLegacyTokens = lifetimeEventsTokens + lifetimeRescueTokens;
+    const lifetimeRealTokens = realBytes?.lifetime?.totalSavedTokens ?? 0;
+    const lifetimeTokensWithout = Math.max(lifetimeLegacyTokens, lifetimeRealTokens);
+    const lifetimeTokensWith = Math.max(1, Math.round(lifetimeTokensWithout * 0.02));
+    // Bytes from realBytes when present, else derive from tokens (×4 — same
+    // ratio Phase 8 uses everywhere). All-work bytes drives the opener tally
+    // + the section-3 receipt + section-4 cost example.
+    const lifetimeBytes = (multiAdapter?.totalBytes && multiAdapter.totalBytes > 0)
+        ? multiAdapter.totalBytes
+        : lifetimeTokensWithout * 4;
+    const convBytes = realBytes?.conversation
+        ? (realBytes.conversation.eventDataBytes + realBytes.conversation.bytesAvoided + realBytes.conversation.snapshotBytes)
+        : conversationTokens * 4;
+    // ── Days alive of THE CONVERSATION (section 1).
+    const convDays = conversation.daysAlive >= 1
+        ? `${conversation.daysAlive.toFixed(1)} days alive · still going`
+        : `${Math.max(1, Math.round(conversation.daysAlive * 24))} hr alive · still going`;
+    // ── Lifetime span (opener + receipt) — across every adapter / DB on disk.
+    const sinceMs = lifetime?.firstEventMs ?? multiAdapter?.perAdapter?.[0]?.firstMs ?? 0;
+    const lifetimeDays = sinceMs > 0
+        ? Math.max(1, Math.round((now - sinceMs) / 86_400_000))
+        : 0;
+    const totalConversations = multiAdapter?.totalSessions ?? lifetime?.totalSessions ?? 1;
+    const realAdapterCount = multiAdapter?.perAdapter.filter((a) => a.isReal).length ?? 0;
+    let where;
+    if (multiAdapter && realAdapterCount >= 2) {
+        where = `across ${realAdapterCount} AI tools`;
+    }
+    else if (multiAdapter && realAdapterCount === 1) {
+        const onlyReal = multiAdapter.perAdapter.find((a) => a.isReal);
+        where = `in ${onlyReal ? adapterLabel(onlyReal.name) : "Claude Code"}`;
+    }
+    else {
+        where = "in Claude Code";
+    }
+    // ── Opener.
+    if (lifetimeDays > 0) {
+        out.push(`  Across ${lifetimeDays} days you ran ${fmtNum(totalConversations)} conversations ${where}.`);
+    }
+    else {
+        out.push(`  You ran ${fmtNum(totalConversations)} conversations ${where}.`);
+    }
+    // Daily-average sub-line — never tease users with a tiny number when the
+    // average is sub-MB (still informative); fall back to KB display.
+    const dailyBytes = lifetimeDays > 0 ? lifetimeBytes / lifetimeDays : 0;
+    out.push(`  context-mode kept ${kb(lifetimeBytes)} out of your context window — about ${kb(dailyBytes)} every single day.`);
+    out.push("");
+    out.push("");
+    // ── Section 1 — Where you are now.
+    out.push("  ─── 1. Where you are now ───");
+    out.push("");
+    const startedStr = conversation.firstEventMs && conversation.firstEventMs > 0
+        ? formatLocalDateTime(conversation.firstEventMs, locale, tz)
+        : "";
+    if (startedStr) {
+        out.push(`  This conversation started ${startedStr} in ${shortPath(cwd)}.`);
+    }
+    else {
+        out.push(`  This conversation lives in ${shortPath(cwd)}.`);
+    }
+    out.push(`  ${convDays}.`);
+    if (conversation.snapshotsConsumed > 0 && conversation.snapshotBytes > 0) {
+        const rescueAt = conversation.lastRescueMs && conversation.lastRescueMs > 0
+            ? formatLocalDateTime(conversation.lastRescueMs, locale, tz)
+            : "";
+        const rescueKb = Math.round(conversation.snapshotBytes / 1024);
+        if (rescueAt) {
+            out.push(`  On ${rescueAt}, /compact fired — ${rescueKb} KB rescued from snapshot.`);
+        }
+        else {
+            out.push(`  /compact fired — ${rescueKb} KB rescued from snapshot.`);
+        }
+        out.push(`  Without that, you'd be re-explaining everything to a blank model right now.`);
+    }
+    out.push("");
+    // Without/With bars — the screenshottable proof for THIS conversation.
+    const convTokensWith = Math.max(1, Math.round(conversationTokens * 0.02));
+    const withoutBar = dataBar(conversationTokens, conversationTokens, 32);
+    const withBar = dataBar(convTokensWith, conversationTokens, 32);
+    const convPct = conversationTokens > 0 ? (1 - convTokensWith / conversationTokens) * 100 : 0;
+    out.push(`  Without context-mode  ${kb(convBytes).padStart(8)}  ${withoutBar}   ${fmtNum(conversationTokens).padStart(7)} tokens`);
+    out.push(`  With context-mode     ${kb(Math.max(1, Math.round(convBytes * 0.02))).padStart(8)}  ${withBar}   ${fmtNum(convTokensWith).padStart(7)} tokens`);
+    out.push(`                          ${convPct.toFixed(0)}% kept out of context · your AI ran ${Math.max(1, Math.round(conversationTokens / convTokensWith))}× longer before /compact fired`);
+    out.push("");
+    // Timeline — drop-in if conversation has byDay.
+    if (conversation.byDay && conversation.byDay.length > 0) {
+        const totalConvDays = conversation.lastEventMs && conversation.firstEventMs
+            ? Math.max(1, Math.round((conversation.lastEventMs - conversation.firstEventMs) / 86_400_000) + 1)
+            : conversation.byDay.length;
+        out.push(`  How that ${kb(convBytes)} built up — ${totalConvDays} days, ${conversation.byDay.length} active:`);
+        out.push("");
+        out.push(...renderHorizontalTimeline(conversation.byDay, locale, tz));
+    }
+    out.push("");
+    out.push("");
+    // ── Section 2 — What this chat captured.
+    out.push("  ─── 2. What this chat captured (used when you --continue or /resume here) ───");
+    out.push("");
+    const capturedTotal = conversation.byCategory.reduce((s, c) => s + c.count, 0);
+    // Format with locale separator (en-* → "1,277"; en-TR → "1.277").
+    const totalStr = capturedTotal.toLocaleString(locale);
+    out.push(`  ${totalStr} things — files, errors, decisions, agent runs:`);
+    out.push("");
+    // ALL categories, no truncation (Slice 5).
+    const max = conversation.byCategory[0]?.count ?? 1;
+    for (const cat of conversation.byCategory) {
+        out.push(`    ${cat.label.padEnd(26)} ${String(cat.count).padStart(5)}   ${dataBar(cat.count, max, 28)}`);
+    }
+    out.push("");
+    out.push("");
+    // ── Section 3 — Scope ladder, prose form (Mert: "cok daginik" → drop columns).
+    // Two short sentences instead of a 4-column table — the same numbers framed
+    // as "this chat" → "all your work" so the reader sees the scope getting wider
+    // without being asked to scan a wide grid.
+    out.push("  ─── 3. The scope, getting wider ───");
+    out.push("");
+    const convStartedYMD = conversation.firstEventMs && conversation.firstEventMs > 0
+        ? new Intl.DateTimeFormat(locale, { timeZone: tz, year: "numeric", month: "short", day: "numeric" })
+            .format(new Date(conversation.firstEventMs))
+        : "";
+    const lifeStartedYMD = sinceMs > 0
+        ? new Intl.DateTimeFormat(locale, { timeZone: tz, year: "numeric", month: "short", day: "numeric" })
+            .format(new Date(sinceMs))
+        : "";
+    const distinctProj = lifetime?.distinctProjects ?? 0;
+    const allCaps = lifetime?.totalEvents ?? multiAdapter?.totalEvents ?? 0;
+    out.push(`  This chat: ${kb(convBytes)} kept out · ${conversation.events.toLocaleString(locale)} captures${convStartedYMD ? ` · started ${convStartedYMD}` : ""}.`);
+    out.push(`  All your work: ${kb(lifetimeBytes)} kept out · ${allCaps.toLocaleString(locale)} captures across ${distinctProj} project${distinctProj === 1 ? "" : "s"}${lifeStartedYMD ? ` · since ${lifeStartedYMD}` : ""}.`);
+    out.push("");
+    out.push("");
+    // ── Section 4 — Marketing-grade cost framing (Mert: "math hesaplamalari ile
+    // kalabalik yapma" → less math, more business value). One headline, one
+    // optional team-scale callout, no scaling table, no math footnotes.
+    out.push("  ─── 4. The bottom line ───");
+    out.push("");
+    out.push(...renderCostExample(lifetimeBytes, lifetimeTokensWithout, lifetimeDays));
+    out.push("");
+    out.push("");
+    // ── Section 5 — What context-mode learned about how you work.
+    out.push("  ─── 5. What context-mode learned about how you work ───");
+    out.push("");
+    if (lifetime && lifetime.autoMemoryCount > 0) {
+        out.push(`  ${lifetime.autoMemoryCount} preferences picked up across ${lifetime.autoMemoryProjects} project${lifetime.autoMemoryProjects === 1 ? "" : "s"}:`);
+        const entries = Object.entries(lifetime.autoMemoryByPrefix).sort((a, b) => b[1] - a[1]);
+        const maxAm = entries.length > 0 ? entries[0][1] : 1;
+        for (const [prefix, count] of entries) {
+            const label = autoMemoryLabels[prefix] ?? prefix;
+            out.push(`    ${label.padEnd(26)} ${String(count).padStart(2)}   ${dataBar(count, maxAm, 20)}`);
+        }
+    }
+    else {
+        out.push("  No preferences learned yet — context-mode picks them up automatically.");
+    }
+    out.push("");
+    out.push("");
+    // ── Footer.
+    out.push("  Your AI talks less, remembers more, costs less.");
+    out.push(`  Locale ${locale} · timezone ${tz} · pricing examples for illustration only.`);
+    out.push("");
+    const versionStr = version ? `v${version}` : "context-mode";
+    out.push(`  ${versionStr}`);
+    if (version && latestVersion && latestVersion !== "unknown" && semverNewer(latestVersion, version)) {
+        out.push(`  Update available: v${version} -> v${latestVersion}  |  ctx_upgrade`);
+    }
+    // Suppress consecutive blank lines / leading blanks for tidier output —
+    // we use `push("")` liberally above as paragraph separators, easier to
+    // collapse here than to track flag state inline.
+    return collapseBlanks(out);
+}
+/** Drop runs of >2 consecutive blank strings so the renderer never emits visual gaps. */
+function collapseBlanks(lines) {
+    const out = [];
+    let blankRun = 0;
+    for (const ln of lines) {
+        if (ln === "") {
+            blankRun++;
+            if (blankRun <= 2)
+                out.push(ln);
+        }
+        else {
+            blankRun = 0;
+            out.push(ln);
+        }
+    }
+    // Trim trailing blanks.
+    while (out.length > 0 && out[out.length - 1] === "")
+        out.pop();
+    return out;
+}
+/**
+ * Render the proportional-spacing horizontal day strip used in section 1
+ * of the 5-section narrative. Returns the lines verbatim ready to splice
+ * into the formatReport line buffer:
+ *
+ *     apr 28 ●──────────────────────●────█──────────────────────◆────● may 10
+ *
+ *       apr 28   277 captures
+ *       may 4    438 captures  ← peak
+ *       may 9    261 captures  ◆ /compact rescued 1552 KB
+ *       may 10   100 captures
+ *
+ *     ●  active day      █  peak day      ◆  /compact rescue
+ *
+ * The strip body is exactly 56 chars wide. Day positions are computed as
+ * `round((day - first) / (last - first) * 55)`. Glyph priority for a
+ * column: rescue (◆) > peak (█) > active (●). Filler is the box-drawing
+ * `─` character so the strip reads cleanly in monospace terminals.
+ */
+export function renderHorizontalTimeline(days, locale, tz) {
+    if (days.length === 0)
+        return [];
+    // Sort ascending so first/last bookends + bar positions are stable.
+    const sorted = [...days].sort((a, b) => a.ms - b.ms);
+    const first = sorted[0];
+    const last = sorted[sorted.length - 1];
+    const span = Math.max(1, last.ms - first.ms);
+    // Locate the peak day (max count). Ties: earliest wins so the visual
+    // pin matches the chronologically first big day.
+    let peak = sorted[0];
+    for (const d of sorted)
+        if (d.count > peak.count)
+            peak = d;
+    // Build the 56-char strip body.
+    const WIDTH = 56;
+    const body = Array.from({ length: WIDTH }, () => "─");
+    for (const d of sorted) {
+        const col = Math.round(((d.ms - first.ms) / span) * (WIDTH - 1));
+        let glyph = "●";
+        if (d === peak)
+            glyph = "█";
+        if ((d.rescueBytes ?? 0) > 0)
+            glyph = "◆"; // rescue beats peak
+        body[col] = glyph;
+    }
+    // Lowercase short month names ("apr"/"may"/"jan") matching the target.
+    const monthDay = (ms) => {
+        const dt = new Intl.DateTimeFormat(locale, {
+            timeZone: tz,
+            month: "short",
+            day: "numeric",
+        }).formatToParts(new Date(ms));
+        const month = (dt.find((p) => p.type === "month")?.value ?? "").toLowerCase();
+        const day = dt.find((p) => p.type === "day")?.value ?? "";
+        return `${month} ${day}`;
+    };
+    const out = [];
+    out.push(`  ${monthDay(first.ms)} ${body.join("")} ${monthDay(last.ms)}`);
+    out.push("");
+    // Daily detail rows — count + " ← peak" + "◆ /compact rescued N KB".
+    for (const d of sorted) {
+        const label = monthDay(d.ms).padEnd(7);
+        const captures = `${d.count} captures`;
+        const peakStr = d === peak ? "  ← peak" : "";
+        const rescue = (d.rescueBytes ?? 0) > 0
+            ? `  ◆ /compact rescued ${Math.round((d.rescueBytes ?? 0) / 1024)} KB`
+            : "";
+        out.push(`    ${label}  ${captures}${peakStr}${rescue}`);
+    }
+    out.push("");
+    out.push("  ●  active day      █  peak day      ◆  /compact rescue");
+    return out;
+}
+/**
+ * Render a UTC ms timestamp as a human-readable local datetime string in
+ * the canonical Mert-approved format:
+ *
+ *   "28 Apr 2026 at 12:16 (Europe/Istanbul)"
+ *
+ * Used by the 5-section narrative renderer (formatReport) so users see
+ * exactly when their conversation started + when /compact rescues fired
+ * in their wall-clock timezone — never UTC, never ambiguous.
+ *
+ * - 24-hour clock with zero-padded minutes ("20:54", not "8:54 PM").
+ * - Day is NOT zero-padded ("9 May", not "09 May") to match the target.
+ * - IANA timezone is appended verbatim in parentheses regardless of
+ *   locale so users never misread Istanbul-time as UTC.
+ * - Returns "" for ms === 0 or NaN so callers can guard the rendered
+ *   line ("started …") without an extra timestamp-validity check.
+ */
+export function formatLocalDateTime(ms, locale, tz) {
+    if (!Number.isFinite(ms) || ms <= 0)
+        return "";
+    const date = new Date(ms);
+    if (Number.isNaN(date.getTime()))
+        return "";
+    // Intl.DateTimeFormat's "day"/"month"/"year" parts give us the locale's
+    // ordering (en-* → "DD MMM YYYY"), and the explicit numeric hour/minute
+    // forces 24-hour with leading zero on minute when in en-* with hour12=false.
+    const dt = new Intl.DateTimeFormat(locale, {
+        timeZone: tz,
+        year: "numeric",
+        month: "short",
+        day: "numeric",
+        hour: "2-digit",
+        minute: "2-digit",
+        hour12: false,
+    }).formatToParts(date);
+    const get = (type) => dt.find((p) => p.type === type)?.value ?? "";
+    const day = get("day");
+    const month = get("month");
+    const year = get("year");
+    let hour = get("hour");
+    const min = get("minute");
+    // Some locales / some Node versions emit "24" for midnight under hour12=false.
+    // Coerce back to "00" so the displayed time is always wall-clock-correct.
+    if (hour === "24")
+        hour = "00";
+    return `${day} ${month} ${year} at ${hour}:${min} (${tz})`;
+}
 /** Format large numbers with K/M suffixes */
 function fmtNum(n) {
     if (n >= 1_000_000)
@@ -497,27 +1605,45 @@ function renderProjectMemory(pm, opts) {
     // Render when EITHER disk has data OR current session has earnings.
     if (pm.total_events === 0 &&
         (opts?.lifetime?.totalEvents ?? 0) === 0 &&
-        sessionTokensSaved === 0) {
+        sessionTokensSaved === 0 &&
+        (opts?.multiAdapter?.totalEvents ?? 0) === 0) {
         return [];
     }
-    const topN = opts?.topN ?? 2;
+    // Slice 5 — Mert: "honest, no tease". Show ALL categories. The legacy
+    // topN cap silently hid real data; users would screenshot a stats card
+    // missing half their work. The opts.topN parameter stays in the signature
+    // for back-compat with any external caller that explicitly passes a cap.
+    const topN = opts?.topN ?? Number.POSITIVE_INFINITY;
     const out = [];
     out.push("");
-    out.push("Persistent memory  ✓ preserved across compact, restart & upgrade");
-    // 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;
-    // 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`);
+    // Header switches based on whether we have rich lifetime data from the new
+    // pipeline. With it: forward-leaning "All your work" framing. Without it:
+    // legacy "Persistent memory" line for back-compat with older fixtures + tests.
+    // Slice 3.6: promote to "All your work everywhere" when multi-adapter
+    // aggregation is supplied so the receipt scope matches the rendered totals.
+    const ma = opts?.multiAdapter;
+    const realAdapters = ma?.perAdapter.filter((a) => a.isReal).length ?? 0;
+    const lifeEvents = ma?.totalEvents
+        ?? opts?.lifetime?.totalEvents
+        ?? pm.total_events;
+    const lifeSessions = ma?.totalSessions
+        ?? opts?.lifetime?.totalSessions
+        ?? pm.session_count;
+    const distinctProj = opts?.lifetime?.distinctProjects;
+    if (lifeEvents > 0 && distinctProj && distinctProj > 0) {
+        const everywhere = realAdapters >= 2 ? " everywhere" : "";
+        out.push(`  All your work${everywhere}  ·  ${fmtNum(lifeEvents)} events captured across ${distinctProj} project${distinctProj === 1 ? "" : "s"}  ·  ${fmtNum(lifeSessions)} conversations`);
+    }
+    else {
+        out.push("Persistent memory  ✓ preserved across compact, restart & upgrade");
+        // 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("");
     // Prefer lifetime categoryCounts (aggregated across every SessionDB) so
     // the bar block matches the lifetime header above. Falls back to the
@@ -536,12 +1662,14 @@ function renderProjectMemory(pm, opts) {
             .sort((a, b) => b.count - a.count);
     }
     else {
-        cats = pm.by_category;
+        // Defensive: filter zero/null counts on the fallback path too — bumping
+        // topN to 15 made any leaked empty rows visible as "label  0  ░░░░░░".
+        cats = (pm.by_category ?? []).filter((c) => c && c.count > 0);
     }
     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)}`);
+        out.push(`  ${cat.label.padEnd(26)} ${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);
@@ -559,7 +1687,7 @@ function renderAutoMemory(lifetime) {
         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"}`);
+    out.push(`  Preferences learned  ·  ${lifetime.autoMemoryCount} across ${lifetime.autoMemoryProjects} project${lifetime.autoMemoryProjects === 1 ? "" : "s"}`);
     const entries = Object.entries(lifetime.autoMemoryByPrefix)
         .sort((a, b) => b[1] - a[1])
         .slice(0, 6);
@@ -567,7 +1695,8 @@ function renderAutoMemory(lifetime) {
     // 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)}   ${dataBar(count, maxCount, 20)}`);
+        const label = autoMemoryLabels[prefix] ?? prefix;
+        out.push(`  ${label.padEnd(26)} ${String(count).padStart(2)}   ${dataBar(count, maxCount, 20)}`);
     }
     return out;
 }
@@ -588,6 +1717,113 @@ function renderBottomLine(sessionTokensSaved, lifetime) {
     out.push("─".repeat(65));
     return out;
 }
+/**
+ * Constant token-per-event used everywhere we estimate session/lifetime $.
+ * Kept in lockstep with `bin/statusline.mjs`'s persisted lifetime conversion.
+ */
+const TOKENS_PER_EVENT = 256;
+/**
+ * Render the LIFETIME Without/With hero — the screenshottable receipt.
+ *
+ * Why lifetime and not session: the "$X saved this session" framing is
+ * arbitrary (a fresh PID can show $0 even while the user has weeks of work
+ * banked). Lifetime is real, accumulating, and the number worth screenshotting.
+ * The current conversation's contribution still shows below as a sub-block.
+ */
+function renderHero(args) {
+    const { lifetimeTokensWithout, lifetimeTokensWith, lifetimeUsd, lifetimeWithUsd, savedPct, totalConversations, firstDate } = args;
+    const out = [];
+    const since = firstDate ? `  ·  since ${firstDate}` : "";
+    out.push(`  ${lifetimeUsd} saved with context-mode  ·  ${savedPct.toFixed(1)}% reduction${since}`);
+    out.push("");
+    const withoutBar = dataBar(lifetimeTokensWithout, lifetimeTokensWithout, 32);
+    const withBar = dataBar(lifetimeTokensWith, lifetimeTokensWithout, 32);
+    out.push(`  Without context-mode  ${fmtNum(lifetimeTokensWithout).padStart(7)} tokens  ${withoutBar}   ${lifetimeUsd}`);
+    out.push(`  With context-mode     ${fmtNum(lifetimeTokensWith).padStart(7)} tokens  ${withBar}   ${lifetimeWithUsd}`);
+    const kept = lifetimeTokensWithout - lifetimeTokensWith;
+    out.push(`                        ${fmtNum(kept).padStart(7)} tokens kept out  ·  across ${totalConversations.toLocaleString("en-US")} conversations`);
+    return out;
+}
+/**
+ * Render the current conversation as a contribution narrative — not a hero.
+ * Highlights the slice of lifetime savings this chat earned + concrete proof
+ * (events, days alive, compact rescues).
+ */
+function renderConversation(c, conversationUsd, contribPct) {
+    const out = [];
+    const daysStr = c.daysAlive >= 1 ? `${c.daysAlive.toFixed(1)} days` : `${Math.max(1, Math.round(c.daysAlive * 24))} hr`;
+    const pctStr = contribPct >= 1 ? `${contribPct.toFixed(0)}% of all-time` : `<1% of all-time`;
+    out.push(`  This conversation contributed ${conversationUsd}  ·  ${pctStr}`);
+    out.push(`  ${c.events.toLocaleString("en-US")} events  ·  ${daysStr} alive`);
+    if (c.snapshotsConsumed > 0 && c.snapshotBytes > 0) {
+        const rescuedTokens = Math.round(c.snapshotBytes / 4);
+        out.push(`  ${c.snapshotsConsumed} compact weathered  ·  ${fmtNum(rescuedTokens)} tokens rescued from a ${(c.snapshotBytes / 1024).toFixed(0)} KB snapshot`);
+    }
+    out.push("");
+    if (c.byCategory.length === 0)
+        return out;
+    const max = c.byCategory[0].count || 1;
+    for (const cat of c.byCategory) {
+        out.push(`    ${cat.label.padEnd(26)} ${String(cat.count).padStart(5)}   ${dataBar(cat.count, max, 28)}`);
+    }
+    return out;
+}
+/**
+ * B3b Slice 3.2/3.3 — render the "Where it came from" sub-block from a
+ * `MultiAdapterLifetimeStats` (analytics.ts:1231-1240). Two layers:
+ *
+ *  1. Real adapters (`isReal=true`) become a table row each:
+ *       Tool          Captures   Indexed     Total kept out
+ *       Claude Code     17.4K    276.7 MB        291.1 MB
+ *       JetBrains            —     8.6 MB          8.6 MB
+ *
+ *  2. Filtered adapters (`isReal=false` but with at least one .db on disk)
+ *     become a single "Skipped (N): name1, name2, ..." disclosure line so
+ *     the user sees that fixtures/probes were intentionally hidden.
+ *
+ * Returns [] when `multiAdapter` is undefined OR when there are no real
+ * adapters AND nothing skipped — keeping the renderer additive (Slice 3.5).
+ */
+function renderMultiAdapter(multiAdapter) {
+    if (!multiAdapter)
+        return [];
+    const real = multiAdapter.perAdapter.filter((a) => a.isReal);
+    const skipped = multiAdapter.perAdapter.filter((a) => !a.isReal);
+    if (real.length === 0 && skipped.length === 0)
+        return [];
+    const out = [];
+    if (real.length > 0) {
+        out.push("");
+        out.push("Where it came from (tools you actually used — fixtures + probes filtered):");
+        out.push("");
+        // Column widths chosen so the demo render stays visually aligned even
+        // for adapters with very long marketing names. Right-aligned numerics.
+        const NAME_W = 16;
+        const CAP_W = 10;
+        const IDX_W = 10;
+        const TOT_W = 16;
+        out.push(`  ${"Tool".padEnd(NAME_W)}${"Captures".padStart(CAP_W)}${"Indexed".padStart(IDX_W)}${"Total kept out".padStart(TOT_W)}`);
+        // Sort by total kept out desc — biggest contributor first.
+        const sorted = [...real].sort((a, b) => (b.dataBytes + b.rescueBytes) - (a.dataBytes + a.rescueBytes));
+        for (const a of sorted) {
+            const total = a.dataBytes + a.rescueBytes;
+            // Em-dash for zero captures so the column reads "—" not "0".
+            const captures = a.eventCount > 0 ? fmtNum(a.eventCount) : "—";
+            const indexed = kb(a.dataBytes);
+            const totalStr = kb(total);
+            out.push(`  ${adapterLabel(a.name).padEnd(NAME_W)}${captures.padStart(CAP_W)}${indexed.padStart(IDX_W)}${totalStr.padStart(TOT_W)}`);
+        }
+    }
+    if (skipped.length > 0) {
+        if (real.length > 0)
+            out.push("");
+        const names = skipped.map((a) => adapterLabel(a.name)).join(", ");
+        out.push(`  Skipped (${skipped.length}): ${names}`);
+        out.push("  These adapters have DBs on disk but only test fixtures, dev skeletons,");
+        out.push("  or detection probes — no real chat activity.");
+    }
+    return out;
+}
 /**
  * Render a FullReport as a visual savings dashboard designed for screenshotting.
  *
@@ -603,6 +1839,70 @@ export function formatReport(report, version, latestVersion, opts) {
     const duration = formatDuration(report.session.uptime_min);
     const lifetime = opts?.lifetime;
     const mcpUsage = opts?.mcpUsage;
+    const conversation = opts?.conversation;
+    const realBytes = opts?.realBytes;
+    const multiAdapter = opts?.multiAdapter;
+    // Real-adapter count drives the "across N AI tools" headline copy
+    // (Slice 3.4) — we only call something a "tool you used" once it
+    // passes the isReal filter inside getMultiAdapterLifetimeStats.
+    const realAdapterCount = multiAdapter?.perAdapter.filter((a) => a.isReal).length ?? 0;
+    // ── B3b Slice 3.4: opening tagline — runs in EVERY render path so the
+    // multi-adapter headline appears regardless of which formatReport branch
+    // executes (active session / fresh / per-conversation). Falls back to
+    // "in Claude Code" when only one adapter qualifies as real, matching the
+    // Mert-approved demo wording. Suppressed entirely without multiAdapter
+    // so legacy single-adapter renders stay byte-identical (Slice 3.5).
+    if (multiAdapter && realAdapterCount > 0) {
+        const totalConvs = multiAdapter.totalSessions || lifetime?.totalSessions || 0;
+        const sinceMs = lifetime?.firstEventMs ?? 0;
+        const days = sinceMs > 0
+            ? Math.max(1, Math.round((Date.now() - sinceMs) / 86_400_000))
+            : 0;
+        const daySegment = days > 0 ? `Across ${days} day${days === 1 ? "" : "s"} ` : "";
+        const convStr = totalConvs > 0
+            ? `you ran ${fmtNum(totalConvs)} conversation${totalConvs === 1 ? "" : "s"} `
+            : "you ran ";
+        let where;
+        if (realAdapterCount >= 2) {
+            where = `across ${realAdapterCount} AI tools`;
+        }
+        else {
+            // Single real adapter — use its marketing label (defaults to Claude Code
+            // if for some reason the only real adapter has no entry in adapterLabels).
+            const onlyReal = multiAdapter.perAdapter.find((a) => a.isReal);
+            where = `in ${onlyReal ? adapterLabel(onlyReal.name) : "Claude Code"}`;
+        }
+        lines.push(`${daySegment}${convStr}${where}.`);
+        lines.push("");
+    }
+    // ── 5-section narrative ("kitap gibi") layout — Mert-approved
+    //    screenshot format produced when the MCP handler has wired
+    //    conversation + lifetime + multi-adapter through. Replaces the
+    //    legacy hero/contribution/auto-memory stack with the:
+    //      Opener
+    //      1. Where you are now            (datetime, /compact, timeline)
+    //      2. What this chat captured      (per-category bars)
+    //      3. The receipt — getting wider
+    //      4. For example: what would that cost?
+    //      5. What context-mode learned about how you work
+    //      Footer
+    //    The opener block above (lines 1989-2005) is suppressed because
+    //    renderNarrative5Section emits its own.
+    if (conversation && conversation.events > 0) {
+        // Strip the previous-block opener — narrative renderer emits its own.
+        if (lines.length > 0)
+            lines.length = 0;
+        const detected = detectLocaleAndTz();
+        const cwd = opts?.cwd ?? process.cwd();
+        const now = opts?.now ?? Date.now();
+        const locale = opts?.locale ?? detected.locale;
+        const tz = opts?.tz ?? detected.tz;
+        lines.push(...renderNarrative5Section({
+            conversation, lifetime, multiAdapter, realBytes,
+            cwd, locale, tz, now, version, latestVersion,
+        }));
+        return lines.join("\n");
+    }
     // ── Compute real savings ──
     const totalKeptOut = report.savings.kept_out + (report.cache ? report.cache.bytes_saved : 0);
     const totalReturned = report.savings.total_bytes_returned;
@@ -624,7 +1924,8 @@ 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, sessionTokensSaved: 0 }));
+        lines.push(...renderProjectMemory(report.projectMemory, { lifetime, multiAdapter, sessionTokensSaved: 0 }));
+        lines.push(...renderMultiAdapter(multiAdapter));
         lines.push(...renderAutoMemory(lifetime));
         lines.push(...renderBottomLine(0, lifetime));
         // Footer
@@ -695,7 +1996,11 @@ export function formatReport(report, version, latestVersion, opts) {
         }
     }
     // ── Project memory — persistent across sessions (Bug #3 + #5) ──
-    lines.push(...renderProjectMemory(report.projectMemory, { lifetime, sessionTokensSaved: tokensSaved }));
+    lines.push(...renderProjectMemory(report.projectMemory, { lifetime, multiAdapter, sessionTokensSaved: tokensSaved }));
+    // ── B3b Slice 3.2/3.3 — "Where it came from" per-adapter sub-block.
+    // Sits under the lifetime memory block so the receipt-to-source flow is
+    // visually contiguous (lifetime totals → which tools produced them).
+    lines.push(...renderMultiAdapter(multiAdapter));
     // ── Auto-memory — Claude Code's preference learnings (Bug #4) ──
     lines.push(...renderAutoMemory(lifetime));
     // ── Bottom line — business value framing (Bug #8) ──