context-mode 1.0.88 → 1.0.90

package/build/server.js

@@ -97,6 +97,9 @@ function maybeIndexSessionEvents(store) {
 // platform-specific paths. All session DB paths go through it — no
 // hardcoded configDir detection in tool handlers.
 let _detectedAdapter = null;
+// Tracks the ctx_insight dashboard child so shutdown can terminate it.
+// See ctx_insight handler + shutdown() in main().
+let _insightChild = null;
 /**
  * Get the platform-specific sessions directory from the detected adapter.
  * Falls back to ~/.claude/context-mode/sessions/ before adapter detection.
@@ -325,8 +328,9 @@ function checkNonShellDenyPolicy(code, language, toolName) {
  */
 function checkFilePathDenyPolicy(filePath, toolName) {
     try {
-        const denyGlobs = readToolDenyPatterns("Read", process.env.CLAUDE_PROJECT_DIR);
-        const result = evaluateFilePath(filePath, denyGlobs);
+        const projectDir = process.env.CLAUDE_PROJECT_DIR ?? process.cwd();
+        const denyGlobs = readToolDenyPatterns("Read", projectDir);
+        const result = evaluateFilePath(filePath, denyGlobs, process.platform === "win32", projectDir);
         if (result.denied) {
             return trackResponse(toolName, {
                 content: [{
@@ -481,7 +485,7 @@ export function formatBatchQueryResults(store, queries, source, maxOutput = 80 *
 // ─────────────────────────────────────────────────────────
 server.registerTool("ctx_execute", {
     title: "Execute Code",
-    description: `MANDATORY: Use for any command where output exceeds 20 lines. Execute code in a sandboxed subprocess. Only stdout enters context — raw data stays in the subprocess.${bunNote} Available: ${langList}.\n\nPREFER THIS OVER BASH for: API calls (gh, curl, aws), test runners (npm test, pytest), git queries (git log, git diff), data processing, and ANY CLI command that may produce large output. Bash should only be used for file mutations, git writes, and navigation.\n\nTHINK IN CODE: When you need to analyze, count, filter, compare, or process data — write code that does the work and console.log() only the answer. Do NOT read raw data into context to process mentally. Program the analysis, don't compute it in your reasoning. Write robust, pure JavaScript (no npm dependencies). Use only Node.js built-ins (fs, path, child_process). Always wrap in try/catch. Handle null/undefined. Works on both Node.js and Bun.`,
+    description: `MANDATORY: Use for any command where output exceeds 20 lines. Execute code in a sandboxed subprocess. Only stdout enters context — raw data stays in the subprocess.${bunNote} Available: ${langList}.\n\nPREFER THIS OVER BASH for: API calls (gh, curl, aws), test runners (npm test, pytest), git queries (git log, git diff), data processing, and ANY CLI command that may produce large output. Bash should only be used for file mutations, git writes, and navigation.\n\nTHINK IN CODE: When you need to analyze, count, filter, compare, or process data — write code that does the work and console.log() only the answer. Do NOT read raw data into context to process mentally. Program the analysis, don't compute it in your reasoning. Write robust, pure JavaScript (no npm dependencies). Use only Node.js built-ins (fs, path, child_process). Always wrap in try/catch. Handle null/undefined. Works on both Node.js and Bun.\n\nWhen reporting results — terse like caveman. Technical substance exact. Only fluff die. Pattern: [thing] [action] [reason]. [next step].`,
     inputSchema: z.object({
         language: z
             .enum([
@@ -502,7 +506,7 @@ server.registerTool("ctx_execute", {
             .string()
             .describe("Source code to execute. Use console.log (JS/TS), print (Python/Ruby/Perl/R), echo (Shell), echo (PHP), fmt.Println (Go), or IO.puts (Elixir) to output a summary to context."),
         timeout: z
-            .number()
+            .coerce.number()
             .optional()
             .default(30000)
             .describe("Max execution time in ms"),
@@ -774,7 +778,7 @@ function intentSearch(stdout, intent, source, maxResults = 5) {
 // ─────────────────────────────────────────────────────────
 server.registerTool("ctx_execute_file", {
     title: "Execute File Processing",
-    description: "Read a file and process it without loading contents into context. The file is read into a FILE_CONTENT variable inside the sandbox. Only your printed summary enters context.\n\nPREFER THIS OVER Read/cat for: log files, data files (CSV, JSON, XML), large source files for analysis, and any file where you need to extract specific information rather than read the entire content.\n\nTHINK IN CODE: Write code that processes FILE_CONTENT and console.log() only the answer. Don't read files into context to analyze mentally. Write robust, pure JavaScript — no npm deps, try/catch, null-safe. Node.js + Bun compatible.",
+    description: "Read a file and process it without loading contents into context. The file is read into a FILE_CONTENT variable inside the sandbox. Only your printed summary enters context.\n\nPREFER THIS OVER Read/cat for: log files, data files (CSV, JSON, XML), large source files for analysis, and any file where you need to extract specific information rather than read the entire content.\n\nTHINK IN CODE: Write code that processes FILE_CONTENT and console.log() only the answer. Don't read files into context to analyze mentally. Write robust, pure JavaScript — no npm deps, try/catch, null-safe. Node.js + Bun compatible.\n\nWhen reporting results — terse like caveman. Technical substance exact. Only fluff die. Pattern: [thing] [action] [reason]. [next step].",
     inputSchema: z.object({
         path: z
             .string()
@@ -798,7 +802,7 @@ server.registerTool("ctx_execute_file", {
             .string()
             .describe("Code to process FILE_CONTENT (file_content in Elixir). Print summary via console.log/print/echo/IO.puts."),
         timeout: z
-            .number()
+            .coerce.number()
             .optional()
             .default(30000)
             .describe("Max execution time in ms"),
@@ -917,6 +921,7 @@ server.registerTool("ctx_index", {
         "- README files, migration guides, changelog entries\n" +
         "- Any content with code examples you may need to reference precisely\n\n" +
         "After indexing, use 'search' to retrieve specific sections on-demand.\n" +
+        "When `path` is provided, a content hash is stored for automatic stale detection in search results.\n" +
         "Do NOT use for: log files, test output, CSV, build output — use 'execute_file' for those.",
     inputSchema: z.object({
         content: z
@@ -1016,8 +1021,10 @@ function coerceCommandsArray(val) {
 server.registerTool("ctx_search", {
     title: "Search Indexed Content",
     description: "Search indexed content. Requires prior indexing via ctx_batch_execute, ctx_index, or ctx_fetch_and_index. " +
-        "Pass ALL search questions as queries array in ONE call.\n\n" +
-        "TIPS: 2-4 specific terms per query. Use 'source' to scope results.",
+        "Pass ALL search questions as queries array in ONE call. " +
+        "File-backed sources are auto-refreshed when the source file changes.\n\n" +
+        "TIPS: 2-4 specific terms per query. Use 'source' to scope results.\n\n" +
+        "When reporting results — terse like caveman. Technical substance exact. Only fluff die. Pattern: [thing] [action] [reason]. [next step].",
     inputSchema: z.object({
         queries: z.preprocess(coerceJsonArray, z
             .array(z.string())
@@ -1121,6 +1128,10 @@ server.registerTool("ctx_search", {
             totalSize += formatted.length;
         }
         let output = sections.join("\n\n---\n\n");
+        // Report auto-refreshed stale sources
+        if (store.lastRefreshCount > 0) {
+            output = `> Auto-refreshed ${store.lastRefreshCount} stale source${store.lastRefreshCount > 1 ? "s" : ""} (file changed since indexing).\n\n` + output;
+        }
         // Add throttle warning after threshold
         if (searchCallCount >= SEARCH_MAX_RESULTS_AFTER) {
             output += `\n\n⚠ search call #${searchCallCount}/${SEARCH_BLOCK_AFTER} in this window. ` +
@@ -1230,7 +1241,8 @@ server.registerTool("ctx_fetch_and_index", {
     description: "Fetches URL content, converts HTML to markdown, indexes into searchable knowledge base, " +
         "and returns a ~3KB preview. Full content stays in sandbox — use search() for deeper lookups.\n\n" +
         "Better than WebFetch: preview is immediate, full content is searchable, raw HTML never enters context.\n\n" +
-        "Content-type aware: HTML is converted to markdown, JSON is chunked by key paths, plain text is indexed directly.",
+        "Content-type aware: HTML is converted to markdown, JSON is chunked by key paths, plain text is indexed directly.\n\n" +
+        "When reporting results — terse like caveman. Technical substance exact. Only fluff die. Pattern: [thing] [action] [reason]. [next step].",
     inputSchema: z.object({
         url: z.string().describe("The URL to fetch and index"),
         source: z
@@ -1379,7 +1391,8 @@ server.registerTool("ctx_batch_execute", {
         "THIS IS THE PRIMARY TOOL. Use this instead of multiple execute() calls.\n\n" +
         "One batch_execute call replaces 30+ execute calls + 10+ search calls.\n" +
         "Provide all commands to run and all queries to search — everything happens in one round trip.\n\n" +
-        "THINK IN CODE: When commands produce data you need to analyze, add processing commands that filter and summarize. Don't pull raw output into context — let the sandbox do the work.",
+        "THINK IN CODE: When commands produce data you need to analyze, add processing commands that filter and summarize. Don't pull raw output into context — let the sandbox do the work.\n\n" +
+        "When reporting results — terse like caveman. Technical substance exact. Only fluff die. Pattern: [thing] [action] [reason]. [next step].",
     inputSchema: z.object({
         commands: z.preprocess(coerceCommandsArray, z
             .array(z.object({
@@ -1399,7 +1412,7 @@ server.registerTool("ctx_batch_execute", {
             "Each returns top 5 matching sections with full content. " +
             "This is your ONLY chance — put ALL your questions here. No follow-up calls needed.")),
         timeout: z
-            .number()
+            .coerce.number()
             .optional()
             .default(60000)
             .describe("Max execution time in ms (default: 60s)"),
@@ -1862,7 +1875,7 @@ server.registerTool("ctx_insight", {
         "parallel work patterns, project focus, and actionable insights. " +
         "First run installs dependencies (~30s). Subsequent runs open instantly.",
     inputSchema: z.object({
-        port: z.number().optional().describe("Port to serve on (default: 4747)"),
+        port: z.coerce.number().optional().describe("Port to serve on (default: 4747)"),
     }),
 }, async ({ port: userPort }) => {
     const port = userPort || 4747;
@@ -1895,11 +1908,26 @@ server.registerTool("ctx_insight", {
         const hasNodeModules = existsSync(join(cacheDir, "node_modules"));
         if (!hasNodeModules) {
             steps.push("Installing dependencies (first run, ~30s)...");
-            execSync("npm install --production=false", {
-                cwd: cacheDir,
-                stdio: "pipe",
-                timeout: 120000,
-            });
+            try {
+                execSync("npm install --production=false", {
+                    cwd: cacheDir,
+                    stdio: "pipe",
+                    timeout: 300000,
+                });
+            }
+            catch {
+                // Clean up partial install so next run retries fresh
+                try {
+                    rmSync(join(cacheDir, "node_modules"), { recursive: true, force: true });
+                }
+                catch { }
+                throw new Error("npm install failed — please retry");
+            }
+            // Sentinel check: verify install completed (cold cache can timeout leaving partial node_modules)
+            if (!existsSync(join(cacheDir, "node_modules", "vite")) || !existsSync(join(cacheDir, "node_modules", "better-sqlite3"))) {
+                rmSync(join(cacheDir, "node_modules"), { recursive: true, force: true });
+                throw new Error("npm install incomplete — please retry");
+            }
             steps.push("Dependencies installed.");
         }
         // Build
@@ -1907,20 +1935,93 @@ server.registerTool("ctx_insight", {
         execSync("npx vite build", {
             cwd: cacheDir,
             stdio: "pipe",
-            timeout: 30000,
+            timeout: 60000,
         });
         steps.push("Build complete.");
-        // Start server in background
+        // Pre-check: is port already in use? (prevents orphan zombie processes)
+        try {
+            const { request } = await import("node:http");
+            await new Promise((resolve, reject) => {
+                const req = request(`http://127.0.0.1:${port}/api/overview`, { timeout: 2000 }, (res) => {
+                    res.resume();
+                    resolve(); // port is responding = already running
+                });
+                req.on("error", () => reject()); // port free
+                req.on("timeout", () => { req.destroy(); reject(); });
+                req.end();
+            });
+            // If we get here, port is already responding
+            steps.push("Dashboard already running.");
+            // Open browser anyway
+            const url = `http://localhost:${port}`;
+            const platform = process.platform;
+            try {
+                if (platform === "darwin")
+                    execSync(`open "${url}"`, { stdio: "pipe" });
+                else if (platform === "win32")
+                    execSync(`start "" "${url}"`, { stdio: "pipe" });
+                else
+                    execSync(`xdg-open "${url}" 2>/dev/null || sensible-browser "${url}" 2>/dev/null`, { stdio: "pipe" });
+            }
+            catch { /* browser open is best-effort */ }
+            return trackResponse("ctx_insight", {
+                content: [{ type: "text", text: `Dashboard already running at http://localhost:${port}` }],
+            });
+        }
+        catch {
+            // Port is free, proceed with spawn
+        }
+        // Kill any previous insight child this MCP spawned (e.g. re-invocation).
+        if (_insightChild && _insightChild.pid && !_insightChild.killed) {
+            try {
+                _insightChild.kill("SIGTERM");
+            }
+            catch { /* best effort */ }
+        }
+        // Start server in background. `detached: true` keeps MCP stdio free, but
+        // we track the handle and kill it in shutdown() so the dashboard does
+        // not orphan when Claude closes. The child also watches INSIGHT_PARENT_PID
+        // as a fallback for SIGKILL/crash paths.
         const { spawn } = await import("node:child_process");
         const child = spawn("node", [join(cacheDir, "server.mjs")], {
             cwd: cacheDir,
-            env: { ...process.env, PORT: String(port) },
+            env: {
+                ...process.env,
+                PORT: String(port),
+                INSIGHT_SESSION_DIR: getSessionDir(),
+                INSIGHT_CONTENT_DIR: join(dirname(getSessionDir()), "content"),
+                INSIGHT_PARENT_PID: String(process.pid),
+            },
             detached: true,
             stdio: "ignore",
         });
+        child.on("error", () => { }); // prevent unhandled error crash
         child.unref();
+        _insightChild = child;
         // Wait for server to be ready
         await new Promise(r => setTimeout(r, 1500));
+        // Verify server is actually running
+        try {
+            const { request } = await import("node:http");
+            await new Promise((resolve, reject) => {
+                const req = request(`http://127.0.0.1:${port}/api/overview`, { timeout: 3000 }, (res) => {
+                    resolve();
+                    res.resume();
+                });
+                req.on("error", reject);
+                req.on("timeout", () => { req.destroy(); reject(new Error("timeout")); });
+                req.end();
+            });
+        }
+        catch {
+            // Server didn't start — likely port in use
+            return trackResponse("ctx_insight", {
+                content: [{
+                        type: "text",
+                        text: `Port ${port} appears to be in use. Either a previous dashboard is still running, or another service is using this port.\n\nTo fix:\n- Kill the existing process: ${process.platform === "win32" ? `netstat -ano | findstr :${port}` : `lsof -ti:${port} | xargs kill`}\n- Or use a different port: ctx_insight({ port: ${port + 1} })`,
+                    }],
+            });
+        }
         // Open browser (cross-platform)
         const url = `http://localhost:${port}`;
         const platform = process.platform;
@@ -1937,7 +2038,7 @@ server.registerTool("ctx_insight", {
         return trackResponse("ctx_insight", {
             content: [{
                     type: "text",
-                    text: steps.map(s => `- ${s}`).join("\n") + `\n\nOpen: ${url}\nPID: ${child.pid} · Stop: kill ${child.pid}`,
+                    text: steps.map(s => `- ${s}`).join("\n") + `\n\nOpen: ${url}\nPID: ${child.pid} · Stop: ${process.platform === "win32" ? `taskkill /PID ${child.pid} /F` : `kill ${child.pid}`}`,
                 }],
         });
     }
@@ -1973,6 +2074,13 @@ async function main() {
             unlinkSync(mcpSentinel);
         }
         catch { /* best effort */ }
+        // Stop ctx_insight dashboard so it does not outlive Claude.
+        if (_insightChild && _insightChild.pid && !_insightChild.killed) {
+            try {
+                _insightChild.kill("SIGTERM");
+            }
+            catch { /* best effort */ }
+        }
     };
     const gracefulShutdown = async () => {
         shutdown();

package/build/session/analytics.d.ts

@@ -149,13 +149,14 @@ export declare class AnalyticsEngine {
     queryAll(runtimeStats: RuntimeStats): FullReport;
 }
 /**
- * Render a FullReport as a before/after comparison developers instantly understand.
+ * Render a FullReport as a visual savings dashboard designed for screenshotting.
  *
- * Design rules:
- * - If no savings, show "fresh session" format (no fake percentages)
- * - Active session shows BEFORE vs AFTER -- what would have flooded your conversation vs what actually did
- * - Per-tool table only if 2+ different tools were called
- * - Time gained is the hero metric
- * - Under 15 lines for typical sessions
+ * Design principles:
+ * - Before/After comparison bar is the HERO — one glance = "wow"
+ * - "tokens saved" is the number people share
+ * - Per-tool breakdown shows what each tool SAVED, sorted by impact
+ * - Session memory: one line, reframed as value
+ * - No: Pct column, category tables, tips, jargon
+ * - Under 22 lines for heavy sessions, under 10 for fresh
  */
 export declare function formatReport(report: FullReport, version?: string, latestVersion?: string | null): string;

package/build/session/analytics.js

@@ -216,7 +216,7 @@ export class AnalyticsEngine {
     }
 }
 // ─────────────────────────────────────────────────────────
-// formatReport — renders FullReport as concise, honest output
+// formatReport — renders FullReport as sales-grade savings dashboard
 // ─────────────────────────────────────────────────────────
 /** Format bytes as human-readable KB or MB. */
 function kb(b) {
@@ -224,7 +224,7 @@ function kb(b) {
         return `${(b / 1024 / 1024).toFixed(1)} MB`;
     if (b >= 1024)
         return `${(b / 1024).toFixed(1)} KB`;
-    return `${b} B`;
+    return `${Math.round(b)} B`;
 }
 /** Format session uptime as human-readable duration. */
 function formatDuration(uptimeMin) {
@@ -237,28 +237,34 @@ function formatDuration(uptimeMin) {
     const m = Math.round(min % 60);
     return m > 0 ? `${h}h ${m}m` : `${h}h`;
 }
+/** Format large numbers with K/M suffixes */
+function fmtNum(n) {
+    if (n >= 1_000_000)
+        return `${(n / 1_000_000).toFixed(1)}M`;
+    if (n >= 1_000)
+        return `${(n / 1_000).toFixed(1)}K`;
+    return String(n);
+}
 /**
- * Build a before/after comparison bar.
- *
- * The "without" bar is always full (40 chars).
- * The "with" bar is proportional to the ratio of returned vs total.
+ * Build a proportional bar using █ chars, scaled to a fixed width.
+ * Returns e.g. "████████████████████████████████████████" for full width.
  */
-function comparisonBars(total, returned) {
-    const BAR_WIDTH = 40;
-    const withoutBar = "#".repeat(BAR_WIDTH);
-    const withFill = total > 0 ? Math.max(1, Math.round((returned / total) * BAR_WIDTH)) : BAR_WIDTH;
-    const withBar = "#".repeat(withFill) + " ".repeat(BAR_WIDTH - withFill);
-    return { withoutBar, withBar };
+function dataBar(bytes, maxBytes, width = 40) {
+    if (maxBytes <= 0)
+        return "░".repeat(width);
+    const filled = Math.max(1, Math.round((bytes / maxBytes) * width));
+    return "█".repeat(Math.min(filled, width)) + "░".repeat(Math.max(0, width - filled));
 }
 /**
- * Render a FullReport as a before/after comparison developers instantly understand.
+ * Render a FullReport as a visual savings dashboard designed for screenshotting.
  *
- * Design rules:
- * - If no savings, show "fresh session" format (no fake percentages)
- * - Active session shows BEFORE vs AFTER -- what would have flooded your conversation vs what actually did
- * - Per-tool table only if 2+ different tools were called
- * - Time gained is the hero metric
- * - Under 15 lines for typical sessions
+ * Design principles:
+ * - Before/After comparison bar is the HERO — one glance = "wow"
+ * - "tokens saved" is the number people share
+ * - Per-tool breakdown shows what each tool SAVED, sorted by impact
+ * - Session memory: one line, reframed as value
+ * - No: Pct column, category tables, tips, jargon
+ * - Under 22 lines for heavy sessions, under 10 for fresh
  */
 export function formatReport(report, version, latestVersion) {
     const lines = [];
@@ -267,86 +273,100 @@ export function formatReport(report, version, latestVersion) {
     const totalKeptOut = report.savings.kept_out + (report.cache ? report.cache.bytes_saved : 0);
     const totalReturned = report.savings.total_bytes_returned;
     const totalCalls = report.savings.total_calls;
-    // ── Fresh session: almost no activity ──
+    const grandTotal = totalKeptOut + totalReturned;
+    const savingsPct = grandTotal > 0 ? (totalKeptOut / grandTotal) * 100 : 0;
+    const tokensSaved = Math.round(totalKeptOut / 4);
+    // ── Fresh session: no savings yet ──
     if (totalKeptOut === 0) {
-        lines.push(`context-mode -- session (${duration})`);
+        lines.push(`context-mode  ${duration}  ${totalCalls} calls`);
         lines.push("");
         if (totalCalls === 0) {
-            lines.push("No tool calls yet.");
+            lines.push("No tool calls yet. Use batch_execute or execute to start saving tokens.");
         }
         else {
-            const callLabel = totalCalls === 1 ? "1 tool call" : `${totalCalls} tool calls`;
-            lines.push(`${callLabel}  |  ${kb(totalReturned)} in context  |  no savings yet`);
+            lines.push(`${kb(totalReturned)} entered context  |  0 tokens saved`);
         }
+        // Footer
         lines.push("");
-        lines.push("Tip: Use ctx_execute to analyze files in sandbox -- savings start there.");
-        lines.push("");
-        lines.push(version ? `v${version}` : "context-mode");
+        const versionStr = version ? `v${version}` : "context-mode";
+        lines.push(versionStr);
         if (version && latestVersion && latestVersion !== "unknown" && latestVersion !== version) {
-            lines.push(`Update available: v${version} -> v${latestVersion}  |  Run: ctx_upgrade`);
+            lines.push(`Update available: v${version} -> v${latestVersion}  |  ctx_upgrade`);
         }
         return lines.join("\n");
     }
-    // ── Active session with real savings ──
-    const grandTotal = totalKeptOut + totalReturned;
-    const savingsPercent = grandTotal > 0
-        ? ((totalKeptOut / grandTotal) * 100).toFixed(1)
-        : "0.0";
-    // ── Time saved estimate (hero metric) ──
-    // ~4 bytes per token, ~1000 tokens per minute of context window capacity
-    const minSaved = Math.round(totalKeptOut / 4 / 1000);
-    lines.push(`context-mode -- session (${duration})`);
+    // ── Active session: visual savings dashboard ──
+    // Line 1: Hero metric — the screenshottable number
+    lines.push(`${fmtNum(tokensSaved)} tokens saved  ·  ${savingsPct.toFixed(1)}% reduction  ·  ${duration}`);
+    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("");
-    // ── Before/after comparison ──
-    const { withoutBar, withBar } = comparisonBars(grandTotal, totalReturned);
-    lines.push(`Without context-mode:  |${withoutBar}| ${kb(grandTotal)} in your conversation`);
-    lines.push(`With context-mode:     |${withBar}| ${kb(totalReturned)} in your conversation`);
+    // Value statement — the line people share
+    lines.push(`${kb(totalKeptOut)} kept out of your conversation. Never entered context.`);
     lines.push("");
-    const savingsLine = `${kb(totalKeptOut)} processed in sandbox, never entered your conversation. (${savingsPercent}% reduction)`;
-    lines.push(savingsLine);
-    if (minSaved > 0) {
-        const timeSaved = minSaved >= 60
-            ? `+${Math.floor(minSaved / 60)}h ${minSaved % 60}m`
-            : `+${minSaved}m`;
-        lines.push(`${timeSaved} session time gained.`);
+    // Compact stats row
+    const statParts = [`${totalCalls} calls`];
+    if (report.cache && report.cache.hits > 0) {
+        statParts.push(`${report.cache.hits} cache hits (+${kb(report.cache.bytes_saved)})`);
     }
-    // ── Per-tool table (only if 2+ different tools) ──
+    lines.push(statParts.join("  ·  "));
+    // ── Per-tool breakdown (only if 2+ tools, sorted by saved) ──
     const activatedTools = report.savings.by_tool.filter((t) => t.calls > 0);
     if (activatedTools.length >= 2) {
         lines.push("");
-        for (const t of activatedTools) {
-            const returned = t.context_kb * 1024;
-            const callLabel = `${t.calls} call${t.calls !== 1 ? "s" : ""}`;
-            lines.push(`  ${t.tool.padEnd(22)} ${callLabel.padEnd(10)} ${kb(returned)} used`);
+        // Estimate per-tool saved using global savings ratio
+        const toolRows = activatedTools.map((t) => {
+            const returnedBytes = t.context_kb * 1024;
+            const estimatedTotal = savingsPct < 100
+                ? returnedBytes / (1 - savingsPct / 100)
+                : returnedBytes;
+            const estimatedSaved = Math.max(0, estimatedTotal - returnedBytes);
+            return { ...t, returnedBytes, estimatedSaved };
+        }).sort((a, b) => b.estimatedSaved - a.estimatedSaved);
+        // Compact table: tool name, calls, saved
+        for (const t of toolRows) {
+            const name = t.tool.length > 22 ? t.tool.slice(0, 19) + "..." : t.tool;
+            lines.push(`  ${name.padEnd(22)}  ${String(t.calls).padStart(4)} calls  ${kb(t.estimatedSaved).padStart(8)} saved`);
         }
     }
-    // ── Session continuity breakdown ──
-    if (report.continuity.by_category.length > 0) {
-        lines.push("");
-        lines.push(`Session continuity: ${report.continuity.total_events} events preserved across ${report.continuity.compact_count} compaction${report.continuity.compact_count !== 1 ? "s" : ""}`);
+    // ── Session memory — business-friendly ──
+    if (report.continuity.total_events > 0) {
         lines.push("");
-        for (const c of report.continuity.by_category) {
-            const cat = c.category.padEnd(9);
-            const count = String(c.count).padStart(3);
-            const preview = c.preview.length > 45 ? c.preview.slice(0, 42) + "..." : c.preview;
-            lines.push(`  ${cat} ${count}   ${preview.padEnd(47)} ${c.why}`);
+        const cats = report.continuity.by_category;
+        // Pick the top 3-4 most impactful categories for a human-readable summary
+        const highlights = [];
+        const fileCount = cats.find(c => c.category === "file")?.count;
+        const gitCount = cats.find(c => c.category === "git")?.count;
+        const promptCount = cats.find(c => c.category === "prompt")?.count;
+        const errorCount = cats.find(c => c.category === "error")?.count;
+        const taskCount = cats.find(c => c.category === "task")?.count;
+        if (fileCount)
+            highlights.push(`${fileCount} files`);
+        if (gitCount)
+            highlights.push(`${gitCount} git ops`);
+        if (promptCount)
+            highlights.push(`${promptCount} prompts`);
+        if (errorCount)
+            highlights.push(`${errorCount} errors`);
+        if (taskCount)
+            highlights.push(`${taskCount} tasks`);
+        const summary = highlights.length > 0 ? `  ·  ${highlights.join(", ")}` : "";
+        if (report.continuity.compact_count > 0) {
+            lines.push(`${fmtNum(report.continuity.total_events)} events remembered across ${report.continuity.compact_count} compaction${report.continuity.compact_count !== 1 ? "s" : ""}${summary}`);
+            lines.push("Zero knowledge lost — picks up exactly where you left off.");
+        }
+        else {
+            lines.push(`${fmtNum(report.continuity.total_events)} events tracked${summary}`);
         }
     }
-    // ── Footer: version + outdated warning ──
-    const footerParts = [];
-    if (report.continuity.by_category.length === 0 && report.continuity.compact_count > 0) {
-        footerParts.push(`${report.continuity.compact_count} compaction${report.continuity.compact_count !== 1 ? "s" : ""}`);
-    }
-    if (report.continuity.by_category.length === 0 && report.continuity.total_events > 0) {
-        footerParts.push(`${report.continuity.total_events} event${report.continuity.total_events !== 1 ? "s" : ""} preserved`);
-    }
-    const versionStr = version ? `v${version}` : "context-mode";
-    footerParts.push(versionStr);
+    // ── Footer ──
     lines.push("");
-    lines.push(footerParts.join("  |  "));
-    // Outdated warning in footer
+    const versionStr = version ? `v${version}` : "context-mode";
+    lines.push(versionStr);
     if (version && latestVersion && latestVersion !== "unknown" && latestVersion !== version) {
-        lines.push(`Update available: v${version} -> v${latestVersion}  |  Run: ctx_upgrade`);
+        lines.push(`Update available: v${version} -> v${latestVersion}  |  ctx_upgrade`);
     }
     return lines.join("\n");
 }

package/build/session/db.d.ts

@@ -7,6 +7,7 @@
  */
 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.
@@ -24,6 +25,9 @@ export interface StoredEvent {
     category: string;
     priority: number;
     data: string;
+    project_dir: string;
+    attribution_source: string;
+    attribution_confidence: number;
     source_hook: string;
     created_at: string;
     data_hash: string;
@@ -71,7 +75,7 @@ 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): void;
+    insertEvent(sessionId: string, event: SessionEvent, sourceHook?: string, attribution?: Partial<ProjectAttribution>): void;
     /**
      * Retrieve events for a session with optional filtering.
      */
@@ -84,8 +88,13 @@ export declare class SessionDB extends SQLiteBase {
      * Get the total event count for a session.
      */
     getEventCount(sessionId: string): number;
+    /**
+     * Return the most recently attributed project dir for a session.
+     */
+    getLatestAttributedProjectDir(sessionId: string): string | null;
     /**
      * Ensure a session metadata entry exists. Idempotent (INSERT OR IGNORE).
+     * `projectDir` is the session origin directory, not per-event attribution.
      */
     ensureSession(sessionId: string, projectDir: string): void;
     /**