@poolzin/pool-bot 2026.2.21 → 2026.2.22

package/dist/commands/doctor-gateway-services.js

@@ -1,104 +1,83 @@
+import { execFile } from "node:child_process";
+import fs from "node:fs/promises";
+import os from "node:os";
 import path from "node:path";
+import { promisify } from "node:util";
 import { resolveGatewayPort, resolveIsNixMode } from "../config/paths.js";
 import { findExtraGatewayServices, renderGatewayServiceCleanupHints } from "../daemon/inspect.js";
-import { findLegacyGatewayServices, uninstallLegacyGatewayServices } from "../daemon/legacy.js";
 import { renderSystemNodeWarning, resolveSystemNodeInfo } from "../daemon/runtime-paths.js";
-import { resolveGatewayService } from "../daemon/service.js";
 import { auditGatewayServiceConfig, needsNodeRuntimeMigration, SERVICE_AUDIT_CODES, } from "../daemon/service-audit.js";
+import { resolveGatewayService } from "../daemon/service.js";
 import { note } from "../terminal/note.js";
-import { buildGatewayInstallPlan, gatewayInstallErrorHint } from "./daemon-install-helpers.js";
-import { DEFAULT_GATEWAY_DAEMON_RUNTIME, GATEWAY_DAEMON_RUNTIME_OPTIONS, } from "./daemon-runtime.js";
+import { buildGatewayInstallPlan } from "./daemon-install-helpers.js";
+import { DEFAULT_GATEWAY_DAEMON_RUNTIME } from "./daemon-runtime.js";
+const execFileAsync = promisify(execFile);
 function detectGatewayRuntime(programArguments) {
     const first = programArguments?.[0];
     if (first) {
         const base = path.basename(first).toLowerCase();
-        if (base === "bun" || base === "bun.exe")
+        if (base === "bun" || base === "bun.exe") {
             return "bun";
-        if (base === "node" || base === "node.exe")
+        }
+        if (base === "node" || base === "node.exe") {
             return "node";
+        }
     }
     return DEFAULT_GATEWAY_DAEMON_RUNTIME;
 }
 function findGatewayEntrypoint(programArguments) {
-    if (!programArguments || programArguments.length === 0)
+    if (!programArguments || programArguments.length === 0) {
         return null;
+    }
     const gatewayIndex = programArguments.indexOf("gateway");
-    if (gatewayIndex <= 0)
+    if (gatewayIndex <= 0) {
         return null;
+    }
     return programArguments[gatewayIndex - 1] ?? null;
 }
 function normalizeExecutablePath(value) {
     return path.resolve(value);
 }
-export async function maybeMigrateLegacyGatewayService(cfg, mode, runtime, prompter) {
-    const legacyServices = await findLegacyGatewayServices(process.env);
-    if (legacyServices.length === 0)
-        return;
-    note(legacyServices.map((svc) => `- ${svc.label} (${svc.platform}, ${svc.detail})`).join("\n"), "Legacy gateway services detected");
-    const migrate = await prompter.confirmSkipInNonInteractive({
-        message: "Migrate legacy gateway services to Poolbot now?",
-        initialValue: true,
-    });
-    if (!migrate)
-        return;
-    try {
-        await uninstallLegacyGatewayServices({
-            env: process.env,
-            stdout: process.stdout,
-        });
+function resolveGatewayAuthToken(cfg, env) {
+    const configToken = cfg.gateway?.auth?.token?.trim();
+    if (configToken) {
+        return configToken;
+    }
+    const envToken = env.POOLBOT_GATEWAY_TOKEN ?? env.CLAWDBOT_GATEWAY_TOKEN;
+    const trimmedEnvToken = envToken?.trim();
+    return trimmedEnvToken || undefined;
+}
+function extractDetailPath(detail, prefix) {
+    if (!detail.startsWith(prefix)) {
+        return null;
     }
-    catch (err) {
-        runtime.error(`Legacy service cleanup failed: ${String(err)}`);
-        return;
+    const value = detail.slice(prefix.length).trim();
+    return value.length > 0 ? value : null;
+}
+async function cleanupLegacyLaunchdService(params) {
+    const domain = typeof process.getuid === "function" ? `gui/${process.getuid()}` : "gui/501";
+    await execFileAsync("launchctl", ["bootout", domain, params.plistPath]).catch(() => undefined);
+    await execFileAsync("launchctl", ["unload", params.plistPath]).catch(() => undefined);
+    const trashDir = path.join(os.homedir(), ".Trash");
+    try {
+        await fs.mkdir(trashDir, { recursive: true });
     }
-    if (resolveIsNixMode(process.env)) {
-        note("Nix mode detected; skip installing services.", "Gateway");
-        return;
+    catch {
+        // ignore
     }
-    if (mode === "remote") {
-        note("Gateway mode is remote; skipped local service install.", "Gateway");
-        return;
+    try {
+        await fs.access(params.plistPath);
     }
-    const service = resolveGatewayService();
-    const loaded = await service.isLoaded({ env: process.env });
-    if (loaded) {
-        note(`Poolbot ${service.label} already ${service.loadedText}.`, "Gateway");
-        return;
+    catch {
+        return null;
     }
-    const install = await prompter.confirmSkipInNonInteractive({
-        message: "Install Poolbot gateway service now?",
-        initialValue: true,
-    });
-    if (!install)
-        return;
-    const daemonRuntime = await prompter.select({
-        message: "Gateway service runtime",
-        options: GATEWAY_DAEMON_RUNTIME_OPTIONS,
-        initialValue: DEFAULT_GATEWAY_DAEMON_RUNTIME,
-    }, DEFAULT_GATEWAY_DAEMON_RUNTIME);
-    const port = resolveGatewayPort(cfg, process.env);
-    const { programArguments, workingDirectory, environment } = await buildGatewayInstallPlan({
-        env: process.env,
-        port,
-        token: cfg.gateway?.auth?.token ??
-            process.env.POOLBOT_GATEWAY_TOKEN ??
-            process.env.CLAWDBOT_GATEWAY_TOKEN,
-        runtime: daemonRuntime,
-        warn: (message, title) => note(message, title),
-        config: cfg,
-    });
+    const dest = path.join(trashDir, `${params.label}-${Date.now()}.plist`);
     try {
-        await service.install({
-            env: process.env,
-            stdout: process.stdout,
-            programArguments,
-            workingDirectory,
-            environment,
-        });
+        await fs.rename(params.plistPath, dest);
+        return dest;
     }
-    catch (err) {
-        runtime.error(`Gateway service install failed: ${String(err)}`);
-        note(gatewayInstallErrorHint(), "Gateway");
+    catch {
+        return null;
     }
 }
 export async function maybeRepairGatewayServiceConfig(cfg, mode, runtime, prompter) {
@@ -118,11 +97,14 @@ export async function maybeRepairGatewayServiceConfig(cfg, mode, runtime, prompt
     catch {
         command = null;
     }
-    if (!command)
+    if (!command) {
         return;
+    }
+    const expectedGatewayToken = resolveGatewayAuthToken(cfg, process.env);
     const audit = await auditGatewayServiceConfig({
         env: process.env,
         command,
+        expectedGatewayToken,
     });
     const needsNodeRuntime = needsNodeRuntimeMigration(audit.issues);
     const systemNodeInfo = needsNodeRuntime
@@ -131,8 +113,9 @@ export async function maybeRepairGatewayServiceConfig(cfg, mode, runtime, prompt
     const systemNodePath = systemNodeInfo?.supported ? systemNodeInfo.path : null;
     if (needsNodeRuntime && !systemNodePath) {
         const warning = renderSystemNodeWarning(systemNodeInfo);
-        if (warning)
+        if (warning) {
             note(warning, "Gateway runtime");
+        }
         note("System Node 22+ not found. Install via Homebrew/apt/choco and rerun doctor to migrate off Bun/version managers.", "Gateway runtime");
     }
     const port = resolveGatewayPort(cfg, process.env);
@@ -140,9 +123,7 @@ export async function maybeRepairGatewayServiceConfig(cfg, mode, runtime, prompt
     const { programArguments, workingDirectory, environment } = await buildGatewayInstallPlan({
         env: process.env,
         port,
-        token: cfg.gateway?.auth?.token ??
-            process.env.POOLBOT_GATEWAY_TOKEN ??
-            process.env.CLAWDBOT_GATEWAY_TOKEN,
+        token: expectedGatewayToken,
         runtime: needsNodeRuntime && systemNodePath ? "node" : runtimeChoice,
         nodePath: systemNodePath ?? undefined,
         warn: (message, title) => note(message, title),
@@ -160,8 +141,9 @@ export async function maybeRepairGatewayServiceConfig(cfg, mode, runtime, prompt
             level: "recommended",
         });
     }
-    if (audit.issues.length === 0)
+    if (audit.issues.length === 0) {
         return;
+    }
     note(audit.issues
         .map((issue) => issue.detail ? `- ${issue.message} (${issue.detail})` : `- ${issue.message}`)
         .join("\n"), "Gateway service config");
@@ -179,8 +161,9 @@ export async function maybeRepairGatewayServiceConfig(cfg, mode, runtime, prompt
             message: "Update gateway service config to the recommended defaults now?",
             initialValue: true,
         });
-    if (!repair)
+    if (!repair) {
         return;
+    }
     try {
         await service.install({
             env: process.env,
@@ -194,13 +177,54 @@ export async function maybeRepairGatewayServiceConfig(cfg, mode, runtime, prompt
         runtime.error(`Gateway service update failed: ${String(err)}`);
     }
 }
-export async function maybeScanExtraGatewayServices(options) {
+export async function maybeScanExtraGatewayServices(options, runtime, prompter) {
     const extraServices = await findExtraGatewayServices(process.env, {
         deep: options.deep,
     });
-    if (extraServices.length === 0)
+    if (extraServices.length === 0) {
         return;
+    }
     note(extraServices.map((svc) => `- ${svc.label} (${svc.scope}, ${svc.detail})`).join("\n"), "Other gateway-like services detected");
+    const legacyServices = extraServices.filter((svc) => svc.legacy === true);
+    if (legacyServices.length > 0) {
+        const shouldRemove = await prompter.confirmSkipInNonInteractive({
+            message: "Remove legacy gateway services (clawdbot/moltbot) now?",
+            initialValue: true,
+        });
+        if (shouldRemove) {
+            const removed = [];
+            const failed = [];
+            for (const svc of legacyServices) {
+                if (svc.platform !== "darwin") {
+                    failed.push(`${svc.label} (${svc.platform})`);
+                    continue;
+                }
+                if (svc.scope !== "user") {
+                    failed.push(`${svc.label} (${svc.scope})`);
+                    continue;
+                }
+                const plistPath = extractDetailPath(svc.detail, "plist:");
+                if (!plistPath) {
+                    failed.push(`${svc.label} (missing plist path)`);
+                    continue;
+                }
+                const dest = await cleanupLegacyLaunchdService({
+                    label: svc.label,
+                    plistPath,
+                });
+                removed.push(dest ? `${svc.label} -> ${dest}` : svc.label);
+            }
+            if (removed.length > 0) {
+                note(removed.map((line) => `- ${line}`).join("\n"), "Legacy gateway removed");
+            }
+            if (failed.length > 0) {
+                note(failed.map((line) => `- ${line}`).join("\n"), "Legacy gateway cleanup skipped");
+            }
+            if (removed.length > 0) {
+                runtime.log("Legacy gateway services removed. Installing Pool Bot gateway next.");
+            }
+        }
+    }
     const cleanupHints = renderGatewayServiceCleanupHints();
     if (cleanupHints.length > 0) {
         note(cleanupHints.map((hint) => `- ${hint}`).join("\n"), "Cleanup hints");

package/dist/commands/doctor-memory-search.js

@@ -7,7 +7,7 @@ import { note } from "../terminal/note.js";
 import { resolveUserPath } from "../utils.js";
 /**
  * Check whether memory search has a usable embedding provider.
- * Runs as part of `openclaw doctor` — config-only, no network calls.
+ * Runs as part of `poolbot doctor` — config-only, no network calls.
  */
 export async function noteMemorySearchHealth(cfg) {
     const agentId = resolveDefaultAgentId(cfg);
@@ -29,9 +29,9 @@ export async function noteMemorySearchHealth(cfg) {
                 "",
                 "Fix (pick one):",
                 `- Install node-llama-cpp and set a local model path in config`,
-                `- Switch to a remote provider: ${formatCliCommand("openclaw config set agents.defaults.memorySearch.provider openai")}`,
+                `- Switch to a remote provider: ${formatCliCommand("poolbot config set agents.defaults.memorySearch.provider openai")}`,
                 "",
-                `Verify: ${formatCliCommand("openclaw memory status --deep")}`,
+                `Verify: ${formatCliCommand("poolbot memory status --deep")}`,
             ].join("\n"), "Memory search");
             return;
         }
@@ -46,10 +46,10 @@ export async function noteMemorySearchHealth(cfg) {
             "",
             "Fix (pick one):",
             `- Set ${envVar} in your environment`,
-            `- Add credentials: ${formatCliCommand(`openclaw auth add --provider ${resolved.provider}`)}`,
-            `- To disable: ${formatCliCommand("openclaw config set agents.defaults.memorySearch.enabled false")}`,
+            `- Add credentials: ${formatCliCommand(`poolbot auth add --provider ${resolved.provider}`)}`,
+            `- To disable: ${formatCliCommand("poolbot config set agents.defaults.memorySearch.enabled false")}`,
             "",
-            `Verify: ${formatCliCommand("openclaw memory status --deep")}`,
+            `Verify: ${formatCliCommand("poolbot memory status --deep")}`,
         ].join("\n"), "Memory search");
         return;
     }
@@ -68,11 +68,11 @@ export async function noteMemorySearchHealth(cfg) {
         "",
         "Fix (pick one):",
         "- Set OPENAI_API_KEY or GEMINI_API_KEY in your environment",
-        `- Add credentials: ${formatCliCommand("openclaw auth add --provider openai")}`,
+        `- Add credentials: ${formatCliCommand("poolbot auth add --provider openai")}`,
         `- For local embeddings: configure agents.defaults.memorySearch.provider and local model path`,
-        `- To disable: ${formatCliCommand("openclaw config set agents.defaults.memorySearch.enabled false")}`,
+        `- To disable: ${formatCliCommand("poolbot config set agents.defaults.memorySearch.enabled false")}`,
         "",
-        `Verify: ${formatCliCommand("openclaw memory status --deep")}`,
+        `Verify: ${formatCliCommand("poolbot memory status --deep")}`,
     ].join("\n"), "Memory search");
 }
 function hasLocalEmbeddings(local) {

package/dist/commands/doctor-platform-notes.js

@@ -10,12 +10,15 @@ function resolveHomeDir() {
     return process.env.HOME ?? os.homedir();
 }
 export async function noteMacLaunchAgentOverrides() {
-    if (process.platform !== "darwin")
+    if (process.platform !== "darwin") {
         return;
-    const markerPath = path.join(resolveHomeDir(), ".poolbot", "disable-launchagent");
-    const hasMarker = fs.existsSync(markerPath);
-    if (!hasMarker)
+    }
+    const home = resolveHomeDir();
+    const markerCandidates = [path.join(home, ".poolbot", "disable-launchagent")];
+    const markerPath = markerCandidates.find((candidate) => fs.existsSync(candidate));
+    if (!markerPath) {
         return;
+    }
     const displayMarkerPath = shortenHomePath(markerPath);
     const lines = [
         `- LaunchAgent writes are disabled via ${displayMarkerPath}.`,
@@ -43,41 +46,65 @@ function hasConfigGatewayCreds(cfg) {
 }
 export async function noteMacLaunchctlGatewayEnvOverrides(cfg, deps) {
     const platform = deps?.platform ?? process.platform;
-    if (platform !== "darwin")
+    if (platform !== "darwin") {
         return;
-    if (!hasConfigGatewayCreds(cfg))
+    }
+    if (!hasConfigGatewayCreds(cfg)) {
         return;
+    }
     const getenv = deps?.getenv ?? launchctlGetenv;
-    // Check both POOLBOT_ (preferred) and CLAWDBOT_ (legacy) launchctl env vars
-    const poolbotToken = await getenv("POOLBOT_GATEWAY_TOKEN");
-    const clawdbotToken = await getenv("CLAWDBOT_GATEWAY_TOKEN");
-    const poolbotPassword = await getenv("POOLBOT_GATEWAY_PASSWORD");
-    const clawdbotPassword = await getenv("CLAWDBOT_GATEWAY_PASSWORD");
-    const hasToken = poolbotToken ?? clawdbotToken;
-    const hasPassword = poolbotPassword ?? clawdbotPassword;
-    if (!hasToken && !hasPassword)
+    const deprecatedLaunchctlEntries = [
+        ["CLAWDBOT_GATEWAY_TOKEN", await getenv("CLAWDBOT_GATEWAY_TOKEN")],
+        ["CLAWDBOT_GATEWAY_PASSWORD", await getenv("CLAWDBOT_GATEWAY_PASSWORD")],
+    ].filter((entry) => Boolean(entry[1]?.trim()));
+    if (deprecatedLaunchctlEntries.length > 0) {
+        const lines = [
+            "- Deprecated launchctl environment variables detected (ignored).",
+            ...deprecatedLaunchctlEntries.map(([key]) => `- \`${key}\` is set; use \`POOLBOT_${key.slice(key.indexOf("_") + 1)}\` instead.`),
+        ];
+        (deps?.noteFn ?? note)(lines.join("\n"), "Gateway (macOS)");
+    }
+    const tokenEntries = [["POOLBOT_GATEWAY_TOKEN", await getenv("POOLBOT_GATEWAY_TOKEN")]];
+    const passwordEntries = [
+        ["POOLBOT_GATEWAY_PASSWORD", await getenv("POOLBOT_GATEWAY_PASSWORD")],
+    ];
+    const tokenEntry = tokenEntries.find(([, value]) => value?.trim());
+    const passwordEntry = passwordEntries.find(([, value]) => value?.trim());
+    const envToken = tokenEntry?.[1]?.trim() ?? "";
+    const envPassword = passwordEntry?.[1]?.trim() ?? "";
+    const envTokenKey = tokenEntry?.[0];
+    const envPasswordKey = passwordEntry?.[0];
+    if (!envToken && !envPassword) {
         return;
-    const tokenUnsets = [];
-    if (poolbotToken)
-        tokenUnsets.push("  launchctl unsetenv POOLBOT_GATEWAY_TOKEN");
-    if (clawdbotToken)
-        tokenUnsets.push("  launchctl unsetenv CLAWDBOT_GATEWAY_TOKEN");
-    const passwordUnsets = [];
-    if (poolbotPassword)
-        passwordUnsets.push("  launchctl unsetenv POOLBOT_GATEWAY_PASSWORD");
-    if (clawdbotPassword)
-        passwordUnsets.push("  launchctl unsetenv CLAWDBOT_GATEWAY_PASSWORD");
+    }
     const lines = [
         "- launchctl environment overrides detected (can cause confusing unauthorized errors).",
-        hasToken
-            ? `- \`${poolbotToken ? "POOLBOT" : "CLAWDBOT"}_GATEWAY_TOKEN\` is set; it overrides config tokens.`
+        envToken && envTokenKey
+            ? `- \`${envTokenKey}\` is set; it overrides config tokens.`
             : undefined,
-        hasPassword
-            ? `- \`${poolbotPassword ? "POOLBOT" : "CLAWDBOT"}_GATEWAY_PASSWORD\` is set; it overrides config passwords.`
+        envPassword
+            ? `- \`${envPasswordKey ?? "POOLBOT_GATEWAY_PASSWORD"}\` is set; it overrides config passwords.`
             : undefined,
         "- Clear overrides and restart the app/gateway:",
-        ...tokenUnsets,
-        ...passwordUnsets,
+        envTokenKey ? `  launchctl unsetenv ${envTokenKey}` : undefined,
+        envPasswordKey ? `  launchctl unsetenv ${envPasswordKey}` : undefined,
     ].filter((line) => Boolean(line));
     (deps?.noteFn ?? note)(lines.join("\n"), "Gateway (macOS)");
 }
+export function noteDeprecatedLegacyEnvVars(env = process.env, deps) {
+    const entries = Object.entries(env)
+        .filter(([key, value]) => key.startsWith("CLAWDBOT_") && value?.trim())
+        .map(([key]) => key);
+    if (entries.length === 0) {
+        return;
+    }
+    const lines = [
+        "- Deprecated legacy environment variables detected (ignored).",
+        "- Use POOLBOT_* equivalents instead:",
+        ...entries.map((key) => {
+            const suffix = key.slice(key.indexOf("_") + 1);
+            return `  ${key} -> POOLBOT_${suffix}`;
+        }),
+    ];
+    (deps?.noteFn ?? note)(lines.join("\n"), "Environment");
+}

package/dist/commands/doctor-prompter.js

@@ -10,48 +10,59 @@ export function createDoctorPrompter(params) {
     const nonInteractive = requestedNonInteractive || (!isTty && !yes);
     const canPrompt = isTty && !yes && !nonInteractive;
     const confirmDefault = async (p) => {
-        if (nonInteractive)
+        if (nonInteractive) {
             return false;
-        if (shouldRepair)
+        }
+        if (shouldRepair) {
             return true;
-        if (!canPrompt)
+        }
+        if (!canPrompt) {
             return Boolean(p.initialValue ?? false);
-        return (guardCancel(await confirm({
+        }
+        return guardCancel(await confirm({
             ...p,
             message: stylePromptMessage(p.message),
-        }), params.runtime) === true);
+        }), params.runtime);
     };
     return {
         confirm: confirmDefault,
         confirmRepair: async (p) => {
-            if (nonInteractive)
+            if (nonInteractive) {
                 return false;
+            }
             return confirmDefault(p);
         },
         confirmAggressive: async (p) => {
-            if (nonInteractive)
+            if (nonInteractive) {
                 return false;
-            if (shouldRepair && shouldForce)
+            }
+            if (shouldRepair && shouldForce) {
                 return true;
-            if (shouldRepair && !shouldForce)
+            }
+            if (shouldRepair && !shouldForce) {
                 return false;
-            if (!canPrompt)
+            }
+            if (!canPrompt) {
                 return Boolean(p.initialValue ?? false);
-            return (guardCancel(await confirm({
+            }
+            return guardCancel(await confirm({
                 ...p,
                 message: stylePromptMessage(p.message),
-            }), params.runtime) === true);
+            }), params.runtime);
         },
         confirmSkipInNonInteractive: async (p) => {
-            if (nonInteractive)
+            if (nonInteractive) {
                 return false;
-            if (shouldRepair)
+            }
+            if (shouldRepair) {
                 return true;
+            }
             return confirmDefault(p);
         },
         select: async (p, fallback) => {
-            if (!canPrompt || shouldRepair)
+            if (!canPrompt || shouldRepair) {
                 return fallback;
+            }
             return guardCancel(await select({
                 ...p,
                 message: stylePromptMessage(p.message),

package/dist/commands/doctor-session-locks.js

@@ -64,7 +64,7 @@ export async function noteSessionLockHealth(params) {
     ];
     if (staleCount > 0 && !shouldRepair) {
         lines.push(`- ${staleCount} lock file${staleCount === 1 ? " is" : "s are"} stale.`);
-        lines.push('- Run "openclaw doctor --fix" to remove stale lock files automatically.');
+        lines.push('- Run "poolbot doctor --fix" to remove stale lock files automatically.');
     }
     if (shouldRepair && removedCount > 0) {
         lines.push(`- Removed ${removedCount} stale session lock file${removedCount === 1 ? "" : "s"}.`);

package/dist/commands/doctor.js

@@ -16,21 +16,24 @@ import { note } from "../terminal/note.js";
 import { stylePromptTitle } from "../terminal/prompt-style.js";
 import { shortenHomePath } from "../utils.js";
 import { maybeRemoveDeprecatedCliAuthProfiles, maybeRepairAnthropicOAuthProfileId, noteAuthProfileHealth, } from "./doctor-auth.js";
+import { doctorShellCompletion } from "./doctor-completion.js";
 import { loadAndMaybeMigrateDoctorConfig } from "./doctor-config-flow.js";
 import { maybeRepairGatewayDaemon } from "./doctor-gateway-daemon-flow.js";
 import { checkGatewayHealth } from "./doctor-gateway-health.js";
-import { maybeMigrateLegacyGatewayService, maybeRepairGatewayServiceConfig, maybeScanExtraGatewayServices, } from "./doctor-gateway-services.js";
+import { maybeRepairGatewayServiceConfig, maybeScanExtraGatewayServices, } from "./doctor-gateway-services.js";
 import { noteSourceInstallIssues } from "./doctor-install.js";
-import { noteMacLaunchAgentOverrides, noteMacLaunchctlGatewayEnvOverrides, } from "./doctor-platform-notes.js";
+import { noteMemorySearchHealth } from "./doctor-memory-search.js";
+import { noteMacLaunchAgentOverrides, noteMacLaunchctlGatewayEnvOverrides, noteDeprecatedLegacyEnvVars, } from "./doctor-platform-notes.js";
 import { createDoctorPrompter } from "./doctor-prompter.js";
 import { maybeRepairSandboxImages, noteSandboxScopeWarnings } from "./doctor-sandbox.js";
 import { noteSecurityWarnings } from "./doctor-security.js";
+import { noteSessionLockHealth } from "./doctor-session-locks.js";
 import { noteStateIntegrity, noteWorkspaceBackupTip } from "./doctor-state-integrity.js";
 import { detectLegacyStateMigrations, runLegacyStateMigrations, } from "./doctor-state-migrations.js";
 import { maybeRepairUiProtocolFreshness } from "./doctor-ui.js";
 import { maybeOfferUpdateBeforeDoctor } from "./doctor-update.js";
-import { MEMORY_SYSTEM_PROMPT, shouldSuggestMemorySystem } from "./doctor-workspace.js";
 import { noteWorkspaceStatus } from "./doctor-workspace-status.js";
+import { MEMORY_SYSTEM_PROMPT, shouldSuggestMemorySystem } from "./doctor-workspace.js";
 import { applyWizardMetadata, printWizardHeader, randomToken } from "./onboard-helpers.js";
 import { ensureSystemdUserLingerInteractive } from "./systemd-linger.js";
 const intro = (message) => clackIntro(stylePromptTitle(message) ?? message);
@@ -41,7 +44,7 @@ function resolveMode(cfg) {
 export async function doctorCommand(runtime = defaultRuntime, options = {}) {
     const prompter = createDoctorPrompter({ runtime, options });
     printWizardHeader(runtime);
-    intro("Poolbot doctor");
+    intro("Pool Bot doctor");
     const root = await resolvePoolBotPackageRoot({
         moduleUrl: import.meta.url,
         argv1: process.argv[1],
@@ -54,15 +57,19 @@ export async function doctorCommand(runtime = defaultRuntime, options = {}) {
         confirm: (p) => prompter.confirm(p),
         outro,
     });
-    if (updateResult.handled)
+    if (updateResult.handled) {
         return;
+    }
     await maybeRepairUiProtocolFreshness(runtime, prompter);
     noteSourceInstallIssues(root);
+    noteDeprecatedLegacyEnvVars();
     const configResult = await loadAndMaybeMigrateDoctorConfig({
         options,
         confirm: (p) => prompter.confirm(p),
     });
     let cfg = configResult.cfg;
+    const cfgForPersistence = structuredClone(cfg);
+    const sourceConfigValid = configResult.sourceConfigValid ?? true;
     const configPath = configResult.path ?? CONFIG_PATH;
     if (!cfg.gateway?.mode) {
         const lines = [
@@ -86,7 +93,7 @@ export async function doctorCommand(runtime = defaultRuntime, options = {}) {
     if (gatewayDetails.remoteFallbackNote) {
         note(gatewayDetails.remoteFallbackNote, "Gateway");
     }
-    if (resolveMode(cfg) === "local") {
+    if (resolveMode(cfg) === "local" && sourceConfigValid) {
         const auth = resolveGatewayAuth({
             authConfig: cfg.gateway?.auth,
             tailscaleMode: cfg.gateway?.tailscale?.mode ?? "off",
@@ -141,10 +148,10 @@ export async function doctorCommand(runtime = defaultRuntime, options = {}) {
         }
     }
     await noteStateIntegrity(cfg, prompter, configResult.path ?? CONFIG_PATH);
+    await noteSessionLockHealth({ shouldRepair: prompter.shouldRepair });
     cfg = await maybeRepairSandboxImages(cfg, runtime, prompter);
     noteSandboxScopeWarnings(cfg);
-    await maybeMigrateLegacyGatewayService(cfg, resolveMode(cfg), runtime, prompter);
-    await maybeScanExtraGatewayServices(options);
+    await maybeScanExtraGatewayServices(options, runtime, prompter);
     await maybeRepairGatewayServiceConfig(cfg, resolveMode(cfg), runtime, prompter);
     await noteMacLaunchAgentOverrides();
     await noteMacLaunchctlGatewayEnvOverrides(cfg);
@@ -207,6 +214,11 @@ export async function doctorCommand(runtime = defaultRuntime, options = {}) {
         }
     }
     noteWorkspaceStatus(cfg);
+    await noteMemorySearchHealth(cfg);
+    // Check and fix shell completion
+    await doctorShellCompletion(runtime, prompter, {
+        nonInteractive: options.nonInteractive,
+    });
     const { healthOk } = await checkGatewayHealth({
         runtime,
         cfg,
@@ -220,7 +232,7 @@ export async function doctorCommand(runtime = defaultRuntime, options = {}) {
         gatewayDetailsMessage: gatewayDetails.message,
         healthOk,
     });
-    const shouldWriteConfig = prompter.shouldRepair || configResult.shouldWriteConfig;
+    const shouldWriteConfig = configResult.shouldWriteConfig || JSON.stringify(cfg) !== JSON.stringify(cfgForPersistence);
     if (shouldWriteConfig) {
         cfg = applyWizardMetadata(cfg, { command: "doctor", mode: resolveMode(cfg) });
         await writeConfigFile(cfg);