@iowarp/clio-coder 0.3.9 → 0.4.1

package/src/cli/doctor-naming.ts

@@ -0,0 +1,323 @@
+import { execFileSync } from "node:child_process";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { parse as parseYaml } from "yaml";
+import { withSettingsLock } from "../core/config.js";
+import { resolveClioDirs } from "../core/xdg.js";
+import type { DoctorFinding } from "../domains/lifecycle/doctor.js";
+import {
+	migrateNamingSettingsFile,
+	transformNamingSettingsDocument,
+} from "../domains/lifecycle/migrations/2026-09-01-clio-coder-naming.js";
+import { inspectNamingHistory } from "../domains/lifecycle/naming-history.js";
+import {
+	inspectInstalledNamingResources,
+	inspectModelOverlayNaming,
+	inspectSkillMetadataNaming,
+} from "../domains/lifecycle/naming-resources.js";
+import { inspectToolMarkerNaming } from "../domains/lifecycle/naming-tool-markers.js";
+import { inspectYaziNaming, regenerateYaziNamingProfile } from "../domains/lifecycle/naming-yazi.js";
+
+export interface NamingDoctorOptions {
+	fix?: boolean;
+	cwd?: string;
+	yaziEnabled?: boolean;
+}
+
+interface SettingsNamingInspection {
+	path: string;
+	legacy: number;
+	conflicts: number;
+	error: string | null;
+}
+
+const LEGACY_ENVIRONMENT_NAMES = [
+	["CLIO_EVAL_RUNNER_STDOUT_FILE", "CLIO_CODER_EVAL_RUNNER_STDOUT_FILE"],
+	["CLIO_YAZI_PICK_TOKEN", "CLIO_CODER_YAZI_PICK_TOKEN"],
+] as const;
+
+function namingEnvironmentFindings(
+	yaziEnabled: boolean,
+	environment: NodeJS.ProcessEnv = process.env,
+): DoctorFinding[] {
+	const present = LEGACY_ENVIRONMENT_NAMES.filter(
+		([legacy]) => (yaziEnabled || legacy !== "CLIO_YAZI_PICK_TOKEN") && Boolean(environment[legacy]?.trim()),
+	);
+	if (present.length === 0) {
+		return [{ ok: true, name: "naming environment", detail: "no legacy Clio Coder environment variables are set" }];
+	}
+	return present.map(([legacy, canonical]) => ({
+		ok: true,
+		level: "warn",
+		name: "naming environment",
+		detail: `${legacy} is deprecated; use ${canonical} (compatibility ends in v0.7.0)`,
+	}));
+}
+
+function namingResourceFindings(options: NamingDoctorOptions): DoctorFinding[] {
+	try {
+		const resourceOptions = {
+			...(options.cwd ? { cwd: options.cwd } : {}),
+			...(options.fix !== undefined ? { fix: options.fix } : {}),
+		};
+		const resources = inspectInstalledNamingResources(resourceOptions);
+		const legacyResources = resources.filter((entry) => entry.status !== "absent");
+		const rootOptions = options.cwd ? { cwd: options.cwd } : {};
+		const skillMetadata = inspectSkillMetadataNaming(rootOptions).filter((entry) => entry.legacyMetadataKey);
+		const overlays = inspectModelOverlayNaming(rootOptions).filter(
+			(entry) => entry.legacyFile || entry.legacyMetadataKeys > 0,
+		);
+		if (legacyResources.length === 0 && skillMetadata.length === 0 && overlays.length === 0) {
+			return [{ ok: true, name: "naming resources", detail: "installed skills and model overlays use canonical names" }];
+		}
+		const renamed = legacyResources.filter((entry) => entry.status === "renamed").length;
+		const renamable = legacyResources.filter((entry) => entry.status === "renamable").length;
+		const conflicts = legacyResources.filter(
+			(entry) => entry.status === "modified" || entry.status === "canonical-present",
+		).length;
+		return [
+			{
+				ok: true,
+				level:
+					renamed > 0 && renamable === 0 && conflicts === 0 && skillMetadata.length === 0 && overlays.length === 0
+						? "ok"
+						: "warn",
+				name: "naming resources",
+				detail: [
+					`${renamed} proven skills renamed`,
+					`${renamable} proven skills await doctor --fix`,
+					`${conflicts} modified/conflicting skills left untouched`,
+					`${skillMetadata.length} legacy skill metadata keys`,
+					`${overlays.length} legacy model overlay files/metadata (manual migration required)`,
+				].join("; "),
+			},
+		];
+	} catch (error) {
+		return [
+			{
+				ok: false,
+				name: "naming resources",
+				detail: `resource naming inspection failed: ${error instanceof Error ? error.message : String(error)}`,
+			},
+		];
+	}
+}
+
+function inspectSettingsNaming(path: string): SettingsNamingInspection {
+	if (!existsSync(path)) return { path, legacy: 0, conflicts: 0, error: null };
+	try {
+		const transformed = transformNamingSettingsDocument(parseYaml(readFileSync(path, "utf8")));
+		return {
+			path,
+			legacy: transformed.replacements.length,
+			conflicts: transformed.conflicts.length,
+			error: null,
+		};
+	} catch (error) {
+		return { path, legacy: 0, conflicts: 0, error: error instanceof Error ? error.message : String(error) };
+	}
+}
+
+function settingsFinding(label: string, inspection: SettingsNamingInspection, fixed: boolean): DoctorFinding {
+	if (inspection.error !== null) {
+		return {
+			ok: false,
+			name: `naming ${label}`,
+			detail: `${inspection.path} could not be inspected: ${inspection.error}`,
+		};
+	}
+	const count = inspection.legacy + inspection.conflicts;
+	if (count === 0) {
+		return { ok: true, name: `naming ${label}`, detail: `${inspection.path} has canonical settings identifiers` };
+	}
+	return {
+		ok: fixed,
+		level: fixed ? "ok" : "warn",
+		name: `naming ${label}`,
+		detail: fixed
+			? `${inspection.path}: migrated ${inspection.legacy} aliases and resolved ${inspection.conflicts} canonical collisions; backup written beside the file`
+			: `${inspection.path}: ${inspection.legacy} legacy aliases and ${inspection.conflicts} canonical collisions (run \`clio-coder doctor --fix\`)`,
+	};
+}
+
+function yaziNamingFinding(fix: boolean, enabled: boolean): DoctorFinding {
+	if (!enabled) {
+		return {
+			ok: true,
+			name: "naming yazi profile",
+			detail: "disabled by settings",
+		};
+	}
+	const inspection = inspectYaziNaming();
+	const legacy = inspection.legacyEvents + inspection.legacyEnvironmentNames;
+	if (legacy === 0) {
+		return {
+			ok: true,
+			name: "naming yazi profile",
+			detail: inspection.present
+				? `${inspection.profileDir} uses canonical event and environment identifiers`
+				: `${inspection.profileDir} is absent; the next managed open will generate canonical identifiers`,
+		};
+	}
+	if (!fix) {
+		return {
+			ok: true,
+			level: "warn",
+			name: "naming yazi profile",
+			detail: `${inspection.profileDir}: ${inspection.legacyEvents} legacy events and ${inspection.legacyEnvironmentNames} legacy environment names (run \`clio-coder doctor --fix\`)`,
+		};
+	}
+	const report = regenerateYaziNamingProfile();
+	return {
+		ok: report.status !== "regeneration-failed",
+		...(report.status === "regeneration-failed" ? {} : { level: "ok" as const }),
+		name: "naming yazi profile",
+		detail: report.detail,
+	};
+}
+
+function toolMarkerNamingFinding(fix: boolean): DoctorFinding {
+	try {
+		const reports = inspectToolMarkerNaming({ fix });
+		if (reports.length === 0) {
+			return { ok: true, name: "naming tool markers", detail: "known tool versions use canonical install markers" };
+		}
+		const fixed = reports.filter((entry) => entry.status === "renamed" || entry.status === "duplicate-removed").length;
+		const fixable = reports.filter(
+			(entry) => entry.status === "renamable" || entry.status === "agreeing-duplicate",
+		).length;
+		const manual = reports.length - fixed - fixable;
+		return {
+			ok: true,
+			level: fixed > 0 && fixable === 0 && manual === 0 ? "ok" : "warn",
+			name: "naming tool markers",
+			detail: `${fixed} validated markers fixed; ${fixable} await doctor --fix; ${manual} invalid/conflicting markers left untouched`,
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			name: "naming tool markers",
+			detail: `tool marker inspection failed: ${error instanceof Error ? error.message : String(error)}`,
+		};
+	}
+}
+
+function immutableHistoryNamingFinding(): DoctorFinding {
+	const dirs = resolveClioDirs();
+	const counts = inspectNamingHistory({ stateDir: dirs.state, dataDir: dirs.data });
+	const errors = counts.filter((entry) => entry.error !== null);
+	if (errors.length > 0) {
+		return {
+			ok: false,
+			name: "naming immutable history",
+			detail: errors.map((entry) => `${entry.area}: ${entry.error}`).join("; "),
+		};
+	}
+	const legacy = counts.reduce((sum, entry) => sum + entry.legacyIdentifiers, 0);
+	return {
+		ok: true,
+		...(legacy > 0 ? { level: "warn" as const } : {}),
+		name: "naming immutable history",
+		detail: `${counts.map((entry) => `${entry.area}=${entry.legacyIdentifiers}`).join("; ")} legacy identifiers; read-only retention, no rewrite`,
+	};
+}
+
+function legacyGitRefsFinding(cwd: string): DoctorFinding {
+	let refs: string[];
+	try {
+		refs = execFileSync(
+			"git",
+			["-C", cwd, "for-each-ref", "--format=%(refname:short)", "refs/heads/clio/task", "refs/heads/clio/compete"],
+			{ encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 5_000 },
+		)
+			.split("\n")
+			.map((entry) => entry.trim())
+			.filter((entry) => /^clio\/(?:task|compete)\//u.test(entry))
+			.sort();
+	} catch {
+		refs = [];
+	}
+	if (refs.length === 0) {
+		return { ok: true, name: "naming git refs", detail: "no legacy Clio Coder task or compete refs found" };
+	}
+	const shown = refs.slice(0, 20);
+	return {
+		ok: true,
+		level: "warn",
+		name: "naming git refs",
+		detail: `${refs.length} legacy refs retained (never auto-renamed): ${shown.join(", ")}${refs.length > shown.length ? ", …" : ""}`,
+	};
+}
+
+function legacyWorktreeMarkerFinding(cwd: string): DoctorFinding {
+	const root = join(cwd, ".clio-coder", "worktrees");
+	let legacy = 0;
+	try {
+		for (const entry of readdirSync(root, { withFileTypes: true })) {
+			const candidates = entry.isFile()
+				? entry.name.endsWith(".task-owner.json")
+					? [join(root, entry.name)]
+					: []
+				: entry.isDirectory()
+					? [join(root, entry.name, ".clio-coder-compete-owner.json")]
+					: [];
+			for (const path of candidates) {
+				if (!existsSync(path)) continue;
+				const parsed = JSON.parse(readFileSync(path, "utf8")) as Record<string, unknown>;
+				if (parsed.kind === "clio-task-worktree" || parsed.kind === "clio-compete-group") legacy += 1;
+			}
+		}
+	} catch {
+		// An absent or partially unreadable project-local worktree root is not a
+		// repair target. Proven markers remain the lifecycle readers' authority.
+	}
+	return {
+		ok: true,
+		...(legacy > 0 ? { level: "warn" as const } : {}),
+		name: "naming worktree markers",
+		detail:
+			legacy === 0
+				? "active worktree markers use canonical identifiers"
+				: `${legacy} active legacy worktree markers retained for cleanup compatibility; no automatic rewrite`,
+	};
+}
+
+/** Read-only naming-footprint settings sweep plus the sanctioned deterministic fixes. */
+export function namingFootprintFindings(options: NamingDoctorOptions = {}): DoctorFinding[] {
+	const cwd = options.cwd ?? process.cwd();
+	const userSettingsPath = join(resolveClioDirs().config, "settings.yaml");
+	const candidates = [
+		{ label: "settings user", path: userSettingsPath, lock: true },
+		{ label: "settings project", path: join(cwd, ".clio-coder", "settings.yaml"), lock: false },
+		{ label: "settings local", path: join(cwd, ".clio-coder", "settings.local.yaml"), lock: false },
+	] as const;
+	const findings: DoctorFinding[] = [];
+	for (const candidate of candidates) {
+		const before = inspectSettingsNaming(candidate.path);
+		let fixed = false;
+		if (options.fix && before.error === null && before.legacy + before.conflicts > 0) {
+			try {
+				if (candidate.lock) withSettingsLock(() => migrateNamingSettingsFile(candidate.path));
+				else migrateNamingSettingsFile(candidate.path);
+				fixed = true;
+			} catch (error) {
+				findings.push({
+					ok: false,
+					name: `naming ${candidate.label}`,
+					detail: `--fix could not migrate ${candidate.path}: ${error instanceof Error ? error.message : String(error)}`,
+				});
+				continue;
+			}
+		}
+		findings.push(settingsFinding(candidate.label, before, fixed));
+	}
+	findings.push(...namingEnvironmentFindings(options.yaziEnabled ?? true));
+	findings.push(...namingResourceFindings({ ...options, cwd }));
+	findings.push(yaziNamingFinding(Boolean(options.fix), options.yaziEnabled ?? true));
+	findings.push(toolMarkerNamingFinding(Boolean(options.fix)));
+	findings.push(immutableHistoryNamingFinding());
+	findings.push(legacyGitRefsFinding(cwd));
+	findings.push(legacyWorktreeMarkerFinding(cwd));
+	return findings;
+}

package/src/cli/doctor-panes.ts

@@ -0,0 +1,156 @@
+import { accessSync, constants } from "node:fs";
+import { join } from "node:path";
+import { readSettings } from "../core/config.js";
+import { resolveClioDirs } from "../core/xdg.js";
+import type { DoctorFinding } from "../domains/lifecycle/doctor.js";
+import { detectMux, MUX_METHOD_MIN_PROTOCOL, resolveSocketCandidates } from "../domains/mux/index.js";
+import { describeResolution, findPinnedTool, toolStatus } from "../domains/toolchain/index.js";
+
+/**
+ * The panes section of `clio-coder doctor`.
+ *
+ * Six rows, in the order an operator debugs them: what mode the pane layer
+ * resolved to, whether the socket answered, whether the server is new enough
+ * for the methods phase 3 uses, where the pane host binary resolves, what the
+ * boot layout composes, and whether the journal directory the viewer reads is
+ * writable.
+ *
+ * No row is an error. Panes are optional: an operator who never wanted them has
+ * a healthy install without them, and doctor's exit code answers "is this
+ * install healthy". The rows that would be errors elsewhere are warnings that
+ * name the next step instead.
+ */
+
+const PANE_HOST_TOOL_ID = "herdr";
+
+/** Highest protocol any method Clio drives requires, for the version row. */
+const REQUIRED_PROTOCOL = Math.max(...Object.values(MUX_METHOD_MIN_PROTOCOL));
+
+function journalWritabilityFinding(root = join(resolveClioDirs().state, "runs")): DoctorFinding {
+	try {
+		accessSync(root, constants.W_OK);
+		return { ok: true, name: "panes journal dir", detail: `${root} is writable` };
+	} catch (error) {
+		return {
+			ok: true,
+			level: "warn",
+			name: "panes journal dir",
+			detail: `${root} is absent or not writable (${error instanceof Error ? error.message : String(error)}); \`clio-coder fleet view\` will have no transcript to follow`,
+		};
+	}
+}
+
+export async function panesFindings(env: NodeJS.ProcessEnv = process.env): Promise<DoctorFinding[]> {
+	let enabled: "auto" | "embedded" | "off" = "off";
+	let layoutRow: DoctorFinding = {
+		ok: true,
+		name: "panes layout",
+		detail: "off",
+	};
+	try {
+		const panes = readSettings().interface.panes;
+		enabled = panes.enabled;
+		if (panes.layout !== "off") {
+			layoutRow = {
+				ok: true,
+				name: "panes layout",
+				detail: `${panes.layout} at boot (workers dock ${(panes.workers.ratio * 100).toFixed(0)}%, files dock ${(panes.files.ratio * 100).toFixed(0)}%)`,
+			};
+		}
+	} catch {
+		// An unreadable settings file is already reported by the settings row;
+		// this section answers on the shipped default (off) rather than throwing.
+	}
+
+	// Inactive by choice is a different answer from unavailable. With the
+	// setting off, detection is skipped the same way the boot skips it, and the
+	// row names the two ways to turn the extension on instead of warning about
+	// a socket nobody asked for.
+	if (enabled === "off") {
+		return [
+			{
+				ok: true,
+				name: "panes mode",
+				detail: "off by choice",
+			},
+			layoutRow,
+		];
+	}
+
+	// Detection is the same ladder the interactive boot runs, so this row is the
+	// answer that boot would get. It opens a socket and nothing else: no file is
+	// created and no pane is touched.
+	const { detection, client } = await detectMux({ enabled, env });
+	const snapshot = client ? await client.snapshot().catch(() => null) : null;
+	await client?.close().catch(() => undefined);
+
+	const candidates = detection.candidates.length > 0 ? detection.candidates : resolveSocketCandidates(env);
+	const findings: DoctorFinding[] = [
+		{
+			ok: true,
+			level: detection.mode === "none" ? "warn" : "ok",
+			name: "panes mode",
+			detail: `${detection.mode} (panes.enabled=${enabled}); ${detection.reason}`,
+		},
+		{
+			ok: true,
+			level: detection.socketPath === null ? "warn" : "ok",
+			name: "panes socket",
+			detail:
+				detection.socketPath === null
+					? `no socket answered; tried ${candidates.length > 0 ? candidates.join(", ") : "no candidates"}`
+					: `${detection.socketPath} answered a ping`,
+		},
+	];
+
+	const server = detection.server;
+	findings.push({
+		ok: true,
+		level: server === null || server.protocol < REQUIRED_PROTOCOL ? "warn" : "ok",
+		name: "panes protocol",
+		detail:
+			server === null
+				? `unknown; Clio's optional methods need protocol ${REQUIRED_PROTOCOL} or newer`
+				: `server ${server.version}, protocol ${server.protocol}; Clio's optional methods need ${REQUIRED_PROTOCOL} (${server.protocol >= REQUIRED_PROTOCOL ? "satisfied" : "toasts and agent focus fall back"})`,
+	});
+
+	const entry = findPinnedTool(PANE_HOST_TOOL_ID);
+	findings.push(
+		entry === null
+			? {
+					ok: true,
+					level: "warn",
+					name: "panes binary",
+					detail: `${PANE_HOST_TOOL_ID} is not in the pinned tool registry`,
+				}
+			: {
+					ok: true,
+					level: toolStatus(entry).resolution.source === "none" ? "warn" : "ok",
+					name: "panes binary",
+					detail: describeResolution(toolStatus(entry)),
+				},
+	);
+
+	findings.push(layoutRow);
+	const legacyOwnedPanes =
+		snapshot?.panes.filter(
+			(pane) => pane.tokens.clio_owner === "clio:mux" && pane.tokens.clio_coder_owner !== "clio-coder:mux",
+		).length ?? 0;
+	const staleWatchTitles =
+		snapshot?.panes.filter(
+			(pane) =>
+				(pane.title === "clio watch" || pane.label === "clio watch") &&
+				(pane.tokens.clio_coder_owner === "clio-coder:mux" || pane.tokens.clio_owner === "clio:mux"),
+		).length ?? 0;
+	findings.push({
+		ok: true,
+		level: legacyOwnedPanes > 0 || staleWatchTitles > 0 ? "warn" : "ok",
+		name: "naming panes",
+		detail:
+			legacyOwnedPanes > 0 || staleWatchTitles > 0
+				? `${legacyOwnedPanes} panes carry only the legacy clio_owner=clio:mux token; ${staleWatchTitles} owned panes retain the stale 'clio watch' title; quit/cleanup recognizes both token schemes`
+				: "no legacy Clio Coder pane ownership tokens or watch titles found",
+	});
+	findings.push(journalWritabilityFinding());
+	return findings;
+}

package/src/cli/doctor-toolchain.ts

@@ -0,0 +1,78 @@
+import type { DoctorFinding } from "../domains/lifecycle/doctor.js";
+import {
+	describeYaziProfile,
+	inspectCurrentYaziProfile,
+	userYaziConfigDir,
+	yaziProfileDir,
+} from "../domains/mux/index.js";
+import { describeResolution, toolStatuses } from "../domains/toolchain/index.js";
+
+export interface ToolchainFindingOptions {
+	panesEnabled?: boolean;
+	filesEnabled?: boolean;
+}
+
+function yaziProfileFinding(enabled: boolean): DoctorFinding {
+	if (!enabled) {
+		return {
+			ok: true,
+			name: "yazi managed profile",
+			detail: "disabled by settings",
+		};
+	}
+	try {
+		const profile = inspectCurrentYaziProfile();
+		return {
+			ok: true,
+			name: "yazi managed profile",
+			detail: describeYaziProfile(profile),
+			level: profile.state === "current" ? "ok" : "warn",
+		};
+	} catch (error) {
+		return {
+			ok: true,
+			name: "yazi managed profile",
+			level: "warn",
+			detail: `${yaziProfileDir()} could not be inspected (${error instanceof Error ? error.message : String(error)}); user config ${userYaziConfigDir()} is separate and untouched`,
+		};
+	}
+}
+
+/**
+ * One row per pinned external tool: where it resolves, and how the version
+ * found compares to the pin.
+ *
+ * Every one of these tools is optional, so no row is ever an error. A missing
+ * tool is a WARN with the command that installs it, because doctor's exit code
+ * answers "is this Clio install healthy", and an operator who never wanted
+ * panes has a healthy install without them.
+ *
+ * A PATH copy Clio rejected for being below the registry floor is never
+ * reported as an absent one. The row says which binary was found, what version
+ * it reported, and which floor it missed, and adds the install command only
+ * when there is no vendored copy already answering for the tool. Doctor is the
+ * surface an operator reaches for when a tool they installed themselves is not
+ * being used, and a row that only said "not found" would send them looking for
+ * a binary that is right there on their PATH.
+ */
+export function toolchainFindings(options: ToolchainFindingOptions = {}): DoctorFinding[] {
+	const panesEnabled = options.panesEnabled ?? true;
+	const filesEnabled = options.filesEnabled ?? true;
+	const tools = toolStatuses().map((status) => ({
+		ok: true,
+		name: `external tool ${status.id}`,
+		// Active integrations share the tools-status resolution sentence. Disabled
+		// experimental integrations stay neutral and do not advertise setup work.
+		detail:
+			(status.id === "herdr" && !panesEnabled) || (status.id === "yazi" && !filesEnabled)
+				? "experimental integration disabled by settings"
+				: describeResolution(status),
+		level:
+			(status.id === "herdr" && !panesEnabled) || (status.id === "yazi" && !filesEnabled)
+				? ("ok" as const)
+				: status.resolution.source === "none"
+					? ("warn" as const)
+					: ("ok" as const),
+	}));
+	return [...tools, yaziProfileFinding(filesEnabled)];
+}

package/src/cli/doctor.ts

@@ -1,3 +1,4 @@
+import { readSettings } from "../core/config.js";
 import {
 	formatDoctorReport,
 	isUninitializedHome,
@@ -7,7 +8,10 @@ import {
 	runDoctorModelChecks,
 	runDoctorRuntimeChecks,
 } from "../domains/lifecycle/doctor.js";
+import { namingFootprintFindings } from "./doctor-naming.js";
+import { panesFindings } from "./doctor-panes.js";
 import { stateStorageFinding } from "./doctor-state-size.js";
+import { toolchainFindings } from "./doctor-toolchain.js";
 import { printError } from "./shared.js";
 
 const HELP = `clio-coder doctor [--fix] [--json]
@@ -36,6 +40,16 @@ export async function runDoctorCommand(args: ReadonlyArray<string> = []): Promis
 	// gets every check on the home it just built.
 	const untouched = !fix && isUninitializedHome();
 	const findings = runDoctor({ fix });
+	let panesEnabled = false;
+	let filesEnabled = false;
+	try {
+		const panes = readSettings().interface.panes;
+		panesEnabled = panes.enabled !== "off";
+		filesEnabled = panesEnabled && panes.files.enabled;
+	} catch {
+		// The settings finding already reports an unreadable document. Optional
+		// integrations stay inactive rather than adding secondary warnings.
+	}
 	const storageChecks = untouched ? [] : [stateStorageFinding()];
 	const runtimeChecks = await runDoctorRuntimeChecks();
 	// Every model pointer is checked against what its target advertises, so a
@@ -49,7 +63,26 @@ export async function runDoctorCommand(args: ReadonlyArray<string> = []): Promis
 	// Fleet preflight probes each configured node over SSH and persists the
 	// per-node eligibility verdicts dispatch placement enforces.
 	const fleetChecks = untouched ? [] : await runDoctorFleetChecks();
-	const all = [...findings, ...storageChecks, ...runtimeChecks, ...modelChecks, ...interopChecks, ...fleetChecks];
+	// Resolution reads PATH and the vendor root and creates nothing, but on an
+	// untouched home there is no vendor root to look at and the answer would be
+	// "none" for every row regardless, so the sweep stays with the others.
+	const toolChecks = untouched ? [] : toolchainFindings({ panesEnabled, filesEnabled });
+	// The pane sweep pings a socket and reads PATH; it creates nothing except the
+	// journal directory it is asked about, which is inside the state root doctor
+	// has already agreed not to build on an untouched home.
+	const paneChecks = untouched ? [] : await panesFindings();
+	const namingChecks = namingFootprintFindings({ fix, yaziEnabled: filesEnabled });
+	const all = [
+		...findings,
+		...storageChecks,
+		...runtimeChecks,
+		...modelChecks,
+		...interopChecks,
+		...fleetChecks,
+		...toolChecks,
+		...paneChecks,
+		...namingChecks,
+	];
 	const ok = all.every((f) => f.ok);
 	if (json) {
 		process.stdout.write(`${JSON.stringify({ ok, fix, findings: all }, null, 2)}\n`);