pi-lens 2.2.9 → 3.0.0

package/index.ts

@@ -8,21 +8,30 @@ import { AgentBehaviorClient } from "./clients/agent-behavior-client.js";
 import { ArchitectClient } from "./clients/architect-client.js";
 import { AstGrepClient } from "./clients/ast-grep-client.js";
 import { BiomeClient } from "./clients/biome-client.js";
+import {
+	enableDebug as enableBusDebug,
+	FileModified,
+	initBusIntegration,
+	SessionStarted,
+	TurnEnded,
+} from "./clients/bus/index.js";
 import { CacheManager } from "./clients/cache-manager.js";
 import { ComplexityClient } from "./clients/complexity-client.js";
 import { DependencyChecker } from "./clients/dependency-checker.js";
+import { dispatchLintWithBus } from "./clients/dispatch/bus-dispatcher.js";
 import { dispatchLint } from "./clients/dispatch/integration.js";
+import {
+	getFormatService,
+	resetFormatService,
+} from "./clients/format-service.js";
 import { GoClient } from "./clients/go-client.js";
+import { ensureTool } from "./clients/installer/index.js";
 import { buildInterviewer } from "./clients/interviewer.js";
 import { JscpdClient } from "./clients/jscpd-client.js";
 import { KnipClient } from "./clients/knip-client.js";
+import { getLSPService, resetLSPService } from "./clients/lsp/index.js";
 import { MetricsClient } from "./clients/metrics-client.js";
-import {
-	captureSnapshot,
-	captureSnapshots,
-	formatTrendCell,
-	getTrendSummary,
-} from "./clients/metrics-history.js";
+import { captureSnapshot } from "./clients/metrics-history.js";
 import { RuffClient } from "./clients/ruff-client.js";
 import {
 	formatRulesForPrompt,
@@ -32,14 +41,13 @@ import {
 import { RustClient } from "./clients/rust-client.js";
 import { getSourceFiles } from "./clients/scan-utils.js";
 import { formatSecrets, scanForSecrets } from "./clients/secrets-scanner.js";
+import { dispatchLintWithEffect } from "./clients/services/effect-integration.js";
 import { TestRunnerClient } from "./clients/test-runner-client.js";
 import { TodoScanner } from "./clients/todo-scanner.js";
 import { TypeCoverageClient } from "./clients/type-coverage-client.js";
 import { TypeScriptClient } from "./clients/typescript-client.js";
 import { handleBooboo } from "./commands/booboo.js";
-import { handleFix } from "./commands/fix.js";
-import { handleRate } from "./commands/rate.js";
-import { handleRefactor, initRefactorLoop } from "./commands/refactor.js";
+import { initRefactorLoop } from "./commands/refactor.js";
 
 /** Parse a diff to extract modified line ranges in the new file.
  * Handles pi's custom diff format:
@@ -133,7 +141,7 @@ export default function (pi: ExtensionAPI) {
 	const agentBehaviorClient = new AgentBehaviorClient();
 	const cacheManager = new CacheManager();
 
-	// --- Initialize auto-loops (must be early for event handlers) ---
+	// --- Initialize auto-loops ---
 	initRefactorLoop(pi);
 
 	// --- Flags ---
@@ -150,6 +158,12 @@ export default function (pi: ExtensionAPI) {
 		default: false,
 	});
 
+	pi.registerFlag("no-oxlint", {
+		description: "Disable Oxlint fast JS/TS linter",
+		type: "boolean",
+		default: false,
+	});
+
 	pi.registerFlag("no-ast-grep", {
 		description: "Disable ast-grep structural analysis",
 		type: "boolean",
@@ -162,6 +176,12 @@ export default function (pi: ExtensionAPI) {
 		default: false,
 	});
 
+	pi.registerFlag("no-shellcheck", {
+		description: "Disable shellcheck for shell scripts",
+		type: "boolean",
+		default: false,
+	});
+
 	pi.registerFlag("no-lsp", {
 		description: "Disable TypeScript LSP",
 		type: "boolean",
@@ -174,17 +194,32 @@ export default function (pi: ExtensionAPI) {
 		default: false,
 	});
 
-	pi.registerFlag("autofix-biome", {
+	pi.registerFlag("no-autoformat", {
 		description:
-			"Auto-fix Biome lint/format issues on write (applies --write --unsafe)",
+			"Disable automatic formatting on file write (formatters run by default)",
 		type: "boolean",
 		default: false,
 	});
 
-	pi.registerFlag("autofix-ruff", {
-		description: "Auto-fix Ruff lint/format issues on write",
+	pi.registerFlag("no-autofix", {
+		description:
+			"Disable auto-fixing of lint issues (Biome, Ruff). Use --no-autofix-biome or --no-autofix-ruff for individual control.",
 		type: "boolean",
-		default: true,
+		default: false,
+	});
+
+	pi.registerFlag("no-autofix-biome", {
+		description:
+			"Disable Biome auto-fix on write (Biome autofix is enabled by default)",
+		type: "boolean",
+		default: false,
+	});
+
+	pi.registerFlag("no-autofix-ruff", {
+		description:
+			"Disable Ruff auto-fix on write (Ruff autofix is enabled by default)",
+		type: "boolean",
+		default: false,
 	});
 
 	pi.registerFlag("no-tests", {
@@ -212,6 +247,39 @@ export default function (pi: ExtensionAPI) {
 		default: false,
 	});
 
+	// Internal flag for development/debugging (not surfaced to users)
+	pi.registerFlag("lens-bus", {
+		description: "[Internal] Enable event bus system",
+		type: "boolean",
+		default: false,
+	});
+
+	pi.registerFlag("lens-bus-debug", {
+		description: "Enable verbose bus event logging",
+		type: "boolean",
+		default: false,
+	});
+
+	pi.registerFlag("lens-effect", {
+		description: "Enable Effect-TS concurrent runner execution (Phase 2)",
+		type: "boolean",
+		default: false,
+	});
+
+	pi.registerFlag("lens-lsp", {
+		description:
+			"Enable LSP (Language Server Protocol) for semantic analysis (Phase 3)",
+		type: "boolean",
+		default: false,
+	});
+
+	pi.registerFlag("auto-install", {
+		description:
+			"Auto-install missing LSP servers without prompting (for Go, Rust, YAML, JSON, Bash)",
+		type: "boolean",
+		default: false,
+	});
+
 	// --- Commands ---
 
 	pi.registerCommand("lens-booboo", {
@@ -235,404 +303,7 @@ export default function (pi: ExtensionAPI) {
 			),
 	});
 
-	// --- Rule action map for lens-booboo-fix ---
-	// Rules marked "skip" are architectural — they need deliberate user decisions.
-	// They are excluded from inline tool_result hard stops (use /lens-refactor instead).
-	const RULE_ACTIONS: Record<
-		string,
-		{ type: "biome" | "agent" | "skip"; note: string }
-	> = {
-		"no-lonely-if": { type: "biome", note: "auto-fixed by Biome --write" },
-		"empty-catch": {
-			type: "agent",
-			note: "Add this.log('Error: ' + err.message) to the catch block",
-		},
-		"no-console-log": {
-			type: "agent",
-			note: "Remove or replace with class logger method",
-		},
-		"no-debugger": { type: "agent", note: "Remove the debugger statement" },
-		"no-return-await": {
-			type: "agent",
-			note: "Remove the unnecessary `return await`",
-		},
-		"nested-ternary": {
-			type: "agent",
-			note: "Extract to if/else or a named variable",
-		},
-		"no-throw-string": {
-			type: "agent",
-			note: "Wrap in `new Error(...)` instead of throwing a string",
-		},
-		"no-star-imports": {
-			type: "skip",
-			note: "Requires knowing which exports are actually used.",
-		},
-		"no-as-any": {
-			type: "skip",
-			note: "Replacing `as any` requires knowing the correct type.",
-		},
-		"no-non-null-assertion": {
-			type: "skip",
-			note: "Each `!` needs nullability analysis in context.",
-		},
-		"large-class": {
-			type: "skip",
-			note: "Splitting a class requires architectural decisions.",
-		},
-		"long-method": {
-			type: "skip",
-			note: "Extraction requires understanding the function's purpose.",
-		},
-		"long-parameter-list": {
-			type: "skip",
-			note: "Redesigning the signature requires an API decision.",
-		},
-		"no-shadow": {
-			type: "skip",
-			note: "Renaming requires understanding all variable scopes.",
-		},
-		"no-process-env": {
-			type: "skip",
-			note: "Using process.env directly makes code untestable. Use DI or a config module.",
-		},
-		"no-param-reassign": {
-			type: "agent",
-			note: "Create a new variable instead of reassigning the parameter.",
-		},
-		"no-single-char-var": {
-			type: "skip",
-			note: "Renaming requires understanding the variable's purpose.",
-		},
-		"switch-without-default": {
-			type: "agent",
-			note: "Add a default case to handle unexpected values.",
-		},
-		"no-architecture-violation": {
-			type: "skip",
-			note: "Layer boundary violations require architectural decisions.",
-		},
-		"switch-exhaustiveness": {
-			type: "agent",
-			note: "Add the missing case(s) or a default clause to handle all union values.",
-		},
-	};
-
-	// Derived from RULE_ACTIONS — used to suppress architectural rules from inline hard stops.
-	const SKIP_RULES = new Set(
-		Object.entries(RULE_ACTIONS)
-			.filter(([, v]) => v.type === "skip")
-			.map(([k]) => k),
-	);
-
-	pi.registerCommand("lens-booboo-fix", {
-		description:
-			"Iterative fix loop: auto-fixes Biome/Ruff, then generates a per-issue plan for agent to execute. Run repeatedly until clean. Usage: /lens-booboo-fix [path] [--reset]",
-		handler: (args, ctx) =>
-			handleFix(
-				args,
-				ctx,
-				{
-					tsClient,
-					astGrep: astGrepClient,
-					ruff: ruffClient,
-					biome: biomeClient,
-					knip: knipClient,
-					jscpd: jscpdClient,
-					complexity: complexityClient,
-				},
-				pi,
-				RULE_ACTIONS,
-			),
-	});
-
-	pi.registerCommand("lens-booboo-refactor", {
-		description:
-			"Interactive architectural refactor: scans for worst offender, opens a browser interview with options + recommendation, then steers the agent with your decision. Usage: /lens-booboo-refactor [path]",
-		handler: (args, ctx) =>
-			handleRefactor(
-				args,
-				ctx,
-				{
-					astGrep: astGrepClient,
-					complexity: complexityClient,
-					architect: architectClient,
-				},
-				pi,
-				SKIP_RULES,
-				RULE_ACTIONS,
-			),
-	});
-
-	pi.registerCommand("lens-metrics", {
-		description:
-			"Measure complexity metrics for all files and export to report.md. Usage: /lens-metrics [path]",
-		handler: async (args, ctx) => {
-			const targetPath = args.trim() || ctx.cwd || process.cwd();
-			ctx.ui.notify("📊 Measuring code metrics...", "info");
-
-			const reviewDir = path.join(process.cwd(), ".pi-lens", "reviews");
-			const timestamp = new Date()
-				.toISOString()
-				.replace(/[:.]/g, "-")
-				.slice(0, 19);
-			const projectName = path.basename(process.cwd());
-
-			const results: import("./clients/complexity-client.js").FileComplexity[] =
-				[];
-
-			const isTsProject = nodeFs.existsSync(
-				path.join(targetPath, "tsconfig.json"),
-			);
-			const files = getSourceFiles(targetPath, isTsProject);
-			for (const fullPath of files) {
-				if (complexityClient.isSupportedFile(fullPath)) {
-					const metrics = complexityClient.analyzeFile(fullPath);
-					if (metrics) {
-						results.push(metrics);
-					}
-				}
-			}
-
-			if (results.length === 0) {
-				ctx.ui.notify("No supported files found to analyze", "warning");
-				return;
-			}
-
-			// Calculate aggregates
-			const avgMI =
-				results.reduce((a, b) => a + b.maintainabilityIndex, 0) /
-				results.length;
-			const avgCognitive =
-				results.reduce((a, b) => a + b.cognitiveComplexity, 0) / results.length;
-			const avgCyclomatic =
-				results.reduce((a, b) => a + b.cyclomaticComplexity, 0) /
-				results.length;
-			const avgFunctionLength =
-				results.reduce((a, b) => a + b.avgFunctionLength, 0) / results.length;
-			const maxNesting = Math.max(...results.map((r) => r.maxNestingDepth));
-			const maxCognitive = Math.max(
-				...results.map((r) => r.cognitiveComplexity),
-			);
-			const minMI = Math.min(...results.map((r) => r.maintainabilityIndex));
-			const totalFunctions = results.reduce((a, b) => a + b.functionCount, 0);
-			const totalLOC = results.reduce((a, b) => a + b.linesOfCode, 0);
-
-			// Grade distribution
-			const grades = results.map((r) => {
-				const mi = r.maintainabilityIndex;
-				if (mi >= 80) return { letter: "A", color: "🟢" };
-				if (mi >= 60) return { letter: "B", color: "🟡" };
-				if (mi >= 40) return { letter: "C", color: "🟠" };
-				if (mi >= 20) return { letter: "D", color: "🔴" };
-				return { letter: "F", color: "⚫" };
-			});
-
-			const gradeCount = { A: 0, B: 0, C: 0, D: 0, F: 0 };
-			for (const g of grades) {
-				gradeCount[g.letter as keyof typeof gradeCount]++;
-			}
-
-			// Capture snapshots for history tracking
-			const history = captureSnapshots(
-				results.map((r) => ({
-					filePath: r.filePath,
-					metrics: {
-						maintainabilityIndex: r.maintainabilityIndex,
-						cognitiveComplexity: r.cognitiveComplexity,
-						maxNestingDepth: r.maxNestingDepth,
-						linesOfCode: r.linesOfCode,
-					},
-				})),
-			);
-
-			// Build report
-			let report = `# Code Metrics Report: ${projectName}\n\n`;
-			report += `**Generated:** ${new Date().toISOString()}\n\n`;
-			report += `**Path:** \`${targetPath}\`\n\n`;
-			report += `---\n\n`;
-
-			// AI slop aggregates
-			const totalAISlopWarnings = results.reduce((a, b) => {
-				return a + complexityClient.checkThresholds(b).length;
-			}, 0);
-			const totalEmojiComments = results.reduce(
-				(a, b) => a + b.aiCommentPatterns,
-				0,
-			);
-			const totalTryCatch = results.reduce((a, b) => a + b.tryCatchCount, 0);
-			const totalSingleUse = results.reduce(
-				(a, b) => a + b.singleUseFunctions,
-				0,
-			);
-			const maxParams = Math.max(...results.map((r) => r.maxParamsInFunction));
-
-			// Summary
-			report += `## Summary\n\n`;
-			report += `| Metric | Value |\n`;
-			report += `|--------|-------|\n`;
-			report += `| Files Analyzed | ${results.length} |\n`;
-			report += `| Total Functions | ${totalFunctions} |\n`;
-			report += `| Total Lines of Code | ${totalLOC.toLocaleString()} |\n`;
-			report += `| Avg Maintainability Index | ${avgMI.toFixed(1)} |\n`;
-			report += `| Min Maintainability Index | ${minMI.toFixed(1)} |\n`;
-			report += `| Avg Cognitive Complexity | ${avgCognitive.toFixed(1)} |\n`;
-			report += `| Max Cognitive Complexity | ${maxCognitive} |\n`;
-			report += `| Avg Cyclomatic Complexity | ${avgCyclomatic.toFixed(1)} |\n`;
-			report += `| Max Nesting Depth | ${maxNesting} |\n`;
-			report += `| Avg Function Length | ${avgFunctionLength.toFixed(1)} lines |\n\n`;
-
-			// AI Slop Summary
-			report += `## AI Slop Indicators (Aggregate)\n\n`;
-			report += `| Indicator | Count |\n`;
-			report += `|-----------|-------|\n`;
-			report += `| Total Warnings | ${totalAISlopWarnings} |\n`;
-			report += `| Emoji/Boilerplate Comments | ${totalEmojiComments} |\n`;
-			report += `| Try/Catch Blocks | ${totalTryCatch} |\n`;
-			report += `| Single-Use Helper Functions | ${totalSingleUse} |\n`;
-			report += `| Max Function Parameters | ${maxParams} |\n\n`;
-
-			// Grade distribution
-			report += `## Maintainability Grade Distribution\n\n`;
-			report += `| Grade | Count | Percentage |\n`;
-			report += `|-------|-------|------------|\n`;
-			for (const [grade, count] of Object.entries(gradeCount)) {
-				const pct = ((count / results.length) * 100).toFixed(1);
-				const gradeIcons: Record<string, string> = {
-					A: "🟢",
-					B: "🟡",
-					C: "🟠",
-					D: "🔴",
-				};
-				const gradeThresholds: Record<string, number> = {
-					A: 80,
-					B: 60,
-					C: 40,
-					D: 20,
-				};
-				const icon = gradeIcons[grade] ?? "⚫";
-				const threshold = gradeThresholds[grade] ?? 0;
-				report += `| ${icon} ${grade} (MI ≥ ${threshold}) | ${count} | ${pct}% |\n`;
-			}
-			report += `\n`;
-
-			// All files table (sorted by MI ascending)
-			report += `## All Files\n\n`;
-			report += `| Grade | File | MI | Cognitive | LOC | Entropy | Trend |\n`;
-			report += `|-------|------|-----|-----------|-----|---------|-------|\n`;
-
-			const sorted = [...results].sort(
-				(a, b) => a.maintainabilityIndex - b.maintainabilityIndex,
-			);
-			for (const f of sorted) {
-				const mi = f.maintainabilityIndex;
-				let grade: string;
-				if (mi >= 80) grade = "🟢 A";
-				else if (mi >= 60) grade = "🟡 B";
-				else if (mi >= 40) grade = "🟠 C";
-				else if (mi >= 20) grade = "🔴 D";
-				else grade = "⚫ F";
-
-				// Make path relative for readability
-				const relPath = path.relative(targetPath, f.filePath);
-				const trendCell = formatTrendCell(f.filePath, history);
-				const entropyCell = f.codeEntropy > 0 ? f.codeEntropy.toFixed(2) : "—";
-
-				report += `| ${grade} | ${relPath} | ${mi.toFixed(1)} | ${f.cognitiveComplexity} | ${f.linesOfCode} | ${entropyCell} | ${trendCell} |\n`;
-			}
-			report += `\n`;
-
-			// Trend Summary
-			const trendSummary = getTrendSummary(history);
-			report += `## Trend Summary\n\n`;
-			report += `| Trend | Count |\n`;
-			report += `|-------|-------|\n`;
-			report += `| 📈 Improving | ${trendSummary.improving} |\n`;
-			report += `| ➡️ Stable | ${trendSummary.stable} |\n`;
-			report += `| 📉 Regressing | ${trendSummary.regressing} |\n\n`;
-
-			if (trendSummary.worstRegressions.length > 0) {
-				report += `### Top Regressions\n\n`;
-				report += `Files with largest MI decline since last scan:\n\n`;
-				for (const r of trendSummary.worstRegressions) {
-					report += `- **${r.file}**: MI ${r.miDelta > 0 ? "+" : ""}${r.miDelta}\n`;
-				}
-				report += `\n`;
-			}
-
-			// Top 10 worst files (actionable)
-			report += `## Top 10 Files Needing Attention\n\n`;
-			report += `These files have the lowest maintainability scores:\n\n`;
-			for (let i = 0; i < Math.min(10, sorted.length); i++) {
-				const f = sorted[i];
-				const relPath = path.relative(targetPath, f.filePath);
-				const warnings: string[] = [];
-
-				if (f.maintainabilityIndex < 20) warnings.push("🔴 Critical: MI < 20");
-				else if (f.maintainabilityIndex < 40) warnings.push("🟠 Low: MI < 40");
-				if (f.cognitiveComplexity > 50)
-					warnings.push(`High cognitive (${f.cognitiveComplexity})`);
-				if (f.maxNestingDepth > 5)
-					warnings.push(`Deep nesting (${f.maxNestingDepth})`);
-				if (f.maxFunctionLength > 50)
-					warnings.push(`Long functions (max ${f.maxFunctionLength})`);
-
-				// AI slop indicators
-				const slopWarnings = complexityClient.checkThresholds(f);
-				for (const w of slopWarnings) {
-					if (
-						w.includes("AI-style") ||
-						w.includes("try/catch") ||
-						w.includes("single-use") ||
-						w.includes("parameter list")
-					) {
-						warnings.push(`🤖 ${w.split(" — ")[0]}`);
-					}
-				}
-
-				report += `${i + 1}. **${relPath}** — MI: ${f.maintainabilityIndex.toFixed(1)}\n`;
-				if (warnings.length > 0) {
-					report += `   - ${warnings.join(", ")}\n`;
-				}
-			}
-			report += `\n`;
-
-			// Save report
-			nodeFs.mkdirSync(reviewDir, { recursive: true });
-
-			const reportPath = path.join(reviewDir, `metrics-${timestamp}.md`);
-			nodeFs.writeFileSync(reportPath, report, "utf-8");
-
-			// Also save latest.md for easy access
-			const latestPath = path.join(reviewDir, "latest.md");
-			nodeFs.writeFileSync(latestPath, report, "utf-8");
-
-			// Console summary
-			const summary = [
-				`📊 Metrics Report`,
-				`   ${results.length} files, ${totalLOC.toLocaleString()} LOC, ${totalFunctions} functions`,
-				`   MI: ${avgMI.toFixed(1)} avg (${gradeCount.A}A ${gradeCount.B}B ${gradeCount.C}C ${gradeCount.D}D ${gradeCount.F}F)`,
-				`   Cognitive: ${avgCognitive.toFixed(1)} avg, ${maxCognitive} max`,
-				`📄 Saved: ${reportPath}`,
-			].join("\n");
-
-			ctx.ui.notify(summary, "info");
-		},
-	});
-
-	pi.registerCommand("lens-rate", {
-		description:
-			"Show code quality score with visual breakdown. Usage: /lens-rate [path]",
-		handler: async (args, ctx) => {
-			const result = await handleRate(args, ctx, {
-				complexity: complexityClient,
-				knip: knipClient,
-				typeCoverage: typeCoverageClient,
-				architect: architectClient,
-			});
-			ctx.ui.notify(result, "info");
-		},
-	});
+	// DISABLED: lens-booboo-fix command - disabled per user request
 
 	pi.registerCommand("lens-tdi", {
 		description:
@@ -914,13 +585,16 @@ export default function (pi: ExtensionAPI) {
 	// Delta baselines: store pre-write diagnostics to diff against post-write
 	const astGrepBaselines = new Map<
 		string,
-		import("./clients/ast-grep-client.js").AstGrepDiagnostic[]
+		import("./clients/ast-grep-types.js").AstGrepDiagnostic[]
 	>();
 	const biomeBaselines = new Map<
 		string,
 		import("./clients/biome-client.js").BiomeDiagnostic[]
 	>();
 
+	// Track files already auto-fixed this turn to prevent fix loops
+	const fixedThisTurn = new Set<string>();
+
 	// Project rules scan result (from .claude/rules, .agents/rules, etc.)
 	let projectRulesScan: RuleScanResult = { rules: [], hasCustomRules: false };
 
@@ -930,6 +604,19 @@ export default function (pi: ExtensionAPI) {
 		_verbose = !!pi.getFlag("lens-verbose");
 		dbg("session_start fired");
 
+		// Initialize event bus system (Phase 1)
+		const busEnabled = pi.getFlag("lens-bus");
+		if (busEnabled) {
+			const busDebug = pi.getFlag("lens-bus-debug");
+			initBusIntegration(pi, { debug: !!busDebug });
+			if (busDebug) enableBusDebug(true);
+			SessionStarted.publish({
+				cwd: ctx.cwd ?? process.cwd(),
+				timestamp: Date.now(),
+			});
+			dbg("session_start: bus integration initialized");
+		}
+
 		// Reset session state
 		metricsClient.reset();
 		complexityBaselines.clear();
@@ -948,6 +635,23 @@ export default function (pi: ExtensionAPI) {
 		log(`Active tools: ${tools.join(", ")}`);
 		dbg(`session_start tools: ${tools.join(", ")}`);
 
+		// 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);
+				});
+		}
+
 		const cwd = ctx.cwd ?? process.cwd();
 		projectRoot = cwd; // Module-level for architect client
 		dbg(`session_start cwd: ${cwd}`);
@@ -1160,10 +864,27 @@ export default function (pi: ExtensionAPI) {
 		if (/\.(ts|tsx|js|jsx)$/.test(filePath) && !pi.getFlag("no-lsp")) {
 			tsClient.updateFile(filePath, nodeFs.readFileSync(filePath, "utf-8"));
 			const diags = tsClient.getDiagnostics(filePath);
+			const fixes = tsClient.getAllCodeFixes(filePath);
 			if (diags.length > 0) {
-				hints.push(
-					`⚠ Pre-write: file already has ${diags.length} TypeScript error(s) — fix before adding more`,
-				);
+				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}`,
+						);
+					}
+					if (errorDiags.length > 3) {
+						hints.push(`  ... and ${errorDiags.length - 3} more errors`);
+					}
+				}
 			}
 		}
 
@@ -1195,17 +916,8 @@ export default function (pi: ExtensionAPI) {
 			);
 		}
 
-		// Architectural rules pre-write hints
-		if (architectClient.hasConfig()) {
-			const relPath = path.relative(projectRoot, filePath).replace(/\\/g, "/");
-			const archHints = architectClient.getHints(relPath);
-			if (archHints.length > 0) {
-				hints.push(`📐 Architectural rules for ${relPath}:`);
-				for (const h of archHints) {
-					hints.push(`  → ${h}`);
-				}
-			}
-		}
+		// 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) {
@@ -1301,6 +1013,58 @@ export default function (pi: ExtensionAPI) {
 			void err;
 		}
 
+		// --- Auto-format on write (default enabled) ---
+		// Runs detected formatters concurrently via Effect-TS
+		let formatChanged = false;
+		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);
+				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}`);
+			}
+		}
+
+		// --- Publish file modified event to bus (Phase 1) ---
+		if (pi.getFlag("lens-bus")) {
+			FileModified.publish({
+				filePath,
+				content: fileContent,
+				changeType: event.toolName === "edit" ? "edit" : "write",
+			});
+		}
+
+		// --- 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);
@@ -1318,14 +1082,142 @@ export default function (pi: ExtensionAPI) {
 
 		let lspOutput = preHint ? `\n\n${preHint}` : "";
 
+		// --- Auto-fix on write (safely - track to prevent loops) ---
+		// 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 &&
+				ruffClient.isAvailable() &&
+				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}`);
+				}
+			}
+		}
+
 		// --- Declarative dispatch: run all applicable lint tools ---
 		// 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);
+
+		// Select dispatcher based on flags:
+		// - lens-effect: Effect-TS concurrent execution (Phase 2)
+		// - lens-bus: Bus-enabled dispatcher (Phase 1)
+		// - default: Original sequential dispatcher
+		let dispatchOutput: string;
+		if (pi.getFlag("lens-effect")) {
+			dispatchOutput = await dispatchLintWithEffect(filePath, projectRoot, pi);
+		} else if (pi.getFlag("lens-bus")) {
+			dispatchOutput = await dispatchLintWithBus(filePath, projectRoot, pi);
+		} else {
+			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.**`;
+		}
+
+		// --- Test runner: run corresponding tests on write ---
+		if (!pi.getFlag("no-tests")) {
+			const testInfo = testRunnerClient.findTestFile(filePath, cwd);
+			if (testInfo) {
+				dbg(
+					`test-runner: found test file ${testInfo.testFile} for ${filePath}`,
+				);
+				const detectedRunner = testRunnerClient.detectRunner(cwd);
+				if (detectedRunner) {
+					const testResult = testRunnerClient.runTestFile(
+						testInfo.testFile,
+						cwd,
+						detectedRunner.runner,
+						detectedRunner.config,
+					);
+					if (testResult && !testResult.error) {
+						const testOutput = testRunnerClient.formatResult(testResult);
+						if (testOutput) {
+							lspOutput += `\n\n${testOutput}`;
+						}
+					}
+				}
+			}
+		}
+
+		// --- TypeScript Language Service diagnostics (post-write) ---
+		// Fast semantic analysis for type errors, unused vars, etc.
+		if (filePath.endsWith(".ts") || filePath.endsWith(".tsx")) {
+			try {
+				const tsClient = new TypeScriptClient();
+
+				// Track the file in the language service
+				tsClient.addFile(filePath, fileContent || "");
+
+				// Get diagnostics (syntactic + semantic)
+				const diagnostics = tsClient.getDiagnostics(filePath);
+
+				if (diagnostics.length > 0) {
+					// Filter to most important diagnostics
+					const importantDiags = diagnostics.filter((d) => {
+						// Focus on errors and important warnings
+						// Skip noisy ones like "cannot find name" from missing imports
+						const code = (d as any).code;
+						if (code === 2304) return false; // "Cannot find name"
+						if (code === 2307) return false; // "Cannot find module"
+						// DiagnosticSeverity.Error = 1, Warning = 2
+						return d.severity === 1 || (d.severity === 2 && !code);
+					});
+
+					if (importantDiags.length > 0) {
+						const tsOutput = importantDiags
+							.slice(0, 5)
+							.map((d) => {
+								// DiagnosticSeverity.Error = 1
+								const severity = d.severity === 1 ? "🔴" : "🟡";
+								return `  ${severity} [TS${(d as any).code}] ${d.message.split("\n")[0]}`;
+							})
+							.join("\n");
+						lspOutput += `\n\n📐 TypeScript Diagnostics:\n${tsOutput}`;
+					}
+				}
+			} catch (err) {
+				dbg(`typescript-client error: ${err}`);
+			}
+		}
+
 		// Agent behavior warnings (blind writes, thrashing)
 		if (behaviorWarnings.length > 0) {
 			lspOutput += `\n\n${agentBehaviorClient.formatWarnings(behaviorWarnings)}`;
@@ -1354,6 +1246,15 @@ export default function (pi: ExtensionAPI) {
 		const turnState = cacheManager.readTurnState(cwd);
 		const files = Object.keys(turnState.files);
 
+		// Publish turn ended event to bus (Phase 1)
+		if (pi.getFlag("lens-bus") && files.length > 0) {
+			TurnEnded.publish({
+				cwd,
+				modifiedFiles: files,
+				timestamp: Date.now(),
+			});
+		}
+
 		if (files.length === 0) return;
 
 		dbg(
@@ -1456,5 +1357,17 @@ export default function (pi: ExtensionAPI) {
 				cwd,
 			);
 		}
+
+		// 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();
+		}
+
+		// --- Format service cleanup ---
+		resetFormatService();
 	});
 }