pi-lens 3.3.0 → 3.6.0

package/index.ts

@@ -1,6 +1,7 @@
 import * as nodeFs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import { fileURLToPath } from "node:url";
 // RELOADED: Testing format/lsp flow on large file
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { isToolCallEventType } from "@mariozechner/pi-coding-agent";
@@ -12,7 +13,8 @@ import { BiomeClient } from "./clients/biome-client.js";
 import { CacheManager } from "./clients/cache-manager.js";
 import { ComplexityClient } from "./clients/complexity-client.js";
 import { DependencyChecker } from "./clients/dependency-checker.js";
-import { dispatchLint } from "./clients/dispatch/integration.js";
+import { resetDispatchBaselines } from "./clients/dispatch/integration.js";
+import { extractFunctions } from "./clients/dispatch/runners/similarity.js";
 import { createFileTime, FileTimeError } from "./clients/file-time.js";
 import {
 	getFormatService,
@@ -28,6 +30,13 @@ import { logLatency } from "./clients/latency-logger.js";
 import { getLSPService, resetLSPService } from "./clients/lsp/index.js";
 import { MetricsClient } from "./clients/metrics-client.js";
 import { captureSnapshot } from "./clients/metrics-history.js";
+import { runPipeline } from "./clients/pipeline.js";
+import {
+	buildProjectIndex,
+	findSimilarFunctions,
+	loadIndex,
+	type ProjectIndex,
+} from "./clients/project-index.js";
 import { RuffClient } from "./clients/ruff-client.js";
 import {
 	formatRulesForPrompt,
@@ -36,7 +45,6 @@ import {
 } from "./clients/rules-scanner.js";
 import { RustClient } from "./clients/rust-client.js";
 import { getSourceFiles } from "./clients/scan-utils.js";
-import { formatSecrets, scanForSecrets } from "./clients/secrets-scanner.js";
 import { TestRunnerClient } from "./clients/test-runner-client.js";
 import { TodoScanner } from "./clients/todo-scanner.js";
 import { TypeCoverageClient } from "./clients/type-coverage-client.js";
@@ -349,9 +357,11 @@ export default function (pi: ExtensionAPI) {
 				`Total cognitive complexity: ${tdi.totalCognitive}`,
 				``,
 				`Debt breakdown:`,
-				`  Maintainability: ${tdi.byCategory.maintainability}%`,
-				`  Complexity: ${tdi.byCategory.complexity}%`,
+				`  Maintainability: ${tdi.byCategory.maintainability}% (MI-based)`,
+				`  Cognitive: ${tdi.byCategory.cognitive}%`,
 				`  Nesting: ${tdi.byCategory.nesting}%`,
+				`  Max Cyclomatic: ${tdi.byCategory.maxCyclomatic}% (worst function)`,
+				`  Entropy: ${tdi.byCategory.entropy}% (code unpredictability)`,
 				``,
 				tdi.score <= 30
 					? "✅ Codebase is healthy!"
@@ -453,7 +463,20 @@ export default function (pi: ExtensionAPI) {
 		name: "ast_grep_search",
 		label: "AST Search",
 		description:
-			"Search code using AST-aware pattern matching. IMPORTANT: Use specific AST patterns, NOT text search. Examples:\n- Find function: 'function $NAME() { $$$BODY }'\n- Find call: 'fetchMetrics($ARGS)'\n- Find import: 'import { $NAMES } from \"$PATH\"'\n- Generic identifier (broad): 'fetchMetrics'\n\nAlways prefer specific patterns with context over bare identifiers. Use 'paths' to scope to specific files/folders. Use 'selector' to extract specific nodes (e.g., just the function name). Use 'context' to show surrounding lines.",
+			"Search code using AST-aware pattern matching. IMPORTANT: Use specific AST patterns, NOT text search.\n\n" +
+			"✅ GOOD patterns (single AST node):\n" +
+			"  - function $NAME() { $$$BODY }     (function declaration)\n" +
+			"  - fetchMetrics($ARGS)               (function call)\n" +
+			'  - import { $NAMES } from "$PATH"   (import statement)\n' +
+			"  - console.log($MSG)                  (method call)\n\n" +
+			"❌ BAD patterns (multiple nodes / raw text):\n" +
+			'  - it"test name"                    (missing parens - use it($TEST))\n' +
+			"  - console.log without args          (incomplete code)\n" +
+			"  - arbitrary text without code structure\n\n" +
+			"Always prefer specific patterns with context over bare identifiers. " +
+			"Use 'paths' to scope to specific files/folders. " +
+			"Use 'selector' to extract specific nodes (e.g., just the function name). " +
+			"Use 'context' to show surrounding lines.",
 		promptSnippet: "Use ast_grep_search for AST-aware code search",
 		parameters: Type.Object({
 			pattern: Type.String({
@@ -527,7 +550,16 @@ export default function (pi: ExtensionAPI) {
 		name: "ast_grep_replace",
 		label: "AST Replace",
 		description:
-			"Replace code using AST-aware pattern matching. IMPORTANT: Use specific AST patterns, not text. Dry-run by default (use apply=true to apply).\n\nExamples:\n- pattern='console.log($MSG)' rewrite='logger.info($MSG)'\n- pattern='var $X' rewrite='let $X'\n- pattern='function $NAME() { }' rewrite='' (delete)\n\nAlways use 'paths' to scope to specific files/folders. Dry-run first to preview changes.",
+			"Replace code using AST-aware pattern matching. IMPORTANT: Use specific AST patterns, not text. Dry-run by default (use apply=true to apply).\n\n" +
+			"✅ GOOD patterns (single AST node):\n" +
+			"  - pattern='console.log($MSG)' rewrite='logger.info($MSG)'\n" +
+			"  - pattern='var $X' rewrite='let $X'\n" +
+			"  - pattern='function $NAME() { }' rewrite='' (delete)\n\n" +
+			"❌ BAD patterns (will error):\n" +
+			"  - Raw text without code structure\n" +
+			'  - Missing parentheses: use it($TEST) not it"text"\n' +
+			"  - Incomplete code fragments\n\n" +
+			"Always use 'paths' to scope to specific files/folders. Dry-run first to preview changes.",
 		promptSnippet: "Use ast_grep_replace for AST-aware find-and-replace",
 		parameters: Type.Object({
 			pattern: Type.String({
@@ -612,7 +644,10 @@ export default function (pi: ExtensionAPI) {
 			"- hover: Get type/doc info at a position\n" +
 			"- documentSymbol: List all symbols (functions/classes/vars) in a file\n" +
 			"- workspaceSymbol: Search symbols across the whole project\n" +
-			"- implementation: Jump to interface implementations\n\n" +
+			"- implementation: Jump to interface implementations\n" +
+			"- prepareCallHierarchy: Get callable item at position (for incoming/outgoing)\n" +
+			"- incomingCalls: Find all functions/methods that CALL this function\n" +
+			"- outgoingCalls: Find all functions/methods CALLED by this function\n\n" +
 			"Line and character are 1-based (as shown in editors).",
 		promptSnippet:
 			"Use lsp_navigation to find definitions, references, and hover info via LSP",
@@ -625,6 +660,9 @@ export default function (pi: ExtensionAPI) {
 					Type.Literal("documentSymbol"),
 					Type.Literal("workspaceSymbol"),
 					Type.Literal("implementation"),
+					Type.Literal("prepareCallHierarchy"),
+					Type.Literal("incomingCalls"),
+					Type.Literal("outgoingCalls"),
 				],
 				{ description: "LSP operation to perform" },
 			),
@@ -648,6 +686,39 @@ export default function (pi: ExtensionAPI) {
 					description: "Symbol name to search. Used by workspaceSymbol",
 				}),
 			),
+			callHierarchyItem: Type.Optional(
+				Type.Object(
+					{
+						name: Type.String(),
+						kind: Type.Number(),
+						uri: Type.String(),
+						range: Type.Object({
+							start: Type.Object({
+								line: Type.Number(),
+								character: Type.Number(),
+							}),
+							end: Type.Object({
+								line: Type.Number(),
+								character: Type.Number(),
+							}),
+						}),
+						selectionRange: Type.Object({
+							start: Type.Object({
+								line: Type.Number(),
+								character: Type.Number(),
+							}),
+							end: Type.Object({
+								line: Type.Number(),
+								character: Type.Number(),
+							}),
+						}),
+					},
+					{
+						description:
+							"Call hierarchy item. Required for incomingCalls/outgoingCalls",
+					},
+				),
+			),
 		}),
 		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
 			if (!pi.getFlag("lens-lsp")) {
@@ -734,6 +805,43 @@ export default function (pi: ExtensionAPI) {
 							lspChar,
 						);
 						break;
+					case "prepareCallHierarchy":
+						result = await lspService.prepareCallHierarchy(
+							filePath,
+							lspLine,
+							lspChar,
+						);
+						break;
+					case "incomingCalls":
+						if (!params.callHierarchyItem) {
+							return {
+								content: [
+									{
+										type: "text" as const,
+										text: "callHierarchyItem parameter required for incomingCalls",
+									},
+								],
+								isError: true,
+								details: {},
+							};
+						}
+						result = await lspService.incomingCalls(params.callHierarchyItem);
+						break;
+					case "outgoingCalls":
+						if (!params.callHierarchyItem) {
+							return {
+								content: [
+									{
+										type: "text" as const,
+										text: "callHierarchyItem parameter required for outgoingCalls",
+									},
+								],
+								isError: true,
+								details: {},
+							};
+						}
+						result = await lspService.outgoingCalls(params.callHierarchyItem);
+						break;
 					default:
 						result = [];
 				}
@@ -768,6 +876,7 @@ export default function (pi: ExtensionAPI) {
 	let _cachedJscpdClones: import("./clients/jscpd-client.js").DuplicateClone[] =
 		[];
 	const cachedExports = new Map<string, string>(); // function name -> file path
+	let cachedProjectIndex: ProjectIndex | null = null; // similarity index for pre-write checks
 	const complexityBaselines: Map<
 		string,
 		import("./clients/complexity-client.js").FileComplexity
@@ -789,247 +898,298 @@ export default function (pi: ExtensionAPI) {
 	// Project rules scan result (from .claude/rules, .agents/rules, etc.)
 	let projectRulesScan: RuleScanResult = { rules: [], hasCustomRules: false };
 
+	// --- Register skills with pi ---
+	pi.on("resources_discover", async (_event, _ctx) => {
+		// Get the extension directory (where this file is located)
+		const extensionDir = path.dirname(fileURLToPath(import.meta.url));
+		const skillsDir = path.join(extensionDir, "skills");
+
+		return {
+			skillPaths: [skillsDir],
+		};
+	});
+
 	// --- Events ---
 
 	pi.on("session_start", async (_event, ctx) => {
-		_verbose = !!pi.getFlag("lens-verbose");
-		dbg("session_start fired");
-
-		// Reset session state
-		metricsClient.reset();
-		complexityBaselines.clear();
-
-		// Reset LSP service so the new session starts with fresh diagnostics.
-		// Without this, stale cascade errors from a previous session persist
-		// if the extension module stayed hot between reloads.
-		if (pi.getFlag("lens-lsp")) {
-			resetLSPService();
-			dbg("session_start: LSP service reset");
-		}
-
-		// Log available tools
-		const tools: string[] = [];
-		tools.push("TypeScript LSP"); // Always available
-		if (biomeClient.isAvailable()) tools.push("Biome");
-		if (astGrepClient.isAvailable()) tools.push("ast-grep");
-		if (ruffClient.isAvailable()) tools.push("Ruff");
-		if (knipClient.isAvailable()) tools.push("Knip");
-		if (depChecker.isAvailable()) tools.push("Madge");
-		if (jscpdClient.isAvailable()) tools.push("jscpd");
-		if (typeCoverageClient.isAvailable()) tools.push("type-coverage");
-
-		log(`Active tools: ${tools.join(", ")}`);
-		dbg(`session_start tools: ${tools.join(", ")}`);
-
-		// Clean up stale TypeScript build caches before LSP starts.
-		// tsconfig.tsbuildinfo caches the full file list from the last build.
-		// If files have been deleted since then, the LSP reads the stale list
-		// and reports phantom "Cannot find module" cascade errors for files
-		// the agent never touched.
-		if (pi.getFlag("lens-lsp")) {
-			const cleaned = cleanStaleTsBuildInfo(ctx.cwd ?? process.cwd());
-			if (cleaned.length > 0) {
-				ctx.ui.notify(
-					`🧹 Deleted stale TypeScript build cache (${cleaned.map((f) => path.basename(f)).join(", ")}) — phantom errors suppressed.`,
-					"info",
-				);
-				dbg(`session_start: cleaned stale tsbuildinfo: ${cleaned.join(", ")}`);
+		try {
+			_verbose = !!pi.getFlag("lens-verbose");
+			dbg("session_start fired");
+
+			// Reset session state
+			metricsClient.reset();
+			complexityBaselines.clear();
+			resetDispatchBaselines();
+			cachedProjectIndex = null;
+
+			// Reset LSP service so the new session starts with fresh diagnostics.
+			// Without this, stale cascade errors from a previous session persist
+			// if the extension module stayed hot between reloads.
+			if (pi.getFlag("lens-lsp")) {
+				resetLSPService();
+				dbg("session_start: LSP service reset");
 			}
-		}
 
-		// Pre-install TypeScript LSP if --lens-lsp flag is set (avoid delay on first use)
-		if (pi.getFlag("lens-lsp")) {
-			dbg("session_start: pre-installing TypeScript LSP...");
-			// Fire-and-forget: don't block session start, just warm up the cache
-			ensureTool("typescript-language-server")
-				.then((path) => {
-					if (path) {
-						dbg(`session_start: TypeScript LSP ready at ${path}`);
-					} else {
-						console.error("[lens] TypeScript LSP installation failed");
-					}
-				})
-				.catch((err) => {
-					console.error("[lens] TypeScript LSP pre-install error:", err);
-				});
-		}
+			// Log available tools
+			const tools: string[] = [];
+			tools.push("TypeScript LSP"); // Always available
+			if (biomeClient.isAvailable()) tools.push("Biome");
+			if (astGrepClient.isAvailable()) tools.push("ast-grep");
+			if (ruffClient.isAvailable()) tools.push("Ruff");
+			if (knipClient.isAvailable()) tools.push("Knip");
+			if (depChecker.isAvailable()) tools.push("Madge");
+			if (jscpdClient.isAvailable()) tools.push("jscpd");
+			if (typeCoverageClient.isAvailable()) tools.push("type-coverage");
+
+			log(`Active tools: ${tools.join(", ")}`);
+			dbg(`session_start tools: ${tools.join(", ")}`);
+
+			// Clean up stale TypeScript build caches before LSP starts.
+			// tsconfig.tsbuildinfo caches the full file list from the last build.
+			// If files have been deleted since then, the LSP reads the stale list
+			// and reports phantom "Cannot find module" cascade errors for files
+			// the agent never touched.
+			if (pi.getFlag("lens-lsp")) {
+				const cleaned = cleanStaleTsBuildInfo(ctx.cwd ?? process.cwd());
+				if (cleaned.length > 0) {
+					ctx.ui.notify(
+						`🧹 Deleted stale TypeScript build cache (${cleaned.map((f) => path.basename(f)).join(", ")}) — phantom errors suppressed.`,
+						"info",
+					);
+					dbg(
+						`session_start: cleaned stale tsbuildinfo: ${cleaned.join(", ")}`,
+					);
+				}
+			}
 
-		const cwd = ctx.cwd ?? process.cwd();
-		projectRoot = cwd; // Module-level for architect client
-		dbg(`session_start cwd: ${cwd}`);
+			// Pre-install TypeScript LSP if --lens-lsp flag is set (avoid delay on first use)
+			if (pi.getFlag("lens-lsp")) {
+				dbg("session_start: pre-installing TypeScript LSP...");
+				// Fire-and-forget: don't block session start, just warm up the cache
+				ensureTool("typescript-language-server")
+					.then((path) => {
+						if (path) {
+							dbg(`session_start: TypeScript LSP ready at ${path}`);
+						} else {
+							console.error("[lens] TypeScript LSP installation failed");
+						}
+					})
+					.catch((err) => {
+						console.error("[lens] TypeScript LSP pre-install error:", err);
+					});
+			}
 
-		// Load architect rules if present
-		const hasArchitectRules = architectClient.loadConfig(cwd);
-		if (hasArchitectRules) tools.push("Architect rules");
+			const cwd = ctx.cwd ?? process.cwd();
+			projectRoot = cwd; // Module-level for architect client
+			dbg(`session_start cwd: ${cwd}`);
 
-		// Log test runner if detected
-		const detectedRunner = testRunnerClient.detectRunner(cwd);
-		if (detectedRunner) {
-			tools.push(`Test runner (${detectedRunner.runner})`);
-		}
-		if (goClient.isGoAvailable()) tools.push("Go (go vet)");
-		if (rustClient.isAvailable()) tools.push("Rust (cargo)");
-		log(`Active tools: ${tools.join(", ")}`);
-		dbg(`session_start tools: ${tools.join(", ")}`);
+			// Load architect rules if present
+			const hasArchitectRules = architectClient.loadConfig(cwd);
+			if (hasArchitectRules) tools.push("Architect rules");
 
-		const parts: string[] = [];
+			// Log test runner if detected
+			const detectedRunner = testRunnerClient.detectRunner(cwd);
+			if (detectedRunner) {
+				tools.push(`Test runner (${detectedRunner.runner})`);
+			}
+			if (goClient.isGoAvailable()) tools.push("Go (go vet)");
+			if (rustClient.isAvailable()) tools.push("Rust (cargo)");
+			log(`Active tools: ${tools.join(", ")}`);
+			dbg(`session_start tools: ${tools.join(", ")}`);
 
-		// --- Error ownership reminder ---
-		// Shown on every session start to encourage fixing existing errors
-		parts.push(
-			"📌 Remember: If you find ANY errors (test failures, compile errors, lint issues) in this codebase, fix them — even if you didn't cause them. Don't skip errors as 'not my fault'.",
-		);
+			const parts: string[] = [];
 
-		// Scan for project-specific rules (.claude/rules, .agents/rules, CLAUDE.md, etc.)
-		projectRulesScan = scanProjectRules(cwd);
-		if (projectRulesScan.hasCustomRules) {
-			const ruleCount = projectRulesScan.rules.length;
-			const sources = [...new Set(projectRulesScan.rules.map((r) => r.source))];
-			dbg(
-				`session_start: found ${ruleCount} project rule(s) from ${sources.join(", ")}`,
-			);
+			// --- Error ownership reminder ---
+			// Shown on every session start to encourage fixing existing errors
 			parts.push(
-				`📋 Project rules found: ${ruleCount} file(s) in ${sources.join(", ")}. These apply alongside pi-lens defaults.`,
+				"📌 Remember: If you find ANY errors (test failures, compile errors, lint issues) in this codebase, fix them — even if you didn't cause them. Don't skip errors as 'not my fault'.",
 			);
-		} else {
-			dbg("session_start: no project rules found");
-		}
 
-		// TODO/FIXME scan — fast, no deps
-		const todoResult = todoScanner.scanDirectory(cwd);
-		const todoReport = todoScanner.formatResult(todoResult);
-		dbg(`session_start TODO scan: ${todoResult.items.length} items`);
-		if (todoReport) parts.push(todoReport);
-
-		// Dead code scan — use cache if fresh, auto-install if needed
-		if (await knipClient.ensureAvailable()) {
-			const cached = cacheManager.readCache<ReturnType<KnipClient["analyze"]>>(
-				"knip",
-				cwd,
-			);
-			if (cached) {
+			// Scan for project-specific rules (.claude/rules, .agents/rules, CLAUDE.md, etc.)
+			projectRulesScan = scanProjectRules(cwd);
+			if (projectRulesScan.hasCustomRules) {
+				const ruleCount = projectRulesScan.rules.length;
+				const sources = [
+					...new Set(projectRulesScan.rules.map((r) => r.source)),
+				];
 				dbg(
-					`session_start Knip: cache hit (${Math.round((Date.now() - new Date(cached.meta.timestamp).getTime()) / 1000)}s ago)`,
+					`session_start: found ${ruleCount} project rule(s) from ${sources.join(", ")}`,
+				);
+				parts.push(
+					`📋 Project rules found: ${ruleCount} file(s) in ${sources.join(", ")}. These apply alongside pi-lens defaults.`,
 				);
-				const knipReport = knipClient.formatResult(cached.data);
-				if (knipReport) parts.push(knipReport);
 			} else {
-				const startMs = Date.now();
-				const knipResult = knipClient.analyze(cwd);
-				cacheManager.writeCache("knip", knipResult, cwd, {
-					scanDurationMs: Date.now() - startMs,
-				});
-				const knipReport = knipClient.formatResult(knipResult);
-				dbg(`session_start Knip scan done`);
-				if (knipReport) parts.push(knipReport);
+				dbg("session_start: no project rules found");
 			}
-		} else {
-			dbg(`session_start Knip: not available`);
-		}
 
-		// Duplicate code detection — use cache if fresh, auto-install if needed
-		if (await jscpdClient.ensureAvailable()) {
-			const cached = cacheManager.readCache<ReturnType<JscpdClient["scan"]>>(
-				"jscpd",
-				cwd,
-			);
-			if (cached) {
-				dbg(`session_start jscpd: cache hit`);
-				_cachedJscpdClones = cached.data.clones;
-				const jscpdReport = jscpdClient.formatResult(cached.data);
-				if (jscpdReport) parts.push(jscpdReport);
+			// TODO/FIXME scan — fast, no deps
+			const todoResult = todoScanner.scanDirectory(cwd);
+			const todoReport = todoScanner.formatResult(todoResult);
+			dbg(`session_start TODO scan: ${todoResult.items.length} items`);
+			if (todoReport) parts.push(todoReport);
+
+			// Dead code scan — use cache if fresh, auto-install if needed
+			if (await knipClient.ensureAvailable()) {
+				const cached = cacheManager.readCache<
+					ReturnType<KnipClient["analyze"]>
+				>("knip", cwd);
+				if (cached) {
+					dbg(
+						`session_start Knip: cache hit (${Math.round((Date.now() - new Date(cached.meta.timestamp).getTime()) / 1000)}s ago)`,
+					);
+					const knipReport = knipClient.formatResult(cached.data);
+					if (knipReport) parts.push(knipReport);
+				} else {
+					const startMs = Date.now();
+					const knipResult = knipClient.analyze(cwd);
+					cacheManager.writeCache("knip", knipResult, cwd, {
+						scanDurationMs: Date.now() - startMs,
+					});
+					const knipReport = knipClient.formatResult(knipResult);
+					dbg(`session_start Knip scan done`);
+					if (knipReport) parts.push(knipReport);
+				}
 			} else {
-				const startMs = Date.now();
-				const jscpdResult = jscpdClient.scan(cwd);
-				_cachedJscpdClones = jscpdResult.clones;
-				cacheManager.writeCache("jscpd", jscpdResult, cwd, {
-					scanDurationMs: Date.now() - startMs,
-				});
-				const jscpdReport = jscpdClient.formatResult(jscpdResult);
-				dbg(`session_start jscpd scan done`);
-				if (jscpdReport) parts.push(jscpdReport);
+				dbg(`session_start Knip: not available`);
 			}
-		} else {
-			dbg(`session_start jscpd: not available`);
-		}
-
-		// Note: type-coverage runs on-demand via /lens-booboo only (not at session_start)
 
-		// Scan for exported functions (cached for duplicate detection on write)
-		if (await astGrepClient.ensureAvailable()) {
-			const exports = await astGrepClient.scanExports(cwd, "typescript");
-			dbg(`session_start exports scan: ${exports.size} functions found`);
-			for (const [name, file] of exports) {
-				cachedExports.set(name, file);
+			// Duplicate code detection — use cache if fresh, auto-install if needed
+			if (await jscpdClient.ensureAvailable()) {
+				const cached = cacheManager.readCache<ReturnType<JscpdClient["scan"]>>(
+					"jscpd",
+					cwd,
+				);
+				if (cached) {
+					dbg(`session_start jscpd: cache hit`);
+					_cachedJscpdClones = cached.data.clones;
+					const jscpdReport = jscpdClient.formatResult(cached.data);
+					if (jscpdReport) parts.push(jscpdReport);
+				} else {
+					const startMs = Date.now();
+					const jscpdResult = jscpdClient.scan(cwd);
+					_cachedJscpdClones = jscpdResult.clones;
+					cacheManager.writeCache("jscpd", jscpdResult, cwd, {
+						scanDurationMs: Date.now() - startMs,
+					});
+					const jscpdReport = jscpdClient.formatResult(jscpdResult);
+					dbg(`session_start jscpd scan done`);
+					if (jscpdReport) parts.push(jscpdReport);
+				}
+			} else {
+				dbg(`session_start jscpd: not available`);
 			}
-		}
 
-		dbg(
-			`session_start: scans complete (${parts.length} part(s)), cached for commands`,
-		);
+			// Note: type-coverage runs on-demand via /lens-booboo only (not at session_start)
 
-		// Output the assembled parts to user
-		if (parts.length > 0) {
-			for (const part of parts) {
-				ctx.ui.notify(part, "info");
+			// Scan for exported functions (cached for duplicate detection on write)
+			if (await astGrepClient.ensureAvailable()) {
+				const exports = await astGrepClient.scanExports(cwd, "typescript");
+				dbg(`session_start exports scan: ${exports.size} functions found`);
+				for (const [name, file] of exports) {
+					cachedExports.set(name, file);
+				}
 			}
-		}
 
-		// --- Error debt: check if tests ran since last session ---
-		// If files were modified in previous turn, run tests and check for regression
-		const errorDebtEnabled = pi.getFlag("error-debt");
-		const pendingDebt = cacheManager.readCache<{
-			pendingCheck: boolean;
-			baselineTestsPassed: boolean;
-		}>("errorDebt", cwd);
-
-		if (errorDebtEnabled && detectedRunner && pendingDebt?.data?.pendingCheck) {
-			dbg("session_start: running pending error debt check");
-			const testResult = testRunnerClient.runTestFile(
-				".",
-				cwd,
-				detectedRunner.runner,
-				detectedRunner.config,
-			);
-			const testsPassed = testResult.failed === 0 && !testResult.error;
-			const baselinePassed = pendingDebt.data.baselineTestsPassed;
-
-			// Regression detected!
-			if (baselinePassed && !testsPassed) {
-				const msg = `🔴 ERROR DEBT: Tests were passing but now failing (${testResult.failed} failure(s)). Fix before continuing.`;
-				dbg(`session_start ERROR DEBT: ${msg}`);
-				parts.push(msg);
+			// Build similarity index for pre-write structural duplicate detection.
+			// Uses the same source files as the exports scan. The index is ~50ms
+			// to query but seconds to build, so we do it once at session start.
+			try {
+				const existing = await loadIndex(cwd);
+				if (existing && existing.entries.size > 0) {
+					cachedProjectIndex = existing;
+					dbg(
+						`session_start: loaded project index from disk (${existing.entries.size} entries)`,
+					);
+				} else {
+					const sourceFiles = getSourceFiles(cwd, true);
+					const tsFiles = sourceFiles.filter(
+						(f) => f.endsWith(".ts") || f.endsWith(".tsx"),
+					);
+					if (tsFiles.length > 0 && tsFiles.length <= 500) {
+						cachedProjectIndex = await buildProjectIndex(cwd, tsFiles);
+						dbg(
+							`session_start: built project index (${cachedProjectIndex.entries.size} entries from ${tsFiles.length} files)`,
+						);
+					} else {
+						dbg(
+							`session_start: skipped project index (${tsFiles.length} files — ${tsFiles.length === 0 ? "none" : "too many"})`,
+						);
+					}
+				}
+			} catch (err) {
+				dbg(`session_start: project index build failed: ${err}`);
 			}
 
-			// Update baseline
-			errorDebtBaseline = {
-				testsPassed: testsPassed,
-				buildPassed: true,
-			};
-		} else if (errorDebtEnabled && detectedRunner) {
-			// No pending check - establish fresh baseline
-			dbg("session_start: establishing fresh error debt baseline");
-			const testResult = testRunnerClient.runTestFile(
-				".",
-				cwd,
-				detectedRunner.runner,
-				detectedRunner.config,
-			);
-			const testsPassed = testResult.failed === 0 && !testResult.error;
-			errorDebtBaseline = {
-				testsPassed: testsPassed,
-				buildPassed: true,
-			};
 			dbg(
-				`session_start error debt baseline: testsPassed=${errorDebtBaseline.testsPassed}`,
+				`session_start: scans complete (${parts.length} part(s)), cached for commands`,
 			);
+
+			// Output the assembled parts to user
+			if (parts.length > 0) {
+				for (const part of parts) {
+					ctx.ui.notify(part, "info");
+				}
+			}
+
+			// --- Error debt: check if tests ran since last session ---
+			// If files were modified in previous turn, run tests and check for regression
+			const errorDebtEnabled = pi.getFlag("error-debt");
+			const pendingDebt = cacheManager.readCache<{
+				pendingCheck: boolean;
+				baselineTestsPassed: boolean;
+			}>("errorDebt", cwd);
+
+			if (
+				errorDebtEnabled &&
+				detectedRunner &&
+				pendingDebt?.data?.pendingCheck
+			) {
+				dbg("session_start: running pending error debt check");
+				const testResult = testRunnerClient.runTestFile(
+					".",
+					cwd,
+					detectedRunner.runner,
+					detectedRunner.config,
+				);
+				const testsPassed = testResult.failed === 0 && !testResult.error;
+				const baselinePassed = pendingDebt.data.baselineTestsPassed;
+
+				// Regression detected!
+				if (baselinePassed && !testsPassed) {
+					const msg = `🔴 ERROR DEBT: Tests were passing but now failing (${testResult.failed} failure(s)). Fix before continuing.`;
+					dbg(`session_start ERROR DEBT: ${msg}`);
+					parts.push(msg);
+				}
+
+				// Update baseline
+				errorDebtBaseline = {
+					testsPassed: testsPassed,
+					buildPassed: true,
+				};
+			} else if (errorDebtEnabled && detectedRunner) {
+				// No pending check - establish fresh baseline
+				dbg("session_start: establishing fresh error debt baseline");
+				const testResult = testRunnerClient.runTestFile(
+					".",
+					cwd,
+					detectedRunner.runner,
+					detectedRunner.config,
+				);
+				const testsPassed = testResult.failed === 0 && !testResult.error;
+				errorDebtBaseline = {
+					testsPassed: testsPassed,
+					buildPassed: true,
+				};
+				dbg(
+					`session_start error debt baseline: testsPassed=${errorDebtBaseline.testsPassed}`,
+				);
+			}
+		} catch (sessionErr) {
+			dbg(`session_start crashed: ${sessionErr}`);
+			dbg(`session_start crash stack: ${(sessionErr as Error).stack}`);
 		}
 	});
 
-	// --- Pre-write proactive hints ---
-	// Stored during tool_call, prepended to tool_result output so the agent sees them.
-	const preWriteHints = new Map<string, string>();
-
 	pi.on("tool_call", async (event, _ctx) => {
 		const filePath =
 			isToolCallEventType("write", event) || isToolCallEventType("edit", event)
@@ -1038,14 +1198,13 @@ export default function (pi: ExtensionAPI) {
 
 		if (!filePath) return;
 
-		const _toolCallStart = Date.now();
 		dbg(
 			`tool_call fired for: ${filePath} (exists: ${nodeFs.existsSync(filePath)})`,
 		);
 		if (!nodeFs.existsSync(filePath)) return;
 
-		// Record complexity baseline for TS/JS files + capture history snapshot
-		const complexityBaselineStart = Date.now();
+		// Record complexity baseline for historical tracking (booboo/tdi).
+		// Not shown inline — just captured for delta analysis.
 		if (
 			complexityClient.isSupportedFile(filePath) &&
 			!complexityBaselines.has(filePath)
@@ -1053,161 +1212,100 @@ export default function (pi: ExtensionAPI) {
 			const baseline = complexityClient.analyzeFile(filePath);
 			if (baseline) {
 				complexityBaselines.set(filePath, baseline);
-				// Capture snapshot for historical tracking (async, non-blocking)
 				captureSnapshot(filePath, {
 					maintainabilityIndex: baseline.maintainabilityIndex,
 					cognitiveComplexity: baseline.cognitiveComplexity,
 					maxNestingDepth: baseline.maxNestingDepth,
 					linesOfCode: baseline.linesOfCode,
+					maxCyclomatic: baseline.maxCyclomaticComplexity,
+					entropy: baseline.codeEntropy,
 				});
 			}
-			logLatency({
-				type: "phase",
-				toolName: event.toolName,
-				filePath,
-				phase: "complexity_baseline",
-				durationMs: Date.now() - complexityBaselineStart,
-				metadata: { hasBaseline: complexityBaselines.has(filePath) },
-			});
 		}
 
-		const hints: string[] = [];
-		let _preCheckDuration = 0;
-
-		if (/\.(ts|tsx|js|jsx)$/.test(filePath) && !pi.getFlag("no-lsp")) {
-			const tsPreCheckStart = Date.now();
-			tsClient.updateFile(filePath, nodeFs.readFileSync(filePath, "utf-8"));
-			const diags = tsClient.getDiagnostics(filePath);
-			// Pass pre-computed diags to avoid a second getSemanticDiagnostics call (~1s on large files)
-			const fixes = tsClient.getAllCodeFixes(filePath, diags);
-			const errorDiags = diags.filter((d) => d.severity === 1);
-			if (errorDiags.length > 0) {
-				hints.push(
-					`⚠ Pre-write: file has ${errorDiags.length} TypeScript error(s):`,
-				);
-				// Show first 3 errors with quick fixes
-				for (const d of errorDiags.slice(0, 3)) {
-					const lineFixes = fixes.get(d.range.start.line);
-					const fixHint = lineFixes?.[0]?.description
-						? ` 💡 ${lineFixes[0].description}`
-						: "";
-					hints.push(
-						`  L${d.range.start.line + 1}: ${d.message.split("\n")[0].substring(0, 80)}${fixHint}`,
-					);
+		// --- Pre-write duplicate detection ---
+		// Check if new content redefines functions that already exist elsewhere.
+		// Uses cachedExports (populated at session_start via ast-grep scan).
+		if (isToolCallEventType("write", event) && cachedExports.size > 0) {
+			const newContent = (event.input as { content?: string }).content;
+			if (newContent) {
+				const dupeWarnings: string[] = [];
+				const exportRe =
+					/export\s+(?:async\s+)?(?:function|class|const|let|type|interface)\s+(\w+)/g;
+				let m: RegExpExecArray | null;
+				while ((m = exportRe.exec(newContent))) {
+					const name = m[1];
+					const existingFile = cachedExports.get(name);
+					if (
+						existingFile &&
+						path.resolve(existingFile) !== path.resolve(filePath)
+					) {
+						dupeWarnings.push(
+							`\`${name}\` already exists in ${path.relative(projectRoot, existingFile)}`,
+						);
+					}
 				}
-				if (errorDiags.length > 3) {
-					hints.push(`  ... and ${errorDiags.length - 3} more errors`);
+				if (dupeWarnings.length > 0) {
+					return {
+						block: true,
+						reason: `🔴 STOP — Redefining existing export(s). Import instead:\n${dupeWarnings.map((w) => `  • ${w}`).join("\n")}`,
+					};
 				}
-			}
-			_preCheckDuration += Date.now() - tsPreCheckStart;
-			logLatency({
-				type: "phase",
-				toolName: event.toolName,
-				filePath,
-				phase: "ts_pre_check",
-				durationMs: Date.now() - tsPreCheckStart,
-				metadata: { errorCount: errorDiags.length, hintCount: hints.length },
-			});
-		}
 
-		// Unified LSP pre-write check (when --lens-lsp enabled)
-		// This provides pre-write hints for all LSP languages (TypeScript, Python, Go, Rust, etc.)
-		if (pi.getFlag("lens-lsp") && !pi.getFlag("no-lsp")) {
-			const lspPreCheckStart = Date.now();
-			const lspService = getLSPService();
-			lspService
-				.hasLSP(filePath)
-				.then(async (hasLSP) => {
-					if (hasLSP) {
-						const content = nodeFs.readFileSync(filePath, "utf-8");
-						await lspService.openFile(filePath, content);
-						await new Promise((r) => setTimeout(r, 300));
-						const diags = await lspService.getDiagnostics(filePath);
-						const errorDiags = diags.filter((d) => d.severity === 1);
-						if (errorDiags.length > 0) {
-							hints.push(
-								`⚠ Pre-write: ${errorDiags.length} LSP error(s) detected:`,
+				// --- Structural similarity check (Phase 7b) ---
+				// If the project index was built at session_start, check new
+				// functions against it for structural clones (~50ms).
+				if (
+					cachedProjectIndex &&
+					cachedProjectIndex.entries.size > 0 &&
+					/\.(ts|tsx)$/.test(filePath)
+				) {
+					try {
+						const ts = await import("typescript");
+						const sourceFile = ts.createSourceFile(
+							filePath,
+							newContent,
+							ts.ScriptTarget.Latest,
+							true,
+						);
+						const newFunctions = extractFunctions(sourceFile, newContent);
+						const simWarnings: string[] = [];
+						const relPath = path.relative(projectRoot, filePath);
+
+						for (const func of newFunctions) {
+							if (func.transitionCount < 20) continue;
+							const matches = findSimilarFunctions(
+								func.matrix,
+								cachedProjectIndex,
+								0.8,
+								1,
 							);
-							for (const d of errorDiags.slice(0, 3)) {
-								hints.push(
-									`  L${d.range?.start?.line ?? 0 + 1}: ${d.message.slice(0, 80)}`,
+							for (const match of matches) {
+								// Skip self-matches
+								if (match.targetId === `${relPath}:${func.name}`) continue;
+								const pct = Math.round(match.similarity * 100);
+								simWarnings.push(
+									`\`${func.name}\` is ${pct}% similar to \`${match.targetName}\` in ${match.targetLocation}`,
 								);
 							}
-							if (errorDiags.length > 3) {
-								hints.push(`  ... and ${errorDiags.length - 3} more`);
-							}
 						}
-						_preCheckDuration += Date.now() - lspPreCheckStart;
-						logLatency({
-							type: "phase",
-							toolName: event.toolName,
-							filePath,
-							phase: "lsp_pre_check",
-							durationMs: Date.now() - lspPreCheckStart,
-							metadata: { hasLSP, errorCount: errorDiags?.length ?? 0 },
-						});
-					}
-				})
-				.catch((err) => {
-					logLatency({
-						type: "phase",
-						toolName: event.toolName,
-						filePath,
-						phase: "lsp_pre_check",
-						durationMs: Date.now() - lspPreCheckStart,
-						status: "failed",
-						metadata: { error: String(err) },
-					});
-				});
-		}
-
-		// Note: ast-grep baseline removed - we use ast-grep-napi in dispatch instead
-		// Note: biome baseline removed - auto-fix handles this in post-write
 
-		// Architectural rules: Skip pre-write hints (too noisy)
-		// Post-write violations will be shown via architect runner in dispatch
-
-		dbg(`  pre-write hints: ${hints.length} — ${hints.join(" | ") || "none"}`);
-		if (hints.length > 0) {
-			preWriteHints.set(filePath, hints.join("\n"));
+						if (simWarnings.length > 0) {
+							return {
+								block: false,
+								reason: `⚠️ Structural similarity detected — consider reusing existing code:\n${simWarnings.map((w) => `  • ${w}`).join("\n")}`,
+							};
+						}
+					} catch {
+						// Parsing failed — skip similarity check silently
+					}
+				}
+			}
 		}
 	});
 
 	// Real-time feedback on file writes/edits
 	pi.on("tool_result", async (event) => {
-		// ═══════════════════════════════════════════════════════════════════
-		// LATENCY TRACKING: Comprehensive phase-based logging
-		// ═══════════════════════════════════════════════════════════════════
-		const toolResultStart = Date.now();
-		const toolName = event.toolName;
-		const phases: Array<{
-			name: string;
-			start: number;
-			end?: number;
-			duration?: number;
-		}> = [];
-
-		function phaseStart(name: string) {
-			phases.push({ name, start: Date.now() });
-		}
-		function phaseEnd(name: string, metadata?: Record<string, unknown>) {
-			const p = phases.find((x) => x.name === name && !x.end);
-			if (p) {
-				p.end = Date.now();
-				p.duration = p.end - p.start;
-				if (filePath) {
-					logLatency({
-						type: "phase",
-						toolName,
-						filePath,
-						phase: name,
-						durationMs: p.duration,
-						metadata,
-					});
-				}
-			}
-		}
-
 		// Track tool call for behavior analysis (all tool types)
 		const filePath = (event.input as { path?: string }).path;
 		const behaviorWarnings = agentBehaviorClient.recordToolCall(
@@ -1243,11 +1341,10 @@ export default function (pi: ExtensionAPI) {
 		}
 		// Record this write so future assertions know the agent has the current state
 		sessionFileTime.read(filePath);
+		const toolResultStart = Date.now();
 		dbg(
 			`tool_result: tracking turn state for ${event.toolName} on ${filePath}`,
 		);
-		phaseStart("total");
-		phaseStart("turn_state_tracking");
 
 		// --- Track modified ranges in turn state for async jscpd/madge at turn_end ---
 		const cwd = projectRoot;
@@ -1292,344 +1389,73 @@ export default function (pi: ExtensionAPI) {
 			dbg(`turn state tracking error stack: ${(err as Error).stack}`);
 		}
 
-		dbg(`tool_result fired for: ${filePath}`);
-		dbg(`  cwd: ${process.cwd()}`);
-		dbg(
-			`  __dirname: ${typeof __dirname !== "undefined" ? __dirname : "undefined"}`,
-		);
-
-		// Prepend any pre-write hints collected during tool_call
-		const preHint = preWriteHints.get(filePath);
-		preWriteHints.delete(filePath);
-
-		// Record write for metrics (silent tracking)
-		phaseEnd("turn_state_tracking");
-		phaseStart("read_file");
+		const turnStateMs = Date.now() - toolResultStart;
+		logLatency({
+			type: "phase",
+			toolName: event.toolName,
+			filePath,
+			phase: "turn_state_tracking",
+			durationMs: turnStateMs,
+		});
+		dbg(`tool_result fired for: ${filePath} (turn_state: ${turnStateMs}ms)`);
 
-		let fileContent: string | undefined;
+		let result: { output: string; isError?: boolean };
 		try {
-			fileContent = nodeFs.readFileSync(filePath, "utf-8");
-			metricsClient.recordWrite(filePath, fileContent);
-		} catch (err) {
-			void err;
-		}
-		phaseEnd("read_file");
-
-		// --- Auto-format on write (default enabled) ---
-		phaseStart("format");
-		// Runs detected formatters concurrently via Effect-TS
-		let formatChanged = false;
-		let formattersUsed: string[] = [];
-		if (!pi.getFlag("no-autoformat") && fileContent) {
-			const formatService = getFormatService();
-			try {
-				// Record file read to establish FileTime baseline before formatting
-				// This prevents "modified externally" false positives when agent writes file
-				formatService.recordRead(filePath);
-				const result = await formatService.formatFile(filePath);
-				formattersUsed = result.formatters.map((f) => f.name);
-				if (result.anyChanged) {
-					formatChanged = true;
-					dbg(
-						`autoformat: ${result.formatters.map((f) => `${f.name}(${f.changed ? "changed" : "unchanged"})`).join(", ")}`,
-					);
-					// Re-read content after formatting for downstream processing
-					fileContent = nodeFs.readFileSync(filePath, "utf-8");
-				}
-			} catch (err) {
-				dbg(`autoformat error: ${err}`);
-			}
-		}
-		phaseEnd("format", { formattersUsed, formatChanged });
-
-		// --- Publish file modified event to bus (Phase 1) ---
-		// --- LSP integration (Phase 3) ---
-		if (pi.getFlag("lens-lsp") && fileContent) {
-			const lspService = getLSPService();
-			lspService
-				.hasLSP(filePath)
-				.then(async (hasLSP) => {
-					if (hasLSP) {
-						// Open or update file in LSP
-						if (event.toolName === "write") {
-							await lspService.openFile(filePath, fileContent);
-						} else {
-							await lspService.updateFile(filePath, fileContent);
-						}
-					}
-				})
-				.catch((err) => {
-					dbg(`LSP error: ${err}`);
-				});
-		}
-
-		// --- Secrets scan (blocking - must check before other linting) ---
-		if (fileContent) {
-			const secretFindings = scanForSecrets(fileContent, filePath);
-			if (secretFindings.length > 0) {
-				const secretsOutput = formatSecrets(secretFindings, filePath);
-				const elapsed = Date.now() - toolResultStart;
-				logLatency({
-					type: "tool_result",
-					toolName,
+			result = await runPipeline(
+				{
 					filePath,
-					durationMs: elapsed,
-					result: "blocked_secrets",
-					metadata: { secretsFound: secretFindings.length },
-				});
-				return {
-					content: [
-						...event.content,
-						{ type: "text" as const, text: `\n\n${secretsOutput}` },
-					],
-					isError: true,
-				};
-			}
-		}
-
-		let lspOutput = preHint ? `\n\n${preHint}` : "";
-
-		// --- Auto-fix on write (safely - track to prevent loops) ---
-		phaseStart("autofix");
-		// Apply fixes BEFORE dispatch so dispatch only reports remaining issues
-		// Autofix is enabled by default, use --no-autofix to disable
-		const noAutofix = pi.getFlag("no-autofix");
-		const noAutofixBiome = pi.getFlag("no-autofix-biome");
-		const noAutofixRuff = pi.getFlag("no-autofix-ruff");
-		let fixedCount = 0;
-
-		if (!fixedThisTurn.has(filePath) && !noAutofix) {
-			// Python: Ruff auto-fix (enabled by default)
-			if (
-				!noAutofixRuff &&
-				(await ruffClient.ensureAvailable()) &&
-				ruffClient.isPythonFile(filePath)
-			) {
-				const result = ruffClient.fixFile(filePath);
-				if (result.success && result.fixed > 0) {
-					fixedCount += result.fixed;
-					fixedThisTurn.add(filePath);
-					dbg(`autofix: ruff fixed ${result.fixed} issue(s) in ${filePath}`);
-				}
-			}
-
-			// JS/TS/JSON: Biome auto-fix (enabled by default)
-			if (
-				!noAutofixBiome &&
-				biomeClient.isAvailable() &&
-				biomeClient.isSupportedFile(filePath)
-			) {
-				const result = biomeClient.fixFile(filePath);
-				if (result.success && result.fixed > 0) {
-					fixedCount += result.fixed;
-					fixedThisTurn.add(filePath);
-					dbg(`autofix: biome fixed ${result.fixed} issue(s) in ${filePath}`);
-				}
-			}
-		}
-		phaseEnd("autofix", { fixedCount, tools: ["ruff", "biome"] });
-
-		// --- Declarative dispatch: run all applicable lint tools ---
-		phaseStart("dispatch_lint");
-		// Phase 2: Replaced ~400 lines of if/else with unified dispatch system
-		dbg(`dispatch: running lint tools for ${filePath}`);
-
-		const dispatchOutput = await dispatchLint(filePath, projectRoot, pi);
-
-		if (dispatchOutput) {
-			lspOutput += `\n\n${dispatchOutput}`;
-		}
-
-		// Report autofix results
-		if (fixedCount > 0) {
-			lspOutput += `\n\n✅ Auto-fixed ${fixedCount} issue(s) in ${path.basename(filePath)}`;
-		}
-
-		// Warn agent if file was modified by auto-format or auto-fix
-		// This ensures they know to re-read before next edit
-		if (formatChanged || fixedCount > 0) {
-			lspOutput += `\n\n⚠️ **File modified by auto-format/fix. Re-read before next edit.**`;
+					cwd: projectRoot,
+					toolName: event.toolName,
+					getFlag: (name: string) => pi.getFlag(name),
+					dbg,
+				},
+				{
+					biomeClient,
+					ruffClient,
+					testRunnerClient,
+					metricsClient,
+					getFormatService,
+					fixedThisTurn,
+				},
+			);
+		} catch (pipelineErr) {
+			dbg(`runPipeline crashed: ${pipelineErr}`);
+			dbg(`runPipeline crash stack: ${(pipelineErr as Error).stack}`);
+			return;
 		}
-		phaseEnd("dispatch_lint", {
-			hasOutput: !!dispatchOutput,
-		});
 
-		// --- Test runner: run corresponding tests on write ---
-		phaseStart("test_runner");
-		let testInfoFound = false;
-		let testRunnerRan = false;
-		if (!pi.getFlag("no-tests")) {
-			const testInfo = testRunnerClient.findTestFile(filePath, cwd);
-			testInfoFound = !!testInfo;
-			if (testInfo) {
-				dbg(
-					`test-runner: found test file ${testInfo.testFile} for ${filePath}`,
-				);
-				const detectedRunner = testRunnerClient.detectRunner(cwd);
-				if (detectedRunner) {
-					testRunnerRan = true;
-					const testStart = Date.now();
-					const testResult = testRunnerClient.runTestFile(
-						testInfo.testFile,
-						cwd,
-						detectedRunner.runner,
-						detectedRunner.config,
-					);
-					const testDuration = Date.now() - testStart;
-					logLatency({
-						type: "phase",
-						toolName,
-						filePath,
-						phase: "test_runner",
-						durationMs: testDuration,
-						metadata: {
-							testFile: testInfo.testFile,
-							runner: detectedRunner.runner,
-							success: !testResult?.error,
-						},
-					});
-					if (testResult && !testResult.error) {
-						const testOutput = testRunnerClient.formatResult(testResult);
-						if (testOutput) {
-							lspOutput += `\n\n${testOutput}`;
-						}
-					}
-				}
-			}
-		}
-		phaseEnd("test_runner", { found: testInfoFound, ran: testRunnerRan });
-
-		// Note: TypeScript diagnostics are handled by the ts-lsp dispatch runner above.
-		// No inline TypeScriptClient check here — dispatch already covers it.
-
-		// --- Complexity tracking (post-write) ---
-		phaseStart("complexity_check");
-		if (complexityClient.isSupportedFile(filePath)) {
-			const oldBaseline = complexityBaselines.get(filePath);
-			const newComplexity = complexityClient.analyzeFile(filePath);
-			if (oldBaseline && newComplexity) {
-				const complexityDelta = {
-					cognitive:
-						newComplexity.cognitiveComplexity - oldBaseline.cognitiveComplexity,
-					maintainability:
-						newComplexity.maintainabilityIndex -
-						oldBaseline.maintainabilityIndex,
-					lines: newComplexity.linesOfCode - oldBaseline.linesOfCode,
-				};
-				// Warn if complexity significantly increased
-				if (
-					complexityDelta.cognitive > 3 ||
-					complexityDelta.maintainability < -5
-				) {
-					lspOutput += `\n\n⚠️ Complexity increased: +${complexityDelta.cognitive} cognitive, ${complexityDelta.maintainability.toFixed(1)} maintainability`;
-				}
-				phaseEnd("complexity_check", {
-					delta: complexityDelta,
-					warned:
-						complexityDelta.cognitive > 3 ||
-						complexityDelta.maintainability < -5,
-				});
-			} else {
-				phaseEnd("complexity_check", { delta: null, warned: false });
-			}
-		} else {
-			phaseEnd("complexity_check", { skipped: true });
+		// Secrets found — block immediately
+		if (result.isError) {
+			return {
+				content: [
+					...event.content,
+					{ type: "text" as const, text: result.output },
+				],
+				isError: true,
+			};
 		}
 
-		// Agent behavior warnings (blind writes, thrashing)
+		// Append behavior warnings
+		let output = result.output;
 		if (behaviorWarnings.length > 0) {
-			lspOutput += `\n\n${agentBehaviorClient.formatWarnings(behaviorWarnings)}`;
-		}
-
-		// --- Cascade diagnostics: check other files for errors (when --lens-lsp) ---
-		if (pi.getFlag("lens-lsp") && !pi.getFlag("no-lsp")) {
-			const MAX_CASCADE_FILES = 5;
-			const MAX_DIAGNOSTICS_PER_FILE = 20;
-			const cascadeStart = Date.now();
-
-			try {
-				const lspService = getLSPService();
-				const allDiags = await lspService.getAllDiagnostics();
-				const normalizedEditedPath = path.resolve(filePath);
-				const otherFileErrors: Array<{
-					file: string;
-					errors: import("./clients/lsp/client.js").LSPDiagnostic[];
-				}> = [];
-
-				for (const [diagPath, diags] of allDiags) {
-					if (path.resolve(diagPath) === normalizedEditedPath) continue; // Skip edited file (dispatch already covered it)
-					const errors = diags.filter((d) => d.severity === 1);
-					if (errors.length > 0) {
-						otherFileErrors.push({ file: diagPath, errors });
-					}
-				}
-
-				if (otherFileErrors.length > 0) {
-					lspOutput += `\n\n📐 Cascade errors detected in ${otherFileErrors.length} other file(s):`;
-					for (const { file, errors } of otherFileErrors.slice(
-						0,
-						MAX_CASCADE_FILES,
-					)) {
-						const limited = errors.slice(0, MAX_DIAGNOSTICS_PER_FILE);
-						const suffix =
-							errors.length > MAX_DIAGNOSTICS_PER_FILE
-								? `\n... and ${errors.length - MAX_DIAGNOSTICS_PER_FILE} more`
-								: "";
-						// Structured XML format (like OpenCode) for cleaner parsing
-						lspOutput += `\n<diagnostics file="${file}">`;
-						for (const e of limited) {
-							const line = (e.range?.start?.line ?? 0) + 1;
-							const col = (e.range?.start?.character ?? 0) + 1;
-							const code = e.code ? ` [${e.code}]` : "";
-							lspOutput += `\n  ${code} (${line}:${col}) ${e.message.split("\n")[0].slice(0, 100)}`;
-						}
-						lspOutput += `${suffix}\n</diagnostics>`;
-					}
-					if (otherFileErrors.length > MAX_CASCADE_FILES) {
-						lspOutput += `\n... and ${otherFileErrors.length - MAX_CASCADE_FILES} more files with errors`;
-					}
-				}
-
-				logLatency({
-					type: "phase",
-					toolName,
-					filePath,
-					phase: "cascade_diagnostics",
-					durationMs: Date.now() - cascadeStart,
-					metadata: { filesWithErrors: otherFileErrors.length },
-				});
-			} catch (err) {
-				dbg(`cascade diagnostics error: ${err}`);
-			}
-		}
-
-		// LATENCY TRACKING: Log timing before returning
-		const elapsed = Date.now() - toolResultStart;
-		phaseEnd("total", { hasOutput: !!lspOutput });
-		if (!lspOutput) {
-			logLatency({
-				type: "tool_result",
-				toolName,
-				filePath,
-				durationMs: elapsed,
-				result: "no_output",
-			});
-			return;
+			output += `\n\n${agentBehaviorClient.formatWarnings(behaviorWarnings)}`;
 		}
 
+		const totalMs = Date.now() - toolResultStart;
 		logLatency({
 			type: "tool_result",
-			toolName,
+			toolName: event.toolName,
 			filePath,
-			durationMs: elapsed,
-			result: "completed",
+			durationMs: totalMs,
+			result: output ? "completed" : "no_output",
 		});
 
+		if (!output) return;
+
 		return {
-			content: [...event.content, { type: "text" as const, text: lspOutput }],
+			content: [...event.content, { type: "text" as const, text: output }],
 		};
 	});
-
 	// --- Inject project rules into system prompt ---
 	pi.on("before_agent_start", async (event) => {
 		if (!projectRulesScan.hasCustomRules) return;
@@ -1642,123 +1468,130 @@ export default function (pi: ExtensionAPI) {
 
 	// --- Turn end: batch jscpd/madge on collected files, then clear state ---
 	pi.on("turn_end", async (_event, ctx) => {
-		const cwd = ctx.cwd ?? process.cwd();
-		const turnState = cacheManager.readTurnState(cwd);
-		const files = Object.keys(turnState.files);
-
-		if (files.length === 0) return;
+		try {
+			const cwd = ctx.cwd ?? process.cwd();
+			const turnState = cacheManager.readTurnState(cwd);
+			const files = Object.keys(turnState.files);
 
-		dbg(
-			`turn_end: ${files.length} file(s) modified, cycles: ${turnState.turnCycles}/${turnState.maxCycles}`,
-		);
+			if (files.length === 0) return;
 
-		// Max cycles guard — force through after N turns with unresolved issues
-		if (cacheManager.isMaxCyclesExceeded(cwd)) {
-			dbg("turn_end: max cycles exceeded, clearing state and forcing through");
-			cacheManager.clearTurnState(cwd);
-			return;
-		}
+			dbg(
+				`turn_end: ${files.length} file(s) modified, cycles: ${turnState.turnCycles}/${turnState.maxCycles}`,
+			);
 
-		const parts: string[] = [];
-
-		// jscpd: scan modified files, filter results to modified line ranges
-		if (jscpdClient.isAvailable()) {
-			const jscpdFiles = cacheManager.getFilesForJscpd(cwd);
-			if (jscpdFiles.length > 0) {
-				dbg(`turn_end: jscpd scanning ${jscpdFiles.length} file(s)`);
-				// Use full scan then filter — jscpd doesn't support per-file scanning
-				const result = jscpdClient.scan(cwd);
-				// Filter clones to only those intersecting modified ranges
-				const jscpdFileSet = new Set(
-					jscpdFiles.map((f) => path.resolve(cwd, f)),
+			// Max cycles guard — force through after N turns with unresolved issues
+			if (cacheManager.isMaxCyclesExceeded(cwd)) {
+				dbg(
+					"turn_end: max cycles exceeded, clearing state and forcing through",
 				);
-				const filtered = result.clones.filter((clone) => {
-					const resolvedA = path.resolve(clone.fileA);
-					if (!jscpdFileSet.has(resolvedA)) return false;
-					const relA = path.relative(cwd, resolvedA).replace(/\\/g, "/");
-					const state = turnState.files[relA];
-					if (!state) return false;
-					return cacheManager.isLineInModifiedRange(
-						clone.startA,
-						state.modifiedRanges,
+				cacheManager.clearTurnState(cwd);
+				return;
+			}
+
+			const parts: string[] = [];
+
+			// jscpd: scan modified files, filter results to modified line ranges
+			if (jscpdClient.isAvailable()) {
+				const jscpdFiles = cacheManager.getFilesForJscpd(cwd);
+				if (jscpdFiles.length > 0) {
+					dbg(`turn_end: jscpd scanning ${jscpdFiles.length} file(s)`);
+					// Use full scan then filter — jscpd doesn't support per-file scanning
+					const result = jscpdClient.scan(cwd);
+					// Filter clones to only those intersecting modified ranges
+					const jscpdFileSet = new Set(
+						jscpdFiles.map((f) => path.resolve(cwd, f)),
 					);
-				});
-				if (filtered.length > 0) {
-					let report = `🔴 New duplicates in modified code:\n`;
-					for (const clone of filtered.slice(0, 5)) {
-						report += `  ${path.basename(clone.fileA)}:${clone.startA} ↔ ${path.basename(clone.fileB)}:${clone.startB} (${clone.lines} lines)\n`;
+					const filtered = result.clones.filter((clone) => {
+						const resolvedA = path.resolve(clone.fileA);
+						if (!jscpdFileSet.has(resolvedA)) return false;
+						const relA = path.relative(cwd, resolvedA).replace(/\\/g, "/");
+						const state = turnState.files[relA];
+						if (!state) return false;
+						return cacheManager.isLineInModifiedRange(
+							clone.startA,
+							state.modifiedRanges,
+						);
+					});
+					if (filtered.length > 0) {
+						let report = `🔴 New duplicates in modified code:\n`;
+						for (const clone of filtered.slice(0, 5)) {
+							report += `  ${path.basename(clone.fileA)}:${clone.startA} ↔ ${path.basename(clone.fileB)}:${clone.startB} (${clone.lines} lines)\n`;
+						}
+						parts.push(report);
 					}
-					parts.push(report);
+					// Update the global cache with fresh results
+					_cachedJscpdClones = result.clones;
+					cacheManager.writeCache("jscpd", result, cwd);
 				}
-				// Update the global cache with fresh results
-				_cachedJscpdClones = result.clones;
-				cacheManager.writeCache("jscpd", result, cwd);
 			}
-		}
 
-		// madge: only check files where imports changed
-		if (await depChecker.ensureAvailable()) {
-			const madgeFiles = cacheManager.getFilesForMadge(cwd);
-			if (madgeFiles.length > 0) {
-				dbg(
-					`turn_end: madge checking ${madgeFiles.length} file(s) for circular deps`,
-				);
-				for (const file of madgeFiles) {
-					const absPath = path.resolve(cwd, file);
-					const depResult = depChecker.checkFile(absPath);
-					if (depResult.hasCircular && depResult.circular.length > 0) {
-						const circularDeps = depResult.circular
-							.flatMap((d) => d.path)
-							.filter((p: string) => !absPath.endsWith(path.basename(p)));
-						const uniqueDeps = [...new Set(circularDeps)];
-						if (uniqueDeps.length > 0) {
-							parts.push(
-								`🟡 Circular dependency in ${file}: imports ${uniqueDeps.join(", ")}`,
-							);
+			// madge: only check files where imports changed
+			if (await depChecker.ensureAvailable()) {
+				const madgeFiles = cacheManager.getFilesForMadge(cwd);
+				if (madgeFiles.length > 0) {
+					dbg(
+						`turn_end: madge checking ${madgeFiles.length} file(s) for circular deps`,
+					);
+					for (const file of madgeFiles) {
+						const absPath = path.resolve(cwd, file);
+						const depResult = depChecker.checkFile(absPath);
+						if (depResult.hasCircular && depResult.circular.length > 0) {
+							const circularDeps = depResult.circular
+								.flatMap((d) => d.path)
+								.filter((p: string) => !absPath.endsWith(path.basename(p)));
+							const uniqueDeps = [...new Set(circularDeps)];
+							if (uniqueDeps.length > 0) {
+								parts.push(
+									`🟡 Circular dependency in ${file}: imports ${uniqueDeps.join(", ")}`,
+								);
+							}
 						}
 					}
 				}
 			}
-		}
 
-		// Increment turn cycle and persist
-		cacheManager.incrementTurnCycle(cwd);
+			// Increment turn cycle and persist
+			cacheManager.incrementTurnCycle(cwd);
 
-		if (parts.length > 0) {
-			dbg(`turn_end: ${parts.length} issue(s) found`);
-			// Issues found — state persists so next turn re-checks.
-			// After maxCycles, clearTurnState forces through.
-		} else {
-			// No issues — clear state for next batch of edits
-			cacheManager.clearTurnState(cwd);
-		}
+			if (parts.length > 0) {
+				dbg(`turn_end: ${parts.length} issue(s) found`);
+				// Issues found — state persists so next turn re-checks.
+				// After maxCycles, clearTurnState forces through.
+			} else {
+				// No issues — clear state for next batch of edits
+				cacheManager.clearTurnState(cwd);
+			}
 
-		// --- Error debt: trigger background test run for next session ---
-		// We don't wait - just set a flag that tests should run at next session_start
-		// This way tests run async (session_start is when agent is idle)
-		if (errorDebtBaseline && files.length > 0) {
-			dbg("turn_end: marking error debt check for next session");
-			// Write a marker file - next session_start will pick this up
-			cacheManager.writeCache(
-				"errorDebt",
-				{
-					pendingCheck: true,
-					baselineTestsPassed: errorDebtBaseline.testsPassed,
-				},
-				cwd,
-			);
-		}
+			// --- Error debt: trigger background test run for next session ---
+			// We don't wait - just set a flag that tests should run at next session_start
+			// This way tests run async (session_start is when agent is idle)
+			if (errorDebtBaseline && files.length > 0) {
+				dbg("turn_end: marking error debt check for next session");
+				// Write a marker file - next session_start will pick this up
+				cacheManager.writeCache(
+					"errorDebt",
+					{
+						pendingCheck: true,
+						baselineTestsPassed: errorDebtBaseline.testsPassed,
+					},
+					cwd,
+				);
+			}
 
-		// Clear fixed tracking so files can be fixed again on next turn
-		fixedThisTurn.clear();
+			// Clear fixed tracking so files can be fixed again on next turn
+			fixedThisTurn.clear();
 
-		// --- LSP cleanup on turn end (Phase 3) ---
-		// Only shutdown if no files are being actively edited
-		if (pi.getFlag("lens-lsp") && files.length === 0) {
-			resetLSPService();
-		}
+			// --- LSP cleanup on turn end (Phase 3) ---
+			// Only shutdown if no files are being actively edited
+			if (pi.getFlag("lens-lsp") && files.length === 0) {
+				resetLSPService();
+			}
 
-		// --- Format service cleanup ---
-		resetFormatService();
+			// --- Format service cleanup ---
+			resetFormatService();
+		} catch (turnEndErr) {
+			dbg(`turn_end crashed: ${turnEndErr}`);
+			dbg(`turn_end crash stack: ${(turnEndErr as Error).stack}`);
+		}
 	});
 }