@botcord/daemon 0.2.90 → 0.2.91

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.js

@@ -23,6 +23,7 @@ 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";
+import { scheduleDaemonSelfRestart } from "./self-restart.js";
 function skillIndexOptionsForLoadedAgent(gateway, agentId) {
     const route = gateway.listManagedRoutes()
         .find((entry) => entry.match?.accountId === agentId);
@@ -240,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": {
@@ -530,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)) {

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));
+`;

package/dist/skill-index.js

@@ -18,6 +18,18 @@ export function defaultSkillDirs(agentId, opts = {}) {
         source: "agent-codex",
         runtime: "codex",
     };
+    const agentGemini = [
+        {
+            dir: path.join(agentWorkspaceDir(agentId), ".gemini", "skills"),
+            source: "agent-gemini",
+            runtime: "gemini",
+        },
+        {
+            dir: path.join(agentWorkspaceDir(agentId), ".agents", "skills"),
+            source: "agent-agents",
+            runtime: "gemini",
+        },
+    ];
     const agentHermes = hermesSkillRoot(agentId, opts.hermesProfile);
     const dirs = [];
     switch (runtimeFamily(opts.runtime)) {
@@ -34,6 +46,20 @@ export function defaultSkillDirs(agentId, opts = {}) {
         case "hermes":
             dirs.push(agentHermes);
             break;
+        case "gemini":
+            dirs.push(...agentGemini);
+            if (includeGlobal) {
+                dirs.push({
+                    dir: path.join(homedir(), ".gemini", "skills"),
+                    source: "global-gemini",
+                    runtime: "gemini",
+                }, {
+                    dir: path.join(homedir(), ".agents", "skills"),
+                    source: "global-agents",
+                    runtime: "gemini",
+                });
+            }
+            break;
         case "claude":
             dirs.push(agentClaude);
             if (includeGlobal) {
@@ -228,6 +254,8 @@ function hermesSkillRoot(agentId, profile) {
 function runtimeFamily(runtime) {
     if (runtime === "codex")
         return "codex";
+    if (runtime === "gemini")
+        return "gemini";
     if (runtime === "hermes-agent")
         return "hermes";
     if (!runtime)
@@ -237,18 +265,11 @@ function runtimeFamily(runtime) {
     return "other";
 }
 function priority(source, _runtime) {
-    switch (source) {
-        case "agent-claude":
-        case "agent-codex":
-        case "agent-hermes":
-        case "agent-hermes-profile":
-            return 0;
-        case "global-claude":
-        case "global-codex":
-            return 1;
-        default:
-            return 2;
-    }
+    if (source.startsWith("agent-"))
+        return 0;
+    if (source.startsWith("global-"))
+        return 1;
+    return 2;
 }
 function snapshotSource(source) {
     return source.startsWith("agent-") ? "workspace" : "runtime-global";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botcord/daemon",
-  "version": "0.2.90",
+  "version": "0.2.91",
   "description": "BotCord local daemon — bridges Hub inbox push to local Claude Code / Codex / Gemini CLIs",
   "type": "module",
   "bin": {
@@ -24,7 +24,7 @@
     "@larksuiteoapi/node-sdk": "^1.63.1",
     "ws": "^8.20.1",
     "@botcord/protocol-core": "^0.2.13",
-    "@botcord/cli": "^0.1.18"
+    "@botcord/cli": "^0.1.19"
   },
   "overrides": {
     "axios": "^1.15.2"

package/src/__tests__/provision.test.ts

@@ -336,6 +336,29 @@ describe("wake_agent handler", () => {
     });
   });
 
+  it("acks wake_agent after queueing instead of waiting for the turn to finish", async () => {
+    const gw = makeFakeGateway(["ag_wake"]);
+    gw.injectInbound.mockImplementation(() => new Promise(() => undefined));
+    const handler = createProvisioner({ gateway: gw as any });
+
+    const res = await Promise.race([
+      handler({
+        id: "req_wake_pending",
+        type: "wake_agent",
+        params: {
+          agent_id: "ag_wake",
+          message: "tick",
+          run_id: "sr_pending",
+        },
+      }),
+      new Promise<"timeout">((resolve) => setTimeout(() => resolve("timeout"), 20)),
+    ]);
+
+    expect(res).not.toBe("timeout");
+    expect(res).toMatchObject({ ok: true, result: { agent_id: "ag_wake", queued: true } });
+    expect(gw.injectInbound).toHaveBeenCalledTimes(1);
+  });
+
   it("rejects wake_agent for an unloaded agent", async () => {
     const gw = makeFakeGateway(["ag_loaded"]);
     const handler = createProvisioner({ gateway: gw as any });

package/src/__tests__/self-restart.test.ts

@@ -0,0 +1,57 @@
+import {
+  mkdirSync,
+  mkdtempSync,
+  realpathSync,
+  rmSync,
+  symlinkSync,
+  writeFileSync,
+} from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { findDaemonInstallPrefix } from "../self-restart.js";
+
+describe("self restart install prefix detection", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = mkdtempSync(path.join(os.tmpdir(), "botcord-self-restart-"));
+  });
+
+  afterEach(() => {
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("finds the npm install prefix for a managed @botcord/daemon entrypoint", () => {
+    const prefix = path.join(tmpDir, ".botcord", "daemon");
+    const packageRoot = path.join(prefix, "node_modules", "@botcord", "daemon");
+    const entrypoint = path.join(packageRoot, "dist", "index.js");
+    mkdirSync(path.dirname(entrypoint), { recursive: true });
+    writeFileSync(path.join(packageRoot, "package.json"), '{"name":"@botcord/daemon"}');
+    writeFileSync(entrypoint, "");
+
+    expect(findDaemonInstallPrefix(entrypoint)).toBe(prefix);
+  });
+
+  it("resolves npm .bin symlinks before looking for the package root", () => {
+    const prefix = path.join(tmpDir, ".botcord", "daemon");
+    const packageRoot = path.join(prefix, "node_modules", "@botcord", "daemon");
+    const entrypoint = path.join(packageRoot, "dist", "index.js");
+    const bin = path.join(prefix, "node_modules", ".bin", "botcord-daemon");
+    mkdirSync(path.dirname(entrypoint), { recursive: true });
+    mkdirSync(path.dirname(bin), { recursive: true });
+    writeFileSync(path.join(packageRoot, "package.json"), '{"name":"@botcord/daemon"}');
+    writeFileSync(entrypoint, "");
+    symlinkSync(entrypoint, bin);
+
+    expect(findDaemonInstallPrefix(bin)).toBe(realpathSync(prefix));
+  });
+
+  it("does not treat a monorepo development entrypoint as self-updatable", () => {
+    const entrypoint = path.join(tmpDir, "packages", "daemon", "dist", "index.js");
+    mkdirSync(path.dirname(entrypoint), { recursive: true });
+    writeFileSync(entrypoint, "");
+
+    expect(findDaemonInstallPrefix(entrypoint)).toBeNull();
+  });
+});

package/src/__tests__/skill-index.test.ts

@@ -149,6 +149,47 @@ describe("skill snapshots", () => {
     });
   });
 
+  it("scans Gemini workspace and user skill roots without mixing Claude or Codex dirs", () => {
+    const agentId = "ag_gemini_skills";
+    const workspaceGemini = path.join(agentWorkspaceDir(agentId), ".gemini", "skills");
+    const workspaceAgents = path.join(agentWorkspaceDir(agentId), ".agents", "skills");
+    writeSkill(workspaceGemini, "workspace-gemini", "Workspace Gemini skill");
+    writeSkill(workspaceAgents, "workspace-agent", "Workspace shared-agent skill");
+    writeSkill(path.join(tmpDir, ".gemini", "skills"), "global-gemini", "Global Gemini skill");
+    writeSkill(path.join(tmpDir, ".agents", "skills"), "global-agent", "Global shared-agent skill");
+    writeSkill(path.join(agentWorkspaceDir(agentId), ".claude", "skills"), "claude-only", "Claude only");
+    writeSkill(path.join(agentCodexHomeDir(agentId), "skills"), "codex-only", "Codex only");
+
+    const geminiScanned = scanSoftSkills(agentId, { runtime: "gemini" });
+    expect(geminiScanned.map((s) => s.name)).toEqual([
+      "global-agent",
+      "global-gemini",
+      "workspace-agent",
+      "workspace-gemini",
+    ]);
+    expect(geminiScanned.every((s) => s.runtime === "gemini")).toBe(true);
+
+    const snapshot = collectAgentSkillSnapshot(agentId, { runtime: "gemini" });
+    expect(snapshot.runtime).toBe("gemini");
+    expect(snapshot.skills.find((s) => s.name === "workspace-gemini"))
+      .toMatchObject({
+        source: "workspace",
+        sourceDetail: "agent-gemini",
+        runtime: "gemini",
+        path: path.join(workspaceGemini, "workspace-gemini", "SKILL.md"),
+      });
+    expect(snapshot.skills.find((s) => s.name === "workspace-agent"))
+      .toMatchObject({
+        source: "workspace",
+        sourceDetail: "agent-agents",
+      });
+    expect(snapshot.skills.find((s) => s.name === "global-agent"))
+      .toMatchObject({
+        source: "runtime-global",
+        sourceDetail: "global-agents",
+      });
+  });
+
   it("keeps same-device workspace skills scoped by agent id", () => {
     writeSkill(
       path.join(agentWorkspaceDir("ag_workspace_a"), ".claude", "skills"),

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

@@ -91,6 +91,7 @@ import {
   handleCloudGatewayRuntimeInbound,
   type CloudGatewayTypingEmitter,
 } from "./cloud-gateway-runtime.js";
+import { scheduleDaemonSelfRestart } from "./self-restart.js";
 
 function skillIndexOptionsForLoadedAgent(gateway: Gateway, agentId: string): SkillIndexOptions {
   const route = gateway.listManagedRoutes()
@@ -397,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();
 
@@ -729,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

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));
+`;

package/src/skill-index.ts

@@ -74,6 +74,18 @@ export function defaultSkillDirs(
     source: "agent-codex",
     runtime: "codex",
   };
+  const agentGemini = [
+    {
+      dir: path.join(agentWorkspaceDir(agentId), ".gemini", "skills"),
+      source: "agent-gemini",
+      runtime: "gemini",
+    },
+    {
+      dir: path.join(agentWorkspaceDir(agentId), ".agents", "skills"),
+      source: "agent-agents",
+      runtime: "gemini",
+    },
+  ];
   const agentHermes = hermesSkillRoot(agentId, opts.hermesProfile);
 
   const dirs: SkillRoot[] = [];
@@ -91,6 +103,23 @@ export function defaultSkillDirs(
     case "hermes":
       dirs.push(agentHermes);
       break;
+    case "gemini":
+      dirs.push(...agentGemini);
+      if (includeGlobal) {
+        dirs.push(
+          {
+            dir: path.join(homedir(), ".gemini", "skills"),
+            source: "global-gemini",
+            runtime: "gemini",
+          },
+          {
+            dir: path.join(homedir(), ".agents", "skills"),
+            source: "global-agents",
+            runtime: "gemini",
+          },
+        );
+      }
+      break;
     case "claude":
       dirs.push(agentClaude);
       if (includeGlobal) {
@@ -308,8 +337,9 @@ function hermesSkillRoot(agentId: string, profile: string | undefined): SkillRoo
   };
 }
 
-function runtimeFamily(runtime: string | undefined): "codex" | "claude" | "hermes" | "other" {
+function runtimeFamily(runtime: string | undefined): "codex" | "claude" | "gemini" | "hermes" | "other" {
   if (runtime === "codex") return "codex";
+  if (runtime === "gemini") return "gemini";
   if (runtime === "hermes-agent") return "hermes";
   if (!runtime) return "claude";
   if (runtime === "claude-code") return "claude";
@@ -317,18 +347,9 @@ function runtimeFamily(runtime: string | undefined): "codex" | "claude" | "herme
 }
 
 function priority(source: string, _runtime: string | undefined): number {
-  switch (source) {
-    case "agent-claude":
-    case "agent-codex":
-    case "agent-hermes":
-    case "agent-hermes-profile":
-      return 0;
-    case "global-claude":
-    case "global-codex":
-      return 1;
-    default:
-      return 2;
-  }
+  if (source.startsWith("agent-")) return 0;
+  if (source.startsWith("global-")) return 1;
+  return 2;
 }
 
 function snapshotSource(source: string): "workspace" | "runtime-global" {