@botcord/daemon 0.2.89 → 0.2.91

package/dist/cloud-daemon.js

@@ -76,6 +76,15 @@ export async function startCloudDaemon(opts) {
     const credentialPathByAgentId = new Map();
     const hubUrlByAgentId = new Map();
     const displayNameByAgent = new Map();
+    const runtimeByAgentId = new Map();
+    const hermesProfileByAgentId = new Map();
+    const skillIndexOptionsForAgent = (agentId) => {
+        const hermesProfile = hermesProfileByAgentId.get(agentId);
+        return {
+            runtime: runtimeByAgentId.get(agentId) ?? opts.config.defaultRoute.adapter,
+            ...(hermesProfile ? { hermesProfile } : {}),
+        };
+    };
     // Seed each per-agent hub URL with the cloud-mode value so that even
     // before the first credential file is written the room-context fetcher
     // has somewhere sensible to point.
@@ -158,16 +167,16 @@ export async function startCloudDaemon(opts) {
         });
     };
     const installedAgentIds = new Set();
-    const runtimeByAgentId = new Map();
     let controlChannel = null;
     const pushInstalledAgentSkillSnapshot = (agentId, reason) => {
         if (!controlChannel)
             return;
-        const runtime = runtimeByAgentId.get(agentId) ?? opts.config.defaultRoute.adapter;
-        const pushed = pushAgentSkillSnapshot(controlChannel, agentId, { runtime });
+        const skillIndexOptions = skillIndexOptionsForAgent(agentId);
+        const pushed = pushAgentSkillSnapshot(controlChannel, agentId, skillIndexOptions);
         logger.info("cloud control-channel: agent_skill_snapshot pushed", {
             agentId,
-            runtime,
+            runtime: skillIndexOptions.runtime,
+            hermesProfile: skillIndexOptions.hermesProfile ?? null,
             reason,
             ok: pushed,
         });
@@ -176,6 +185,10 @@ export async function startCloudDaemon(opts) {
         installedAgentIds.add(info.agentId);
         if (info.runtime)
             runtimeByAgentId.set(info.agentId, info.runtime);
+        if (info.hermesProfile)
+            hermesProfileByAgentId.set(info.agentId, info.hermesProfile);
+        else if (info.runtime)
+            hermesProfileByAgentId.delete(info.agentId);
         credentialPathByAgentId.set(info.agentId, info.credentialsFile);
         if (info.hubUrl)
             hubUrlByAgentId.set(info.agentId, info.hubUrl);
@@ -186,6 +199,7 @@ export async function startCloudDaemon(opts) {
                 agentId: info.agentId,
                 activityTracker,
                 roomContextBuilder,
+                skillIndexOptions: () => skillIndexOptionsForAgent(info.agentId),
                 // Cloud daemons run isolated — no loop-risk guard wired in PR1;
                 // the runtime adapter's wall-time budget enforces the equivalent.
                 loopRiskBuilder: () => null,

package/dist/daemon.d.ts

@@ -3,6 +3,7 @@ import type { DaemonConfig } from "./config.js";
 import { type BootAgentsResult } from "./agent-discovery.js";
 import { ensureAgentWorkspace } from "./agent-workspace.js";
 import { UserAuthManager } from "./user-auth.js";
+import { type SkillIndexOptions } from "./skill-index.js";
 import { classifyActivitySender } from "./sender-classify.js";
 export { classifyActivitySender };
 /** Minimal activity-tracker surface the inbound observer uses. */
@@ -65,9 +66,7 @@ export interface RuntimeSnapshotSink {
  * or wait for the next daemon restart). Exported for unit tests.
  */
 export declare function pushRuntimeSnapshot(sink: RuntimeSnapshotSink, liveSnapshot?: GatewayRuntimeSnapshot): boolean;
-export declare function pushAgentSkillSnapshot(sink: RuntimeSnapshotSink, agentId: string, opts?: {
-    runtime?: string;
-}): boolean;
+export declare function pushAgentSkillSnapshot(sink: RuntimeSnapshotSink, agentId: string, opts?: SkillIndexOptions): boolean;
 /** Options accepted by {@link startDaemon} — the P0.5 compatibility shim. */
 export interface DaemonRuntimeOptions {
     config: DaemonConfig;

package/dist/daemon.js

@@ -221,6 +221,13 @@ export async function startDaemon(opts) {
     const agentIds = boot.agents.map((a) => a.agentId);
     const { credentialPathByAgentId, agentRuntimes } = backfillBootAgents(boot.agents, { logger });
     const gwConfig = toGatewayConfig(opts.config, { agentIds, agentRuntimes });
+    const skillIndexOptionsForAgent = (agentId) => {
+        const meta = agentRuntimes[agentId];
+        return {
+            runtime: meta?.runtime ?? opts.config.defaultRoute.adapter,
+            ...(meta?.hermesProfile ? { hermesProfile: meta.hermesProfile } : {}),
+        };
+    };
     // Per-agent hub URL — read from each credential file at boot. Used to
     // populate `BOTCORD_HUB` for runtime CLI subprocesses so the bundled
     // `botcord` CLI talks to the same hub the agent is registered against,
@@ -273,6 +280,7 @@ export async function startDaemon(opts) {
             activityTracker,
             roomContextBuilder,
             loopRiskBuilder,
+            skillIndexOptions: () => skillIndexOptionsForAgent(aid),
         }));
     }
     const buildSystemContext = (message) => {
@@ -372,11 +380,16 @@ export async function startDaemon(opts) {
         // next room-context fetch re-loads the BotCordClient against the new
         // credential file.
         credentialPathByAgentId.set(info.agentId, info.credentialsFile);
-        if (info.runtime) {
-            agentRuntimes[info.agentId] = {
+        if (info.runtime || info.hermesProfile) {
+            const next = {
                 ...(agentRuntimes[info.agentId] ?? {}),
-                runtime: info.runtime,
+                ...(info.runtime ? { runtime: info.runtime } : {}),
+                ...(info.hermesProfile ? { hermesProfile: info.hermesProfile } : {}),
             };
+            if (info.runtime && !info.hermesProfile) {
+                delete next.hermesProfile;
+            }
+            agentRuntimes[info.agentId] = next;
         }
         if (info.hubUrl)
             hubUrlByAgentId.set(info.agentId, info.hubUrl);
@@ -388,6 +401,7 @@ export async function startDaemon(opts) {
                 activityTracker,
                 roomContextBuilder,
                 loopRiskBuilder,
+                skillIndexOptions: () => skillIndexOptionsForAgent(info.agentId),
             }));
         }
     };
@@ -507,11 +521,12 @@ export async function startDaemon(opts) {
                 ok: pushed,
             });
             for (const agentId of agentIds) {
-                const runtime = agentRuntimes[agentId]?.runtime ?? opts.config.defaultRoute.adapter;
-                const skillsPushed = pushAgentSkillSnapshot(controlChannel, agentId, { runtime });
+                const skillIndexOptions = skillIndexOptionsForAgent(agentId);
+                const skillsPushed = pushAgentSkillSnapshot(controlChannel, agentId, skillIndexOptions);
                 logger.info("control-channel: initial agent_skill_snapshot push", {
                     agentId,
-                    runtime,
+                    runtime: skillIndexOptions.runtime,
+                    hermesProfile: skillIndexOptions.hermesProfile ?? null,
                     ok: skillsPushed,
                 });
             }

package/dist/gateway/channels/botcord.js

@@ -187,6 +187,35 @@ function normalizeInboxBatch(msgs, options) {
         raw: { ...latest, batch: msgs },
     };
 }
+/**
+ * Fire-and-forget authenticated POST for presence/streaming control requests
+ * (`/hub/typing`, `/hub/stream-block`). Mirrors `BotCordClient.hubFetch`'s 401
+ * handling: a stale-but-unexpired token (e.g. after a Hub JWT secret rotation,
+ * which `ensureToken()` won't refresh because it only refreshes near expiry) is
+ * refreshed once and the request retried. Without this, typing/stream-block
+ * silently 401 in a loop until the next actual message send happens to refresh
+ * the token — leaving the conversation with no typing indicator or live stream.
+ */
+async function postControlWithRefresh(client, hubUrl, path, body) {
+    let token = await client.ensureToken();
+    for (let attempt = 0; attempt <= 1; attempt++) {
+        const resp = await fetch(`${hubUrl}${path}`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${token}`,
+            },
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(10_000),
+        });
+        if (resp.status === 401 && attempt === 0) {
+            token = await client.refreshToken();
+            continue;
+        }
+        return resp;
+    }
+    throw new Error("postControlWithRefresh: exhausted retries");
+}
 /**
  * Construct a BotCord channel adapter.
  *
@@ -758,21 +787,12 @@ export function createBotCordChannel(options) {
             const client = ensureClient();
             const hubUrl = options.hubBaseUrl ?? client.getHubUrl();
             try {
-                const token = await client.ensureToken();
                 const block = ctx.block;
                 const seq = typeof block?.seq === "number" ? block.seq : 0;
-                const resp = await fetch(`${hubUrl}/hub/stream-block`, {
-                    method: "POST",
-                    headers: {
-                        "Content-Type": "application/json",
-                        Authorization: `Bearer ${token}`,
-                    },
-                    body: JSON.stringify({
-                        trace_id: ctx.traceId,
-                        seq,
-                        block: normalizeBlockForHub(block, seq),
-                    }),
-                    signal: AbortSignal.timeout(10_000),
+                const resp = await postControlWithRefresh(client, hubUrl, "/hub/stream-block", {
+                    trace_id: ctx.traceId,
+                    seq,
+                    block: normalizeBlockForHub(block, seq),
                 });
                 if (!resp.ok && resp.status !== 204) {
                     const body = await resp.text().catch(() => "");
@@ -790,15 +810,8 @@ export function createBotCordChannel(options) {
             const client = ensureClient();
             const hubUrl = options.hubBaseUrl ?? client.getHubUrl();
             try {
-                const token = await client.ensureToken();
-                const resp = await fetch(`${hubUrl}/hub/typing`, {
-                    method: "POST",
-                    headers: {
-                        "Content-Type": "application/json",
-                        Authorization: `Bearer ${token}`,
-                    },
-                    body: JSON.stringify({ room_id: ctx.conversationId }),
-                    signal: AbortSignal.timeout(10_000),
+                const resp = await postControlWithRefresh(client, hubUrl, "/hub/typing", {
+                    room_id: ctx.conversationId,
                 });
                 if (!resp.ok && resp.status !== 204) {
                     const body = await resp.text().catch(() => "");

package/dist/provision.d.ts

@@ -18,6 +18,7 @@ export interface InstalledAgentInfo {
     hubUrl: string;
     displayName?: string;
     runtime?: string;
+    hermesProfile?: string;
 }
 /**
  * Hook fired after `installLocalAgent` / `installExistingOpenclawBinding`

package/dist/provision.js

@@ -20,12 +20,26 @@ import { discoverAgentCredentials } from "./agent-discovery.js";
 import { resolveMemoryDir } from "./working-memory.js";
 import { discoverRuntimeModelCatalog } from "./runtime-models.js";
 import { collectAgentSkillSnapshot } from "./skill-index.js";
+import { installAgentSkillManifest, installBotLearnArchiveManifest, installVercelSkillsForAgent, } from "./skill-installer.js";
 import { buildRuntimeSelectionExtraArgs, mergeRuntimeExtraArgs, } from "./runtime-route-options.js";
 import { handleCloudGatewayRuntimeInbound, } from "./cloud-gateway-runtime.js";
-function runtimeForLoadedAgent(gateway, agentId) {
-    return gateway.listManagedRoutes()
-        .find((route) => route.match?.accountId === agentId)
-        ?.runtime;
+import { scheduleDaemonSelfRestart } from "./self-restart.js";
+function skillIndexOptionsForLoadedAgent(gateway, agentId) {
+    const route = gateway.listManagedRoutes()
+        .find((entry) => entry.match?.accountId === agentId);
+    let credentials = null;
+    try {
+        credentials = loadStoredCredentials(defaultCredentialsFile(agentId));
+    }
+    catch {
+        credentials = null;
+    }
+    const runtime = route?.runtime ?? credentials?.runtime;
+    const hermesProfile = route?.hermesProfile ?? credentials?.hermesProfile;
+    return {
+        ...(runtime ? { runtime } : {}),
+        ...(hermesProfile ? { hermesProfile } : {}),
+    };
 }
 /**
  * Build a dispatcher function that routes a `ControlFrame` to the right
@@ -227,6 +241,16 @@ export function createProvisioner(opts) {
                 daemonLog.debug("list_runtimes", { count: snapshot.runtimes.length });
                 return { ok: true, result: snapshot };
             }
+            case CONTROL_FRAME_TYPES.RESTART_DAEMON: {
+                const plan = scheduleDaemonSelfRestart({ update: true });
+                daemonLog.warn("restart_daemon: scheduled self restart", {
+                    updateRequested: plan.updateRequested,
+                    updateSupported: plan.updateSupported,
+                    installPrefix: plan.installPrefix,
+                    packageSpec: plan.packageSpec,
+                });
+                return { ok: true, result: plan };
+            }
             case "list_gateways":
                 return gatewayControl.handleList();
             case "upsert_gateway": {
@@ -339,15 +363,76 @@ export function createProvisioner(opts) {
                         },
                     };
                 }
-                const runtime = runtimeForLoadedAgent(gateway, params.agentId);
-                const result = collectAgentSkillSnapshot(params.agentId, { runtime });
+                const skillIndexOptions = skillIndexOptionsForLoadedAgent(gateway, params.agentId);
+                const result = collectAgentSkillSnapshot(params.agentId, skillIndexOptions);
                 daemonLog.debug("list_agent_skills", {
                     agentId: params.agentId,
-                    runtime,
+                    runtime: skillIndexOptions.runtime,
+                    hermesProfile: skillIndexOptions.hermesProfile ?? null,
                     count: result.skills.length,
                 });
                 return { ok: true, result };
             }
+            case CONTROL_FRAME_TYPES.INSTALL_AGENT_SKILL: {
+                const params = (frame.params ?? {});
+                if (!params.agentId) {
+                    return {
+                        ok: false,
+                        error: { code: "bad_params", message: "install_agent_skill requires params.agentId" },
+                    };
+                }
+                const channels = gateway.snapshot().channels;
+                if (!channels[params.agentId]) {
+                    return {
+                        ok: false,
+                        error: {
+                            code: "agent_not_loaded",
+                            message: `agent ${params.agentId} is not loaded in daemon gateway`,
+                        },
+                    };
+                }
+                const skillIndexOptions = skillIndexOptionsForLoadedAgent(gateway, params.agentId);
+                const runtime = skillIndexOptions.runtime;
+                const modes = [params.manifest, params.archiveManifest, params.vercel].filter(Boolean).length;
+                if (modes !== 1) {
+                    return {
+                        ok: false,
+                        error: {
+                            code: "bad_params",
+                            message: "install_agent_skill requires exactly one of manifest, archiveManifest, or vercel",
+                        },
+                    };
+                }
+                let result;
+                try {
+                    result = params.vercel
+                        ? await installVercelSkillsForAgent({
+                            agentId: params.agentId,
+                            packageSpec: params.vercel.packageSpec,
+                            skills: params.vercel.skills,
+                            runtime,
+                        })
+                        : params.archiveManifest
+                            ? installBotLearnArchiveManifest(params.agentId, params.archiveManifest, { runtime })
+                            : installAgentSkillManifest(params.agentId, params.manifest, { runtime });
+                }
+                catch (err) {
+                    return {
+                        ok: false,
+                        error: {
+                            code: "skill_install_failed",
+                            message: err instanceof Error ? err.message : String(err),
+                        },
+                    };
+                }
+                daemonLog.debug("install_agent_skill", {
+                    agentId: params.agentId,
+                    runtime,
+                    installed: result.installed.map((s) => s.name),
+                    snapshotCount: result.snapshot.skills.length,
+                });
+                return { ok: true, result };
+            }
             case "wake_agent": {
                 return handleWakeAgent(gateway, frame.params);
             }
@@ -456,8 +541,15 @@ async function handleWakeAgent(gateway, raw) {
             streamable: false,
         },
     };
-    await gateway.injectInbound(msg);
-    return { ok: true, result: { agent_id: agentId } };
+    void gateway.injectInbound(msg).catch((err) => {
+        daemonLog.error("wake_agent: async inject failed", {
+            agentId,
+            scheduleId: scheduleId ?? null,
+            runId,
+            error: err instanceof Error ? err.message : String(err),
+        });
+    });
+    return { ok: true, result: { agent_id: agentId, queued: true } };
 }
 function validateGatewayParams(raw, spec) {
     if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
@@ -823,6 +915,7 @@ async function installLocalAgent(credentials, ctx) {
                 hubUrl: credentials.hubUrl,
                 ...(credentials.displayName ? { displayName: credentials.displayName } : {}),
                 ...(credentials.runtime ? { runtime: credentials.runtime } : {}),
+                ...(credentials.hermesProfile ? { hermesProfile: credentials.hermesProfile } : {}),
             });
         }
         catch (err) {
@@ -904,6 +997,7 @@ async function installExistingOpenclawBinding(agentId, ctx) {
                 hubUrl: credentials.hubUrl,
                 ...(credentials.displayName ? { displayName: credentials.displayName } : {}),
                 ...(credentials.runtime ? { runtime: credentials.runtime } : {}),
+                ...(credentials.hermesProfile ? { hermesProfile: credentials.hermesProfile } : {}),
             });
         }
         catch (err) {

package/dist/runtime-models.js

@@ -54,6 +54,36 @@ const KIMI_FALLBACK_MODELS = [
     { id: "kimi-k2-5-preview", displayName: "kimi-k2-5-preview", provider: "kimi", source: "builtin" },
     { id: "kimi-k2-0711", displayName: "kimi-k2-0711", provider: "kimi", source: "builtin" },
 ];
+// Gemini CLI has no `gemini models list` command — the model set is
+// hard-coded inside the bundle's `VALID_GEMINI_MODELS` (see `@google/gemini-cli`
+// bundle `chunk-BE42OOYM.js:275832`). We mirror the documented user-facing
+// names here as a static catalog; the actual availability depends on the
+// user's auth tier (gcloud ADC / Vertex / GEMINI_API_KEY) and project quota.
+// The `auto` alias is the default — it lets gemini pick the best model.
+const GEMINI_FALLBACK_MODELS = [
+    { id: "auto", displayName: "Auto (let Gemini pick)", provider: "google", source: "builtin", isDefault: true },
+    { id: "pro", displayName: "Pro alias", provider: "google", source: "builtin" },
+    { id: "flash", displayName: "Flash alias", provider: "google", source: "builtin" },
+    { id: "flash-lite", displayName: "Flash Lite alias", provider: "google", source: "builtin" },
+    { id: "gemini-2.5-pro", displayName: "Gemini 2.5 Pro", provider: "google", source: "builtin" },
+    { id: "gemini-2.5-flash", displayName: "Gemini 2.5 Flash", provider: "google", source: "builtin" },
+    { id: "gemini-2.5-flash-lite", displayName: "Gemini 2.5 Flash Lite", provider: "google", source: "builtin" },
+    { id: "gemini-3-pro-preview", displayName: "Gemini 3 Pro (preview)", provider: "google", source: "builtin" },
+    { id: "gemini-3-flash-preview", displayName: "Gemini 3 Flash (preview)", provider: "google", source: "builtin" },
+    { id: "gemini-3.1-pro-preview", displayName: "Gemini 3.1 Pro (preview)", provider: "google", source: "builtin" },
+    {
+        id: "gemini-3.1-pro-preview-customtools",
+        displayName: "Gemini 3.1 Pro Custom Tools (preview)",
+        provider: "google",
+        source: "builtin",
+    },
+    {
+        id: "gemini-3.1-flash-lite-preview",
+        displayName: "Gemini 3.1 Flash Lite (preview)",
+        provider: "google",
+        source: "builtin",
+    },
+];
 const backgroundRefreshes = new Set();
 export function discoverRuntimeModelCatalog(entry) {
     if (!entry.result.available)
@@ -126,6 +156,22 @@ function runtimeCatalogStrategy(entry) {
                     ],
                 }),
             };
+        case "gemini":
+            // Gemini CLI exposes no runtime discovery command and its thinking
+            // budget / level (see bundle `ThinkingLevel`, `thinkingBudget`) is
+            // configured per-installation in `~/.gemini/settings.json`, not via
+            // any CLI flag — so we ship a static model catalog with no parameter
+            // controls. settings.json + BOTCORD_GEMINI_BIN feed the cache key so
+            // user-side reconfig (e.g. switching auth type) busts the cache.
+            return {
+                id: entry.id,
+                contextKey: runtimeCatalogContextKey(entry, {
+                    settings: fileStatKey(path.join(homedir(), ".gemini", "settings.json")),
+                    env: pickEnv(["BOTCORD_GEMINI_BIN", "GEMINI_CLI_HOME"]),
+                }),
+                discoverFresh: () => ({ models: GEMINI_FALLBACK_MODELS.slice() }),
+                fallback: () => ({ models: GEMINI_FALLBACK_MODELS.slice() }),
+            };
         default:
             return null;
     }

package/dist/self-restart.d.ts

@@ -0,0 +1,29 @@
+import { spawn } from "node:child_process";
+export interface DaemonRestartPlan {
+    scheduled: boolean;
+    updateRequested: boolean;
+    updateSupported: boolean;
+    installPrefix: string | null;
+    packageSpec: string;
+}
+export interface ScheduleDaemonSelfRestartOptions {
+    update?: boolean;
+    packageSpec?: string;
+    delayMs?: number;
+    forceExitAfterMs?: number;
+    entrypoint?: string;
+    restartArgs?: string[];
+}
+export interface ScheduleDaemonSelfRestartDeps {
+    spawn?: typeof spawn;
+    setTimeout?: typeof setTimeout;
+    kill?: (pid: number, signal: NodeJS.Signals) => void;
+    exit?: (code?: number) => never;
+    pid?: number;
+    execPath?: string;
+    argv?: string[];
+    env?: NodeJS.ProcessEnv;
+}
+export declare function findDaemonInstallPrefix(entrypoint?: string): string | null;
+export declare function resolveNpmBin(nodePath?: string): string;
+export declare function scheduleDaemonSelfRestart(opts?: ScheduleDaemonSelfRestartOptions, deps?: ScheduleDaemonSelfRestartDeps): DaemonRestartPlan;

package/dist/self-restart.js

@@ -0,0 +1,172 @@
+import { spawn } from "node:child_process";
+import { existsSync, realpathSync } from "node:fs";
+import path from "node:path";
+const DEFAULT_DAEMON_PACKAGE = "@botcord/daemon@latest";
+const DEFAULT_SHUTDOWN_DELAY_MS = 750;
+const DEFAULT_FORCE_EXIT_MS = 10_000;
+const DEFAULT_PARENT_EXIT_WAIT_MS = 30_000;
+const DEFAULT_INSTALL_TIMEOUT_MS = 120_000;
+export function findDaemonInstallPrefix(entrypoint) {
+    if (!entrypoint)
+        return null;
+    const candidates = [entrypoint, safeRealpath(entrypoint)];
+    for (const candidate of candidates) {
+        if (!candidate)
+            continue;
+        const prefix = installPrefixFromPath(candidate);
+        if (prefix)
+            return prefix;
+    }
+    return null;
+}
+export function resolveNpmBin(nodePath = process.execPath) {
+    const name = process.platform === "win32" ? "npm.cmd" : "npm";
+    const sibling = path.join(path.dirname(nodePath), name);
+    return existsSync(sibling) ? sibling : name;
+}
+export function scheduleDaemonSelfRestart(opts = {}, deps = {}) {
+    const env = deps.env ?? process.env;
+    const argv = deps.argv ?? process.argv;
+    const entrypoint = opts.entrypoint ?? argv[1];
+    if (!entrypoint) {
+        throw new Error("cannot restart daemon: process entrypoint is unknown");
+    }
+    const updateRequested = opts.update !== false;
+    const installPrefix = updateRequested ? findDaemonInstallPrefix(entrypoint) : null;
+    const packageSpec = opts.packageSpec ?? env.BOTCORD_DAEMON_PACKAGE ?? DEFAULT_DAEMON_PACKAGE;
+    const execPath = deps.execPath ?? process.execPath;
+    const pid = deps.pid ?? process.pid;
+    const restartArgs = opts.restartArgs ?? ["start", "--foreground"];
+    const supervisorEnv = {
+        ...env,
+        BOTCORD_DAEMON_CHILD: "1",
+        BOTCORD_RESTART_PARENT_PID: String(pid),
+        BOTCORD_RESTART_ENTRYPOINT: entrypoint,
+        BOTCORD_RESTART_ARGS_JSON: JSON.stringify(restartArgs),
+        BOTCORD_RESTART_NODE: execPath,
+        BOTCORD_RESTART_NPM_BIN: resolveNpmBin(execPath),
+        BOTCORD_RESTART_UPDATE: updateRequested && installPrefix ? "1" : "0",
+        BOTCORD_RESTART_INSTALL_PREFIX: installPrefix ?? "",
+        BOTCORD_RESTART_PACKAGE: packageSpec,
+        BOTCORD_RESTART_PARENT_EXIT_WAIT_MS: String(DEFAULT_PARENT_EXIT_WAIT_MS),
+        BOTCORD_RESTART_INSTALL_TIMEOUT_MS: String(DEFAULT_INSTALL_TIMEOUT_MS),
+    };
+    const spawnImpl = deps.spawn ?? spawn;
+    const child = spawnImpl(execPath, ["-e", RESTART_SUPERVISOR_SCRIPT], {
+        detached: true,
+        stdio: "ignore",
+        env: supervisorEnv,
+    });
+    child.unref();
+    const setTimer = deps.setTimeout ?? setTimeout;
+    const kill = deps.kill ?? process.kill.bind(process);
+    const exit = deps.exit ?? process.exit.bind(process);
+    const delayMs = opts.delayMs ?? DEFAULT_SHUTDOWN_DELAY_MS;
+    const forceExitAfterMs = opts.forceExitAfterMs ?? DEFAULT_FORCE_EXIT_MS;
+    const shutdownTimer = setTimer(() => {
+        try {
+            kill(pid, "SIGTERM");
+        }
+        catch {
+            exit(0);
+            return;
+        }
+        const exitTimer = setTimer(() => exit(0), forceExitAfterMs);
+        unrefTimer(exitTimer);
+    }, delayMs);
+    unrefTimer(shutdownTimer);
+    return {
+        scheduled: true,
+        updateRequested,
+        updateSupported: installPrefix !== null,
+        installPrefix,
+        packageSpec,
+    };
+}
+function safeRealpath(input) {
+    try {
+        return realpathSync(input);
+    }
+    catch {
+        return null;
+    }
+}
+function installPrefixFromPath(input) {
+    const parts = path.resolve(input).split(path.sep);
+    for (let i = parts.length - 3; i >= 0; i--) {
+        if (parts[i] !== "node_modules" ||
+            parts[i + 1] !== "@botcord" ||
+            parts[i + 2] !== "daemon") {
+            continue;
+        }
+        const prefix = parts.slice(0, i).join(path.sep) || path.sep;
+        const packageJson = path.join(prefix, "node_modules", "@botcord", "daemon", "package.json");
+        return existsSync(packageJson) ? prefix : null;
+    }
+    return null;
+}
+function unrefTimer(timer) {
+    const maybe = timer;
+    if (typeof maybe.unref === "function") {
+        maybe.unref();
+    }
+}
+const RESTART_SUPERVISOR_SCRIPT = `
+const cp = require("node:child_process");
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function alive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function main() {
+  const parentPid = Number(process.env.BOTCORD_RESTART_PARENT_PID || "0");
+  const waitMs = Number(process.env.BOTCORD_RESTART_PARENT_EXIT_WAIT_MS || "30000");
+  const deadline = Date.now() + waitMs;
+  while (parentPid > 0 && alive(parentPid) && Date.now() < deadline) {
+    await sleep(250);
+  }
+
+  const update = process.env.BOTCORD_RESTART_UPDATE === "1";
+  const installPrefix = process.env.BOTCORD_RESTART_INSTALL_PREFIX || "";
+  if (update && installPrefix) {
+    const npmBin = process.env.BOTCORD_RESTART_NPM_BIN || "npm";
+    const packageSpec = process.env.BOTCORD_RESTART_PACKAGE || "${DEFAULT_DAEMON_PACKAGE}";
+    const timeout = Number(process.env.BOTCORD_RESTART_INSTALL_TIMEOUT_MS || "120000");
+    cp.spawnSync(npmBin, ["install", "--prefix", installPrefix, packageSpec], {
+      stdio: "ignore",
+      env: process.env,
+      timeout,
+    });
+  }
+
+  const node = process.env.BOTCORD_RESTART_NODE || process.execPath;
+  const entrypoint = process.env.BOTCORD_RESTART_ENTRYPOINT;
+  if (!entrypoint) process.exit(1);
+  let args = ["start", "--foreground"];
+  try {
+    const parsed = JSON.parse(process.env.BOTCORD_RESTART_ARGS_JSON || "[]");
+    if (Array.isArray(parsed) && parsed.every((item) => typeof item === "string")) {
+      args = parsed;
+    }
+  } catch {
+    // keep default args
+  }
+  const child = cp.spawn(node, [entrypoint, ...args], {
+    detached: true,
+    stdio: "ignore",
+    env: { ...process.env, BOTCORD_DAEMON_CHILD: "1" },
+  });
+  child.unref();
+}
+
+main().catch(() => process.exit(1));
+`;