@poolzin/pool-bot 2026.2.24 → 2026.2.26

package/dist/channels/telegram/api.js

@@ -0,0 +1,18 @@
+export async function fetchTelegramChatId(params) {
+    const url = `https://api.telegram.org/bot${params.token}/getChat?chat_id=${encodeURIComponent(params.chatId)}`;
+    try {
+        const res = await fetch(url, params.signal ? { signal: params.signal } : undefined);
+        if (!res.ok) {
+            return null;
+        }
+        const data = (await res.json().catch(() => null));
+        const id = data?.ok ? data?.result?.id : undefined;
+        if (typeof id === "number" || typeof id === "string") {
+            return String(id);
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/cli/argv.js

@@ -1,40 +1,85 @@
 const HELP_FLAGS = new Set(["-h", "--help"]);
-const VERSION_FLAGS = new Set(["-v", "-V", "--version"]);
+const VERSION_FLAGS = new Set(["-V", "--version"]);
+const ROOT_VERSION_ALIAS_FLAG = "-v";
+const ROOT_BOOLEAN_FLAGS = new Set(["--dev", "--no-color"]);
+const ROOT_VALUE_FLAGS = new Set(["--profile"]);
 const FLAG_TERMINATOR = "--";
 export function hasHelpOrVersion(argv) {
-    return argv.some((arg) => HELP_FLAGS.has(arg) || VERSION_FLAGS.has(arg));
+    return (argv.some((arg) => HELP_FLAGS.has(arg) || VERSION_FLAGS.has(arg)) || hasRootVersionAlias(argv));
 }
 function isValueToken(arg) {
-    if (!arg)
+    if (!arg) {
         return false;
-    if (arg === FLAG_TERMINATOR)
+    }
+    if (arg === FLAG_TERMINATOR) {
         return false;
-    if (!arg.startsWith("-"))
+    }
+    if (!arg.startsWith("-")) {
         return true;
+    }
     return /^-\d+(?:\.\d+)?$/.test(arg);
 }
 function parsePositiveInt(value) {
     const parsed = Number.parseInt(value, 10);
-    if (Number.isNaN(parsed) || parsed <= 0)
+    if (Number.isNaN(parsed) || parsed <= 0) {
         return undefined;
+    }
     return parsed;
 }
 export function hasFlag(argv, name) {
     const args = argv.slice(2);
     for (const arg of args) {
-        if (arg === FLAG_TERMINATOR)
+        if (arg === FLAG_TERMINATOR) {
             break;
-        if (arg === name)
+        }
+        if (arg === name) {
             return true;
+        }
     }
     return false;
 }
+export function hasRootVersionAlias(argv) {
+    const args = argv.slice(2);
+    let hasAlias = false;
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (!arg) {
+            continue;
+        }
+        if (arg === FLAG_TERMINATOR) {
+            break;
+        }
+        if (arg === ROOT_VERSION_ALIAS_FLAG) {
+            hasAlias = true;
+            continue;
+        }
+        if (ROOT_BOOLEAN_FLAGS.has(arg)) {
+            continue;
+        }
+        if (arg.startsWith("--profile=")) {
+            continue;
+        }
+        if (ROOT_VALUE_FLAGS.has(arg)) {
+            const next = args[i + 1];
+            if (isValueToken(next)) {
+                i += 1;
+            }
+            continue;
+        }
+        if (arg.startsWith("-")) {
+            continue;
+        }
+        return false;
+    }
+    return hasAlias;
+}
 export function getFlagValue(argv, name) {
     const args = argv.slice(2);
     for (let i = 0; i < args.length; i += 1) {
         const arg = args[i];
-        if (arg === FLAG_TERMINATOR)
+        if (arg === FLAG_TERMINATOR) {
             break;
+        }
         if (arg === name) {
             const next = args[i + 1];
             return isValueToken(next) ? next : null;
@@ -47,16 +92,19 @@ export function getFlagValue(argv, name) {
     return undefined;
 }
 export function getVerboseFlag(argv, options) {
-    if (hasFlag(argv, "--verbose"))
+    if (hasFlag(argv, "--verbose")) {
         return true;
-    if (options?.includeDebug && hasFlag(argv, "--debug"))
+    }
+    if (options?.includeDebug && hasFlag(argv, "--debug")) {
         return true;
+    }
     return false;
 }
 export function getPositiveIntFlagValue(argv, name) {
     const raw = getFlagValue(argv, name);
-    if (raw === null || raw === undefined)
+    if (raw === null || raw === undefined) {
         return raw;
+    }
     return parsePositiveInt(raw);
 }
 export function getCommandPath(argv, depth = 2) {
@@ -64,15 +112,19 @@ export function getCommandPath(argv, depth = 2) {
     const path = [];
     for (let i = 0; i < args.length; i += 1) {
         const arg = args[i];
-        if (!arg)
+        if (!arg) {
             continue;
-        if (arg === "--")
+        }
+        if (arg === "--") {
             break;
-        if (arg.startsWith("-"))
+        }
+        if (arg.startsWith("-")) {
             continue;
+        }
         path.push(arg);
-        if (path.length >= depth)
+        if (path.length >= depth) {
             break;
+        }
     }
     return path;
 }
@@ -94,8 +146,9 @@ export function buildParseArgv(params) {
             : baseArgv;
     const executable = (normalizedArgv[0]?.split(/[/\\]/).pop() ?? "").toLowerCase();
     const looksLikeNode = normalizedArgv.length >= 2 && (isNodeExecutable(executable) || isBunExecutable(executable));
-    if (looksLikeNode)
+    if (looksLikeNode) {
         return normalizedArgv;
+    }
     return ["node", programName || "poolbot", ...normalizedArgv];
 }
 const nodeExecutablePattern = /^node-\d+(?:\.\d+)*(?:\.exe)?$/;
@@ -110,15 +163,25 @@ function isBunExecutable(executable) {
     return executable === "bun" || executable === "bun.exe";
 }
 export function shouldMigrateStateFromPath(path) {
-    if (path.length === 0)
+    if (path.length === 0) {
         return true;
+    }
     const [primary, secondary] = path;
-    if (primary === "health" || primary === "status" || primary === "sessions")
+    if (primary === "health" || primary === "status" || primary === "sessions") {
         return false;
-    if (primary === "memory" && secondary === "status")
+    }
+    if (primary === "config" && (secondary === "get" || secondary === "unset")) {
         return false;
-    if (primary === "agent")
+    }
+    if (primary === "models" && (secondary === "list" || secondary === "status")) {
         return false;
+    }
+    if (primary === "memory" && secondary === "status") {
+        return false;
+    }
+    if (primary === "agent") {
+        return false;
+    }
     return true;
 }
 export function shouldMigrateState(argv) {

package/dist/cli/banner.js

@@ -1,6 +1,7 @@
 import { resolveCommitHash } from "../infra/git-commit.js";
 import { visibleWidth } from "../terminal/ansi.js";
 import { isRich, theme } from "../terminal/theme.js";
+import { hasRootVersionAlias } from "./argv.js";
 import { pickTagline } from "./tagline.js";
 import { resolveCliName } from "./cli-name.js";
 let bannerEmitted = false;
@@ -18,13 +19,13 @@ function splitGraphemes(value) {
     }
 }
 const hasJsonFlag = (argv) => argv.some((arg) => arg === "--json" || arg.startsWith("--json="));
-const hasVersionFlag = (argv) => argv.some((arg) => arg === "--version" || arg === "-V" || arg === "-v");
+const hasVersionFlag = (argv) => argv.some((arg) => arg === "--version" || arg === "-V") || hasRootVersionAlias(argv);
 export function formatCliBannerLine(version, options = {}) {
     const commit = options.commit ?? resolveCommitHash({ env: options.env });
     const commitLabel = commit ?? "unknown";
     const tagline = pickTagline(options);
     const rich = options.richTty ?? isRich();
-    const cliName = resolveCliName(options.argv ?? process.argv, options.env);
+    const cliName = resolveCliName(options.argv ?? process.argv);
     const title = cliName === "poolbot" ? "🎱 Pool Bot" : "🎱 Pool Bot";
     const prefix = "🎱 ";
     const columns = options.columns ?? process.stdout.columns ?? 120;

package/dist/cli/browser-cli-actions-input/register.files-downloads.js

@@ -1,13 +1,55 @@
+import { DEFAULT_UPLOAD_DIR, resolveExistingPathsWithinRoot } from "../../browser/paths.js";
 import { danger } from "../../globals.js";
 import { defaultRuntime } from "../../runtime.js";
+import { shortenHomePath } from "../../utils.js";
 import { callBrowserRequest } from "../browser-cli-shared.js";
 import { resolveBrowserActionContext } from "./shared.js";
-import { shortenHomePath } from "../../utils.js";
+async function normalizeUploadPaths(paths) {
+    const result = await resolveExistingPathsWithinRoot({
+        rootDir: DEFAULT_UPLOAD_DIR,
+        requestedPaths: paths,
+        scopeLabel: `uploads directory (${DEFAULT_UPLOAD_DIR})`,
+    });
+    if (!result.ok) {
+        throw new Error(result.error);
+    }
+    return result.paths;
+}
 export function registerBrowserFilesAndDownloadsCommands(browser, parentOpts) {
+    const resolveTimeoutAndTarget = (opts) => {
+        const timeoutMs = Number.isFinite(opts.timeoutMs) ? Number(opts.timeoutMs) : undefined;
+        const targetId = typeof opts.targetId === "string" ? opts.targetId.trim() || undefined : undefined;
+        return { timeoutMs, targetId };
+    };
+    const runDownloadCommand = async (cmd, opts, request) => {
+        const { parent, profile } = resolveBrowserActionContext(cmd, parentOpts);
+        try {
+            const { timeoutMs, targetId } = resolveTimeoutAndTarget(opts);
+            const result = await callBrowserRequest(parent, {
+                method: "POST",
+                path: request.path,
+                query: profile ? { profile } : undefined,
+                body: {
+                    ...request.body,
+                    targetId,
+                    timeoutMs,
+                },
+            }, { timeoutMs: timeoutMs ?? 20000 });
+            if (parent?.json) {
+                defaultRuntime.log(JSON.stringify(result, null, 2));
+                return;
+            }
+            defaultRuntime.log(`downloaded: ${shortenHomePath(result.download.path)}`);
+        }
+        catch (err) {
+            defaultRuntime.error(danger(String(err)));
+            defaultRuntime.exit(1);
+        }
+    };
     browser
         .command("upload")
         .description("Arm file upload for the next file chooser")
-        .argument("<paths...>", "File paths to upload")
+        .argument("<paths...>", "File paths to upload (must be within Pool Bot temp uploads dir, e.g. /tmp/poolbot/uploads/file.pdf)")
         .option("--ref <ref>", "Ref id from snapshot to click after arming")
         .option("--input-ref <ref>", "Ref id for <input type=file> to set directly")
         .option("--element <selector>", "CSS selector for <input type=file>")
@@ -16,17 +58,18 @@ export function registerBrowserFilesAndDownloadsCommands(browser, parentOpts) {
         .action(async (paths, opts, cmd) => {
         const { parent, profile } = resolveBrowserActionContext(cmd, parentOpts);
         try {
-            const timeoutMs = Number.isFinite(opts.timeoutMs) ? opts.timeoutMs : undefined;
+            const normalizedPaths = await normalizeUploadPaths(paths);
+            const { timeoutMs, targetId } = resolveTimeoutAndTarget(opts);
             const result = await callBrowserRequest(parent, {
                 method: "POST",
                 path: "/hooks/file-chooser",
                 query: profile ? { profile } : undefined,
                 body: {
-                    paths,
+                    paths: normalizedPaths,
                     ref: opts.ref?.trim() || undefined,
                     inputRef: opts.inputRef?.trim() || undefined,
                     element: opts.element?.trim() || undefined,
-                    targetId: opts.targetId?.trim() || undefined,
+                    targetId,
                     timeoutMs,
                 },
             }, { timeoutMs: timeoutMs ?? 20000 });
@@ -44,66 +87,32 @@ export function registerBrowserFilesAndDownloadsCommands(browser, parentOpts) {
     browser
         .command("waitfordownload")
         .description("Wait for the next download (and save it)")
-        .argument("[path]", "Save path (default: /tmp/poolbot/downloads/...)")
+        .argument("[path]", "Save path within poolbot temp downloads dir (default: /tmp/poolbot/downloads/...; fallback: os.tmpdir()/poolbot/downloads/...)")
         .option("--target-id <id>", "CDP target id (or unique prefix)")
         .option("--timeout-ms <ms>", "How long to wait for the next download (default: 120000)", (v) => Number(v))
         .action(async (outPath, opts, cmd) => {
-        const { parent, profile } = resolveBrowserActionContext(cmd, parentOpts);
-        try {
-            const timeoutMs = Number.isFinite(opts.timeoutMs) ? opts.timeoutMs : undefined;
-            const result = await callBrowserRequest(parent, {
-                method: "POST",
-                path: "/wait/download",
-                query: profile ? { profile } : undefined,
-                body: {
-                    path: outPath?.trim() || undefined,
-                    targetId: opts.targetId?.trim() || undefined,
-                    timeoutMs,
-                },
-            }, { timeoutMs: timeoutMs ?? 20000 });
-            if (parent?.json) {
-                defaultRuntime.log(JSON.stringify(result, null, 2));
-                return;
-            }
-            defaultRuntime.log(`downloaded: ${shortenHomePath(result.download.path)}`);
-        }
-        catch (err) {
-            defaultRuntime.error(danger(String(err)));
-            defaultRuntime.exit(1);
-        }
+        await runDownloadCommand(cmd, opts, {
+            path: "/wait/download",
+            body: {
+                path: outPath?.trim() || undefined,
+            },
+        });
     });
     browser
         .command("download")
         .description("Click a ref and save the resulting download")
         .argument("<ref>", "Ref id from snapshot to click")
-        .argument("<path>", "Save path")
+        .argument("<path>", "Save path within poolbot temp downloads dir (e.g. report.pdf or /tmp/poolbot/downloads/report.pdf)")
         .option("--target-id <id>", "CDP target id (or unique prefix)")
         .option("--timeout-ms <ms>", "How long to wait for the download to start (default: 120000)", (v) => Number(v))
         .action(async (ref, outPath, opts, cmd) => {
-        const { parent, profile } = resolveBrowserActionContext(cmd, parentOpts);
-        try {
-            const timeoutMs = Number.isFinite(opts.timeoutMs) ? opts.timeoutMs : undefined;
-            const result = await callBrowserRequest(parent, {
-                method: "POST",
-                path: "/download",
-                query: profile ? { profile } : undefined,
-                body: {
-                    ref,
-                    path: outPath,
-                    targetId: opts.targetId?.trim() || undefined,
-                    timeoutMs,
-                },
-            }, { timeoutMs: timeoutMs ?? 20000 });
-            if (parent?.json) {
-                defaultRuntime.log(JSON.stringify(result, null, 2));
-                return;
-            }
-            defaultRuntime.log(`downloaded: ${shortenHomePath(result.download.path)}`);
-        }
-        catch (err) {
-            defaultRuntime.error(danger(String(err)));
-            defaultRuntime.exit(1);
-        }
+        await runDownloadCommand(cmd, opts, {
+            path: "/download",
+            body: {
+                ref,
+                path: outPath,
+            },
+        });
     });
     browser
         .command("dialog")
@@ -122,7 +131,7 @@ export function registerBrowserFilesAndDownloadsCommands(browser, parentOpts) {
             return;
         }
         try {
-            const timeoutMs = Number.isFinite(opts.timeoutMs) ? opts.timeoutMs : undefined;
+            const { timeoutMs, targetId } = resolveTimeoutAndTarget(opts);
             const result = await callBrowserRequest(parent, {
                 method: "POST",
                 path: "/hooks/dialog",
@@ -130,7 +139,7 @@ export function registerBrowserFilesAndDownloadsCommands(browser, parentOpts) {
                 body: {
                     accept,
                     promptText: opts.prompt?.trim() || undefined,
-                    targetId: opts.targetId?.trim() || undefined,
+                    targetId,
                     timeoutMs,
                 },
             }, { timeoutMs: timeoutMs ?? 20000 });

package/dist/cli/cli-name.js

@@ -1,25 +1,25 @@
 import path from "node:path";
 export const DEFAULT_CLI_NAME = "poolbot";
-export const LEGACY_CLI_NAME = "poolbot";
-const KNOWN_CLI_NAMES = new Set([DEFAULT_CLI_NAME, LEGACY_CLI_NAME]);
-const CLI_PREFIX_RE = /^(?:((?:pnpm|npm|bunx|npx)\s+))?(poolbot|poolbot)\b/;
-export function resolveCliName(argv = process.argv, env = process.env) {
-    const override = env.POOLBOT_CLI_NAME?.trim() || env.MOLTBOT_CLI_NAME?.trim() || env.CLAWDBOT_CLI_NAME?.trim();
-    if (override)
-        return override;
+const KNOWN_CLI_NAMES = new Set([DEFAULT_CLI_NAME]);
+const CLI_PREFIX_RE = /^(?:((?:pnpm|npm|bunx|npx)\s+))?(poolbot)\b/;
+export function resolveCliName(argv = process.argv) {
     const argv1 = argv[1];
-    if (!argv1)
+    if (!argv1) {
         return DEFAULT_CLI_NAME;
+    }
     const base = path.basename(argv1).trim();
-    if (KNOWN_CLI_NAMES.has(base))
+    if (KNOWN_CLI_NAMES.has(base)) {
         return base;
+    }
     return DEFAULT_CLI_NAME;
 }
 export function replaceCliName(command, cliName = resolveCliName()) {
-    if (!command.trim())
+    if (!command.trim()) {
         return command;
-    if (!CLI_PREFIX_RE.test(command))
+    }
+    if (!CLI_PREFIX_RE.test(command)) {
         return command;
+    }
     return command.replace(CLI_PREFIX_RE, (_match, runner) => {
         return `${runner ?? ""}${cliName}`;
     });

package/dist/cli/cli-utils.js

@@ -1,6 +1,5 @@
-export function formatErrorMessage(err) {
-    return err instanceof Error ? err.message : String(err);
-}
+import { formatErrorMessage } from "../infra/errors.js";
+export { formatErrorMessage };
 export async function withManager(params) {
     const { manager, error } = await params.getManager();
     if (!manager) {
@@ -32,3 +31,14 @@ export async function runCommandWithRuntime(runtime, action, onError) {
         runtime.exit(1);
     }
 }
+export function resolveOptionFromCommand(command, key) {
+    let current = command;
+    while (current) {
+        const opts = current.opts?.() ?? {};
+        if (opts[key] !== undefined) {
+            return opts[key];
+        }
+        current = current.parent ?? undefined;
+    }
+    return undefined;
+}

package/dist/cli/command-format.js

@@ -4,7 +4,7 @@ const CLI_PREFIX_RE = /^(?:pnpm|npm|bunx|npx)\s+(?:poolbot|poolbot)\b|^(?:poolbo
 const PROFILE_FLAG_RE = /(?:^|\s)--profile(?:\s|=|$)/;
 const DEV_FLAG_RE = /(?:^|\s)--dev(?:\s|$)/;
 export function formatCliCommand(command, env = process.env) {
-    const cliName = resolveCliName(undefined, env);
+    const cliName = resolveCliName();
     const normalizedCommand = replaceCliName(command, cliName);
     const profile = normalizeProfileName(env.POOLBOT_PROFILE || env.CLAWDBOT_PROFILE);
     if (!profile)

package/dist/cli/config-cli.js

@@ -234,7 +234,7 @@ export async function runConfigUnset(opts) {
             runtime.exit(1);
             return;
         }
-        await writeConfigFile(next);
+        await writeConfigFile(next, { unsetPaths: [parsedPath] });
         runtime.log(info(`Removed ${opts.path}. Restart the gateway to apply.`));
     }
     catch (err) {

package/dist/cli/daemon-cli/lifecycle-core.js

@@ -51,6 +51,15 @@ async function handleServiceNotLoaded(params) {
         }
     }
 }
+async function resolveServiceLoadedOrFail(params) {
+    try {
+        return await params.service.isLoaded({ env: process.env });
+    }
+    catch (err) {
+        params.fail(`${params.serviceNoun} service check failed: ${String(err)}`);
+        return null;
+    }
+}
 export async function runServiceUninstall(params) {
     const json = Boolean(params.opts?.json);
     const { stdout, emit, fail } = createActionIO({ action: "uninstall", json });
@@ -100,12 +109,12 @@ export async function runServiceUninstall(params) {
 export async function runServiceStart(params) {
     const json = Boolean(params.opts?.json);
     const { stdout, emit, fail } = createActionIO({ action: "start", json });
-    let loaded = false;
-    try {
-        loaded = await params.service.isLoaded({ env: process.env });
-    }
-    catch (err) {
-        fail(`${params.serviceNoun} service check failed: ${String(err)}`);
+    const loaded = await resolveServiceLoadedOrFail({
+        serviceNoun: params.serviceNoun,
+        service: params.service,
+        fail,
+    });
+    if (loaded === null) {
         return;
     }
     if (!loaded) {
@@ -143,12 +152,12 @@ export async function runServiceStart(params) {
 export async function runServiceStop(params) {
     const json = Boolean(params.opts?.json);
     const { stdout, emit, fail } = createActionIO({ action: "stop", json });
-    let loaded = false;
-    try {
-        loaded = await params.service.isLoaded({ env: process.env });
-    }
-    catch (err) {
-        fail(`${params.serviceNoun} service check failed: ${String(err)}`);
+    const loaded = await resolveServiceLoadedOrFail({
+        serviceNoun: params.serviceNoun,
+        service: params.service,
+        fail,
+    });
+    if (loaded === null) {
         return;
     }
     if (!loaded) {
@@ -186,12 +195,12 @@ export async function runServiceStop(params) {
 export async function runServiceRestart(params) {
     const json = Boolean(params.opts?.json);
     const { stdout, emit, fail } = createActionIO({ action: "restart", json });
-    let loaded = false;
-    try {
-        loaded = await params.service.isLoaded({ env: process.env });
-    }
-    catch (err) {
-        fail(`${params.serviceNoun} service check failed: ${String(err)}`);
+    const loaded = await resolveServiceLoadedOrFail({
+        serviceNoun: params.serviceNoun,
+        service: params.service,
+        fail,
+    });
+    if (loaded === null) {
         return false;
     }
     if (!loaded) {
@@ -222,7 +231,7 @@ export async function runServiceRestart(params) {
                     : driftIssue.message;
                 warnings.push(warning);
                 if (!json) {
-                    defaultRuntime.log(`\n⚠️  ${driftIssue.message}`);
+                    defaultRuntime.log(`\n\u26a0\ufe0f  ${driftIssue.message}`);
                     if (driftIssue.detail) {
                         defaultRuntime.log(`   ${driftIssue.detail}\n`);
                     }
@@ -235,6 +244,9 @@ export async function runServiceRestart(params) {
     }
     try {
         await params.service.restart({ env: process.env, stdout });
+        if (params.postRestartCheck) {
+            await params.postRestartCheck({ json, stdout, warnings, fail });
+        }
         let restarted = true;
         try {
             restarted = await params.service.isLoaded({ env: process.env });

package/dist/cli/daemon-cli/lifecycle.js

@@ -1,6 +1,24 @@
+import { loadConfig, resolveGatewayPort } from "../../config/config.js";
 import { resolveGatewayService } from "../../daemon/service.js";
+import { defaultRuntime } from "../../runtime.js";
+import { theme } from "../../terminal/theme.js";
+import { formatCliCommand } from "../command-format.js";
 import { runServiceRestart, runServiceStart, runServiceStop, runServiceUninstall, } from "./lifecycle-core.js";
-import { renderGatewayServiceStartHints } from "./shared.js";
+import { renderRestartDiagnostics, terminateStaleGatewayPids, waitForGatewayHealthyRestart, } from "./restart-health.js";
+import { parsePortFromArgs, renderGatewayServiceStartHints } from "./shared.js";
+const POST_RESTART_HEALTH_ATTEMPTS = 8;
+const POST_RESTART_HEALTH_DELAY_MS = 450;
+async function resolveGatewayRestartPort() {
+    const service = resolveGatewayService();
+    const command = await service.readCommand(process.env).catch(() => null);
+    const serviceEnv = command?.environment ?? undefined;
+    const mergedEnv = {
+        ...process.env,
+        ...(serviceEnv ?? undefined),
+    };
+    const portFromArgs = parsePortFromArgs(command?.programArguments);
+    return portFromArgs ?? resolveGatewayPort(loadConfig(), mergedEnv);
+}
 export async function runDaemonUninstall(opts = {}) {
     return await runServiceUninstall({
         serviceNoun: "Gateway",
@@ -31,11 +49,55 @@ export async function runDaemonStop(opts = {}) {
  * Throws/exits on check or restart failures.
  */
 export async function runDaemonRestart(opts = {}) {
+    const json = Boolean(opts.json);
+    const service = resolveGatewayService();
+    const restartPort = await resolveGatewayRestartPort().catch(() => resolveGatewayPort(loadConfig(), process.env));
     return await runServiceRestart({
         serviceNoun: "Gateway",
-        service: resolveGatewayService(),
+        service,
         renderStartHints: renderGatewayServiceStartHints,
         opts,
         checkTokenDrift: true,
+        postRestartCheck: async ({ warnings, fail, stdout }) => {
+            let health = await waitForGatewayHealthyRestart({
+                service,
+                port: restartPort,
+                attempts: POST_RESTART_HEALTH_ATTEMPTS,
+                delayMs: POST_RESTART_HEALTH_DELAY_MS,
+            });
+            if (!health.healthy && health.staleGatewayPids.length > 0) {
+                const staleMsg = `Found stale gateway process(es): ${health.staleGatewayPids.join(", ")}.`;
+                warnings.push(staleMsg);
+                if (!json) {
+                    defaultRuntime.log(theme.warn(staleMsg));
+                    defaultRuntime.log(theme.muted("Stopping stale process(es) and retrying restart..."));
+                }
+                await terminateStaleGatewayPids(health.staleGatewayPids);
+                await service.restart({ env: process.env, stdout });
+                health = await waitForGatewayHealthyRestart({
+                    service,
+                    port: restartPort,
+                    attempts: POST_RESTART_HEALTH_ATTEMPTS,
+                    delayMs: POST_RESTART_HEALTH_DELAY_MS,
+                });
+            }
+            if (health.healthy) {
+                return;
+            }
+            const diagnostics = renderRestartDiagnostics(health);
+            if (!json) {
+                defaultRuntime.log(theme.warn("Gateway did not become healthy after restart."));
+                for (const line of diagnostics) {
+                    defaultRuntime.log(theme.muted(line));
+                }
+            }
+            else {
+                warnings.push(...diagnostics);
+            }
+            fail("Gateway restart failed health checks.", [
+                formatCliCommand("poolbot gateway status --probe --deep"),
+                formatCliCommand("poolbot doctor"),
+            ]);
+        },
     });
 }