@botcord/daemon 0.2.89 → 0.2.91

package/src/daemon.ts

@@ -52,7 +52,7 @@ import { PolicyResolver, type DaemonAttentionPolicy } from "./gateway/policy-res
 import { scanMention } from "./mention-scan.js";
 import { createDiagnosticBundle, uploadDiagnosticBundle } from "./diagnostics.js";
 import { createAttentionPolicyFetcher } from "./attention-policy-fetcher.js";
-import { collectAgentSkillSnapshot } from "./skill-index.js";
+import { collectAgentSkillSnapshot, type SkillIndexOptions } from "./skill-index.js";
 
 /**
  * Default hard cap for a single runtime turn. Long-running coding/research
@@ -249,7 +249,7 @@ export function pushRuntimeSnapshot(
 export function pushAgentSkillSnapshot(
   sink: RuntimeSnapshotSink,
   agentId: string,
-  opts: { runtime?: string } = {},
+  opts: SkillIndexOptions = {},
 ): boolean {
   const snap = collectAgentSkillSnapshot(agentId, opts);
   const ok = sink.send({
@@ -354,6 +354,13 @@ export async function startDaemon(opts: DaemonRuntimeOptions): Promise<DaemonHan
   );
 
   const gwConfig = toGatewayConfig(opts.config, { agentIds, agentRuntimes });
+  const skillIndexOptionsForAgent = (agentId: string): SkillIndexOptions => {
+    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
@@ -420,6 +427,7 @@ export async function startDaemon(opts: DaemonRuntimeOptions): Promise<DaemonHan
         activityTracker,
         roomContextBuilder,
         loopRiskBuilder,
+        skillIndexOptions: () => skillIndexOptionsForAgent(aid),
       }),
     );
   }
@@ -530,11 +538,16 @@ export async function startDaemon(opts: DaemonRuntimeOptions): Promise<DaemonHan
     // 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);
     if (info.displayName) displayNameByAgent.set(info.agentId, info.displayName);
@@ -546,6 +559,7 @@ export async function startDaemon(opts: DaemonRuntimeOptions): Promise<DaemonHan
           activityTracker,
           roomContextBuilder,
           loopRiskBuilder,
+          skillIndexOptions: () => skillIndexOptionsForAgent(info.agentId),
         }),
       );
     }
@@ -677,11 +691,12 @@ export async function startDaemon(opts: DaemonRuntimeOptions): Promise<DaemonHan
         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/src/gateway/__tests__/botcord-channel.test.ts

@@ -1347,6 +1347,44 @@ describe("createBotCordChannel — typing()", () => {
       globalThis.fetch = realFetch;
     }
   });
+
+  it("refreshes the token and retries once on 401 (stale-token recovery)", async () => {
+    const fetchSpy = vi
+      .fn()
+      .mockResolvedValueOnce(new Response('{"code":"invalid_token"}', { status: 401 }))
+      .mockResolvedValueOnce(new Response(null, { status: 204 }));
+    const realFetch = globalThis.fetch;
+    globalThis.fetch = fetchSpy as unknown as typeof fetch;
+    try {
+      const client = makeClient({
+        getHubUrl: vi.fn().mockReturnValue("https://hub.example.com"),
+      });
+      const channel = createBotCordChannel({
+        id: "botcord-main",
+        accountId: "ag_self",
+        agentId: "ag_self",
+        client,
+        hubBaseUrl: "https://hub.example.com",
+      });
+      await channel.typing!({
+        traceId: "trace_401",
+        accountId: "ag_self",
+        conversationId: "rm_oc_42",
+        log: silentLog,
+      });
+      expect(client.refreshToken).toHaveBeenCalledTimes(1);
+      expect(fetchSpy).toHaveBeenCalledTimes(2);
+      // First attempt uses the stale token; the retry uses the refreshed one.
+      expect((fetchSpy.mock.calls[0][1].headers as Record<string, string>).Authorization).toBe(
+        "Bearer test-token",
+      );
+      expect((fetchSpy.mock.calls[1][1].headers as Record<string, string>).Authorization).toBe(
+        "Bearer test-token-2",
+      );
+    } finally {
+      globalThis.fetch = realFetch;
+    }
+  });
 });
 
 describe("createBotCordChannel — websocket logging", () => {

package/src/gateway/channels/botcord.ts

@@ -308,6 +308,41 @@ function normalizeInboxBatch(
   };
 }
 
+/**
+ * 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: BotCordChannelClient,
+  hubUrl: string,
+  path: string,
+  body: unknown,
+): Promise<Response> {
+  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.
  *
@@ -895,21 +930,12 @@ export function createBotCordChannel(options: BotCordChannelOptions): ChannelAda
       const client = ensureClient();
       const hubUrl = options.hubBaseUrl ?? client.getHubUrl();
       try {
-        const token = await client.ensureToken();
         const block = ctx.block as { raw?: unknown; kind?: string; seq?: number } | undefined;
         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(() => "");
@@ -927,15 +953,8 @@ export function createBotCordChannel(options: BotCordChannelOptions): ChannelAda
       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/src/provision.ts

@@ -28,6 +28,8 @@ import {
   type StoredBotCordCredentials,
   type UpdateAgentParams,
   type GatewayInboundFrame,
+  type InstallAgentSkillParams,
+  type ListAgentSkillsParams,
 } from "@botcord/protocol-core";
 import type { Gateway } from "./gateway/index.js";
 import type { GatewayInboundMessage } from "./gateway/index.js";
@@ -75,7 +77,12 @@ import { log as daemonLog } from "./log.js";
 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 { collectAgentSkillSnapshot, type SkillIndexOptions } from "./skill-index.js";
+import {
+  installAgentSkillManifest,
+  installBotLearnArchiveManifest,
+  installVercelSkillsForAgent,
+} from "./skill-installer.js";
 import {
   buildRuntimeSelectionExtraArgs,
   mergeRuntimeExtraArgs,
@@ -84,15 +91,23 @@ import {
   handleCloudGatewayRuntimeInbound,
   type CloudGatewayTypingEmitter,
 } from "./cloud-gateway-runtime.js";
+import { scheduleDaemonSelfRestart } from "./self-restart.js";
 
-interface ListAgentSkillsParams {
-  agentId: string;
-}
-
-function runtimeForLoadedAgent(gateway: Gateway, agentId: string): string | undefined {
-  return gateway.listManagedRoutes()
-    .find((route) => route.match?.accountId === agentId)
-    ?.runtime;
+function skillIndexOptionsForLoadedAgent(gateway: Gateway, agentId: string): SkillIndexOptions {
+  const route = gateway.listManagedRoutes()
+    .find((entry) => entry.match?.accountId === agentId);
+  let credentials: StoredBotCordCredentials | null = 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 } : {}),
+  };
 }
 
 /**
@@ -108,6 +123,7 @@ export interface InstalledAgentInfo {
   hubUrl: string;
   displayName?: string;
   runtime?: string;
+  hermesProfile?: string;
 }
 
 /**
@@ -382,6 +398,17 @@ export function createProvisioner(opts: ProvisionerOptions): (
         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();
 
@@ -516,16 +543,77 @@ export function createProvisioner(opts: ProvisionerOptions): (
             },
           };
         }
-        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 ?? {}) as unknown as InstallAgentSkillParams;
+        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);
       }
@@ -653,8 +741,15 @@ async function handleWakeAgent(gateway: Gateway, raw: unknown): Promise<AckBody>
     },
   };
 
-  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 } };
 }
 
 // W8: hand-written runtime validator for the third-party gateway frame
@@ -1118,6 +1213,7 @@ async function installLocalAgent(
         hubUrl: credentials.hubUrl,
         ...(credentials.displayName ? { displayName: credentials.displayName } : {}),
         ...(credentials.runtime ? { runtime: credentials.runtime } : {}),
+        ...(credentials.hermesProfile ? { hermesProfile: credentials.hermesProfile } : {}),
       });
     } catch (err) {
       // Hook misbehavior must not fail the install — the agent is already
@@ -1212,6 +1308,7 @@ async function installExistingOpenclawBinding(
         hubUrl: credentials.hubUrl,
         ...(credentials.displayName ? { displayName: credentials.displayName } : {}),
         ...(credentials.runtime ? { runtime: credentials.runtime } : {}),
+        ...(credentials.hermesProfile ? { hermesProfile: credentials.hermesProfile } : {}),
       });
     } catch (err) {
       daemonLog.error("provision.onAgentInstalled threw — caches may be stale", {

package/src/runtime-models.ts

@@ -68,6 +68,37 @@ const KIMI_FALLBACK_MODELS: RuntimeModelProbe[] = [
   { 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: RuntimeModelProbe[] = [
+  { 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",
+  },
+];
+
 export interface RuntimeModelDiscovery {
   models?: RuntimeModelProbe[];
   parameters?: RuntimeParameterProbe[];
@@ -160,6 +191,22 @@ function runtimeCatalogStrategy(entry: RuntimeProbeEntry): RuntimeCatalogStrateg
           ],
         }),
       };
+    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/src/self-restart.ts

@@ -0,0 +1,218 @@
+import { spawn, type ChildProcess } 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 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 function findDaemonInstallPrefix(entrypoint?: string): string | null {
+  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): string {
+  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: ScheduleDaemonSelfRestartOptions = {},
+  deps: ScheduleDaemonSelfRestartDeps = {},
+): DaemonRestartPlan {
+  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: NodeJS.ProcessEnv = {
+    ...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,
+  }) as ChildProcess;
+  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: string): string | null {
+  try {
+    return realpathSync(input);
+  } catch {
+    return null;
+  }
+}
+
+function installPrefixFromPath(input: string): string | null {
+  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: ReturnType<typeof setTimeout>): void {
+  const maybe = timer as { unref?: () => void };
+  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));
+`;