pi-lens 3.3.0 → 3.6.0

package/clients/lsp/index.ts

@@ -242,6 +242,41 @@ export class LSPService {
 		return spawned.client.implementation(filePath, line, character);
 	}
 
+	/**
+	 * Navigation: prepare call hierarchy at position
+	 */
+	async prepareCallHierarchy(
+		filePath: string,
+		line: number,
+		character: number,
+	) {
+		const spawned = await this.getClientForFile(filePath);
+		if (!spawned) return [];
+		return spawned.client.prepareCallHierarchy(filePath, line, character);
+	}
+
+	/**
+	 * Navigation: find incoming calls (callers)
+	 */
+	async incomingCalls(item: import("./client.js").LSPCallHierarchyItem) {
+		const spawned = await this.getClientForFile(
+			item.uri.replace("file://", ""),
+		);
+		if (!spawned) return [];
+		return spawned.client.incomingCalls(item);
+	}
+
+	/**
+	 * Navigation: find outgoing calls (callees)
+	 */
+	async outgoingCalls(item: import("./client.js").LSPCallHierarchyItem) {
+		const spawned = await this.getClientForFile(
+			item.uri.replace("file://", ""),
+		);
+		if (!spawned) return [];
+		return spawned.client.outgoingCalls(item);
+	}
+
 	/**
 	 * Get all diagnostics across all tracked files (for cascade checking)
 	 */

package/clients/lsp/launch.js

@@ -149,8 +149,11 @@ export async function launchLSP(command, args = [], options = {}) {
         if (npmGlobalPath) {
             spawnCommand = npmGlobalPath;
             // Recompute needsShell for npm global path
-            const globalHasExt = /\.(exe|cmd|bat)$/i.test(spawnCommand);
-            needsShell = isWindows && (spawnCommand.includes(" ") || !globalHasExt);
+            needsShell =
+                isWindows &&
+                    (spawnCommand.includes(" ") ||
+                        /\.(cmd|bat)$/i.test(spawnCommand) ||
+                        !/\.(exe|cmd|bat)$/i.test(spawnCommand));
         }
     }
     let proc;
@@ -166,8 +169,10 @@ export async function launchLSP(command, args = [], options = {}) {
             if (npmGlobalPath && npmGlobalPath !== spawnCommand) {
                 console.error(`[lsp] Trying npm global: ${npmGlobalPath}`);
                 // Recompute needsShell for npm global path
-                const globalHasExt = /\.(exe|cmd|bat)$/i.test(npmGlobalPath);
-                const needsShellGlobal = isWindows && (npmGlobalPath.includes(" ") || !globalHasExt);
+                const needsShellGlobal = isWindows &&
+                    (npmGlobalPath.includes(" ") ||
+                        /\.(cmd|bat)$/i.test(npmGlobalPath) ||
+                        !/\.(exe|cmd|bat)$/i.test(npmGlobalPath));
                 proc = trySpawn(npmGlobalPath, args, cwd, env, needsShellGlobal);
             }
             else {
@@ -192,7 +197,7 @@ export async function launchLSP(command, args = [], options = {}) {
         let settled = false;
         // Attach error handler that can reject for immediate errors
         proc.on("error", (err) => {
-            if (!settled && err.code === "ENOENT") {
+            if (!settled && (err.code === "ENOENT" || err.code === "EINVAL")) {
                 settled = true;
                 reject(new Error(`LSP server binary not found: ${command}. ` +
                     `Install it or check your PATH.`));
@@ -254,7 +259,7 @@ export async function launchViaPackageManager(packageName, args = [], options =
         await new Promise((resolve, reject) => {
             let settled = false;
             proc.on("error", (err) => {
-                if (!settled && err.code === "ENOENT") {
+                if (!settled && (err.code === "ENOENT" || err.code === "EINVAL")) {
                     settled = true;
                     reject(new Error(`Package manager not found for: ${packageName}. ` +
                         `Install Node.js or check your PATH.`));

package/clients/lsp/launch.ts

@@ -205,8 +205,11 @@ export async function launchLSP(
 		if (npmGlobalPath) {
 			spawnCommand = npmGlobalPath;
 			// Recompute needsShell for npm global path
-			const globalHasExt = /\.(exe|cmd|bat)$/i.test(spawnCommand);
-			needsShell = isWindows && (spawnCommand.includes(" ") || !globalHasExt);
+			needsShell =
+				isWindows &&
+				(spawnCommand.includes(" ") ||
+					/\.(cmd|bat)$/i.test(spawnCommand) ||
+					!/\.(exe|cmd|bat)$/i.test(spawnCommand));
 		}
 	}
 
@@ -225,9 +228,11 @@ export async function launchLSP(
 			if (npmGlobalPath && npmGlobalPath !== spawnCommand) {
 				console.error(`[lsp] Trying npm global: ${npmGlobalPath}`);
 				// Recompute needsShell for npm global path
-				const globalHasExt = /\.(exe|cmd|bat)$/i.test(npmGlobalPath);
 				const needsShellGlobal =
-					isWindows && (npmGlobalPath.includes(" ") || !globalHasExt);
+					isWindows &&
+					(npmGlobalPath.includes(" ") ||
+						/\.(cmd|bat)$/i.test(npmGlobalPath) ||
+						!/\.(exe|cmd|bat)$/i.test(npmGlobalPath));
 				proc = trySpawn(npmGlobalPath, args, cwd, env, needsShellGlobal);
 			} else {
 				throw err;
@@ -256,7 +261,7 @@ export async function launchLSP(
 
 		// Attach error handler that can reject for immediate errors
 		proc.on("error", (err: Error & { code?: string }) => {
-			if (!settled && err.code === "ENOENT") {
+			if (!settled && (err.code === "ENOENT" || err.code === "EINVAL")) {
 				settled = true;
 				reject(
 					new Error(
@@ -346,7 +351,7 @@ export async function launchViaPackageManager(
 			let settled = false;
 
 			proc.on("error", (err: Error & { code?: string }) => {
-				if (!settled && err.code === "ENOENT") {
+				if (!settled && (err.code === "ENOENT" || err.code === "EINVAL")) {
 					settled = true;
 					reject(
 						new Error(

package/clients/metrics-client.js

@@ -5,8 +5,6 @@
  * Metrics are aggregated and shown in session summary only.
  *
  * Tracks:
- * - TDR (Technical Debt Ratio): composite score from existing signals
- * - AI Code Ratio: % of file written by agent this session vs pre-existing
  * - Code Entropy: Shannon entropy delta per file
  *
  * These are observational metrics — they inform the human in session summary,
@@ -18,8 +16,6 @@ import * as path from "node:path";
 export class MetricsClient {
     constructor(verbose = false) {
         this.fileBaselines = new Map();
-        this.fileSessionWrites = new Map(); // agent-written lines
-        this.tdrFindings = new Map();
         this.log = verbose
             ? (msg) => console.error(`[metrics] ${msg}`)
             : () => { };
@@ -27,7 +23,7 @@ export class MetricsClient {
     /**
      * Record initial state of a file when first touched this session
      */
-    recordBaseline(filePath, initialTdr = 0) {
+    recordBaseline(filePath) {
         const absolutePath = path.resolve(filePath);
         if (!fs.existsSync(absolutePath))
             return;
@@ -35,48 +31,8 @@ export class MetricsClient {
             return; // Already recorded
         const content = fs.readFileSync(absolutePath, "utf-8");
         const entropy = this.calculateEntropy(content);
-        this.fileBaselines.set(absolutePath, { content, entropy, tdr: initialTdr });
-        this.fileSessionWrites.set(absolutePath, 0);
-        this.log(`Baseline recorded: ${path.basename(filePath)} (entropy: ${entropy.toFixed(2)}, tdr: ${initialTdr})`);
-    }
-    /**
-     * Update TDR findings for a file
-     */
-    updateTDR(filePath, entries) {
-        const absolutePath = path.resolve(filePath);
-        this.tdrFindings.set(absolutePath, entries);
-    }
-    /**
-     * Get overall TDR score for the session
-     * 0-100, where 100 is high debt.
-     */
-    getTDRScore() {
-        let totalScore = 0;
-        for (const entries of this.tdrFindings.values()) {
-            for (const entry of entries) {
-                // Each entry adds to the debt index based on its Grade (count as the Grade value)
-                totalScore += entry.count;
-            }
-        }
-        // Normalize to 0-100? Or just return the raw Index.
-        // SCA.md says "Technical Debt Index"
-        return totalScore;
-    }
-    /**
-     * Record that the agent wrote/replaced content in a file
-     * @param newContent The new content after the write
-     */
-    recordWrite(filePath, newContent) {
-        const absolutePath = path.resolve(filePath);
-        this.recordBaseline(absolutePath);
-        const baseline = this.fileBaselines.get(absolutePath);
-        const _baselineLines = baseline.content.split("\n").length;
-        const _newLines = newContent.split("\n").length;
-        // Estimate agent-written lines: count the diff
-        const diffLines = this.estimateDiffLines(baseline.content, newContent);
-        const currentAgentLines = this.fileSessionWrites.get(absolutePath) || 0;
-        this.fileSessionWrites.set(absolutePath, currentAgentLines + diffLines);
-        this.log(`Write recorded: ${path.basename(filePath)} (+~${diffLines} agent lines)`);
+        this.fileBaselines.set(absolutePath, { content, entropy });
+        this.log(`Baseline recorded: ${path.basename(filePath)} (entropy: ${entropy.toFixed(2)})`);
     }
     /**
      * Get metrics for a specific file
@@ -90,53 +46,14 @@ export class MetricsClient {
             return null;
         const currentContent = fs.readFileSync(absolutePath, "utf-8");
         const totalLines = currentContent.split("\n").length;
-        const agentLines = this.fileSessionWrites.get(absolutePath) || 0;
         const entropyCurrent = this.calculateEntropy(currentContent);
         const entropyDelta = entropyCurrent - baseline.entropy;
-        const currentTdrFindings = this.tdrFindings.get(absolutePath) || [];
-        const tdrCurrent = currentTdrFindings.reduce((a, b) => a + b.count, 0);
         return {
             filePath: path.relative(process.cwd(), absolutePath),
             totalLines,
-            agentLines: Math.min(agentLines, totalLines),
-            preExistingLines: Math.max(0, totalLines - agentLines),
             entropyStart: baseline.entropy,
             entropyCurrent,
             entropyDelta,
-            tdrStart: baseline.tdr,
-            tdrCurrent,
-            tdrContributors: currentTdrFindings,
-        };
-    }
-    /**
-     * Calculate AI Code Ratio for the session
-     * Returns 0-1 where 1 = all code written by agent
-     */
-    getAICodeRatio() {
-        let totalAgentLines = 0;
-        let totalPreExistingLines = 0;
-        let fileCount = 0;
-        for (const [filePath, agentLines] of this.fileSessionWrites) {
-            if (!fs.existsSync(filePath))
-                continue;
-            const content = fs.readFileSync(filePath, "utf-8");
-            const totalLines = content.split("\n").length;
-            const baseline = this.fileBaselines.get(filePath);
-            const _baselineLines = baseline
-                ? baseline.content.split("\n").length
-                : totalLines;
-            // Pre-existing = lines that existed before this session and weren't replaced
-            const preExisting = Math.max(0, totalLines - agentLines);
-            totalAgentLines += agentLines;
-            totalPreExistingLines += preExisting;
-            fileCount++;
-        }
-        const total = totalAgentLines + totalPreExistingLines;
-        return {
-            ratio: total > 0 ? totalAgentLines / total : 0, // fixed
-            agentLines: totalAgentLines,
-            preExistingLines: totalPreExistingLines,
-            fileCount,
         };
     }
     /**
@@ -147,8 +64,6 @@ export class MetricsClient {
         for (const [filePath, baseline] of this.fileBaselines) {
             if (!fs.existsSync(filePath))
                 continue;
-            if (!this.fileSessionWrites.has(filePath))
-                continue;
             const content = fs.readFileSync(filePath, "utf-8");
             const current = this.calculateEntropy(content);
             const delta = current - baseline.entropy;
@@ -182,83 +97,11 @@ export class MetricsClient {
         }
         return entropy;
     }
-    /**
-     * Format metrics for session summary
-     */
-    formatSessionSummary() {
-        const aiRatio = this.getAICodeRatio();
-        const entropyDeltas = this.getEntropyDeltas();
-        const fileCount = this.fileSessionWrites.size;
-        if (fileCount === 0)
-            return ""; // No files touched
-        const parts = [];
-        // Aggregate TDR from details
-        let totalTdrCurrent = 0;
-        let totalTdrStart = 0;
-        for (const path of this.fileSessionWrites.keys()) {
-            const m = this.getFileMetrics(path);
-            if (m) {
-                totalTdrCurrent += m.tdrCurrent;
-                totalTdrStart += m.tdrStart;
-            }
-        }
-        // Technical Debt Index
-        if (totalTdrCurrent > 0 || totalTdrStart > 0) {
-            const delta = totalTdrCurrent - totalTdrStart;
-            const deltaStr = delta !== 0
-                ? ` (${delta > 0 ? "+" : ""}${delta.toFixed(1)} this session)`
-                : "";
-            parts.push(`[TDR Index] Total Debt: ${totalTdrCurrent.toFixed(1)}${deltaStr}`);
-        }
-        // AI Code Ratio
-        const pct = (aiRatio.ratio * 100).toFixed(1);
-        parts.push(`[AI Code] ${pct}% of ${fileCount} file(s) written by agent this session (${aiRatio.agentLines} lines, ${aiRatio.preExistingLines} pre-existing)`);
-        // Entropy deltas (only show files with significant changes)
-        const significant = entropyDeltas.filter((e) => Math.abs(e.delta) > 0.1);
-        if (significant.length > 0) {
-            const topChanges = significant.slice(0, 5);
-            parts.push(`[Entropy] ${significant.length} file(s) with complexity changes:`);
-            for (const e of topChanges) {
-                const arrow = e.delta > 0 ? "↑" : "↓";
-                const sign = e.delta > 0 ? "+" : "";
-                parts.push(`  ${arrow} ${e.file}: ${e.start.toFixed(2)} → ${e.current.toFixed(2)} (${sign}${e.delta.toFixed(2)} bits)`);
-            }
-            if (significant.length > 5) {
-                parts.push(`  ... and ${significant.length - 5} more`);
-            }
-        }
-        return parts.join("\n");
-    }
     /**
      * Reset session state (for new session)
      */
     reset() {
         this.fileBaselines.clear();
-        this.fileSessionWrites.clear();
         this.log("Session metrics reset");
     }
-    // --- Internal ---
-    /**
-     * Estimate number of lines that changed between two texts
-     * Simple line-based diff (not Myers, but good enough for metrics)
-     */
-    estimateDiffLines(oldText, newText) {
-        const oldLines = new Set(oldText.split("\n"));
-        const newLines = newText.split("\n");
-        let changed = 0;
-        for (const line of newLines) {
-            if (!oldLines.has(line)) {
-                changed++;
-            }
-        }
-        // Also count deleted lines
-        const newLinesSet = new Set(newLines);
-        for (const line of oldLines) {
-            if (!newLinesSet.has(line)) {
-                changed++;
-            }
-        }
-        // Return roughly half (additions + deletions / 2)
-        return Math.max(1, Math.ceil(changed / 2));
-    }
 }

package/clients/metrics-client.tdr.test.js

@@ -0,0 +1,78 @@
+import { describe, expect, test } from "vitest";
+import { convertDiagnosticsToTDREntries, } from "./metrics-client.js";
+describe("TDR conversion", () => {
+    test("converts type errors to TDR entries", () => {
+        const diagnostics = [
+            {
+                id: "ts-lsp:TS2345:10",
+                message: "Argument of type 'string' is not assignable",
+                filePath: "/test/file.ts",
+                line: 10,
+                column: 5,
+                severity: "error",
+                semantic: "blocking",
+                tool: "ts-lsp",
+                rule: "TS2345",
+                tdrCategory: "type_errors",
+            },
+        ];
+        const entries = convertDiagnosticsToTDREntries(diagnostics);
+        expect(entries).toHaveLength(1);
+        expect(entries[0]).toEqual({
+            category: "type_errors",
+            count: 1,
+            severity: "error",
+        });
+    });
+    test("groups multiple diagnostics by category", () => {
+        const diagnostics = [
+            {
+                id: "1",
+                message: "Type error 1",
+                filePath: "/test.ts",
+                severity: "error",
+                semantic: "blocking",
+                tool: "ts-lsp",
+                tdrCategory: "type_errors",
+            },
+            {
+                id: "2",
+                message: "Type error 2",
+                filePath: "/test.ts",
+                severity: "error",
+                semantic: "blocking",
+                tool: "ts-lsp",
+                tdrCategory: "type_errors",
+            },
+            {
+                id: "3",
+                message: "Security issue",
+                filePath: "/test.ts",
+                severity: "error",
+                semantic: "blocking",
+                tool: "ast-grep-napi",
+                tdrCategory: "security",
+            },
+        ];
+        const entries = convertDiagnosticsToTDREntries(diagnostics);
+        expect(entries).toHaveLength(2);
+        expect(entries.find((e) => e.category === "type_errors")?.count).toBe(2);
+        expect(entries.find((e) => e.category === "security")?.count).toBe(1);
+    });
+    test("auto-categorizes diagnostics without tdrCategory", () => {
+        const diagnostics = [
+            {
+                id: "1",
+                message: "Unused variable",
+                filePath: "/test.ts",
+                severity: "warning",
+                semantic: "warning",
+                tool: "biome",
+                rule: "no-unused",
+            },
+        ];
+        const entries = convertDiagnosticsToTDREntries(diagnostics);
+        expect(entries).toHaveLength(1);
+        expect(entries[0].category).toBe("dead_code");
+    });
+});

package/clients/metrics-client.test.js

@@ -62,34 +62,37 @@ describe("MetricsClient", () => {
             expect(metrics?.entropyStart).toBe(client.calculateEntropy(content1));
         });
     });
-    describe("recordWrite", () => {
-        it("should track agent-written lines", () => {
-            const original = "const x = 1;\n";
-            const filePath = createTempFile(tmpDir, "test.ts", original);
-            client.recordBaseline(filePath);
-            const modified = "const x = 1;\nconst y = 2;\nconst z = 3;\n";
-            fs.writeFileSync(filePath, modified);
-            client.recordWrite(filePath, modified);
-            const aiRatio = client.getAICodeRatio();
-            expect(aiRatio.agentLines).toBeGreaterThan(0);
+    describe("getFileMetrics", () => {
+        it("should return null for file without baseline", () => {
+            const filePath = createTempFile(tmpDir, "test.ts", "content");
+            // Don't record baseline
+            const metrics = client.getFileMetrics(filePath);
+            expect(metrics).toBeNull();
         });
-        it("should calculate AI code ratio", () => {
-            const file1 = createTempFile(tmpDir, "file1.ts", "original content line 1\noriginal content line 2\n");
-            const file2 = createTempFile(tmpDir, "file2.ts", "original\n");
-            client.recordBaseline(file1);
-            client.recordBaseline(file2);
-            // Simulate agent writing new content
-            const newContent1 = "original content line 1\noriginal content line 2\nagent line 3\nagent line 4\n";
-            fs.writeFileSync(file1, newContent1);
-            client.recordWrite(file1, newContent1);
-            const aiRatio = client.getAICodeRatio();
-            expect(aiRatio.fileCount).toBe(2);
-            expect(aiRatio.ratio).toBeGreaterThanOrEqual(0);
-            expect(aiRatio.ratio).toBeLessThanOrEqual(1);
+        it("should track entropy changes", () => {
+            const simple = "const x = 1;\n";
+            const filePath = createTempFile(tmpDir, "test.ts", simple);
+            client.recordBaseline(filePath);
+            // Make file more complex
+            const complex = `
+function complex(a: number, b: number, c: number): number {
+  if (a > 0) {
+    if (b > 0) {
+      if (c > 0) {
+        return a + b + c;
+      }
+    }
+  }
+  return 0;
+}
+`;
+            fs.writeFileSync(filePath, complex);
+            const metrics = client.getFileMetrics(filePath);
+            expect(metrics?.entropyDelta).not.toBe(0);
         });
     });
     describe("getEntropyDeltas", () => {
-        it("should track entropy changes", () => {
+        it("should track entropy changes for baselined files", () => {
             const simple = "const x = 1;\n";
             const filePath = createTempFile(tmpDir, "test.ts", simple);
             client.recordBaseline(filePath);
@@ -107,35 +110,19 @@ function complex(a: number, b: number, c: number): number {
 }
 `;
             fs.writeFileSync(filePath, complex);
-            client.recordWrite(filePath, complex);
             const deltas = client.getEntropyDeltas();
             expect(deltas.length).toBe(1);
             expect(deltas[0].delta).not.toBe(0);
         });
     });
-    describe("formatSessionSummary", () => {
-        it("should return empty string when no files touched", () => {
-            expect(client.formatSessionSummary()).toBe("");
-        });
-        it("should format AI code ratio when files are modified", () => {
-            const filePath = createTempFile(tmpDir, "test.ts", "original\n");
-            client.recordBaseline(filePath);
-            const modified = "original\nnew line 1\nnew line 2\n";
-            fs.writeFileSync(filePath, modified);
-            client.recordWrite(filePath, modified);
-            const summary = client.formatSessionSummary();
-            expect(summary).toContain("AI Code");
-            expect(summary).toContain("file(s)");
-        });
-    });
     describe("reset", () => {
         it("should clear all tracked data", () => {
             const filePath = createTempFile(tmpDir, "test.ts", "content\n");
             client.recordBaseline(filePath);
             client.reset();
-            const aiRatio = client.getAICodeRatio();
-            expect(aiRatio.fileCount).toBe(0);
-            expect(client.formatSessionSummary()).toBe("");
+            // After reset, metrics should be null (baseline cleared)
+            const metrics = client.getFileMetrics(filePath);
+            expect(metrics).toBeNull();
         });
     });
 });

package/clients/metrics-client.test.ts

@@ -85,47 +85,43 @@ describe("MetricsClient", () => {
 		});
 	});
 
-	describe("recordWrite", () => {
-		it("should track agent-written lines", () => {
-			const original = "const x = 1;\n";
-			const filePath = createTempFile(tmpDir, "test.ts", original);
+	describe("getFileMetrics", () => {
+		it("should return null for file without baseline", () => {
+			const filePath = createTempFile(tmpDir, "test.ts", "content");
 
-			client.recordBaseline(filePath);
-
-			const modified = "const x = 1;\nconst y = 2;\nconst z = 3;\n";
-			fs.writeFileSync(filePath, modified);
-			client.recordWrite(filePath, modified);
-
-			const aiRatio = client.getAICodeRatio();
-			expect(aiRatio.agentLines).toBeGreaterThan(0);
+			// Don't record baseline
+			const metrics = client.getFileMetrics(filePath);
+			expect(metrics).toBeNull();
 		});
 
-		it("should calculate AI code ratio", () => {
-			const file1 = createTempFile(
-				tmpDir,
-				"file1.ts",
-				"original content line 1\noriginal content line 2\n",
-			);
-			const file2 = createTempFile(tmpDir, "file2.ts", "original\n");
+		it("should track entropy changes", () => {
+			const simple = "const x = 1;\n";
+			const filePath = createTempFile(tmpDir, "test.ts", simple);
 
-			client.recordBaseline(file1);
-			client.recordBaseline(file2);
+			client.recordBaseline(filePath);
 
-			// Simulate agent writing new content
-			const newContent1 =
-				"original content line 1\noriginal content line 2\nagent line 3\nagent line 4\n";
-			fs.writeFileSync(file1, newContent1);
-			client.recordWrite(file1, newContent1);
+			// Make file more complex
+			const complex = `
+function complex(a: number, b: number, c: number): number {
+  if (a > 0) {
+    if (b > 0) {
+      if (c > 0) {
+        return a + b + c;
+      }
+    }
+  }
+  return 0;
+}
+`;
+			fs.writeFileSync(filePath, complex);
 
-			const aiRatio = client.getAICodeRatio();
-			expect(aiRatio.fileCount).toBe(2);
-			expect(aiRatio.ratio).toBeGreaterThanOrEqual(0);
-			expect(aiRatio.ratio).toBeLessThanOrEqual(1);
+			const metrics = client.getFileMetrics(filePath);
+			expect(metrics?.entropyDelta).not.toBe(0);
 		});
 	});
 
 	describe("getEntropyDeltas", () => {
-		it("should track entropy changes", () => {
+		it("should track entropy changes for baselined files", () => {
 			const simple = "const x = 1;\n";
 			const filePath = createTempFile(tmpDir, "test.ts", simple);
 
@@ -145,7 +141,6 @@ function complex(a: number, b: number, c: number): number {
 }
 `;
 			fs.writeFileSync(filePath, complex);
-			client.recordWrite(filePath, complex);
 
 			const deltas = client.getEntropyDeltas();
 			expect(deltas.length).toBe(1);
@@ -153,25 +148,6 @@ function complex(a: number, b: number, c: number): number {
 		});
 	});
 
-	describe("formatSessionSummary", () => {
-		it("should return empty string when no files touched", () => {
-			expect(client.formatSessionSummary()).toBe("");
-		});
-
-		it("should format AI code ratio when files are modified", () => {
-			const filePath = createTempFile(tmpDir, "test.ts", "original\n");
-			client.recordBaseline(filePath);
-
-			const modified = "original\nnew line 1\nnew line 2\n";
-			fs.writeFileSync(filePath, modified);
-			client.recordWrite(filePath, modified);
-
-			const summary = client.formatSessionSummary();
-			expect(summary).toContain("AI Code");
-			expect(summary).toContain("file(s)");
-		});
-	});
-
 	describe("reset", () => {
 		it("should clear all tracked data", () => {
 			const filePath = createTempFile(tmpDir, "test.ts", "content\n");
@@ -179,9 +155,9 @@ function complex(a: number, b: number, c: number): number {
 
 			client.reset();
 
-			const aiRatio = client.getAICodeRatio();
-			expect(aiRatio.fileCount).toBe(0);
-			expect(client.formatSessionSummary()).toBe("");
+			// After reset, metrics should be null (baseline cleared)
+			const metrics = client.getFileMetrics(filePath);
+			expect(metrics).toBeNull();
 		});
 	});
 });