@iowarp/clio-coder 0.4.0 → 0.4.2

package/src/domains/extensions/types.ts

@@ -27,6 +27,19 @@ export interface ExtensionDiagnostic {
 	path?: string;
 }
 
+export interface ExtensionProvenance {
+	id: string;
+	scope: ExtensionScope;
+	/** Path recorded in install state, when known. */
+	sourcePath?: string;
+	/** Canonical filesystem identity of the installed package root. */
+	canonicalRoot: string;
+	/** SHA-256 of the manifest bytes covered by the installed-tree digest. */
+	manifestDigest: string;
+	/** Installed-tree digest recorded at install and reverified on this load. */
+	contentDigest: string;
+}
+
 export interface InstalledExtension {
 	id: string;
 	name: string;
@@ -36,14 +49,28 @@ export interface InstalledExtension {
 	rootPath: string;
 	manifestPath: string;
 	enabled: boolean;
+	/** Whether the complete manifest and declared resource tree are valid. */
+	valid: boolean;
 	/** Whether this package admits the running Clio version. */
 	compatible: boolean;
 	effective: boolean;
+	/** The single admission decision for extension-owned resources and hooks. */
+	loadable: boolean;
+	/** Present exactly when the installed tree and manifest bytes were reverified. */
+	provenance?: ExtensionProvenance;
+	/** Digest observed while checking installed content on this load. */
+	observedContentDigest?: string;
 	resources: ExtensionManifestResources;
 	overriddenBy?: ExtensionScope;
 	diagnostics: ExtensionDiagnostic[];
 }
 
+export type LoadableExtension = InstalledExtension & { loadable: true; provenance: ExtensionProvenance };
+
+export function isLoadableExtension(entry: InstalledExtension): entry is LoadableExtension {
+	return entry.loadable && entry.provenance !== undefined;
+}
+
 export interface ExtensionCandidate {
 	path: string;
 	manifestPath?: string;
@@ -58,8 +85,88 @@ export interface ExtensionResourceRoot {
 	path: string;
 	rootPath: string;
 	source: string;
+	provenance: ExtensionProvenance;
+	/** Zero denotes an ephemeral, uncommitted projection. */
+	generation: number;
+}
+
+export interface ExtensionHookSource {
+	provenance: ExtensionProvenance;
+	/** SHA-256 of the captured hooks.yaml bytes. */
+	declarationsDigest: string;
+	/** Parsed captured YAML, or an empty list when parsing failed. */
+	declarations: unknown;
+	parseError?: string;
 }
 
+export interface ExtensionSnapshotDiagnostics {
+	entries: ReadonlyArray<ExtensionDiagnostic & { extensionId?: string }>;
+	truncated: number;
+}
+
+export interface ExtensionSnapshot {
+	version: 1;
+	generation: number;
+	cwd: string;
+	builtAt: string;
+	/** Content identity; generation, timestamp, and diagnostic text are excluded. */
+	digest: string;
+	packages: ReadonlyArray<InstalledExtension>;
+	resourceRoots: Readonly<Record<ExtensionResourceKind, ReadonlyArray<ExtensionResourceRoot>>>;
+	hookSources: ReadonlyArray<ExtensionHookSource>;
+	diagnostics: ExtensionSnapshotDiagnostics;
+}
+
+export type ExtensionReloadRejectionReason = "build-failed" | "reentrant" | "stale" | "workspace-changed";
+
+export interface ExtensionReloadRejection {
+	status: "rejected";
+	reason: ExtensionReloadRejectionReason;
+	/** Generation that remains committed. */
+	generation: number;
+	diagnostics: ExtensionSnapshotDiagnostics;
+}
+
+/**
+ * A fully built and validated generation that has not been published. The
+ * bundle holds at most one candidate at a time. `publish` is one reference
+ * assignment that never validates, refuses, throws, or calls out; the caller
+ * checks `current()` on the same stack immediately before it. `discard`
+ * releases the candidate without any visible change.
+ */
+export interface ExtensionReloadCandidate {
+	generation: number;
+	previousGeneration: number;
+	snapshot: ExtensionSnapshot;
+	/** False when the candidate digest equals the committed digest. */
+	changed: boolean;
+	added: ReadonlyArray<string>;
+	removed: ReadonlyArray<string>;
+	modified: ReadonlyArray<string>;
+	/** True while this is the in-flight candidate and the committed snapshot it was diffed against is still live. */
+	current(): boolean;
+	publish(): void;
+	discard(): void;
+}
+
+export type ExtensionReloadPrepareResult =
+	| { status: "prepared"; candidate: ExtensionReloadCandidate }
+	| ExtensionReloadRejection;
+
+export interface ExtensionReloadCommitted {
+	status: "committed";
+	generation: number;
+	previousGeneration: number;
+	changed: boolean;
+	digest: string;
+	added: ReadonlyArray<string>;
+	removed: ReadonlyArray<string>;
+	modified: ReadonlyArray<string>;
+	diagnostics: ExtensionSnapshotDiagnostics;
+}
+
+export type ExtensionReloadResult = ExtensionReloadCommitted | ExtensionReloadRejection;
+
 export interface ExtensionListOptions {
 	scope?: ExtensionScope;
 	cwd?: string;
@@ -72,17 +179,27 @@ export interface ExtensionInstallOptions extends ExtensionListOptions {
 
 export interface ExtensionInstallResult {
 	extension?: InstalledExtension;
+	recovery?: { stateBackup?: string; packageBackup?: string };
 	diagnostics: ExtensionDiagnostic[];
 }
 
 export interface ExtensionMutationResult {
 	extension?: InstalledExtension;
 	removed?: { id: string; scope: ExtensionScope; path: string };
+	recovery?: { stateBackup?: string; packageBackup?: string };
 	diagnostics: ExtensionDiagnostic[];
 }
 
+export interface ExtensionStateUpgradeReport {
+	scope: ExtensionScope;
+	statePath: string;
+	backupPath?: string;
+	upgraded: string[];
+	refused: Array<{ id: string; reason: string }>;
+}
+
 export interface ExtensionState {
 	version: 1;
 	disabled: string[];
-	installed: Record<string, { installedAt: string; source?: string }>;
+	installed: Record<string, { installedAt: string; source?: string; contentDigest?: string }>;
 }

package/src/domains/interop/consent.ts

@@ -24,7 +24,7 @@ export const INHERITED_PROJECT_CONTEXT = "none";
 /** The delegation entry a given agent kind would be wired as. */
 export function delegationEntryForKind(
 	kind: InteropAgentKind,
-	defaults: ClioSettings["delegation"]["defaults"],
+	defaults: ClioSettings["integrations"]["externalAgents"]["defaults"],
 ): DelegationAgentConfig {
 	const recipe = kind.acp;
 	if (recipe === undefined) throw new Error(`interop kind ${kind.id} has no ACP recipe`);
@@ -35,7 +35,7 @@ export function delegationEntryForKind(
 		connectTimeoutMs: defaults.connectTimeoutMs,
 		turnTimeoutMs: defaults.turnTimeoutMs,
 		permissionTimeoutMs: defaults.permissionTimeoutMs,
-		toolGovernance: "clio-policy",
+		toolGovernance: "clio-coder-policy",
 	};
 }
 
@@ -45,7 +45,7 @@ export function delegationEntryForKind(
  * declined agent whose binary or version moved comes back as a fresh proposal.
  */
 export function interopProposals(report: InteropReport, settings: ClioSettings): ReadonlyArray<InteropProposal> {
-	const configured = new Set(settings.delegation.agents.map((agent) => agent.id));
+	const configured = new Set(settings.integrations.externalAgents.entries.map((agent) => agent.id));
 	const proposals: InteropProposal[] = [];
 	for (const record of report.agents) {
 		const kind = interopAgentKind(record.kind);
@@ -57,7 +57,7 @@ export function interopProposals(report: InteropReport, settings: ClioSettings):
 			kind: kind.id,
 			label: kind.label,
 			fingerprint: record.fingerprint,
-			entry: delegationEntryForKind(kind, settings.delegation.defaults),
+			entry: delegationEntryForKind(kind, settings.integrations.externalAgents.defaults),
 			needsNetworkInstall: record.adapter !== "present",
 		});
 	}
@@ -149,7 +149,7 @@ export function interopBootHint(report: InteropReport, settings: ClioSettings):
 		(record) => ({ ...record, hintedFingerprint: record.fingerprint }),
 	);
 	const names = fresh.map((proposal) => proposal.entry.id).join(", ");
-	return `clio: ${names} detected on PATH and not configured. Run /interop to review.`;
+	return `clio-coder: ${names} detected on PATH and not configured. Run /interop to review.`;
 }
 
 /**
@@ -167,8 +167,8 @@ export function acceptInteropAgents(ids: ReadonlyArray<InteropAgentId>, report:
 	const wired: string[] = [];
 	updateSettings((settings) => {
 		for (const proposal of proposals) {
-			if (settings.delegation.agents.some((agent) => agent.id === proposal.entry.id)) continue;
-			settings.delegation.agents.push({ ...proposal.entry, args: [...proposal.entry.args] });
+			if (settings.integrations.externalAgents.entries.some((agent) => agent.id === proposal.entry.id)) continue;
+			settings.integrations.externalAgents.entries.push({ ...proposal.entry, args: [...proposal.entry.args] });
 			wired.push(proposal.entry.id);
 		}
 	});

package/src/domains/interop/extension.ts

@@ -39,7 +39,7 @@ export function createInteropBundle(_context: DomainContext): DomainBundle<Inter
 		// from the proposals, which read the file, and not yet in the configured
 		// list, which read the snapshot, so it was in neither until a reopen.
 		configured() {
-			return readSettings().delegation.agents;
+			return readSettings().integrations.externalAgents.entries;
 		},
 		accept(ids) {
 			const result = acceptInteropAgents(ids, detected ?? readInteropReport() ?? EMPTY_REPORT);

package/src/domains/lifecycle/doctor.ts

@@ -491,7 +491,7 @@ export async function runDoctorFleetChecks(projectRoot: string = process.cwd()):
 	}
 	const nodes = settings.fleet?.nodes ?? [];
 	if (nodes.length === 0) return [];
-	const { recordFleetPreflight, runFleetNodePreflight } = await import("../dispatch/fleet-preflight.js");
+	const { runFleetNodePreflight } = await import("../dispatch/fleet-preflight.js");
 	// Endpoint facts are per node. Every configured target is probed from every
 	// node, because a `localhost` URL names a different machine on each one and
 	// an orchestrator-side probe would describe none of them.
@@ -502,12 +502,6 @@ export async function runDoctorFleetChecks(projectRoot: string = process.cwd()):
 		...(target.defaultModel !== undefined ? { wireModelId: target.defaultModel } : {}),
 	}));
 	const records = await Promise.all(nodes.map((node) => runFleetNodePreflight(node, projectRoot, { targets })));
-	try {
-		recordFleetPreflight(records);
-	} catch {
-		// The findings below still tell the operator what happened; a store
-		// write failure just means placement will keep denying these nodes.
-	}
 	return records.map((record) => ({
 		ok: true,
 		level: record.ok ? "ok" : "warn",
@@ -533,14 +527,26 @@ export async function runDoctorInteropChecks(projectRoot: string = process.cwd()
 	} catch {
 		return [];
 	}
-	const skills = loadSkills({ cwd: projectRoot });
+	const configDir = resolveClioDirs().config;
+	// Extension discovery resolves through the ensuring config accessor. With no
+	// config root there cannot be user Clio extensions or skills to inspect, so
+	// keep the broken partial home untouched and retain the binary checks below.
+	const skills = existsSync(configDir) ? loadSkills({ cwd: projectRoot, configDir }) : { items: [], diagnostics: [] };
 	const foreign = skills.items.filter((skill) => FOREIGN_SKILL_SOURCES.has(skill.source));
-	const report = await detectInteropAgents({
-		cwd: projectRoot,
-		probeVersion: true,
-		skillSources: skills.items.map((skill) => skill.source),
-	});
-	const configured = new Set(settings.delegation.agents.map((agent) => agent.id));
+	const report = await detectInteropAgents(
+		{
+			cwd: projectRoot,
+			// Version probes use the shared command runner, which prepares managed Git
+			// hooks before spawning. Doctor promises observation only, so PATH presence
+			// is the strongest safe fact here.
+			probeVersion: false,
+			skillSources: skills.items.map((skill) => skill.source),
+		},
+		// Reading the prior report resolves through the ensuring state accessor.
+		// Existing decisions are irrelevant to doctor's presence-only projection.
+		[],
+	);
+	const configured = new Set(settings.integrations.externalAgents.entries.map((agent) => agent.id));
 	const findings: DoctorFinding[] = report.agents.map((agent) => {
 		const kind = interopAgentKind(agent.kind);
 		const status = configured.has(agent.kind)
@@ -557,7 +563,7 @@ export async function runDoctorInteropChecks(projectRoot: string = process.cwd()
 					: "";
 		return { ok: true, level: "ok", name: `interop ${agent.kind}`, detail: `${head} (${status})${where}` };
 	});
-	for (const agent of settings.delegation.agents) {
+	for (const agent of settings.integrations.externalAgents.entries) {
 		if (resolveOnPath([agent.command]).presence === "present") continue;
 		findings.push({
 			ok: true,
@@ -618,14 +624,14 @@ function configuredModelRoles(
 ): ConfiguredModelRole[] {
 	const roles: ConfiguredModelRole[] = [];
 	if (target.defaultModel) roles.push({ role: "defaultModel", model: target.defaultModel });
-	if (settings.orchestrator.target === target.id && settings.orchestrator.model) {
-		roles.push({ role: "orchestrator.model", model: settings.orchestrator.model });
+	if (settings.chat.target === target.id && settings.chat.model) {
+		roles.push({ role: "orchestrator.model", model: settings.chat.model });
 	}
-	if (settings.background.target === target.id && settings.background.model) {
-		roles.push({ role: "background.model", model: settings.background.model });
+	if (settings.context.memory.target === target.id && settings.context.memory.model) {
+		roles.push({ role: "background.model", model: settings.context.memory.model });
 	}
-	if (settings.workers.default.target === target.id && settings.workers.default.model) {
-		roles.push({ role: "workers.default.model", model: settings.workers.default.model });
+	if (settings.fleet.default.target === target.id && settings.fleet.default.model) {
+		roles.push({ role: "workers.default.model", model: settings.fleet.default.model });
 	}
 	return roles;
 }

package/src/domains/lifecycle/migrations/2026-09-01-clio-coder-naming.ts

@@ -0,0 +1,155 @@
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+import { settingsPath, withSettingsLock } from "../../../core/config.js";
+import { safeResourceWrite } from "../../../core/safe-resource-write.js";
+import { type MutableNamingStateReport, migrateMutableNamingState } from "../naming-mutable-state.js";
+import { inspectInstalledNamingResources, type NamingResourceReport } from "../naming-resources.js";
+import { inspectToolMarkerNaming, type ToolMarkerNamingReport } from "../naming-tool-markers.js";
+import { regenerateYaziNamingProfile, type YaziNamingRegenerationReport } from "../naming-yazi.js";
+import type { Migration } from "./index.js";
+
+export const CLIO_CODER_NAMING_MIGRATION_ID = "2026-09-01-clio-coder-naming";
+export const CLIO_CODER_NAMING_SETTINGS_BACKUP_SUFFIX = ".pre-clio-coder-naming.bak";
+
+export interface NamingSettingsTransform {
+	document: Record<string, unknown>;
+	replacements: string[];
+	conflicts: string[];
+}
+
+export interface NamingSettingsFileReport {
+	path: string;
+	changed: boolean;
+	backupPath: string | null;
+	replacements: string[];
+	conflicts: string[];
+}
+
+export interface ClioCoderNamingMigrationReport {
+	migrationId: typeof CLIO_CODER_NAMING_MIGRATION_ID;
+	version: 1;
+	settings: NamingSettingsFileReport[];
+	toolMarkers: ToolMarkerNamingReport[];
+	resources: NamingResourceReport[];
+	yazi: YaziNamingRegenerationReport[];
+	mutableState: MutableNamingStateReport[];
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function visitNamingValues(value: unknown, path: string, replacements: string[], conflicts: string[]): void {
+	if (Array.isArray(value)) {
+		for (const [index, entry] of value.entries()) visitNamingValues(entry, `${path}[${index}]`, replacements, conflicts);
+		return;
+	}
+	if (!isPlainObject(value)) return;
+
+	for (const [key, entry] of Object.entries(value)) {
+		const entryPath = path ? `${path}.${key}` : key;
+		if (key === "lifecycle" && entry === "clio-managed") {
+			value[key] = "clio-coder-managed";
+			replacements.push(`${entryPath}: clio-managed -> clio-coder-managed`);
+			continue;
+		}
+		if (key === "toolGovernance" && entry === "clio-policy") {
+			value[key] = "clio-coder-policy";
+			replacements.push(`${entryPath}: clio-policy -> clio-coder-policy`);
+			continue;
+		}
+		if (key === "keybindings" && isPlainObject(entry)) {
+			for (const legacyKey of Object.keys(entry).filter((name) => name.startsWith("clio."))) {
+				const canonicalKey = `clio-coder.${legacyKey.slice("clio.".length)}`;
+				const legacyPath = `${entryPath}.${legacyKey}`;
+				if (Object.hasOwn(entry, canonicalKey)) {
+					delete entry[legacyKey];
+					conflicts.push(`${legacyPath}: discarded because canonical ${entryPath}.${canonicalKey} wins`);
+					continue;
+				}
+				entry[canonicalKey] = entry[legacyKey];
+				delete entry[legacyKey];
+				replacements.push(`${legacyPath} -> ${entryPath}.${canonicalKey}`);
+			}
+		}
+		visitNamingValues(entry, entryPath, replacements, conflicts);
+	}
+}
+
+/** Pure deterministic settings transform shared by upgrade and doctor --fix. */
+export function transformNamingSettingsDocument(raw: unknown): NamingSettingsTransform {
+	if (!isPlainObject(raw)) throw new Error("Clio Coder naming migration expected a YAML map at the document root");
+	const document = structuredClone(raw);
+	const replacements: string[] = [];
+	const conflicts: string[] = [];
+	visitNamingValues(document, "", replacements, conflicts);
+	return { document, replacements, conflicts };
+}
+
+/**
+ * Rewrite one settings file atomically when it contains deterministic released
+ * aliases. The caller owns any cross-process lock needed for the selected file.
+ */
+export function migrateNamingSettingsFile(path: string): NamingSettingsFileReport {
+	if (!existsSync(path)) return { path, changed: false, backupPath: null, replacements: [], conflicts: [] };
+	let parsed: unknown;
+	try {
+		parsed = parseYaml(readFileSync(path, "utf8"));
+	} catch (error) {
+		throw new Error(
+			`Clio Coder naming migration could not read and parse ${path}: ${error instanceof Error ? error.message : String(error)}`,
+		);
+	}
+	const transformed = transformNamingSettingsDocument(parsed);
+	const changed = transformed.replacements.length > 0 || transformed.conflicts.length > 0;
+	if (!changed) {
+		return {
+			path,
+			changed: false,
+			backupPath: null,
+			replacements: transformed.replacements,
+			conflicts: transformed.conflicts,
+		};
+	}
+	const backupPath = `${path}${CLIO_CODER_NAMING_SETTINGS_BACKUP_SUFFIX}`;
+	safeResourceWrite(path, stringifyYaml(transformed.document), {
+		encoding: "utf8",
+		mode: 0o644,
+		backup: { path: backupPath },
+	});
+	return {
+		path,
+		changed: true,
+		backupPath,
+		replacements: transformed.replacements,
+		conflicts: transformed.conflicts,
+	};
+}
+
+function namingMigrationReportPath(stateDir: string): string {
+	return join(stateDir, "migration-reports", `${CLIO_CODER_NAMING_MIGRATION_ID}.json`);
+}
+
+const migration: Migration = {
+	id: CLIO_CODER_NAMING_MIGRATION_ID,
+	async up(stateDir: string): Promise<void> {
+		const settings: NamingSettingsFileReport[] = [];
+		withSettingsLock(() => settings.push(migrateNamingSettingsFile(settingsPath())));
+		const report: ClioCoderNamingMigrationReport = {
+			migrationId: CLIO_CODER_NAMING_MIGRATION_ID,
+			version: 1,
+			settings,
+			toolMarkers: inspectToolMarkerNaming({ fix: true }),
+			resources: inspectInstalledNamingResources({ fix: true }),
+			yazi: [regenerateYaziNamingProfile()],
+			mutableState: migrateMutableNamingState(stateDir),
+		};
+		const target = namingMigrationReportPath(stateDir);
+		mkdirSync(join(stateDir, "migration-reports"), { recursive: true });
+		safeResourceWrite(target, `${JSON.stringify(report, null, 2)}\n`, { encoding: "utf8", mode: 0o644 });
+	},
+};
+
+export default migration;

package/src/domains/lifecycle/migrations/2026-09-01-extension-install-digests.ts

@@ -0,0 +1,27 @@
+import { mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { safeResourceWrite } from "../../../core/safe-resource-write.js";
+import { upgradeLegacyExtensionInstallState } from "../../extensions/state.js";
+import type { Migration } from "./index.js";
+
+export const EXTENSION_INSTALL_DIGESTS_MIGRATION_ID = "2026-09-01-extension-install-digests";
+
+function migrateExtensionInstallDigests(stateDir: string, cwd = process.cwd()): void {
+	const scopes = upgradeLegacyExtensionInstallState(cwd);
+	const reportDir = join(stateDir, "migration-reports");
+	mkdirSync(reportDir, { recursive: true });
+	safeResourceWrite(
+		join(reportDir, `${EXTENSION_INSTALL_DIGESTS_MIGRATION_ID}.json`),
+		`${JSON.stringify({ migration: EXTENSION_INSTALL_DIGESTS_MIGRATION_ID, scopes }, null, 2)}\n`,
+		{ encoding: "utf8", mode: 0o644 },
+	);
+}
+
+const migration: Migration = {
+	id: EXTENSION_INSTALL_DIGESTS_MIGRATION_ID,
+	async up(stateDir: string): Promise<void> {
+		migrateExtensionInstallDigests(stateDir);
+	},
+};
+
+export default migration;

package/src/domains/lifecycle/migrations/2026-09-01-retire-panes-knobs.ts

@@ -0,0 +1,59 @@
+import { existsSync, readFileSync } from "node:fs";
+
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+import { settingsPath, withSettingsLock } from "../../../core/config.js";
+import { safeResourceWrite } from "../../../core/safe-resource-write.js";
+import type { Migration } from "./index.js";
+
+/**
+ * `panes.agents` and `panes.keepFailed` are retired, and the schema refuses
+ * them by name rather than ignoring them. That refusal is right for a file
+ * written today and wrong as an upgrade experience: an operator whose settings
+ * predate 0.4.0 did nothing but keep a key two releases honored, and the first
+ * thing the new version would do is refuse to start.
+ *
+ * This is the sanctioned exception the settings lock exists for. It cannot go
+ * through `readSettings` or `updateSettings`, because those run the strict
+ * validator that rejects exactly the keys being removed, so it reads and writes
+ * the raw document under the same lock every other writer takes.
+ */
+const RETIRED_PANE_KEYS = ["agents", "keepFailed"] as const;
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+const migration: Migration = {
+	id: "2026-09-01-retire-panes-knobs",
+	async up(): Promise<void> {
+		withSettingsLock(() => {
+			const path = settingsPath();
+			if (!existsSync(path)) return;
+			let parsed: unknown;
+			try {
+				parsed = parseYaml(readFileSync(path, "utf8"));
+			} catch {
+				// A document this cannot parse is one it must not rewrite: writing a
+				// re-serialized guess over an operator's malformed or transiently
+				// unreadable file would destroy the original they still have to fix.
+				// The strict reader already names the syntax error on the next boot.
+				return;
+			}
+			if (!isPlainObject(parsed)) return;
+			const panes = parsed.panes;
+			if (!isPlainObject(panes)) return;
+			const present = RETIRED_PANE_KEYS.filter((key) => key in panes);
+			// Rewriting is not free: the document is re-serialized from the parse, so
+			// comments and formatting the operator wrote do not survive. A file that
+			// never named these keys must therefore never be touched.
+			if (present.length === 0) return;
+			for (const key of present) delete panes[key];
+			// A `panes` map that held nothing but the retired knobs is left naming no
+			// setting at all, so it goes with them rather than staying as `panes: {}`.
+			if (Object.keys(panes).length === 0) delete parsed.panes;
+			safeResourceWrite(path, stringifyYaml(parsed), { encoding: "utf8", mode: 0o644 });
+		});
+	},
+};
+
+export default migration;