@botcord/daemon 0.2.85 → 0.2.86

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botcord/daemon",
-  "version": "0.2.85",
+  "version": "0.2.86",
   "description": "BotCord local daemon — bridges Hub inbox push to local Claude Code / Codex / Gemini CLIs",
   "type": "module",
   "bin": {
@@ -8,12 +8,6 @@
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "scripts": {
-    "build": "tsc -p tsconfig.build.json",
-    "prepublishOnly": "tsc -p tsconfig.build.json",
-    "test": "vitest run",
-    "test:watch": "vitest"
-  },
   "files": [
     "dist/",
     "src/",
@@ -27,10 +21,10 @@
     "access": "public"
   },
   "dependencies": {
-    "@botcord/cli": "^0.1.7",
-    "@botcord/protocol-core": "^0.2.12",
     "@larksuiteoapi/node-sdk": "^1.63.1",
-    "ws": "^8.20.1"
+    "ws": "^8.20.1",
+    "@botcord/cli": "^0.1.18",
+    "@botcord/protocol-core": "^0.2.13"
   },
   "overrides": {
     "axios": "^1.15.2"
@@ -40,5 +34,10 @@
     "@types/ws": "^8.5.0",
     "typescript": "^5.4.0",
     "vitest": "^4.0.18"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "test": "vitest run",
+    "test:watch": "vitest"
   }
-}
+}

package/src/__tests__/cloud-daemon.test.ts

@@ -20,6 +20,7 @@ import type { CloudModeConfig } from "../cloud-mode.js";
 import { ControlChannel } from "../control-channel.js";
 import type { DaemonConfig } from "../config.js";
 import type { Gateway, GatewayChannelConfig } from "../gateway/index.js";
+import type { OnAgentInstalledHook } from "../provision.js";
 
 class FakeWebSocket extends EventEmitter {
   public readyState = 0;
@@ -75,6 +76,10 @@ function makeDaemonCfg(): DaemonConfig {
   };
 }
 
+function sentFrames(ws: FakeWebSocket): Array<{ type?: string; params?: any }> {
+  return ws.sent.map((raw) => JSON.parse(raw));
+}
+
 describe("startCloudDaemon", () => {
   let tmpDir: string;
 
@@ -173,6 +178,80 @@ describe("startCloudDaemon", () => {
     }
   });
 
+  it("pushes skill snapshots for agents installed before control-channel startup completes", async () => {
+    const ctor = makeFakeCtor();
+    class TestControlChannel extends ControlChannel {
+      constructor(opts: ConstructorParameters<typeof ControlChannel>[0]) {
+        super({ ...opts, webSocketCtor: ctor, hubPublicKey: null });
+      }
+    }
+    const handle = await startCloudDaemon({
+      cloudConfig: makeCfg(),
+      config: makeDaemonCfg(),
+      configPath: "(cloud-mode)",
+      controlChannelFactory: TestControlChannel as unknown as typeof ControlChannel,
+      provisionerFactory: ((args: { onAgentInstalled: OnAgentInstalledHook }) => {
+        args.onAgentInstalled({
+          agentId: "ag_preinstalled",
+          credentialsFile: path.join(tmpDir, "ag_preinstalled.json"),
+          hubUrl: "http://localhost:9000",
+        });
+        return vi.fn();
+      }) as unknown as typeof import("../provision.js").createProvisioner,
+      sessionStorePath: path.join(tmpDir, "sessions.json"),
+      snapshotPath: path.join(tmpDir, "snapshot.json"),
+      snapshotIntervalMs: 60_000,
+    });
+    try {
+      await new Promise((r) => setImmediate(r));
+      const ws = FakeWebSocket.instances[0]!;
+      const skillFrames = sentFrames(ws).filter((frame) => frame.type === "agent_skill_snapshot");
+      expect(skillFrames).toHaveLength(1);
+      expect(skillFrames[0]!.params.agentId).toBe("ag_preinstalled");
+      expect(Array.isArray(skillFrames[0]!.params.skills)).toBe(true);
+    } finally {
+      await handle.stop("test");
+    }
+  });
+
+  it("pushes a skill snapshot when a cloud agent is installed after startup", async () => {
+    let onAgentInstalled: OnAgentInstalledHook | undefined;
+    const ctor = makeFakeCtor();
+    class TestControlChannel extends ControlChannel {
+      constructor(opts: ConstructorParameters<typeof ControlChannel>[0]) {
+        super({ ...opts, webSocketCtor: ctor, hubPublicKey: null });
+      }
+    }
+    const handle = await startCloudDaemon({
+      cloudConfig: makeCfg(),
+      config: makeDaemonCfg(),
+      configPath: "(cloud-mode)",
+      controlChannelFactory: TestControlChannel as unknown as typeof ControlChannel,
+      provisionerFactory: ((args: { onAgentInstalled: OnAgentInstalledHook }) => {
+        onAgentInstalled = args.onAgentInstalled;
+        return vi.fn();
+      }) as unknown as typeof import("../provision.js").createProvisioner,
+      sessionStorePath: path.join(tmpDir, "sessions.json"),
+      snapshotPath: path.join(tmpDir, "snapshot.json"),
+      snapshotIntervalMs: 60_000,
+    });
+    try {
+      await new Promise((r) => setImmediate(r));
+      onAgentInstalled!({
+        agentId: "ag_hot_installed",
+        credentialsFile: path.join(tmpDir, "ag_hot_installed.json"),
+        hubUrl: "http://localhost:9000",
+      });
+      const ws = FakeWebSocket.instances[0]!;
+      const skillFrames = sentFrames(ws).filter((frame) => frame.type === "agent_skill_snapshot");
+      expect(skillFrames).toHaveLength(1);
+      expect(skillFrames[0]!.params.agentId).toBe("ag_hot_installed");
+      expect(Array.isArray(skillFrames[0]!.params.skills)).toBe(true);
+    } finally {
+      await handle.stop("test");
+    }
+  });
+
   it.each(["telegram", "wechat", "feishu"] as const)(
     "allows %s gateway channels to be hot-plugged in cloud mode",
     async (type) => {

package/src/__tests__/daemon-singleton.test.ts

@@ -1,9 +1,10 @@
 import { spawn, type ChildProcess } from "node:child_process";
-import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
 import {
+  acquireDaemonSingletonLock,
   ensureNoOtherDaemonFromPidFile,
   isBotCordDaemonStartCommand,
   parseDaemonProcesses,
@@ -79,6 +80,63 @@ describe("daemon singleton pid helpers", () => {
     expect(child.exitCode === null && child.signalCode === null).toBe(false);
   });
 
+  it("holds an atomic singleton lock until release", async () => {
+    const pidPath = path.join(tmpDir, "daemon.pid");
+    const lockPath = `${pidPath}.lock`;
+
+    const lock = await acquireDaemonSingletonLock({
+      pidPath,
+      lockPath,
+      currentPid: process.pid,
+    });
+
+    expect(existsSync(lockPath)).toBe(true);
+    expect(readPid(path.join(lockPath, "owner.pid"))).toBe(process.pid);
+
+    lock.release();
+
+    expect(existsSync(lockPath)).toBe(false);
+  });
+
+  it("removes stale singleton locks", async () => {
+    const pidPath = path.join(tmpDir, "daemon.pid");
+    const lockPath = `${pidPath}.lock`;
+    mkdirSync(lockPath, { recursive: true });
+    writeCurrentPid({ pidPath: path.join(lockPath, "owner.pid"), currentPid: 99999999 });
+
+    const lock = await acquireDaemonSingletonLock({
+      pidPath,
+      lockPath,
+      currentPid: process.pid,
+    });
+
+    expect(readPid(path.join(lockPath, "owner.pid"))).toBe(process.pid);
+    lock.release();
+  });
+
+  it("terminates a live singleton lock owner before acquiring", async () => {
+    const pidPath = path.join(tmpDir, "daemon.pid");
+    const lockPath = `${pidPath}.lock`;
+    const child = spawn(process.execPath, ["-e", "setInterval(() => {}, 1000)"], {
+      stdio: "ignore",
+    });
+    children.push(child);
+    await waitForPid(child);
+    mkdirSync(lockPath, { recursive: true });
+    writeCurrentPid({ pidPath: path.join(lockPath, "owner.pid"), currentPid: child.pid! });
+
+    const lock = await acquireDaemonSingletonLock({
+      pidPath,
+      lockPath,
+      currentPid: process.pid,
+    });
+
+    await waitForExit(child);
+    expect(child.exitCode === null && child.signalCode === null).toBe(false);
+    expect(readPid(path.join(lockPath, "owner.pid"))).toBe(process.pid);
+    lock.release();
+  });
+
   it("removes stale pid files", () => {
     const pidPath = path.join(tmpDir, "daemon.pid");
     writeCurrentPid({ pidPath, currentPid: 99999999 });

package/src/__tests__/provision.test.ts

@@ -719,6 +719,48 @@ describe("provision_agent handler writes runtime + cwd", () => {
     }
   });
 
+  it("normalizes Hub-supplied millisecond tokenExpiresAt before writing credentials", async () => {
+    const os = await import("node:os");
+    const fs = await import("node:fs");
+    const nodePath = await import("node:path");
+
+    const tmp = fs.mkdtempSync(nodePath.join(os.tmpdir(), "daemon-provision-"));
+    const prevHome = process.env.HOME;
+    process.env.HOME = tmp;
+    try {
+      const gw = makeFakeGateway();
+      const provisioner = createProvisioner({
+        gateway: gw as unknown as Parameters<typeof createProvisioner>[0]["gateway"],
+      });
+      const privateKey = Buffer.alloc(32, 9).toString("base64");
+
+      const ack = await provisioner({
+        id: "req_token_expiry",
+        type: CONTROL_FRAME_TYPES.PROVISION_AGENT,
+        params: {
+          runtime: "codex",
+          credentials: {
+            agentId: "ag_token_expiry",
+            keyId: "k_token_expiry",
+            privateKey,
+            hubUrl: "https://hub.example",
+            token: "agent-token",
+            tokenExpiresAt: 1_779_856_985_546,
+          },
+        },
+      });
+
+      expect(ack.ok).toBe(true);
+      const credFile = nodePath.join(tmp, ".botcord", "credentials", "ag_token_expiry.json");
+      const saved = JSON.parse(fs.readFileSync(credFile, "utf8")) as Record<string, unknown>;
+      expect(saved.tokenExpiresAt).toBe(1_779_856_985);
+    } finally {
+      if (prevHome === undefined) delete process.env.HOME;
+      else process.env.HOME = prevHome;
+      fs.rmSync(tmp, { recursive: true, force: true });
+    }
+  });
+
   it("rejects unknown runtime ids before touching disk", async () => {
     const gw = makeFakeGateway();
     const provisioner = createProvisioner({

package/src/__tests__/runtime-discovery.test.ts

@@ -40,7 +40,7 @@ beforeEach(() => {
   // mocked runtime list between cases, so reset before each.
   clearRuntimeProbeCache();
 });
-const { pushRuntimeSnapshot } = await import("../daemon.js");
+const { pushAgentSkillSnapshot, pushRuntimeSnapshot } = await import("../daemon.js");
 const { CONTROL_FRAME_TYPES } = await import("@botcord/protocol-core");
 import type { GatewayChannelConfig, GatewayRuntimeSnapshot } from "../gateway/index.js";
 
@@ -474,6 +474,22 @@ describe("pushRuntimeSnapshot (first-connect push)", () => {
   });
 });
 
+describe("pushAgentSkillSnapshot", () => {
+  it("sends an agent_skill_snapshot frame", () => {
+    const frames: any[] = [];
+    const ok = pushAgentSkillSnapshot(
+      { send: (frame) => { frames.push(frame); return true; } },
+      "ag_skills",
+    );
+    expect(ok).toBe(true);
+    expect(frames).toHaveLength(1);
+    expect(frames[0].type).toBe("agent_skill_snapshot");
+    expect(frames[0].params.agentId).toBe("ag_skills");
+    expect(Array.isArray(frames[0].params.skills)).toBe(true);
+    expect(typeof frames[0].params.probedAt).toBe("number");
+  });
+});
+
 describe("attachRuntimeHealth", () => {
   it("groups live circuit breakers onto matching runtime entries", () => {
     const snap = {

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

@@ -0,0 +1,91 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import {
+  agentCodexHomeDir,
+  agentWorkspaceDir,
+} from "../agent-workspace.js";
+import {
+  buildSoftSkillIndexPrompt,
+  collectAgentSkillSnapshot,
+  scanSoftSkills,
+} from "../skill-index.js";
+
+let tmpDir = "";
+let prevHome: string | undefined;
+
+function writeSkill(dir: string, name: string, description: string): void {
+  const skillDir = path.join(dir, name);
+  mkdirSync(skillDir, { recursive: true });
+  writeFileSync(
+    path.join(skillDir, "SKILL.md"),
+    `---\nname: ${name}\ndescription: "${description}"\n---\n\n# ${name}\n`,
+  );
+}
+
+beforeEach(() => {
+  tmpDir = mkdtempSync(path.join(tmpdir(), "skill-index-"));
+  prevHome = process.env.HOME;
+  process.env.HOME = tmpDir;
+});
+
+afterEach(() => {
+  if (prevHome === undefined) delete process.env.HOME;
+  else process.env.HOME = prevHome;
+  rmSync(tmpDir, { recursive: true, force: true });
+});
+
+describe("skill snapshots", () => {
+  it("scans agent workspace/runtime-global skills and maps UI source buckets", () => {
+    const agentId = "ag_skilltest";
+    writeSkill(path.join(agentWorkspaceDir(agentId), ".claude", "skills"), "workspace-skill", "Workspace skill");
+    writeSkill(path.join(agentCodexHomeDir(agentId), "skills"), "codex-skill", "Codex skill");
+    writeSkill(path.join(tmpDir, ".codex", "skills"), "global-skill", "Global skill");
+
+    const scanned = scanSoftSkills(agentId);
+    expect(scanned.map((s) => s.name).sort()).toEqual([
+      "codex-skill",
+      "global-skill",
+      "workspace-skill",
+    ]);
+
+    const snapshot = collectAgentSkillSnapshot(agentId);
+    expect(snapshot.agentId).toBe(agentId);
+    expect(snapshot.skills).toHaveLength(3);
+    expect(snapshot.skills.find((s) => s.name === "workspace-skill")?.source)
+      .toBe("workspace");
+    expect(snapshot.skills.find((s) => s.name === "codex-skill")?.source)
+      .toBe("workspace");
+    expect(snapshot.skills.find((s) => s.name === "global-skill")?.source)
+      .toBe("runtime-global");
+    expect(snapshot.probedAt).toBeGreaterThan(0);
+  });
+
+  it("returns complete snapshots while keeping the prompt soft index capped", () => {
+    const agentId = "ag_manyskills";
+    const workspaceSkills = path.join(agentWorkspaceDir(agentId), ".claude", "skills");
+    for (let i = 0; i < 30; i += 1) {
+      const name = `skill-${String(i).padStart(2, "0")}`;
+      writeSkill(workspaceSkills, name, `Skill ${i}`);
+    }
+
+    const scanned = scanSoftSkills(agentId);
+    expect(scanned).toHaveLength(30);
+    expect(scanned.map((s) => s.name)).toEqual(
+      Array.from({ length: 30 }, (_, i) => `skill-${String(i).padStart(2, "0")}`),
+    );
+
+    const snapshot = collectAgentSkillSnapshot(agentId);
+    expect(snapshot.skills).toHaveLength(30);
+
+    const prompt = buildSoftSkillIndexPrompt(agentId);
+    expect(prompt).not.toBeNull();
+    const skillLines = prompt
+      ?.split("\n")
+      .filter((line) => line.startsWith("- skill-"));
+    expect(skillLines).toHaveLength(24);
+    expect(skillLines?.at(0)).toContain("skill-00");
+    expect(skillLines?.at(-1)).toContain("skill-23");
+  });
+});

package/src/cloud-daemon.ts

@@ -27,7 +27,7 @@ import { ControlChannel } from "./control-channel.js";
 import { toGatewayConfig } from "./daemon-config-map.js";
 import { log as daemonLog } from "./log.js";
 import { createProvisioner } from "./provision.js";
-import { createDaemonChannel, pushRuntimeSnapshot } from "./daemon.js";
+import { createDaemonChannel, pushAgentSkillSnapshot, pushRuntimeSnapshot } from "./daemon.js";
 import { SnapshotWriter } from "./snapshot-writer.js";
 import { createDaemonSystemContextBuilder } from "./system-context.js";
 import { readWorkingMemorySnapshot } from "./working-memory.js";
@@ -234,7 +234,20 @@ export async function startCloudDaemon(
     });
   };
 
+  const installedAgentIds = new Set<string>();
+  let controlChannel: ControlChannel | null = null;
+  const pushInstalledAgentSkillSnapshot = (agentId: string, reason: string): void => {
+    if (!controlChannel) return;
+    const pushed = pushAgentSkillSnapshot(controlChannel, agentId);
+    logger.info("cloud control-channel: agent_skill_snapshot pushed", {
+      agentId,
+      reason,
+      ok: pushed,
+    });
+  };
+
   const onAgentInstalled: OnAgentInstalledHook = (info: InstalledAgentInfo) => {
+    installedAgentIds.add(info.agentId);
     credentialPathByAgentId.set(info.agentId, info.credentialsFile);
     if (info.hubUrl) hubUrlByAgentId.set(info.agentId, info.hubUrl);
     if (info.displayName) displayNameByAgent.set(info.agentId, info.displayName);
@@ -251,6 +264,7 @@ export async function startCloudDaemon(
         }),
       );
     }
+    pushInstalledAgentSkillSnapshot(info.agentId, "agent_installed");
   };
 
   const gateway = new Gateway({
@@ -281,7 +295,6 @@ export async function startCloudDaemon(
   await gateway.start();
   logger.info("cloud daemon gateway started (zero agents at boot)");
 
-  let controlChannel: ControlChannel | null = null;
   if (!opts.disableControlChannel) {
     const auth = asUserAuthManager(new CloudAuthManager(cloudCfg));
     const provisionerFactory = opts.provisionerFactory ?? createProvisioner;
@@ -330,6 +343,9 @@ export async function startCloudDaemon(
       logger.info("cloud control-channel started; runtime_snapshot pushed", {
         ok: pushed,
       });
+      for (const agentId of installedAgentIds) {
+        pushInstalledAgentSkillSnapshot(agentId, "control_channel_started");
+      }
     } catch (err) {
       logger.warn("cloud control-channel start failed; daemon will retry", {
         error: err instanceof Error ? err.message : String(err),

package/src/daemon-singleton.ts

@@ -1,5 +1,5 @@
 import { execFileSync } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import { PID_PATH } from "./config.js";
 
@@ -17,6 +17,18 @@ const noopLogger: SingletonLogger = {
   },
 };
 
+const DEFAULT_LOCK_WAIT_MS = 15_000;
+const DEFAULT_LOCK_RETRY_MS = 50;
+
+export interface DaemonSingletonLock {
+  lockPath: string;
+  release(): void;
+}
+
+export function defaultLockPath(pidPath = PID_PATH): string {
+  return `${pidPath}.lock`;
+}
+
 export function readPid(pidPath = PID_PATH): number | null {
   if (!existsSync(pidPath)) return null;
   const raw = readFileSync(pidPath, "utf8").trim();
@@ -24,6 +36,10 @@ export function readPid(pidPath = PID_PATH): number | null {
   return Number.isFinite(pid) && pid > 0 ? pid : null;
 }
 
+function readLockOwner(lockPath: string): number | null {
+  return readPid(path.join(lockPath, "owner.pid"));
+}
+
 export function pidAlive(pid: number): boolean {
   try {
     process.kill(pid, 0);
@@ -127,6 +143,78 @@ export async function stopDaemonFromPidFileForRestart(
   }
 }
 
+export async function acquireDaemonSingletonLock(
+  opts: {
+    lockPath?: string;
+    pidPath?: string;
+    currentPid?: number;
+    logger?: SingletonLogger;
+    timeoutMs?: number;
+  } = {},
+): Promise<DaemonSingletonLock> {
+  const pidPath = opts.pidPath ?? PID_PATH;
+  const lockPath = opts.lockPath ?? defaultLockPath(pidPath);
+  const currentPid = opts.currentPid ?? process.pid;
+  const logger = opts.logger ?? noopLogger;
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_LOCK_WAIT_MS;
+  const deadline = Date.now() + timeoutMs;
+
+  ensureParentDir(lockPath);
+  while (true) {
+    try {
+      mkdirSync(lockPath, { mode: 0o700 });
+      writeFileSync(path.join(lockPath, "owner.pid"), String(currentPid), { mode: 0o600 });
+      return {
+        lockPath,
+        release() {
+          const owner = readLockOwner(lockPath);
+          if (owner !== null && owner !== currentPid) return;
+          try {
+            rmSync(lockPath, { recursive: true, force: true });
+          } catch {
+            // ignore
+          }
+        },
+      };
+    } catch (err) {
+      const code = (err as NodeJS.ErrnoException).code;
+      if (code !== "EEXIST") throw err;
+    }
+
+    const owner = readLockOwner(lockPath);
+    if (owner === currentPid) {
+      return {
+        lockPath,
+        release() {
+          try {
+            rmSync(lockPath, { recursive: true, force: true });
+          } catch {
+            // ignore
+          }
+        },
+      };
+    }
+    if (owner !== null && pidAlive(owner)) {
+      logger.info("daemon singleton lock owner found; restarting", { pid: owner });
+      await stopExistingDaemonForRestart(owner, { pidPath, currentPid, logger });
+    }
+
+    const refreshedOwner = readLockOwner(lockPath);
+    if (refreshedOwner === null || !pidAlive(refreshedOwner)) {
+      try {
+        rmSync(lockPath, { recursive: true, force: true });
+      } catch {
+        // another starter may have removed/recreated it
+      }
+    }
+
+    if (Date.now() >= deadline) {
+      throw new Error(`timed out acquiring daemon singleton lock at ${lockPath}`);
+    }
+    await delay(DEFAULT_LOCK_RETRY_MS);
+  }
+}
+
 export async function stopOtherDaemonProcessesForRestart(
   opts: {
     currentPid?: number;
@@ -187,11 +275,7 @@ export function writeCurrentPid(
   // Cloud-mode startup writes the PID file before `saveConfig` runs, so
   // the daemon dir may not exist yet. mkdir its parent (0700) so the
   // first write doesn't crash with ENOENT.
-  try {
-    mkdirSync(path.dirname(pidPath), { recursive: true, mode: 0o700 });
-  } catch {
-    // best-effort — writeFileSync below will surface the real error
-  }
+  ensureParentDir(pidPath);
   writeFileSync(pidPath, String(opts.currentPid ?? process.pid), { mode: 0o600 });
 }
 
@@ -231,3 +315,11 @@ export function isBotCordDaemonStartCommand(command: string): boolean {
 function delay(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+
+function ensureParentDir(filePath: string): void {
+  try {
+    mkdirSync(path.dirname(filePath), { recursive: true, mode: 0o700 });
+  } catch {
+    // best-effort — the next filesystem operation will surface real errors
+  }
+}

package/src/daemon.ts

@@ -52,6 +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";
 
 /**
  * Default hard cap for a single runtime turn. Long-running coding/research
@@ -245,6 +246,26 @@ export function pushRuntimeSnapshot(
   return ok;
 }
 
+export function pushAgentSkillSnapshot(
+  sink: RuntimeSnapshotSink,
+  agentId: string,
+): boolean {
+  const snap = collectAgentSkillSnapshot(agentId);
+  const ok = sink.send({
+    id: `skill_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+    type: "agent_skill_snapshot",
+    params: snap as unknown as Record<string, unknown>,
+    ts: Date.now(),
+  });
+  if (!ok) {
+    daemonLog.warn("agent-skill-snapshot: control-channel send returned false", {
+      agentId,
+      skills: snap.skills.length,
+    });
+  }
+  return ok;
+}
+
 /** Options accepted by {@link startDaemon} — the P0.5 compatibility shim. */
 export interface DaemonRuntimeOptions {
   config: DaemonConfig;
@@ -648,6 +669,13 @@ export async function startDaemon(opts: DaemonRuntimeOptions): Promise<DaemonHan
       logger.info("control-channel: initial runtime_snapshot push", {
         ok: pushed,
       });
+      for (const agentId of agentIds) {
+        const skillsPushed = pushAgentSkillSnapshot(controlChannel, agentId);
+        logger.info("control-channel: initial agent_skill_snapshot push", {
+          agentId,
+          ok: skillsPushed,
+        });
+      }
     } catch (err) {
       logger.warn("control-channel failed to start; continuing without it", {
         error: err instanceof Error ? err.message : String(err),