pi-lens 3.8.44 → 3.8.45

package/README.md

@@ -13,7 +13,7 @@ pi-lens focuses on real-time inline code feedback for AI agents.
 On every `write` and `edit`, pi-lens runs a fast, language-aware pipeline (checks depend on file language, project config, and installed tools):
 
 1. **Secrets scan** — blocking; aborts the write if credentials are detected
-2. **Auto-format** — deferred to `agent_end` by default; queued files are formatted once after all agent tool calls complete. Use `--immediate-format` for per-edit formatting
+2. **Auto-format** — deferred to `agent_end` by default; queued files are formatted once after all agent tool calls complete. Use `--immediate-format` or global config `format.mode: "immediate"` for per-edit formatting
 3. **Auto-fix** — safe autofixes from 6 tools (Biome `check --write`, Ruff `check --fix`, ESLint `--fix`, stylelint `--fix`, sqlfluff `fix`, RuboCop `-a`) applied before analysis
 4. **LSP file sync** — opens/updates the file in active language servers
 5. **Dispatch lint** — parallel runner groups: LSP diagnostics, tree-sitter structural rules, ast-grep security/correctness rules, fact rules, language-specific linters, experimental Semgrep security scans, similarity detection
@@ -83,13 +83,15 @@ pi-lens includes **37 language server definitions**. LSP is **enabled by default
 { "warmFiles": ["src/main.cpp", "src/lib.cpp"] }
 ```
 
-LSP servers for: TypeScript, Deno, Python (pyright + pylsp), Go, Rust, Ruby (ruby-lsp + solargraph), PHP, C# (omnisharp), F#, Java, Kotlin, Swift, Dart, Lua, C/C++, Zig, Haskell, Elixir, Gleam, OCaml, Clojure, Terraform, Nix, Bash, Docker, YAML, JSON, HTML, TOML, Prisma, Vue, Svelte, ESLint, CSS.
+**Agent LSP tools:** `lsp_diagnostics` can check one file, a directory, or an explicit `filePaths` batch with bounded concurrency. `lsp_navigation` provides definitions, references, hover, workspace symbols, call hierarchy, rename edits, and `findSymbol` for filtered document-symbol lookup.
+
+LSP servers for: TypeScript, Deno, Python (pyright/basedpyright + jedi), Go, Rust, Ruby (ruby-lsp + solargraph), PHP, C# (omnisharp), F#, Java, Kotlin, Swift, Dart, Lua, C/C++, Zig, Haskell, Elixir, Gleam, OCaml, Clojure, Terraform, Nix, Bash, Docker, YAML, JSON, HTML, TOML, Prisma, Vue, Svelte, ESLint, CSS.
 
 ### Formatters
 
-pi-lens auto-detects and runs **26 formatters** based on project config:
+pi-lens auto-detects and runs **32 formatters** based on project config:
 
-biome, prettier, ruff, black, sqlfluff, gofmt, rustfmt, zig fmt, dart format, shfmt, nixfmt, mix format, ocamlformat, clang-format, ktlint, rubocop, standardrb, gleam format, terraform fmt, php-cs-fixer, csharpier, fantomas, swiftformat, stylua, ormolu, taplo
+biome, prettier, oxfmt, ruff, black, sqlfluff, gofmt, rustfmt, zig fmt, dart format, shfmt, nixfmt, mix format, ocamlformat, clang-format, ktlint, rubocop, standardrb, gleam format, terraform fmt, php-cs-fixer, csharpier, fantomas, swiftformat, stylua, ormolu, taplo, fish_indent, google-java-format, cljfmt, cmake-format, psscriptanalyzer-format
 
 Detection rules:
 
@@ -110,7 +112,7 @@ pi-lens enforces a **read-before-edit** policy on all file writes and edits. Bef
 - **File-modified block** — blocks if the file changed on disk since the last read (auto-format, external tool, or a previous edit that was then reformatted)
 - **Out-of-range block** — blocks if the edit target lines fall outside the ranges previously read, ensuring the agent cannot modify code it hasn't seen
 
-Coverage is tracked across multiple reads: two reads of lines 1–100 and 101–200 together satisfy a full-file write. Symbol-expanded reads (small reads silently widened to the enclosing symbol via tree-sitter) count toward coverage at the symbol level. Markdown, text, and log files are exempt.
+Coverage is tracked across multiple reads: two reads of lines 1–100 and 101–200 together satisfy a full-file write. Symbol-expanded reads (small reads silently widened to the enclosing symbol via tree-sitter) count toward coverage at the symbol level. Markdown files generate a warning instead of blocking (edits outside the section-expanded read range are warned, not silently passed). Plain-text (`.txt`) and log (`.log`) files remain fully exempt.
 
 Override for a single edit: `/lens-allow-edit <path>`
 
@@ -127,12 +129,14 @@ Supported: TypeScript, TSX, JavaScript, JSX, Python, Go, Rust, Ruby.
 Covers JavaScript/TypeScript, Python, Go, Rust, Ruby, Shell, and CMake. A TypeScript AST-based fact-rule engine extracts function-level metrics and evaluates quality and security rules inline. Blocking rules surface immediately at write time; advisory rules are available via `/lens-booboo`.
 
 **Blocking (surface inline at write time):**
+
 - **cors-wildcard** — `Access-Control-Allow-Origin: *` in server-side code
 - **error-swallowing** — empty catch block (skips documented local fallbacks and fs-boundary catches)
 - **no-commented-credentials** — password/token/secret in commented-out code
 - **high-entropy-string** — string literals with suspiciously high Shannon entropy (possible hardcoded secret)
 
 **Advisory (accessible via `/lens-booboo`):**
+
 - **high-complexity** / **no-complex-conditionals** — cyclomatic complexity and deeply nested conditions
 - **high-fan-out** — function calls too many distinct functions (coordination smell)
 - **unsafe-boundary** — dangerous `any` casts at API boundaries
@@ -273,6 +277,26 @@ pi --lens-semgrep         # Enable Semgrep dispatch when a local/configured Semg
 pi --lens-semgrep-config p/ci  # Explicit Semgrep config for dispatch (requires --lens-semgrep)
 ```
 
+## Global Config
+
+pi-lens reads optional user preferences from `~/.pi-lens/config.json` (`%USERPROFILE%\\.pi-lens\\config.json` on Windows). Unknown keys are ignored, and missing or invalid config falls back to defaults.
+
+Hide the diagnostics widget by default and run formatting immediately after write/edit tool calls instead of at `agent_end`:
+
+```json
+{
+  "widget": {
+    "visible": false
+  },
+  "format": {
+    "enabled": true,
+    "mode": "immediate"
+  }
+}
+```
+
+`format.mode` can be `"deferred"` (default) or `"immediate"`. Set `format.enabled` to `false` to match `--no-autoformat`. `/lens-widget-toggle` still works as a session-only override.
+
 ## Environment Variables
 
 - `PILENS_DATA_DIR` — redirect per-project state (scanner caches,
@@ -291,51 +315,55 @@ pi --lens-semgrep-config p/ci  # Explicit Semgrep config for dispatch (requires
 - `/lens-widget-toggle` — show/hide the pi-lens diagnostics widget below the editor
 - `/lens-booboo` — full quality report for current project state
 - `/lens-health` — runtime health, latency, and diagnostic telemetry
+- `/lens-allow-edit <path>` — override the read-before-edit guard for a single edit
 - `/lens-tools` — tool installation status: globally installed, auto-installed, or npx fallback
 - `/lens-tdi` — Technical Debt Index (TDI) and project health trend
 - `/lens-semgrep` — manage experimental Semgrep dispatch (`status`, `init`, `enable`, `disable`, `clear`)
 
 ## Language Coverage
 
-pi-lens supports **35+ languages** through dispatch runners and LSP integration.
+pi-lens supports **36+ languages** through dispatch runners and LSP integration.
 
 Formatting uses a single selected formatter per file: explicit project config wins, otherwise pi-lens uses a smart default where supported, and config-first ecosystems do not autoformat without config.
 
 Dispatch is diagnostics-oriented: automatic formatting and safe autofix happen in the post-write pipeline rather than through dispatch format-check runners.
 
-| Language              | LSP | Dispatch Runners                                                                                               | Formatter           |
-| --------------------- | --- | -------------------------------------------------------------------------------------------------------------- | ------------------- |
-| JavaScript/TypeScript | ✓   | lsp, ts-lsp, biome-check-json, tree-sitter, ast-grep-napi, type-safety, similarity, fact-rules, eslint, oxlint | biome, prettier     |
-| Python                | ✓   | lsp, pyright, ruff-lint, tree-sitter, python-slop                                                              | ruff, black         |
-| Go                    | ✓   | lsp, go-vet, golangci-lint, tree-sitter                                                                        | gofmt               |
-| Rust                  | ✓   | lsp, rust-clippy, tree-sitter                                                                                  | rustfmt             |
-| Ruby                  | ✓   | lsp, rubocop, tree-sitter                                                                                      | rubocop, standardrb |
-| C/C++                 | ✓   | lsp, cpp-check                                                                                                 | clang-format        |
-| Shell                 | ✓   | lsp, shellcheck                                                                                                | shfmt               |
-| CSS/SCSS/Less         | ✓   | lsp, stylelint                                                                                                 | biome, prettier     |
-| HTML                  | ✓   | lsp, htmlhint                                                                                                  | prettier            |
-| YAML                  | ✓   | lsp, yamllint                                                                                                  | prettier            |
-| JSON                  | ✓   | lsp                                                                                                            | biome, prettier     |
-| SQL                   | —   | sqlfluff                                                                                                       | sqlfluff            |
-| Markdown              | —   | spellcheck, markdownlint                                                                                       | prettier            |
-| Docker                | ✓   | lsp, hadolint                                                                                                  | —                   |
-| PHP                   | ✓   | lsp, php-lint, phpstan                                                                                         | php-cs-fixer        |
-| PowerShell            | ✓   | lsp, psscriptanalyzer                                                                                          | —                   |
-| Prisma                | ✓   | lsp, prisma-validate                                                                                           | —                   |
-| C#                    | ✓   | lsp, dotnet-build                                                                                              | csharpier           |
-| F#                    | ✓   | lsp                                                                                                            | fantomas            |
-| Java                  | ✓   | lsp, javac                                                                                                     | —                   |
-| Kotlin                | ✓   | lsp, ktlint                                                                                                    | ktlint              |
-| Swift                 | ✓   | lsp                                                                                                            | swiftformat         |
-| Dart                  | ✓   | lsp, dart-analyze                                                                                              | dart format         |
-| Lua                   | ✓   | lsp                                                                                                            | stylua              |
-| Zig                   | ✓   | lsp, zig-check                                                                                                 | zig fmt             |
-| Haskell               | ✓   | lsp                                                                                                            | ormolu              |
-| Elixir                | ✓   | lsp, elixir-check, credo                                                                                       | mix format          |
-| Gleam                 | ✓   | lsp, gleam-check                                                                                               | gleam format        |
-| OCaml                 | ✓   | lsp                                                                                                            | ocamlformat         |
-| Clojure               | ✓   | lsp                                                                                                            | —                   |
-| Terraform             | ✓   | lsp, tflint                                                                                                    | terraform fmt       |
-| Nix                   | ✓   | lsp                                                                                                            | nixfmt              |
-| TOML                  | ✓   | lsp, taplo                                                                                                     | taplo               |
-| CMake                 | ✓   | lsp                                                                                                            | —                   |
+| Language              | LSP | Dispatch Runners                                                                                               | Formatter               |
+| --------------------- | --- | -------------------------------------------------------------------------------------------------------------- | ----------------------- |
+| JavaScript/TypeScript | ✓   | lsp, ts-lsp, biome-check-json, tree-sitter, ast-grep-napi, type-safety, similarity, fact-rules, eslint, oxlint | biome, prettier         |
+| Python                | ✓   | lsp, pyright, ruff-lint, tree-sitter, python-slop                                                              | ruff, black             |
+| Go                    | ✓   | lsp, go-vet, golangci-lint, tree-sitter                                                                        | gofmt                   |
+| Rust                  | ✓   | lsp, rust-clippy, tree-sitter                                                                                  | rustfmt                 |
+| Ruby                  | ✓   | lsp, rubocop, tree-sitter                                                                                      | rubocop, standardrb     |
+| C/C++                 | ✓   | lsp, cpp-check, tree-sitter                                                                                    | clang-format            |
+| Shell                 | ✓   | lsp, shellcheck                                                                                                | shfmt                   |
+| Fish                  | ✓   | lsp, fish-indent                                                                                               | fish_indent             |
+| CSS/SCSS/Less         | ✓   | lsp, stylelint                                                                                                 | biome, prettier         |
+| HTML                  | ✓   | lsp, htmlhint                                                                                                  | prettier                |
+| YAML                  | ✓   | lsp, yamllint                                                                                                  | prettier                |
+| JSON                  | ✓   | lsp                                                                                                            | biome, prettier         |
+| Svelte                | ✓   | lsp                                                                                                            | —                       |
+| Vue                   | ✓   | lsp                                                                                                            | —                       |
+| SQL                   | —   | sqlfluff                                                                                                       | sqlfluff                |
+| Markdown              | —   | spellcheck, markdownlint, vale                                                                                 | prettier                |
+| Docker                | ✓   | lsp, hadolint                                                                                                  | —                       |
+| PHP                   | ✓   | lsp, php-lint, phpstan                                                                                         | php-cs-fixer            |
+| PowerShell            | ✓   | lsp, psscriptanalyzer                                                                                          | psscriptanalyzer-format |
+| Prisma                | ✓   | lsp, prisma-validate                                                                                           | —                       |
+| C#                    | ✓   | lsp, dotnet-build                                                                                              | csharpier               |
+| F#                    | ✓   | lsp                                                                                                            | fantomas                |
+| Java                  | ✓   | lsp, javac                                                                                                     | google-java-format      |
+| Kotlin                | ✓   | lsp, ktlint, detekt                                                                                            | ktlint                  |
+| Swift                 | ✓   | lsp, swiftlint                                                                                                 | swiftformat             |
+| Dart                  | ✓   | lsp, dart-analyze                                                                                              | dart format             |
+| Lua                   | ✓   | lsp                                                                                                            | stylua                  |
+| Zig                   | ✓   | lsp, zig-check                                                                                                 | zig fmt                 |
+| Haskell               | ✓   | lsp                                                                                                            | ormolu                  |
+| Elixir                | ✓   | lsp, elixir-check, credo                                                                                       | mix format              |
+| Gleam                 | ✓   | lsp, gleam-check                                                                                               | gleam format            |
+| OCaml                 | ✓   | lsp                                                                                                            | ocamlformat             |
+| Clojure               | ✓   | lsp                                                                                                            | cljfmt                  |
+| Terraform             | ✓   | lsp, tflint                                                                                                    | terraform fmt           |
+| Nix                   | ✓   | lsp                                                                                                            | nixfmt                  |
+| TOML                  | ✓   | lsp, taplo                                                                                                     | taplo                   |
+| CMake                 | ✓   | lsp                                                                                                            | cmake-format            |

package/clients/ast-grep-client.ts

@@ -171,14 +171,14 @@ export class AstGrepClient {
 	/**
 	 * Run a one-off scan with a temporary rule and configuration
 	 */
-	private runTempScan(
+	private async runTempScanAsync(
 		dir: string,
 		ruleId: string,
 		ruleYaml: string,
 		timeout = 30000,
-	): AstGrepMatch[] {
+	): Promise<AstGrepMatch[]> {
 		if (!this.isAvailable()) return [];
-		return this.runner.tempScan(dir, ruleId, ruleYaml, timeout);
+		return this.runner.tempScanAsync(dir, ruleId, ruleYaml, timeout);
 	}
 
 	/**
@@ -201,7 +201,7 @@ severity: info
 message: found
 `;
 
-		const matches = this.runTempScan(dir, "find-functions", ruleYaml);
+		const matches = await this.runTempScanAsync(dir, "find-functions", ruleYaml);
 		if (matches.length === 0) return [];
 
 		return this.groupSimilarFunctions(matches);
@@ -279,7 +279,7 @@ severity: info
 message: found
 `;
 
-		const matches = this.runTempScan(dir, "find-functions", ruleYaml, 15000);
+		const matches = await this.runTempScanAsync(dir, "find-functions", ruleYaml, 15000);
 		this.log(`scanExports output length: ${matches.length}`);
 
 		for (const item of matches) {

package/clients/cache/rule-cache.ts

@@ -10,7 +10,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { getProjectDataDir } from "../file-utils.js";
 
-const CACHE_VERSION = "v1";
+const CACHE_VERSION = "v2";
 
 export interface QueryCacheEntry {
 	version: string;
@@ -27,6 +27,7 @@ export interface QueryCacheEntry {
 		post_filter?: string;
 		// biome-ignore lint/suspicious/noExplicitAny: Flexible filter params
 		post_filter_params?: Record<string, any>;
+		filePath?: string;
 	}>;
 }
 

package/clients/dispatch/dispatcher.ts

@@ -14,10 +14,12 @@
  * - BaselineStore: Track pre-existing issues for delta mode
  */
 
+import * as fs from "node:fs";
 import * as path from "node:path";
 import type { FileKind } from "../file-kinds.js";
 import { recordRunner } from "../widget-state.js";
 import { detectFileKind } from "../file-kinds.js";
+import { detectFileRole } from "../file-role.js";
 import { isTestFile } from "../file-utils.js";
 import { getPrimaryDispatchGroup } from "../language-policy.js";
 import { resolveLanguageRootForFile } from "../language-profile.js";
@@ -116,6 +118,26 @@ async function checkToolAvailability(
 
 // --- Dispatch Context Factory ---
 
+function readFilePrefix(filePath: string, maxBytes = 4096): string | undefined {
+	let fd: number | undefined;
+	try {
+		fd = fs.openSync(filePath, "r");
+		const buffer = Buffer.alloc(maxBytes);
+		const bytesRead = fs.readSync(fd, buffer, 0, maxBytes, 0);
+		return buffer.subarray(0, bytesRead).toString("utf8");
+	} catch {
+		return undefined;
+	} finally {
+		if (fd !== undefined) {
+			try {
+				fs.closeSync(fd);
+			} catch {
+				// ignore close errors
+			}
+		}
+	}
+}
+
 export function createDispatchContext(
 	filePath: string,
 	cwd: string,
@@ -130,11 +152,16 @@ export function createDispatchContext(
 	);
 	const normalizedFilePath = normalizeMapKey(absoluteFilePath);
 	const kind = detectFileKind(normalizedFilePath);
+	const fileRole = detectFileRole(
+		normalizedFilePath,
+		readFilePrefix(normalizedFilePath),
+	);
 
 	return {
 		filePath: normalizedFilePath,
 		cwd: normalizedCwd,
 		kind,
+		fileRole,
 		pi,
 		autofix: false,
 		deltaMode: !pi.getFlag("no-delta"),
@@ -598,6 +625,15 @@ async function runGroup(
 			status: result.status,
 			diagnosticCount: result.diagnostics.length,
 			semantic: result.semantic ?? semantic,
+			diagnostics:
+				result.diagnostics.length > 0
+					? result.diagnostics.map((d) => ({
+							rule: d.rule,
+							message: d.message.slice(0, 120),
+							line: d.line,
+							semantic: d.semantic,
+						}))
+					: undefined,
 		});
 		recordRunner(
 			ctx.filePath,
@@ -634,6 +670,19 @@ export async function dispatchForFile(
 	registry: RunnerRegistryContract,
 ): Promise<DispatchResult> {
 	const _overallStart = Date.now();
+	if (ctx.fileRole === "generated") {
+		return {
+			diagnostics: [],
+			blockers: [],
+			warnings: [],
+			baselineWarningCount: 0,
+			fixed: [],
+			resolvedCount: 0,
+			output: "",
+			blockerOutput: "",
+			hasBlockers: false,
+		};
+	}
 	const allDiagnostics: Diagnostic[] = [];
 	let stopped = false;
 	const runnerLatencies: RunnerLatency[] = [];

package/clients/dispatch/integration.ts

@@ -42,6 +42,7 @@ export type { DispatchLatencyReport, RunnerLatency };
 export { clearLatencyReports, formatLatencyReport, getLatencyReports };
 
 import * as nodeFs from "node:fs";
+import { fileURLToPath } from "node:url";
 import { formatCascadeNeighborDiagnostics } from "../cascade-format.js";
 import { logCascade } from "../cascade-logger.js";
 import type { CascadeResult } from "../cascade-types.js";
@@ -58,6 +59,7 @@ import {
 	computeImpactCascade,
 	formatImpactCascade,
 } from "../review-graph/service.js";
+import { clearModuleGraphCache } from "../review-graph/workspace-modules.js";
 import { RUNTIME_CONFIG } from "../runtime-config.js";
 // Register fact providers
 import { registerProvider, runProviders } from "./fact-runner.js";
@@ -402,6 +404,7 @@ export function resetDispatchBaselines(): void {
 	resetSessionSlopScore();
 	clearCoverageNoticeState();
 	clearReviewGraphWorkspaceCache();
+	clearModuleGraphCache();
 	neighborTouchCache.clear();
 	recentlyCleanNeighborCache.clear();
 	primaryFilesThisTurn.clear();
@@ -470,7 +473,14 @@ function ensureCascadeTurnScope(turnSeq: number): void {
 const CASCADE_TTL_MS = 240_000;
 const MAX_PER_FILE = RUNTIME_CONFIG.pipeline.cascadeMaxDiagnosticsPerFile;
 const MAX_FILES = RUNTIME_CONFIG.pipeline.cascadeMaxFiles;
-const CASCADE_GRAPH_KINDS = new Set(["jsts", "python", "go", "rust", "ruby"]);
+const CASCADE_GRAPH_KINDS = new Set([
+	"jsts",
+	"python",
+	"go",
+	"rust",
+	"ruby",
+	"cxx",
+]);
 
 /**
  * Unified cascade orchestration — builds graph, discovers neighbors, and
@@ -559,7 +569,70 @@ export async function computeCascadeForFile(
 			metadata: { graphBuildMode: graphBuildInfo.mode },
 		});
 
-		impact = computeImpactCascade(graph, normalizedFile);
+		impact = computeImpactCascade(graph, normalizedFile, cwd);
+
+		// Symbol-level blast radius via LSP references (precision upgrade over
+		// file-level import edges). Only when changed symbols are detected.
+		// Keep the budget tight: 750ms per symbol, 1200ms total, max 3 symbols.
+		if (impact.changedSymbols.length > 0) {
+			const lspService = getLSPService();
+			const symbolNodeIds =
+				graph.symbolNodesByFile.get(normalizedFileKey) ?? [];
+			const refFiles = new Set<string>();
+			const refsStart = Date.now();
+			for (const symbolName of impact.changedSymbols.slice(0, 3)) {
+				const symbolNodeId = symbolNodeIds.find((id) => {
+					const node = graph.nodes.get(id);
+					return node?.symbolName === symbolName;
+				});
+				if (!symbolNodeId) continue;
+				const node = graph.nodes.get(symbolNodeId);
+				const line = Number(node?.metadata?.line ?? 0);
+				const column = Number(node?.metadata?.column ?? 0);
+				if (line <= 0) continue;
+				try {
+					const refs = await Promise.race([
+						lspService.references(normalizedFile, line - 1, column - 1, false),
+						new Promise<never>((_, reject) =>
+							setTimeout(() => reject(new Error("timeout")), 750),
+						),
+					]);
+					for (const ref of refs) {
+						let resolved: string;
+						try {
+							resolved = ref.uri.startsWith("file://")
+								? fileURLToPath(ref.uri)
+								: ref.uri;
+						} catch {
+							continue;
+						}
+						if (
+							normalizeMapKey(resolved) !== normalizedFileKey &&
+							nodeFs.existsSync(resolved)
+						) {
+							refFiles.add(normalizeMapKey(resolved));
+						}
+					}
+				} catch {
+					// Timeout or LSP error — fall back to import-graph neighbors
+				}
+				if (Date.now() - refsStart > 1200) break; // Hard ceiling
+			}
+			if (refFiles.size > 0) {
+				impact.neighborFiles = [
+					...new Set([...impact.neighborFiles, ...refFiles]),
+				];
+				logCascade({
+					phase: "neighbor_snapshot",
+					filePath,
+					neighborFile: "[lsp-references]",
+					diagnosticCount: refFiles.size,
+					durationMs: Date.now() - refsStart,
+					autoPropagate: false,
+					metadata: { lspReferences: true },
+				});
+			}
+		}
 
 		// Sort by relationship strength (B6) then cap to MAX_FILES.
 		// directImporters are most impactful, then callers, then reference edges.

package/clients/dispatch/plan.ts

@@ -99,8 +99,11 @@ export const LANGUAGE_CAPABILITY_MATRIX: Record<
 	},
 	cxx: {
 		name: "C/C++ Linting",
-		capabilities: ["types", "lint"],
-		writeGroups: [primary("cxx")],
+		capabilities: ["types", "lint", "smells"],
+		writeGroups: [
+			primary("cxx"),
+			{ mode: "all", runnerIds: ["tree-sitter"], filterKinds: ["cxx"] },
+		],
 	},
 	cmake: {
 		name: "CMake Processing",

package/clients/dispatch/runners/cpp-check.ts

@@ -1,3 +1,4 @@
+import * as fs from "node:fs";
 import * as path from "node:path";
 import { safeSpawnAsync } from "../../safe-spawn.js";
 import { PRIORITY } from "../priorities.js";
@@ -12,13 +13,79 @@ type CompilerSpec =
 	| { command: string; args: string[]; flavor: "gcc" | "msvc" }
 	| undefined;
 
+const C_SOURCE_EXTENSIONS = new Set([".c"]);
+const C_HEADER_EXTENSIONS = new Set([".h"]);
+const CPP_SOURCE_EXTENSIONS = new Set([
+	".c++",
+	".cc",
+	".cp",
+	".cpp",
+	".cxx",
+	".c++m",
+	".cppm",
+	".cxxm",
+	".ixx",
+	".cu",
+	".hip",
+	".mm",
+	".clcpp",
+]);
+const CPP_HEADER_EXTENSIONS = new Set([
+	".hh",
+	".hpp",
+	".hxx",
+	".inl",
+	".ipp",
+	".tpp",
+	".txx",
+]);
+
+function headerLooksLikeCpp(absPath: string): boolean {
+	try {
+		const content = fs.readFileSync(absPath, "utf-8");
+		return /\b(namespace|template|class|constexpr|concept|using)\b|std::|\b(public|private|protected)\s*:/.test(
+			content,
+		);
+	} catch {
+		return false;
+	}
+}
+
+function getGccLikeCandidates(absPath: string): Array<{
+	command: string;
+	args: string[];
+}> {
+	const ext = path.extname(absPath).toLowerCase();
+	const cMode =
+		C_SOURCE_EXTENSIONS.has(ext) ||
+		(C_HEADER_EXTENSIONS.has(ext) && !headerLooksLikeCpp(absPath));
+	const cppMode =
+		CPP_SOURCE_EXTENSIONS.has(ext) || CPP_HEADER_EXTENSIONS.has(ext);
+
+	if (cMode) {
+		const cArgs = C_HEADER_EXTENSIONS.has(ext)
+			? ["-x", "c-header", "-fsyntax-only", absPath]
+			: ["-x", "c", "-fsyntax-only", absPath];
+		return [
+			{ command: "clang", args: cArgs },
+			{ command: "gcc", args: cArgs },
+			{ command: "cc", args: cArgs },
+		];
+	}
+
+	if (cppMode || ext) {
+		return [
+			{ command: "clang++", args: ["-fsyntax-only", absPath] },
+			{ command: "g++", args: ["-fsyntax-only", absPath] },
+			{ command: "c++", args: ["-fsyntax-only", absPath] },
+		];
+	}
+
+	return [];
+}
+
 async function resolveCompiler(absPath: string): Promise<CompilerSpec> {
-	const gccLike: Array<{ command: string; args: string[] }> = [
-		{ command: "clang++", args: ["-fsyntax-only", absPath] },
-		{ command: "g++", args: ["-fsyntax-only", absPath] },
-		{ command: "c++", args: ["-fsyntax-only", absPath] },
-	];
-	for (const candidate of gccLike) {
+	for (const candidate of getGccLikeCandidates(absPath)) {
 		const probe = await safeSpawnAsync(candidate.command, ["--version"], {
 			timeout: 5000,
 		});

package/clients/dispatch/runners/go-vet.ts

@@ -4,6 +4,7 @@
  * Runs `go vet` for Go files to catch common mistakes.
  */
 
+import { GoClient } from "../../go-client.js";
 import { safeSpawnAsync } from "../../safe-spawn.js";
 import { stripAnsi } from "../../sanitize.js";
 import { parseGoVetOutput } from "./utils/diagnostic-parsers.js";
@@ -14,6 +15,8 @@ import type {
 } from "../types.js";
 import { PRIORITY } from "../priorities.js";
 
+const goClient = new GoClient();
+
 const goVetRunner: RunnerDefinition = {
 	id: "go-vet",
 	appliesTo: ["go"],
@@ -21,17 +24,14 @@ const goVetRunner: RunnerDefinition = {
 	enabledByDefault: true,
 
 	async run(ctx: DispatchContext): Promise<RunnerResult> {
-		// Check if go is available
-		const check = await safeSpawnAsync("go", ["version"], {
-			timeout: 5000,
-		});
-
-		if (check.error || check.status !== 0) {
+		// Resolve go path using platform-aware lookup (handles system install paths on Windows)
+		const goExe = goClient.findGoPath();
+		if (!goExe) {
 			return { status: "skipped", diagnostics: [], semantic: "none" };
 		}
 
 		// Run go vet on the file
-		const result = await safeSpawnAsync("go", ["vet", ctx.filePath], {
+		const result = await safeSpawnAsync(goExe, ["vet", ctx.filePath], {
 			timeout: 30000,
 		});
 

package/clients/dispatch/runners/index.ts

@@ -43,8 +43,10 @@ import similarityRunner from "./similarity.js";
 import spellcheckRunner from "./spellcheck.js";
 import sqlfluffRunner from "./sqlfluff.js";
 import stylelintRunner from "./stylelint.js";
+import swiftlintRunner from "./swiftlint.js";
 import taploRunner from "./taplo.js";
 import tflintRunner from "./tflint.js";
+import valeRunner from "./vale.js";
 // Import tree-sitter runner
 import treeSitterRunner from "./tree-sitter.js";
 import tsLspRunner from "./ts-lsp.js";
@@ -83,11 +85,13 @@ export function registerDefaultRunners(registry: RunnerRegistry): void {
 	registry.register(markdownlintRunner); // Markdown lint (priority 30)
 	registry.register(mypyRunner); // Python type checking — mypy (priority 20, config-gated)
 	registry.register(stylelintRunner); // CSS/SCSS/Less lint (priority 10, config-gated)
+	registry.register(swiftlintRunner); // Swift lint — out-of-the-box defaults (priority 20)
 	registry.register(shfmtRunner); // Shell formatting check (priority 10)
 	registry.register(fishIndentRunner); // Fish script formatting check (priority 10)
 	registry.register(factRulesRunner); // FactRule pipeline — all registered rules (priority 21)
 	registry.register(htmlhintRunner); // HTML linting — tag pairs, attribute rules (priority 20)
 	registry.register(hadolintRunner); // Dockerfile linting — syntax, best practices (priority 20)
+	registry.register(valeRunner); // Prose/style linting for Markdown — config-gated (.vale.ini) (priority 30)
 	registry.register(phpLintRunner); // PHP syntax validation via php -l (priority 20)
 	registry.register(psScriptAnalyzerRunner); // PowerShell linting via PSScriptAnalyzer module (priority 20)
 	registry.register(prismaValidateRunner); // Prisma schema validation via CLI (priority 20)

package/clients/dispatch/runners/python-slop.ts

@@ -21,7 +21,7 @@ import type {
 import {
 	createConfigFinder,
 	getSgCommand,
-	isSgAvailable,
+	isSgAvailableAsync,
 } from "./utils/runner-helpers.js";
 
 const findSlopConfig = createConfigFinder("python-slop-rules");
@@ -35,7 +35,7 @@ const pythonSlopRunner: RunnerDefinition = {
 
 	async run(ctx: DispatchContext): Promise<RunnerResult> {
 		// Check if ast-grep is available
-		if (!isSgAvailable()) {
+		if (!await isSgAvailableAsync()) {
 			return { status: "skipped", diagnostics: [], semantic: "none" };
 		}