@pixelzx/genesis 2026.5.5-3 → 2026.5.5-4

package/dist/doctor-health-contributions-CGMp0dRt.js

@@ -0,0 +1,486 @@
+import fs from "node:fs";
+//#region src/flows/doctor-health-contributions.ts
+function resolveDoctorMode(cfg) {
+	return cfg.gateway?.mode === "remote" ? "remote" : "local";
+}
+function createDoctorHealthContribution(params) {
+	return {
+		id: params.id,
+		kind: "core",
+		surface: "health",
+		option: {
+			value: params.id,
+			label: params.label,
+			...params.hint ? { hint: params.hint } : {}
+		},
+		source: "doctor",
+		run: params.run
+	};
+}
+async function runGatewayConfigHealth(ctx) {
+	const { formatCliCommand } = await import("./command-format-BAulzC9p.js");
+	const { hasAmbiguousGatewayAuthModeConfig } = await import("./auth-mode-policy-BbTQwce8.js");
+	const { note } = await import("./note-DzYNWGih.js");
+	if (!ctx.cfg.gateway?.mode) {
+		const lines = [
+			"gateway.mode is unset; gateway start will be blocked.",
+			`Fix: run ${formatCliCommand("genesis configure")} and set Gateway mode (local/remote).`,
+			`Or set directly: ${formatCliCommand("genesis config set gateway.mode local")}`
+		];
+		if (!fs.existsSync(ctx.configPath)) lines.push(`Missing config: run ${formatCliCommand("genesis setup")} first.`);
+		note(lines.join("\n"), "Gateway");
+	}
+	if (resolveDoctorMode(ctx.cfg) === "local" && hasAmbiguousGatewayAuthModeConfig(ctx.cfg)) note([
+		"gateway.auth.token and gateway.auth.password are both configured while gateway.auth.mode is unset.",
+		"Set an explicit mode to avoid ambiguous auth selection and startup/runtime failures.",
+		`Set token mode: ${formatCliCommand("genesis config set gateway.auth.mode token")}`,
+		`Set password mode: ${formatCliCommand("genesis config set gateway.auth.mode password")}`
+	].join("\n"), "Gateway auth");
+}
+async function runAuthProfileHealth(ctx) {
+	const { maybeRepairLegacyOAuthProfileIds } = await import("./doctor-auth-legacy-oauth-C2ojfRvc.js");
+	const { noteAuthProfileHealth, noteLegacyCodexProviderOverride } = await import("./doctor-auth-CqdmPgiK.js");
+	const { buildGatewayConnectionDetails } = await import("./call-qzfm6lro.js");
+	const { note } = await import("./note-DzYNWGih.js");
+	ctx.cfg = await maybeRepairLegacyOAuthProfileIds(ctx.cfg, ctx.prompter);
+	await noteAuthProfileHealth({
+		cfg: ctx.cfg,
+		prompter: ctx.prompter,
+		allowKeychainPrompt: ctx.options.nonInteractive !== true && process.stdin.isTTY
+	});
+	noteLegacyCodexProviderOverride(ctx.cfg);
+	ctx.gatewayDetails = buildGatewayConnectionDetails({ config: ctx.cfg });
+	if (ctx.gatewayDetails.remoteFallbackNote) note(ctx.gatewayDetails.remoteFallbackNote, "Gateway");
+}
+async function runGatewayAuthHealth(ctx) {
+	const { resolveSecretInputRef } = await import("./types.secrets-CciGbG83.js");
+	const { resolveGatewayAuth } = await import("./auth-D-EZ46P-.js");
+	const { note } = await import("./note-DzYNWGih.js");
+	const { randomToken } = await import("./onboard-helpers-Cc2AnoIU.js");
+	if (resolveDoctorMode(ctx.cfg) !== "local" || !ctx.sourceConfigValid) return;
+	const gatewayTokenRef = resolveSecretInputRef({
+		value: ctx.cfg.gateway?.auth?.token,
+		defaults: ctx.cfg.secrets?.defaults
+	}).ref;
+	const auth = resolveGatewayAuth({
+		authConfig: ctx.cfg.gateway?.auth,
+		tailscaleMode: ctx.cfg.gateway?.tailscale?.mode ?? "off"
+	});
+	if (!(auth.mode !== "password" && auth.mode !== "none" && auth.mode !== "trusted-proxy" && (auth.mode !== "token" || !auth.token))) return;
+	if (gatewayTokenRef) {
+		note([
+			"Gateway token is managed via SecretRef and is currently unavailable.",
+			"Doctor will not overwrite gateway.auth.token with a plaintext value.",
+			"Resolve/rotate the external secret source, then rerun doctor."
+		].join("\n"), "Gateway auth");
+		return;
+	}
+	note("Gateway auth is off or missing a token. Token auth is now the recommended default (including loopback).", "Gateway auth");
+	if (!(ctx.options.generateGatewayToken === true ? true : ctx.options.nonInteractive === true ? false : await ctx.prompter.confirmAutoFix({
+		message: "Generate and configure a gateway token now?",
+		initialValue: true
+	}))) return;
+	const nextToken = randomToken();
+	ctx.cfg = {
+		...ctx.cfg,
+		gateway: {
+			...ctx.cfg.gateway,
+			auth: {
+				...ctx.cfg.gateway?.auth,
+				mode: "token",
+				token: nextToken
+			}
+		}
+	};
+	note("Gateway token configured.", "Gateway auth");
+}
+async function runClaudeCliHealth(ctx) {
+	const { noteClaudeCliHealth } = await import("./doctor-claude-cli-B6pnkFEn.js");
+	noteClaudeCliHealth(ctx.cfg);
+}
+async function runLegacyStateHealth(ctx) {
+	const { detectLegacyStateMigrations, runLegacyStateMigrations } = await import("./doctor-state-migrations-DgYUKVNF.js");
+	const { note } = await import("./note-DzYNWGih.js");
+	const legacyState = await detectLegacyStateMigrations({ cfg: ctx.cfg });
+	if (legacyState.preview.length === 0) return;
+	note(legacyState.preview.join("\n"), "Legacy state detected");
+	if (!(ctx.options.nonInteractive === true ? true : await ctx.prompter.confirm({
+		message: "Migrate legacy state (sessions/agent/WhatsApp auth) now?",
+		initialValue: true
+	}))) return;
+	const migrated = await runLegacyStateMigrations({ detected: legacyState });
+	if (migrated.changes.length > 0) note(migrated.changes.join("\n"), "Doctor changes");
+	if (migrated.warnings.length > 0) note(migrated.warnings.join("\n"), "Doctor warnings");
+}
+async function runLegacyPluginManifestHealth(ctx) {
+	const { maybeRepairLegacyPluginManifestContracts } = await import("./doctor-plugin-manifests-nv5c8vsh.js");
+	await maybeRepairLegacyPluginManifestContracts({
+		env: process.env,
+		runtime: ctx.runtime,
+		prompter: ctx.prompter
+	});
+}
+async function runBundledPluginRuntimeDepsHealth(ctx) {
+	const { maybeRepairBundledPluginRuntimeDeps } = await import("./doctor-bundled-plugin-runtime-deps-BHZzZsM4.js");
+	await maybeRepairBundledPluginRuntimeDeps({
+		runtime: ctx.runtime,
+		prompter: ctx.prompter,
+		config: ctx.cfg,
+		includeConfiguredChannels: true
+	});
+}
+async function runStateIntegrityHealth(ctx) {
+	const { noteStateIntegrity } = await import("./doctor-state-integrity-jbbt8OVU.js");
+	await noteStateIntegrity(ctx.cfg, ctx.prompter, ctx.configPath);
+}
+async function runSessionLocksHealth(ctx) {
+	const { noteSessionLockHealth } = await import("./doctor-session-locks-CYaHscyv.js");
+	await noteSessionLockHealth({ shouldRepair: ctx.prompter.shouldRepair });
+}
+async function runLegacyCronHealth(ctx) {
+	const { maybeRepairLegacyCronStore } = await import("./doctor-cron-D6zdpRVA.js");
+	await maybeRepairLegacyCronStore({
+		cfg: ctx.cfg,
+		options: ctx.options,
+		prompter: ctx.prompter
+	});
+}
+async function runSandboxHealth(ctx) {
+	const { maybeRepairSandboxImages, noteSandboxScopeWarnings } = await import("./doctor-sandbox-CNi6l2wR.js");
+	ctx.cfg = await maybeRepairSandboxImages(ctx.cfg, ctx.runtime, ctx.prompter);
+	noteSandboxScopeWarnings(ctx.cfg);
+}
+async function runGatewayServicesHealth(ctx) {
+	const { maybeRepairGatewayServiceConfig, maybeScanExtraGatewayServices } = await import("./doctor-gateway-services-ChajuYZL.js");
+	const { noteMacLaunchAgentOverrides, noteMacLaunchctlGatewayEnvOverrides } = await import("./doctor-platform-notes-BVMr2J02.js");
+	await maybeScanExtraGatewayServices(ctx.options, ctx.runtime, ctx.prompter);
+	await maybeRepairGatewayServiceConfig(ctx.cfg, resolveDoctorMode(ctx.cfg), ctx.runtime, ctx.prompter);
+	await noteMacLaunchAgentOverrides();
+	await noteMacLaunchctlGatewayEnvOverrides(ctx.cfg);
+}
+async function runStartupChannelMaintenanceHealth(ctx) {
+	const { maybeRunDoctorStartupChannelMaintenance } = await import("./doctor-startup-channel-maintenance-1qtGL60B.js");
+	await maybeRunDoctorStartupChannelMaintenance({
+		cfg: ctx.cfg,
+		env: process.env,
+		runtime: ctx.runtime,
+		shouldRepair: ctx.prompter.shouldRepair
+	});
+}
+async function runSecurityHealth(ctx) {
+	const { noteSecurityWarnings } = await import("./doctor-security-4aFTDiAv.js");
+	await noteSecurityWarnings(ctx.cfg);
+}
+async function runBrowserHealth(ctx) {
+	const { noteChromeMcpBrowserReadiness } = await import("./doctor-browser-BXaCNm13.js");
+	await noteChromeMcpBrowserReadiness(ctx.cfg);
+}
+async function runOpenAIOAuthTlsHealth(ctx) {
+	const { noteOpenAIOAuthTlsPrerequisites } = await import("./oauth-tls-preflight-D0FbO3vA.js");
+	await noteOpenAIOAuthTlsPrerequisites({
+		cfg: ctx.cfg,
+		deep: ctx.options.deep === true
+	});
+}
+async function runHooksModelHealth(ctx) {
+	if (!ctx.cfg.hooks?.gmail?.model?.trim()) return;
+	const { DEFAULT_MODEL, DEFAULT_PROVIDER } = await import("./defaults-Bg4-Ke4I.js");
+	const { loadModelCatalog } = await import("./model-catalog-S5TqfK9t.js");
+	const { getModelRefStatus, resolveConfiguredModelRef, resolveHooksGmailModel } = await import("./model-selection-C4mV44-W.js");
+	const { note } = await import("./note-DzYNWGih.js");
+	const hooksModelRef = resolveHooksGmailModel({
+		cfg: ctx.cfg,
+		defaultProvider: DEFAULT_PROVIDER
+	});
+	if (!hooksModelRef) {
+		note(`- hooks.gmail.model "${ctx.cfg.hooks.gmail.model}" could not be resolved`, "Hooks");
+		return;
+	}
+	const { provider: defaultProvider, model: defaultModel } = resolveConfiguredModelRef({
+		cfg: ctx.cfg,
+		defaultProvider: DEFAULT_PROVIDER,
+		defaultModel: DEFAULT_MODEL
+	});
+	const catalog = await loadModelCatalog({ config: ctx.cfg });
+	const status = getModelRefStatus({
+		cfg: ctx.cfg,
+		catalog,
+		ref: hooksModelRef,
+		defaultProvider,
+		defaultModel
+	});
+	const warnings = [];
+	if (!status.allowed) warnings.push(`- hooks.gmail.model "${status.key}" not in agents.defaults.models allowlist (will use primary instead)`);
+	if (!status.inCatalog) warnings.push(`- hooks.gmail.model "${status.key}" not in the model catalog (may fail at runtime)`);
+	if (warnings.length > 0) note(warnings.join("\n"), "Hooks");
+}
+async function runSystemdLingerHealth(ctx) {
+	if (ctx.options.nonInteractive === true || process.platform !== "linux" || resolveDoctorMode(ctx.cfg) !== "local") return;
+	const { resolveGatewayService } = await import("./service-fyUTnkAE.js");
+	const { ensureSystemdUserLingerInteractive } = await import("./systemd-linger-BAS2KLxe.js");
+	const { note } = await import("./note-DzYNWGih.js");
+	const service = resolveGatewayService();
+	let loaded = false;
+	try {
+		loaded = await service.isLoaded({ env: process.env });
+	} catch {
+		loaded = false;
+	}
+	if (!loaded) return;
+	await ensureSystemdUserLingerInteractive({
+		runtime: ctx.runtime,
+		prompter: {
+			confirm: async (p) => ctx.prompter.confirm(p),
+			note
+		},
+		reason: "Gateway runs as a systemd user service. Without lingering, systemd stops the user session on logout/idle and kills the Gateway.",
+		requireConfirm: true
+	});
+}
+async function runWorkspaceStatusHealth(ctx) {
+	const { noteWorkspaceStatus } = await import("./doctor-workspace-status-DL2fRPoT.js");
+	noteWorkspaceStatus(ctx.cfg);
+}
+async function runBootstrapSizeHealth(ctx) {
+	const { noteBootstrapFileSize } = await import("./doctor-bootstrap-size-C490XmUO.js");
+	await noteBootstrapFileSize(ctx.cfg);
+}
+async function runShellCompletionHealth(ctx) {
+	const { doctorShellCompletion } = await import("./doctor-completion-CTvvZMUY.js");
+	await doctorShellCompletion(ctx.runtime, ctx.prompter, { nonInteractive: ctx.options.nonInteractive });
+}
+async function runGatewayHealthChecks(ctx) {
+	const { checkGatewayHealth, probeGatewayMemoryStatus } = await import("./doctor-gateway-health-CD7Vzth9.js");
+	const { healthOk } = await checkGatewayHealth({
+		runtime: ctx.runtime,
+		cfg: ctx.cfg,
+		timeoutMs: ctx.options.nonInteractive === true ? 3e3 : 1e4
+	});
+	ctx.healthOk = healthOk;
+	ctx.gatewayMemoryProbe = healthOk ? await probeGatewayMemoryStatus({
+		cfg: ctx.cfg,
+		timeoutMs: ctx.options.nonInteractive === true ? 3e3 : 1e4
+	}) : {
+		checked: false,
+		ready: false
+	};
+}
+async function runMemorySearchHealthContribution(ctx) {
+	const { maybeRepairMemoryRecallHealth, noteMemoryRecallHealth, noteMemorySearchHealth } = await import("./doctor-memory-search-C25cUVoI.js");
+	if (ctx.prompter.shouldRepair) await maybeRepairMemoryRecallHealth({
+		cfg: ctx.cfg,
+		prompter: ctx.prompter
+	});
+	await noteMemorySearchHealth(ctx.cfg, { gatewayMemoryProbe: ctx.gatewayMemoryProbe ?? {
+		checked: false,
+		ready: false
+	} });
+	if (ctx.options.deep === true) await noteMemoryRecallHealth(ctx.cfg);
+}
+async function runDevicePairingHealth(ctx) {
+	const { noteDevicePairingHealth } = await import("./doctor-device-pairing-Qm-r7mwu.js");
+	await noteDevicePairingHealth({
+		cfg: ctx.cfg,
+		healthOk: ctx.healthOk ?? false
+	});
+}
+async function runGatewayDaemonHealth(ctx) {
+	const { maybeRepairGatewayDaemon } = await import("./doctor-gateway-daemon-flow-DJUA40sd.js");
+	await maybeRepairGatewayDaemon({
+		cfg: ctx.cfg,
+		runtime: ctx.runtime,
+		prompter: ctx.prompter,
+		options: ctx.options,
+		gatewayDetailsMessage: ctx.gatewayDetails?.message ?? "",
+		healthOk: ctx.healthOk ?? false
+	});
+}
+async function runWriteConfigHealth(ctx) {
+	const { formatCliCommand } = await import("./command-format-BAulzC9p.js");
+	const { applyWizardMetadata } = await import("./onboard-helpers-Cc2AnoIU.js");
+	const { CONFIG_PATH, writeConfigFile } = await import("./config-DDoTcXdn.js");
+	const { logConfigUpdated } = await import("./logging-CZpl4hS4.js");
+	const { shortenHomePath } = await import("./utils-2OHrwfUp.js");
+	if (ctx.configResult.shouldWriteConfig || JSON.stringify(ctx.cfg) !== JSON.stringify(ctx.cfgForPersistence)) {
+		ctx.cfg = applyWizardMetadata(ctx.cfg, {
+			command: "doctor",
+			mode: resolveDoctorMode(ctx.cfg)
+		});
+		await writeConfigFile(ctx.cfg);
+		logConfigUpdated(ctx.runtime);
+		const backupPath = `${CONFIG_PATH}.bak`;
+		if (fs.existsSync(backupPath)) ctx.runtime.log(`Backup: ${shortenHomePath(backupPath)}`);
+		return;
+	}
+	if (!ctx.prompter.shouldRepair) ctx.runtime.log(`Run "${formatCliCommand("genesis doctor --fix")}" to apply changes.`);
+}
+async function runWorkspaceSuggestionsHealth(ctx) {
+	if (ctx.options.workspaceSuggestions === false) return;
+	const { resolveAgentWorkspaceDir, resolveDefaultAgentId } = await import("./agent-scope-AmIuqhnH.js");
+	const { noteWorkspaceBackupTip } = await import("./doctor-state-integrity-jbbt8OVU.js");
+	const { MEMORY_SYSTEM_PROMPT, shouldSuggestMemorySystem } = await import("./doctor-workspace-Cbskz6Oe.js");
+	const { note } = await import("./note-DzYNWGih.js");
+	const workspaceDir = resolveAgentWorkspaceDir(ctx.cfg, resolveDefaultAgentId(ctx.cfg));
+	noteWorkspaceBackupTip(workspaceDir);
+	if (await shouldSuggestMemorySystem(workspaceDir)) note(MEMORY_SYSTEM_PROMPT, "Workspace");
+}
+async function runFinalConfigValidationHealth(_ctx) {
+	const { readConfigFileSnapshot } = await import("./config-DDoTcXdn.js");
+	const finalSnapshot = await readConfigFileSnapshot();
+	if (finalSnapshot.exists && !finalSnapshot.valid) {
+		_ctx.runtime.error("Invalid config:");
+		for (const issue of finalSnapshot.issues) {
+			const path = issue.path || "<root>";
+			_ctx.runtime.error(`- ${path}: ${issue.message}`);
+		}
+	}
+}
+function resolveDoctorHealthContributions() {
+	return [
+		createDoctorHealthContribution({
+			id: "doctor:gateway-config",
+			label: "Gateway config",
+			run: runGatewayConfigHealth
+		}),
+		createDoctorHealthContribution({
+			id: "doctor:bundled-plugin-runtime-deps",
+			label: "Bundled plugin runtime deps",
+			run: runBundledPluginRuntimeDepsHealth
+		}),
+		createDoctorHealthContribution({
+			id: "doctor:auth-profiles",
+			label: "Auth profiles",
+			run: runAuthProfileHealth
+		}),
+		createDoctorHealthContribution({
+			id: "doctor:claude-cli",
+			label: "Claude CLI",
+			run: runClaudeCliHealth
+		}),
+		createDoctorHealthContribution({
+			id: "doctor:gateway-auth",
+			label: "Gateway auth",
+			run: runGatewayAuthHealth
+		}),
+		createDoctorHealthContribution({
+			id: "doctor:legacy-state",
+			label: "Legacy state",
+			run: runLegacyStateHealth
+		}),
+		createDoctorHealthContribution({
+			id: "doctor:legacy-plugin-manifests",
+			label: "Legacy plugin manifests",
+			run: runLegacyPluginManifestHealth
+		}),
+		createDoctorHealthContribution({
+			id: "doctor:state-integrity",
+			label: "State integrity",
+			run: runStateIntegrityHealth
+		}),
+		createDoctorHealthContribution({
+			id: "doctor:session-locks",
+			label: "Session locks",
+			run: runSessionLocksHealth
+		}),
+		createDoctorHealthContribution({
+			id: "doctor:legacy-cron",
+			label: "Legacy cron",
+			run: runLegacyCronHealth
+		}),
+		createDoctorHealthContribution({
+			id: "doctor:sandbox",
+			label: "Sandbox",
+			run: runSandboxHealth
+		}),
+		createDoctorHealthContribution({
+			id: "doctor:gateway-services",
+			label: "Gateway services",
+			run: runGatewayServicesHealth
+		}),
+		createDoctorHealthContribution({
+			id: "doctor:startup-channel-maintenance",
+			label: "Startup channel maintenance",
+			run: runStartupChannelMaintenanceHealth
+		}),
+		createDoctorHealthContribution({
+			id: "doctor:security",
+			label: "Security",
+			run: runSecurityHealth
+		}),
+		createDoctorHealthContribution({
+			id: "doctor:browser",
+			label: "Browser",
+			run: runBrowserHealth
+		}),
+		createDoctorHealthContribution({
+			id: "doctor:oauth-tls",
+			label: "OAuth TLS",
+			run: runOpenAIOAuthTlsHealth
+		}),
+		createDoctorHealthContribution({
+			id: "doctor:hooks-model",
+			label: "Hooks model",
+			run: runHooksModelHealth
+		}),
+		createDoctorHealthContribution({
+			id: "doctor:systemd-linger",
+			label: "systemd linger",
+			run: runSystemdLingerHealth
+		}),
+		createDoctorHealthContribution({
+			id: "doctor:workspace-status",
+			label: "Workspace status",
+			run: runWorkspaceStatusHealth
+		}),
+		createDoctorHealthContribution({
+			id: "doctor:bootstrap-size",
+			label: "Bootstrap size",
+			run: runBootstrapSizeHealth
+		}),
+		createDoctorHealthContribution({
+			id: "doctor:shell-completion",
+			label: "Shell completion",
+			run: runShellCompletionHealth
+		}),
+		createDoctorHealthContribution({
+			id: "doctor:gateway-health",
+			label: "Gateway health",
+			run: runGatewayHealthChecks
+		}),
+		createDoctorHealthContribution({
+			id: "doctor:memory-search",
+			label: "Memory search",
+			run: runMemorySearchHealthContribution
+		}),
+		createDoctorHealthContribution({
+			id: "doctor:device-pairing",
+			label: "Device pairing",
+			run: runDevicePairingHealth
+		}),
+		createDoctorHealthContribution({
+			id: "doctor:gateway-daemon",
+			label: "Gateway daemon",
+			run: runGatewayDaemonHealth
+		}),
+		createDoctorHealthContribution({
+			id: "doctor:write-config",
+			label: "Write config",
+			run: runWriteConfigHealth
+		}),
+		createDoctorHealthContribution({
+			id: "doctor:workspace-suggestions",
+			label: "Workspace suggestions",
+			run: runWorkspaceSuggestionsHealth
+		}),
+		createDoctorHealthContribution({
+			id: "doctor:final-config-validation",
+			label: "Final config validation",
+			run: runFinalConfigValidationHealth
+		})
+	];
+}
+async function runDoctorHealthContributions(ctx) {
+	for (const contribution of resolveDoctorHealthContributions()) await contribution.run(ctx);
+}
+//#endregion
+export { runDoctorHealthContributions };

package/dist/doctor-prompter-BYIoKiZ8.js

@@ -0,0 +1,56 @@
+import { n as stylePromptMessage, t as stylePromptHint } from "./prompt-style-C0fEzBHW.js";
+import { a as guardCancel } from "./onboard-helpers-DIxfEXNM.js";
+import { n as resolveDoctorRepairMode, r as shouldAutoApproveDoctorFix } from "./doctor-repair-mode-B287pN3E.js";
+import { confirm, select } from "@clack/prompts";
+//#region src/commands/doctor-prompter.ts
+function createDoctorPrompter(params) {
+	const repairMode = resolveDoctorRepairMode(params.options);
+	const confirmDefault = async (p) => {
+		if (shouldAutoApproveDoctorFix(repairMode)) return true;
+		if (repairMode.nonInteractive) return false;
+		if (!repairMode.canPrompt) return p.initialValue ?? false;
+		return guardCancel(await confirm({
+			...p,
+			message: stylePromptMessage(p.message)
+		}), params.runtime);
+	};
+	return {
+		confirm: confirmDefault,
+		confirmAutoFix: confirmDefault,
+		confirmAggressiveAutoFix: async (p) => {
+			if (shouldAutoApproveDoctorFix(repairMode, { requiresForce: true })) return true;
+			if (repairMode.nonInteractive) return false;
+			if (repairMode.shouldRepair && !repairMode.shouldForce) return false;
+			if (!repairMode.canPrompt) return p.initialValue ?? false;
+			return guardCancel(await confirm({
+				...p,
+				message: stylePromptMessage(p.message)
+			}), params.runtime);
+		},
+		confirmRuntimeRepair: async (p) => {
+			if (shouldAutoApproveDoctorFix(repairMode, { blockDuringUpdate: true })) return true;
+			if (repairMode.nonInteractive) return false;
+			if (!repairMode.canPrompt) return p.initialValue ?? false;
+			return guardCancel(await confirm({
+				...p,
+				message: stylePromptMessage(p.message)
+			}), params.runtime);
+		},
+		select: async (p, fallback) => {
+			if (!repairMode.canPrompt || repairMode.shouldRepair) return fallback;
+			return guardCancel(await select({
+				...p,
+				message: stylePromptMessage(p.message),
+				options: p.options.map((opt) => opt.hint === void 0 ? opt : {
+					...opt,
+					hint: stylePromptHint(opt.hint)
+				})
+			}), params.runtime);
+		},
+		shouldRepair: repairMode.shouldRepair,
+		shouldForce: repairMode.shouldForce,
+		repairMode
+	};
+}
+//#endregion
+export { createDoctorPrompter };

package/dist/doctor-workspace-status-DL2fRPoT.js

@@ -0,0 +1,75 @@
+import { t as formatCliCommand } from "./command-format-DAeUlu7u.js";
+import { b as resolveAgentWorkspaceDir, x as resolveDefaultAgentId } from "./agent-scope-CDjZLqNk.js";
+import { N as listTaskFlowRecords, d as listTasksForFlowId } from "./task-registry-M1bHrFvP.js";
+import "./runtime-internal-Bu1n9i4P.js";
+import { t as note } from "./note-DH98sfDq.js";
+import { t as buildWorkspaceSkillStatus } from "./skills-status-7DS_HH5S.js";
+import { i as buildPluginCompatibilityWarnings, s as buildPluginSnapshotReport } from "./status-DagNCfVv.js";
+import { i as formatLegacyWorkspaceWarning, n as detectLegacyWorkspaceDirs } from "./doctor-workspace-BRS3jS99.js";
+//#region src/commands/doctor-workspace-status.ts
+function noteFlowRecoveryHints() {
+	const suspicious = listTaskFlowRecords().flatMap((flow) => {
+		const tasks = listTasksForFlowId(flow.flowId);
+		const findings = [];
+		if (flow.syncMode === "managed" && flow.status === "running" && tasks.length === 0 && flow.waitJson === void 0) findings.push(`${flow.flowId}: running managed TaskFlow has no linked tasks or wait state; inspect or cancel it manually.`);
+		if (flow.status === "blocked" && flow.blockedTaskId && !tasks.some((task) => task.taskId === flow.blockedTaskId)) findings.push(`${flow.flowId}: blocked TaskFlow points at missing task ${flow.blockedTaskId}; inspect before retrying.`);
+		return findings;
+	});
+	if (suspicious.length === 0) return;
+	note([
+		...suspicious.slice(0, 5),
+		suspicious.length > 5 ? `...and ${suspicious.length - 5} more.` : null,
+		`Inspect: ${formatCliCommand("genesis tasks flow show <flow-id>")}`,
+		`Cancel: ${formatCliCommand("genesis tasks flow cancel <flow-id>")}`
+	].filter((line) => Boolean(line)).join("\n"), "TaskFlow recovery");
+}
+function noteWorkspaceStatus(cfg) {
+	const workspaceDir = resolveAgentWorkspaceDir(cfg, resolveDefaultAgentId(cfg));
+	const legacyWorkspace = detectLegacyWorkspaceDirs({ workspaceDir });
+	if (legacyWorkspace.legacyDirs.length > 0) note(formatLegacyWorkspaceWarning(legacyWorkspace), "Extra workspace");
+	const skillsReport = buildWorkspaceSkillStatus(workspaceDir, { config: cfg });
+	note([
+		`Eligible: ${skillsReport.skills.filter((s) => s.eligible).length}`,
+		`Missing requirements: ${skillsReport.skills.filter((s) => !s.eligible && !s.disabled && !s.blockedByAllowlist).length}`,
+		`Blocked by allowlist: ${skillsReport.skills.filter((s) => s.blockedByAllowlist).length}`
+	].join("\n"), "Skills status");
+	const pluginRegistry = buildPluginSnapshotReport({
+		config: cfg,
+		workspaceDir
+	});
+	if (pluginRegistry.plugins.length > 0) {
+		const loaded = pluginRegistry.plugins.filter((p) => p.status === "loaded");
+		const disabled = pluginRegistry.plugins.filter((p) => p.status === "disabled");
+		const errored = pluginRegistry.plugins.filter((p) => p.status === "error");
+		const imported = pluginRegistry.plugins.filter((p) => p.imported);
+		const lines = [
+			`Loaded: ${loaded.length}`,
+			`Imported: ${imported.length}`,
+			`Disabled: ${disabled.length}`,
+			`Errors: ${errored.length}`,
+			errored.length > 0 ? `- ${errored.slice(0, 10).map((p) => p.id).join("\n- ")}${errored.length > 10 ? "\n- ..." : ""}` : null
+		].filter((line) => Boolean(line));
+		const bundlePlugins = loaded.filter((p) => p.format === "bundle" && (p.bundleCapabilities?.length ?? 0) > 0);
+		if (bundlePlugins.length > 0) {
+			const allCaps = new Set(bundlePlugins.flatMap((p) => p.bundleCapabilities ?? []));
+			lines.push(`Bundle plugins: ${bundlePlugins.length} (${[...allCaps].toSorted().join(", ")})`);
+		}
+		note(lines.join("\n"), "Plugins");
+	}
+	const compatibilityWarnings = buildPluginCompatibilityWarnings({
+		config: cfg,
+		workspaceDir,
+		report: pluginRegistry
+	});
+	if (compatibilityWarnings.length > 0) note(compatibilityWarnings.map((line) => `- ${line}`).join("\n"), "Plugin compatibility");
+	if (pluginRegistry.diagnostics.length > 0) note(pluginRegistry.diagnostics.map((diag) => {
+		const prefix = diag.level.toUpperCase();
+		const plugin = diag.pluginId ? ` ${diag.pluginId}` : "";
+		const source = diag.source ? ` (${diag.source})` : "";
+		return `- ${prefix}${plugin}: ${diag.message}${source}`;
+	}).join("\n"), "Plugin diagnostics");
+	noteFlowRecoveryHints();
+	return { workspaceDir };
+}
+//#endregion
+export { noteWorkspaceStatus };