pi-lens 3.8.19 → 3.8.21

package/CHANGELOG.md

@@ -2,6 +2,32 @@
 
 All notable changes to pi-lens will be documented in this file.
 
+## [3.8.21] - 2026-04-08
+
+### Changed
+- **Session guidance channeling** — session-start guidance is now injected as `system` context instead of synthetic `user` context, reducing acknowledgement-only first replies before task execution.
+- **Coverage warning dedupe** — "Pi-lens analysis unavailable" warnings are now shown once per file per session and reset on session baseline reset.
+
+### Fixed
+- **Turn-end read-loop pressure** — turn-end findings now suppress duplicate persisted blocker prompts and avoid imperative "read this file" phrasing that could trigger repeated read loops.
+
+## [3.8.20] - 2026-04-08
+
+### Changed
+- **Session startup hardening** — background startup tasks now run with session-generation safety guards and startup in-flight tracking, preventing stale task writes across session boundaries.
+- **Turn-end overlap guardrails** — turn-end `knip`/`jscpd` checks now skip when the corresponding startup scan is still in-flight.
+- **Language-profile centralization** — startup and dispatch now share a centralized project language profile for supported language detection and LSP-capable kind policy.
+- **No-config startup defaults** — startup preinstall now applies language defaults (for example JS/TS -> `typescript-language-server`, Python -> `pyright`/`ruff`) while keeping heavy JS/TS scans config-gated.
+- **Language setup hints** — `session_start` now emits actionable install hints for detected Go/Rust/Ruby projects when key tools are missing.
+
+### Fixed
+- **TODO baseline scan resilience** — unreadable files are now skipped safely instead of crashing TODO scanning in cloud-synced projects.
+- **Startup scan gating consistency** — TODO warmup now respects startup warm-cache gating and avoids unnecessary scan work in restricted startup contexts.
+- **Path exclusion coverage** — shared exclusion list now includes common agent/tooling directories (`.claude`, `.codex`, `.worktrees`, `.vscode`, and related dirs).
+- **Ruff auto-install on Windows** — pip-based installation now supports fallback chains (`pip`, `py -m pip`, `python -m pip`) and process PATH normalization for user-level scripts.
+- **Installer race duplication** — concurrent `ensureTool(...)` calls are now deduplicated per tool to avoid duplicate install attempts/noisy logs.
+- **Python LSP root fallback** — Python LSP root detection now supports `.git` projects without Python config files.
+
 ## [3.8.19] - 2026-04-07
 
 ### Fixed

package/README.md

@@ -15,15 +15,18 @@ On every `write` and `edit`, pi-lens runs a fast, language-aware pipeline (check
 - **Security checks**: secret scanning and structural security rules
 - **Structural analysis**: tree-sitter + ast-grep for bug patterns across supported languages
 - **Delta reporting**: prioritize new issues over legacy baseline noise
+- **Coverage transparency**: when primary analysis tools are unavailable for a file kind, pi-lens emits a non-blocking inline "analysis unavailable" warning (deduped per file per session)
 
 ### Session Start
 
 At `session_start`, pi-lens:
 
 - resets runtime state and diagnostic telemetry
-- detects project root and active tools
-- warms caches and optional indexes
-- preps LSP/tool installers when needed
+- detects project root, language profile, and active tools
+- applies language-aware startup defaults for tool preinstall
+- warms caches and optional indexes (with overlap/session guardrails)
+- emits missing-tool install hints for detected languages when relevant
+- injects session guidance through internal context (non-user channel) to reduce acknowledgement-only first responses
 
 ### Turn End
 
@@ -94,12 +97,12 @@ Auto-install behavior depends on gate type:
 | `prettier` | Formatting fallback | Yes | Config-gated (Prettier dep or `package.json#prettier`) |
 | `yamllint` | YAML linting | Yes | Config-gated (`.yamllint*` / tool section / dep hint) |
 | `sqlfluff` | SQL linting/formatting | Yes | Config-gated (`.sqlfluff` / tool section / dep hint) |
-| `ruff` | Python lint/format/autofix | Yes | Flow/language-gated (Python file paths/runners) |
-| `typescript-language-server` | Unified LSP diagnostics | Yes | Flow-gated (LSP enabled; default on unless `--no-lsp`) |
+| `ruff` | Python lint/format/autofix | Yes | Language-default + flow-gated (Python detected; respects `--no-autofix-ruff`) |
+| `typescript-language-server` | Unified LSP diagnostics | Yes | Language-default + flow-gated (JS/TS detected and LSP enabled) |
 | `pyright` | Python type diagnostics fallback | Yes | Flow/language-gated (Python fallback paths) |
 | `@ast-grep/cli` (`sg`) | AST scans/search/replace | Yes | Operational prewarm + analysis flows |
-| `knip` | Dead code analysis | Yes | Operational prewarm + turn-end flows |
-| `jscpd` | Duplicate code detection | Yes | Operational prewarm + turn-end flows |
+| `knip` | Dead code analysis | Yes | Operational prewarm + turn-end flows (JS/TS language + config gated at startup) |
+| `jscpd` | Duplicate code detection | Yes | Operational prewarm + turn-end flows (JS/TS language + config gated at startup) |
 | `madge` | Circular dependency analysis | Yes | Turn-end analysis flow |
 
 LSP is enabled by default. pi-lens includes many language-server definitions (including up to 31+ servers), and activates them when the server is installed and the project/root detection matches the file.

package/clients/dispatch/dispatcher.ts

@@ -17,6 +17,8 @@
 import * as path from "node:path";
 import type { FileKind } from "../file-kinds.js";
 import { detectFileKind } from "../file-kinds.js";
+import { getPrimaryDispatchGroup } from "../language-policy.js";
+import { resolveLanguageRootForFile } from "../language-profile.js";
 import { isTestFile } from "../file-utils.js";
 import { logLatency } from "../latency-logger.js";
 import { normalizeMapKey } from "../path-utils.js";
@@ -129,7 +131,9 @@ export function createDispatchContext(
 	blockingOnly?: boolean,
 	modifiedRanges?: import("./types.js").ModifiedRange[],
 ): DispatchContext {
-	const normalizedCwd = normalizeMapKey(path.resolve(cwd));
+	const normalizedCwd = normalizeMapKey(
+		resolveLanguageRootForFile(path.resolve(cwd, filePath), cwd),
+	);
 	const normalizedFilePath = resolveRunnerPath(normalizedCwd, filePath);
 	const kind = detectFileKind(normalizedFilePath);
 
@@ -325,7 +329,46 @@ export interface DispatchLatencyReport {
 	warnings: number;
 }
 
+function buildCoverageNotice(
+	ctx: DispatchContext,
+	runnerLatencies: RunnerLatency[],
+): Diagnostic | undefined {
+	if (!ctx.kind) return undefined;
+	const lspEnabled = !!ctx.pi.getFlag("lens-lsp") && !ctx.pi.getFlag("no-lsp");
+	const primary = getPrimaryDispatchGroup(ctx.kind, lspEnabled);
+	if (!primary || primary.runnerIds.length === 0) return undefined;
+
+	const relevant = runnerLatencies.filter((r) =>
+		primary.runnerIds.includes(r.runnerId),
+	);
+	if (relevant.length === 0) return undefined;
+
+	const hasCoverage = relevant.some(
+		(r) => r.status === "succeeded" || r.status === "failed",
+	);
+	if (hasCoverage) return undefined;
+
+	const allSkipped = relevant.every(
+		(r) => r.status === "skipped" || r.status === "when_skipped",
+	);
+	if (!allSkipped) return undefined;
+
+	const onceKey = `${ctx.kind}:${normalizeMapKey(ctx.filePath)}`;
+	if (coverageNoticeSeen.has(onceKey)) return undefined;
+	coverageNoticeSeen.add(onceKey);
+
+	return {
+		id: `coverage-unavailable:${ctx.kind}:${path.basename(ctx.filePath)}`,
+		message: `Pi-lens analysis unavailable. Tools for ${ctx.kind} not installed.`,
+		filePath: ctx.filePath,
+		severity: "warning",
+		semantic: "warning",
+		tool: "pi-lens",
+	};
+}
+
 const latencyReports: DispatchLatencyReport[] = [];
+const coverageNoticeSeen = new Set<string>();
 
 export function getLatencyReports(): DispatchLatencyReport[] {
 	return [...latencyReports];
@@ -335,6 +378,10 @@ export function clearLatencyReports(): void {
 	latencyReports.length = 0;
 }
 
+export function clearCoverageNoticeState(): void {
+	coverageNoticeSeen.clear();
+}
+
 export function formatLatencyReport(report: DispatchLatencyReport): string {
 	const lines: string[] = [];
 	lines.push(
@@ -606,11 +653,16 @@ export async function dispatchForFile(
 	const fixedItems = visibleDiagnostics.filter((d) => d.semantic === "fixed");
 	const inlineBlockers = blockers.filter((d) => d.tool !== "similarity");
 	const inlineFixed = fixedItems.filter((d) => d.tool !== "similarity");
+	const coverageNotice = buildCoverageNotice(ctx, runnerLatencies);
 
 	// Format output — only blocking issues shown inline
 	// Warnings tracked but not shown (noise) — surfaced via /lens-booboo
 	let output = formatDiagnostics(inlineBlockers, "blocking");
 	output += formatDiagnostics(inlineFixed, "fixed");
+	if (coverageNotice) {
+		output += formatDiagnostics([coverageNotice], "warning", 1);
+		warnings.push(coverageNotice);
+	}
 
 	// Generate and store latency report
 	const overallEnd = Date.now();

package/clients/dispatch/integration.ts

@@ -7,8 +7,13 @@
 
 import { detectFileKind } from "../file-kinds.js";
 import type { FileKind } from "../file-kinds.js";
+import {
+	getLspCapableKinds,
+	getPrimaryDispatchGroup,
+} from "../language-policy.js";
 import {
 	clearLatencyReports,
+	clearCoverageNoticeState,
 	createBaselineStore,
 	createDispatchContext,
 	type DispatchLatencyReport,
@@ -40,35 +45,40 @@ import "./runners/index.js";
 // store, so baselines.get() always returns undefined and every issue
 // looks "new" every time.
 const sessionBaselines: BaselineStore = createBaselineStore();
-const LSP_CAPABLE_KINDS = new Set<FileKind>([
-	"jsts",
-	"python",
-	"go",
-	"rust",
-	"ruby",
-	"cxx",
-	"cmake",
-	"shell",
-	"json",
-	"markdown",
-	"css",
-	"yaml",
-]);
-
-function withPrimaryLspGroup(
+const LSP_CAPABLE_KINDS = new Set<FileKind>(getLspCapableKinds());
+
+function withPrimaryPolicyGroup(
 	kind: keyof typeof TOOL_PLANS,
 	groups: RunnerGroup[],
 	pi: PiAgentAPI,
 ): RunnerGroup[] {
-	if (!pi.getFlag("lens-lsp") || !!pi.getFlag("no-lsp")) return groups;
-
-	const alreadyHasLsp = groups.some((g) => g.runnerIds.includes("lsp"));
-	if (alreadyHasLsp) return groups;
-
-	return [
-		{ mode: "all", runnerIds: ["lsp"], filterKinds: [kind as FileKind] },
-		...groups,
-	];
+	const lspEnabled = !!pi.getFlag("lens-lsp") && !pi.getFlag("no-lsp");
+	const normalizedGroups = lspEnabled
+		? groups
+		: groups
+				.map((group) => {
+					const runnerIds = group.runnerIds.filter(
+						(id) => id !== "lsp" && id !== "ts-lsp",
+					);
+					if (runnerIds.length === 0) return null;
+					return {
+						...group,
+						runnerIds,
+					};
+				})
+				.filter((group): group is RunnerGroup => group !== null);
+
+	const primary = getPrimaryDispatchGroup(kind as FileKind, lspEnabled);
+	if (!primary) return normalizedGroups;
+
+	const alreadyHasPrimary = normalizedGroups.some((group) => {
+		if (group.mode !== primary.mode) return false;
+		if (group.runnerIds.length !== primary.runnerIds.length) return false;
+		return group.runnerIds.every((id, index) => primary.runnerIds[index] === id);
+	});
+	if (alreadyHasPrimary) return normalizedGroups;
+
+	return [primary, ...normalizedGroups];
 }
 
 export function getDispatchGroupsForKind(
@@ -86,7 +96,7 @@ export function getDispatchGroupsForKind(
 		}
 		return [];
 	}
-	return withPrimaryLspGroup(kind, plan.groups, pi);
+	return withPrimaryPolicyGroup(kind, plan.groups, pi);
 }
 
 /**
@@ -95,6 +105,7 @@ export function getDispatchGroupsForKind(
  */
 export function resetDispatchBaselines(): void {
 	sessionBaselines.clear();
+	clearCoverageNoticeState();
 }
 
 /**

package/clients/dispatch/plan.ts

@@ -1,4 +1,5 @@
 import type { FileKind } from "../file-kinds.js";
+import { getPrimaryDispatchGroup } from "../language-policy.js";
 import type { RunnerGroup, ToolPlan } from "./types.js";
 
 type CapabilityDimension =
@@ -17,12 +18,20 @@ interface CapabilityMatrixEntry {
 	fullOnlyGroups?: RunnerGroup[];
 }
 
+function primary(kind: FileKind): RunnerGroup {
+	const group = getPrimaryDispatchGroup(kind, true);
+	if (!group) {
+		throw new Error(`Missing primary dispatch group for ${kind}`);
+	}
+	return group;
+}
+
 export const LANGUAGE_CAPABILITY_MATRIX: Record<FileKind, CapabilityMatrixEntry> = {
 	jsts: {
 		name: "JavaScript/TypeScript Linting",
 		capabilities: ["types", "security", "smells", "format", "lint", "architecture"],
 		writeGroups: [
-			{ mode: "fallback", runnerIds: ["lsp", "ts-lsp"], filterKinds: ["jsts"] },
+			primary("jsts"),
 			{ mode: "all", runnerIds: ["biome-check-json"], filterKinds: ["jsts"] },
 			{ mode: "all", runnerIds: ["tree-sitter"], filterKinds: ["jsts"] },
 			{ mode: "all", runnerIds: ["ast-grep-napi"], filterKinds: ["jsts"] },
@@ -39,7 +48,7 @@ export const LANGUAGE_CAPABILITY_MATRIX: Record<FileKind, CapabilityMatrixEntry>
 		name: "Python Linting",
 		capabilities: ["types", "lint", "architecture", "smells"],
 		writeGroups: [
-			{ mode: "fallback", runnerIds: ["lsp", "pyright"], filterKinds: ["python"] },
+			primary("python"),
 			{ mode: "fallback", runnerIds: ["ruff-lint"], filterKinds: ["python"] },
 			{ mode: "fallback", runnerIds: ["architect"], filterKinds: ["python"] },
 		],
@@ -51,7 +60,7 @@ export const LANGUAGE_CAPABILITY_MATRIX: Record<FileKind, CapabilityMatrixEntry>
 		name: "Go Linting",
 		capabilities: ["types", "lint", "smells"],
 		writeGroups: [
-			{ mode: "all", runnerIds: ["lsp"], filterKinds: ["go"] },
+			primary("go"),
 			{ mode: "fallback", runnerIds: ["go-vet"], filterKinds: ["go"] },
 			{ mode: "fallback", runnerIds: ["golangci-lint"], filterKinds: ["go"] },
 			{ mode: "all", runnerIds: ["tree-sitter"], filterKinds: ["go"] },
@@ -61,7 +70,7 @@ export const LANGUAGE_CAPABILITY_MATRIX: Record<FileKind, CapabilityMatrixEntry>
 		name: "Rust Linting",
 		capabilities: ["types", "lint", "smells"],
 		writeGroups: [
-			{ mode: "all", runnerIds: ["lsp"], filterKinds: ["rust"] },
+			primary("rust"),
 			{ mode: "fallback", runnerIds: ["rust-clippy"], filterKinds: ["rust"] },
 			{ mode: "all", runnerIds: ["tree-sitter"], filterKinds: ["rust"] },
 		],
@@ -70,7 +79,7 @@ export const LANGUAGE_CAPABILITY_MATRIX: Record<FileKind, CapabilityMatrixEntry>
 		name: "Ruby Linting",
 		capabilities: ["types", "lint", "smells"],
 		writeGroups: [
-			{ mode: "all", runnerIds: ["lsp"], filterKinds: ["ruby"] },
+			primary("ruby"),
 			{ mode: "fallback", runnerIds: ["rubocop"], filterKinds: ["ruby"] },
 			{ mode: "all", runnerIds: ["tree-sitter"], filterKinds: ["ruby"] },
 		],
@@ -78,42 +87,42 @@ export const LANGUAGE_CAPABILITY_MATRIX: Record<FileKind, CapabilityMatrixEntry>
 	cxx: {
 		name: "C/C++ Linting",
 		capabilities: ["types", "lint"],
-		writeGroups: [],
+		writeGroups: [primary("cxx")],
 	},
 	cmake: {
 		name: "CMake Processing",
 		capabilities: ["lint"],
-		writeGroups: [],
+		writeGroups: [primary("cmake")],
 	},
 	shell: {
 		name: "Shell Script Linting",
 		capabilities: ["lint", "security"],
-		writeGroups: [{ mode: "fallback", runnerIds: ["shellcheck"] }],
+		writeGroups: [primary("shell")],
 	},
 	json: {
 		name: "JSON Processing",
 		capabilities: ["format"],
-		writeGroups: [],
+		writeGroups: [primary("json")],
 	},
 	markdown: {
 		name: "Markdown Processing",
 		capabilities: ["docs"],
-		writeGroups: [{ mode: "fallback", runnerIds: ["spellcheck"] }],
+		writeGroups: [primary("markdown")],
 	},
 	css: {
 		name: "CSS Processing",
 		capabilities: ["format", "lint"],
-		writeGroups: [],
+		writeGroups: [primary("css")],
 	},
 	yaml: {
 		name: "YAML Processing",
 		capabilities: ["format", "lint"],
-		writeGroups: [{ mode: "fallback", runnerIds: ["yamllint"], filterKinds: ["yaml"] }],
+		writeGroups: [primary("yaml")],
 	},
 	sql: {
 		name: "SQL Processing",
 		capabilities: ["format", "lint"],
-		writeGroups: [{ mode: "fallback", runnerIds: ["sqlfluff"], filterKinds: ["sql"] }],
+		writeGroups: [primary("sql")],
 	},
 };
 
@@ -126,10 +135,11 @@ function toWritePlan(entry: CapabilityMatrixEntry): ToolPlan {
 
 function toFullPlan(kind: FileKind, entry: CapabilityMatrixEntry): ToolPlan {
 	if (kind === "jsts") {
+		const primaryGroup = primary("jsts");
 		return {
 			name: "JavaScript/TypeScript Full Lint",
 			groups: [
-				{ mode: "fallback", runnerIds: ["lsp", "ts-lsp"], filterKinds: ["jsts"] },
+				primaryGroup,
 				{ mode: "all", runnerIds: ["tree-sitter"], filterKinds: ["jsts"] },
 				{ mode: "all", runnerIds: ["ast-grep-napi"], filterKinds: ["jsts"] },
 				...(entry.fullOnlyGroups ?? []),
@@ -142,10 +152,11 @@ function toFullPlan(kind: FileKind, entry: CapabilityMatrixEntry): ToolPlan {
 	}
 
 	if (kind === "python") {
+		const primaryGroup = primary("python");
 		return {
 			name: "Python Full Lint",
 			groups: [
-				{ mode: "fallback", runnerIds: ["lsp", "pyright"], filterKinds: ["python"] },
+				primaryGroup,
 				{ mode: "fallback", runnerIds: ["ruff-lint"], filterKinds: ["python"] },
 				...(entry.fullOnlyGroups ?? []),
 				{ mode: "fallback", runnerIds: ["architect"], filterKinds: ["python"] },

package/clients/dispatch/runners/lsp.ts

@@ -115,7 +115,12 @@ const lspRunner: RunnerDefinition = {
 		}
 
 		if (lspDiags.length === 0) {
-			return { status: "skipped", diagnostics: [], semantic: "none" };
+			return {
+				status: "succeeded",
+				diagnostics: [],
+				semantic: "none",
+				rawOutput: "no-diagnostics",
+			};
 		}
 
 		// Convert LSP diagnostics to our format

package/clients/dispatch/runners/pyright.ts

@@ -27,14 +27,12 @@ const pyrightRunner: RunnerDefinition = {
 	enabledByDefault: true,
 
 	async run(ctx: DispatchContext): Promise<RunnerResult> {
-		// When --lens-lsp is active, prefer the unified lsp runner.
-		// But if LSP is unavailable for this file, keep pyright CLI fallback.
+		// Always allow pyright CLI fallback even when LSP is enabled.
+		// LSP can be present but still fail transiently for a file; in that case,
+		// pyright provides a resilient second signal path.
 		if (ctx.pi.getFlag("lens-lsp") && !ctx.pi.getFlag("no-lsp")) {
 			const lspService = getLSPService();
-			const spawned = await lspService.getClientForFile(ctx.filePath);
-			if (spawned) {
-				return { status: "skipped", diagnostics: [], semantic: "none" };
-			}
+			await lspService.getClientForFile(ctx.filePath);
 		}
 
 		const cwd = ctx.cwd || process.cwd();

package/clients/dispatch/runners/ruff.ts

@@ -9,6 +9,7 @@ import { ensureTool } from "../../installer/index.js";
 import { safeSpawnAsync } from "../../safe-spawn.js";
 import { stripAnsi } from "../../sanitize.js";
 import type {
+	Diagnostic,
 	DispatchContext,
 	RunnerDefinition,
 	RunnerResult,
@@ -18,6 +19,39 @@ import { createAvailabilityChecker } from "./utils/runner-helpers.js";
 
 const ruff = createAvailabilityChecker("ruff", ".exe");
 
+function parseRuffJson(raw: string, filePath: string): Diagnostic[] {
+	try {
+		const parsed = JSON.parse(raw) as Array<{
+			code?: string;
+			message?: string;
+			filename?: string;
+			location?: { row?: number; column?: number };
+			severity?: string;
+			fix?: unknown;
+		}>;
+		if (!Array.isArray(parsed)) return [];
+
+		return parsed.map((item, index) => {
+			const severity = item.severity === "error" ? "error" : "warning";
+			const code = item.code || "ruff";
+			return {
+				id: `ruff-${code}-${item.location?.row ?? index + 1}`,
+				message: item.message || code,
+				filePath: item.filename || filePath,
+				line: item.location?.row ?? 1,
+				column: item.location?.column ?? 1,
+				severity,
+				semantic: severity === "error" ? "blocking" : "warning",
+				tool: "ruff",
+				rule: code,
+				fixable: Boolean(item.fix),
+			};
+		});
+	} catch {
+		return [];
+	}
+}
+
 const ruffRunner: RunnerDefinition = {
 	id: "ruff-lint",
 	appliesTo: ["python"],
@@ -47,25 +81,36 @@ const ruffRunner: RunnerDefinition = {
 		// not silent correction. Auto-fix (ruff --fix) already runs in the
 		// format phase before dispatch, handling all safe style transforms.
 		// Silently rewriting here would leave the agent's context window stale.
-		const args = ["check", ctx.filePath];
+		const args = ["check", "--output-format", "json", ctx.filePath];
 
 		const result = await safeSpawnAsync(cmd, args, {
 			timeout: 30000,
 		});
 
 		const raw = stripAnsi(result.stdout + result.stderr);
+		const diagnostics = parseRuffJson(result.stdout || "", ctx.filePath);
+		const parsedDiagnostics =
+			diagnostics.length > 0 ? diagnostics : parseRuffOutput(raw, ctx.filePath);
 
-		if (result.status === 0) {
+		if (result.status === 0 && parsedDiagnostics.length === 0) {
 			return { status: "succeeded", diagnostics: [], semantic: "none" };
 		}
 
-		// Parse diagnostics
-		const diagnostics = parseRuffOutput(raw, ctx.filePath);
+		if (parsedDiagnostics.length === 0) {
+			return {
+				status: "failed",
+				diagnostics: [],
+				semantic: "warning",
+				rawOutput: raw.slice(0, 500),
+			};
+		}
+
+		const hasErrors = parsedDiagnostics.some((d) => d.severity === "error");
 
 		return {
-			status: "failed",
-			diagnostics,
-			semantic: "warning",
+			status: hasErrors ? "failed" : "succeeded",
+			diagnostics: parsedDiagnostics,
+			semantic: hasErrors ? "blocking" : "warning",
 		};
 	},
 };

package/clients/dispatch/runners/sqlfluff.ts

@@ -96,8 +96,9 @@ const sqlfluffRunner: RunnerDefinition = {
 
 	async run(ctx: DispatchContext): Promise<RunnerResult> {
 		const cwd = ctx.cwd || process.cwd();
-		if (!hasSqlfluffConfig(cwd)) {
-			return { status: "skipped", diagnostics: [], semantic: "none" };
+		const hasConfig = hasSqlfluffConfig(cwd);
+		if (!hasConfig) {
+			ctx.log("sqlfluff: no config detected, using ANSI dialect defaults");
 		}
 
 		let cmd: string | null = null;
@@ -113,7 +114,12 @@ const sqlfluffRunner: RunnerDefinition = {
 
 		if (!cmd) return { status: "skipped", diagnostics: [], semantic: "none" };
 
-		const result = safeSpawn(cmd, ["lint", "--format", "json", ctx.filePath], {
+		const args = ["lint", "--format", "json", ctx.filePath];
+		if (!hasConfig) {
+			args.splice(2, 0, "--dialect", "ansi");
+		}
+
+		const result = safeSpawn(cmd, args, {
 			timeout: 20000,
 		});
 

package/clients/dispatch/runners/yamllint.ts

@@ -89,8 +89,9 @@ const yamllintRunner: RunnerDefinition = {
 
 	async run(ctx: DispatchContext): Promise<RunnerResult> {
 		const cwd = ctx.cwd || process.cwd();
-		if (!hasYamllintConfig(cwd)) {
-			return { status: "skipped", diagnostics: [], semantic: "none" };
+		const hasConfig = hasYamllintConfig(cwd);
+		if (!hasConfig) {
+			ctx.log("yamllint: no config detected, running with default rules");
 		}
 
 		let cmd: string | null = null;

package/clients/file-utils.ts

@@ -23,8 +23,19 @@ export const EXCLUDED_DIRS = [
 	".gradle",
 	".next",
 	".pi-lens",
-	".pi",              // pi agent directory
-	".ruff_cache",      // Python linter cache
+	".pi", // pi agent directory
+	".ruff_cache", // Python linter cache
+	".worktrees",
+	".claude",
+	".codex",
+	".rescue",
+	".agents",
+	".gstack",
+	".superpowers",
+	".guardrails",
+	".playwright-cli",
+	".playwright-mcp",
+	".vscode",
 	"venv",
 	".venv",
 	"coverage",

package/clients/formatters.ts

@@ -346,6 +346,9 @@ export const ruffFormatter: FormatterInfo = {
 	async resolveCommand(filePath, cwd) {
 		const venv = await findInVenv("ruff", cwd);
 		if (venv) return [venv, "format", filePath];
+		const { getToolPath } = await import("./installer/index.js");
+		const installed = await getToolPath("ruff");
+		if (installed) return [installed, "format", filePath];
 		return null;
 	},
 	async detect(cwd: string) {
@@ -372,10 +375,11 @@ export const ruffFormatter: FormatterInfo = {
 			}
 		}
 
-		// Only enable if the project explicitly uses ruff (config or deps).
-		// Do NOT fall back to "ruff binary is installed" — that would format
-		// projects that never asked for ruff.
-		return false;
+		// No-config fallback: if Ruff is already available, allow formatter usage.
+		// This keeps Python default behavior consistent with startup defaults.
+		const { getToolPath } = await import("./installer/index.js");
+		const installed = await getToolPath("ruff");
+		return Boolean(installed);
 	},
 };