@botcord/daemon 0.2.85 → 0.2.87

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

@@ -0,0 +1,130 @@
+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("scans Codex .system skills and prefers Codex copies for Codex agents", () => {
+    const agentId = "ag_codex_system";
+    writeSkill(path.join(agentWorkspaceDir(agentId), ".claude", "skills"), "shared", "Claude copy");
+    writeSkill(path.join(agentCodexHomeDir(agentId), "skills"), "shared", "Codex copy");
+    writeSkill(
+      path.join(agentCodexHomeDir(agentId), "skills", ".system"),
+      "agent-system",
+      "Agent Codex system skill",
+    );
+    writeSkill(
+      path.join(tmpDir, ".codex", "skills", ".system"),
+      "imagegen",
+      "Codex global system skill",
+    );
+
+    const codexScanned = scanSoftSkills(agentId, { runtime: "codex" });
+    expect(codexScanned.map((s) => s.name).sort()).toEqual([
+      "agent-system",
+      "imagegen",
+      "shared",
+    ]);
+    expect(codexScanned.find((s) => s.name === "shared")).toMatchObject({
+      source: "agent-codex",
+      description: "Codex copy",
+    });
+
+    const claudeScanned = scanSoftSkills(agentId, { runtime: "claude-code" });
+    expect(claudeScanned.find((s) => s.name === "shared")).toMatchObject({
+      source: "agent-claude",
+      description: "Claude copy",
+    });
+
+    const snapshot = collectAgentSkillSnapshot(agentId, { runtime: "codex" });
+    expect(snapshot.skills.find((s) => s.name === "agent-system")?.source)
+      .toBe("workspace");
+    expect(snapshot.skills.find((s) => s.name === "imagegen")?.source)
+      .toBe("runtime-global");
+  });
+
+  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/__tests__/turn-text.test.ts

@@ -370,3 +370,124 @@ describe("composeBotCordUserTurn", () => {
     expect(headerLines.length).toBe(1);
   });
 });
+
+describe("composeBotCordUserTurn quote-reply", () => {
+  it("inserts a [quoting …] line above the body when reply_preview is present", () => {
+    const out = composeBotCordUserTurn(
+      makeMessage({
+        text: "agreed, ship it",
+        sender: { id: "ag_alice", name: "Alice", kind: "agent" },
+        raw: {
+          reply_preview: {
+            msg_id: "h_orig",
+            sender_id: "ag_bob",
+            sender_display_name: "Bob",
+            text_preview: "We should ship the feature next sprint",
+            topic_id: null,
+            deleted: false,
+          },
+        },
+      }),
+    );
+    expect(out).toContain('<agent-message sender="ag_alice" sender_kind="agent">');
+    expect(out).toContain('[quoting Bob: "We should ship the feature next sprint"]');
+    expect(out).toContain("agreed, ship it");
+    // Quote line precedes body inside the tag block.
+    const quoteIdx = out.indexOf("[quoting Bob");
+    const bodyIdx = out.indexOf("agreed, ship it");
+    expect(quoteIdx).toBeGreaterThan(-1);
+    expect(quoteIdx).toBeLessThan(bodyIdx);
+  });
+
+  it("renders a tombstone line when the quote target was deleted", () => {
+    const out = composeBotCordUserTurn(
+      makeMessage({
+        text: "RE: that thing",
+        sender: { id: "ag_alice", kind: "agent" },
+        raw: {
+          reply_preview: {
+            msg_id: "h_gone",
+            sender_id: null,
+            sender_display_name: null,
+            text_preview: null,
+            topic_id: null,
+            deleted: true,
+          },
+        },
+      }),
+    );
+    expect(out).toContain("[quoting (deleted message)]");
+    expect(out).toContain("RE: that thing");
+  });
+
+  it("falls back to sender_id when display name is missing", () => {
+    const out = composeBotCordUserTurn(
+      makeMessage({
+        text: "ack",
+        sender: { id: "ag_alice", kind: "agent" },
+        raw: {
+          reply_preview: {
+            msg_id: "h_orig",
+            sender_id: "ag_bob",
+            sender_display_name: null,
+            text_preview: "hi",
+            topic_id: null,
+            deleted: false,
+          },
+        },
+      }),
+    );
+    expect(out).toContain('[quoting ag_bob: "hi"]');
+  });
+
+  it("emits no quote line when reply_preview is absent (regression guard)", () => {
+    const out = composeBotCordUserTurn(
+      makeMessage({
+        text: "just a normal message",
+        sender: { id: "ag_alice", kind: "agent" },
+      }),
+    );
+    expect(out).not.toContain("[quoting");
+  });
+
+  it("renders per-entry quote lines in a batched turn", () => {
+    const batchedRaw = {
+      batch: [
+        {
+          hub_msg_id: "h_1",
+          text: "first reply",
+          envelope: { from: "ag_alice", type: "message" },
+          source_type: "agent",
+          reply_preview: {
+            msg_id: "h_orig1",
+            sender_id: "ag_bob",
+            sender_display_name: "Bob",
+            text_preview: "the plan",
+            topic_id: null,
+            deleted: false,
+          },
+        },
+        {
+          hub_msg_id: "h_2",
+          text: "second reply (no quote)",
+          envelope: { from: "ag_alice", type: "message" },
+          source_type: "agent",
+        },
+      ],
+    };
+    const out = composeBotCordUserTurn(
+      makeMessage({
+        text: "ignored — batch path reads raw.batch",
+        sender: { id: "ag_alice", kind: "agent" },
+        raw: batchedRaw,
+      }),
+    );
+    expect(out).toContain("[BotCord Messages (2 new)]");
+    expect(out).toContain('[quoting Bob: "the plan"]');
+    expect(out).toContain("first reply");
+    expect(out).toContain("second reply (no quote)");
+    // The second entry has no quote line.
+    const quoteCount = (out.match(/\[quoting /g) || []).length;
+    expect(quoteCount).toBe(1);
+  });
+});

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,24 @@ export async function startCloudDaemon(
     });
   };
 
+  const installedAgentIds = new Set<string>();
+  const runtimeByAgentId = new Map<string, string>();
+  let controlChannel: ControlChannel | null = null;
+  const pushInstalledAgentSkillSnapshot = (agentId: string, reason: string): void => {
+    if (!controlChannel) return;
+    const runtime = runtimeByAgentId.get(agentId) ?? opts.config.defaultRoute.adapter;
+    const pushed = pushAgentSkillSnapshot(controlChannel, agentId, { runtime });
+    logger.info("cloud control-channel: agent_skill_snapshot pushed", {
+      agentId,
+      runtime,
+      reason,
+      ok: pushed,
+    });
+  };
+
   const onAgentInstalled: OnAgentInstalledHook = (info: InstalledAgentInfo) => {
+    installedAgentIds.add(info.agentId);
+    if (info.runtime) runtimeByAgentId.set(info.agentId, info.runtime);
     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 +268,7 @@ export async function startCloudDaemon(
         }),
       );
     }
+    pushInstalledAgentSkillSnapshot(info.agentId, "agent_installed");
   };
 
   const gateway = new Gateway({
@@ -281,7 +299,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 +347,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,27 @@ export function pushRuntimeSnapshot(
   return ok;
 }
 
+export function pushAgentSkillSnapshot(
+  sink: RuntimeSnapshotSink,
+  agentId: string,
+  opts: { runtime?: string } = {},
+): boolean {
+  const snap = collectAgentSkillSnapshot(agentId, opts);
+  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;
@@ -508,6 +530,12 @@ 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] = {
+        ...(agentRuntimes[info.agentId] ?? {}),
+        runtime: info.runtime,
+      };
+    }
     if (info.hubUrl) hubUrlByAgentId.set(info.agentId, info.hubUrl);
     if (info.displayName) displayNameByAgent.set(info.agentId, info.displayName);
     if (!scBuilders.has(info.agentId)) {
@@ -648,6 +676,15 @@ export async function startDaemon(opts: DaemonRuntimeOptions): Promise<DaemonHan
       logger.info("control-channel: initial runtime_snapshot push", {
         ok: pushed,
       });
+      for (const agentId of agentIds) {
+        const runtime = agentRuntimes[agentId]?.runtime ?? opts.config.defaultRoute.adapter;
+        const skillsPushed = pushAgentSkillSnapshot(controlChannel, agentId, { runtime });
+        logger.info("control-channel: initial agent_skill_snapshot push", {
+          agentId,
+          runtime,
+          ok: skillsPushed,
+        });
+      }
     } catch (err) {
       logger.warn("control-channel failed to start; continuing without it", {
         error: err instanceof Error ? err.message : String(err),

package/src/gateway/__tests__/botcord-channel.test.ts

@@ -793,6 +793,85 @@ describe("createBotCordChannel — streamBlock()", () => {
     });
   });
 
+  it("normalizes wrapped DeepSeek item.started tool input from the runtime event stream", () => {
+    expect(
+      __normalizeBlockForHubForTests(
+        {
+          kind: "tool_use",
+          seq: 5,
+          raw: {
+            event: "item.started",
+            payload: {
+              seq: 922,
+              thread_id: "thr_test",
+              turn_id: "turn_test",
+              item_id: "item_exec",
+              event: "item.started",
+              payload: {
+                item: {
+                  id: "item_exec",
+                  kind: "tool_call",
+                  status: "in_progress",
+                  summary: "exec_shell started",
+                  detail: "{\"cmd\":\"botcord-daemon status\"}",
+                },
+              },
+            },
+          },
+        },
+        5,
+      ),
+    ).toMatchObject({
+      kind: "tool_call",
+      seq: 5,
+      payload: {
+        id: "item_exec",
+        name: "exec_shell",
+        params: { cmd: "botcord-daemon status" },
+        status: "in_progress",
+      },
+    });
+  });
+
+  it("normalizes wrapped DeepSeek item.completed output without showing the event envelope", () => {
+    expect(
+      __normalizeBlockForHubForTests(
+        {
+          kind: "tool_result",
+          seq: 6,
+          raw: {
+            event: "item.completed",
+            payload: {
+              seq: 955,
+              thread_id: "thr_test",
+              turn_id: "turn_test",
+              item_id: "item_exec",
+              event: "item.completed",
+              payload: {
+                item: {
+                  id: "item_exec",
+                  kind: "command_execution",
+                  status: "completed",
+                  summary: "exec_shell: daemon: pid 49616",
+                  detail: "daemon: pid 49616 (alive)",
+                },
+              },
+            },
+          },
+        },
+        6,
+      ),
+    ).toMatchObject({
+      kind: "tool_result",
+      seq: 6,
+      payload: {
+        name: "exec_shell",
+        result: "daemon: pid 49616 (alive)",
+        tool_use_id: "item_exec",
+      },
+    });
+  });
+
   it("POSTs to /hub/stream-block with the right trace_id + block", async () => {
     const fetchSpy = vi.fn().mockResolvedValue(new Response(null, { status: 204 }));
     const realFetch = globalThis.fetch;

package/src/gateway/__tests__/deepseek-tui-adapter.test.ts

@@ -353,6 +353,55 @@ describe("DeepseekTuiAdapter", () => {
     }
   });
 
+  it("treats DeepSeek command_execution item.started events as tool blocks", async () => {
+    const server = await startMockDeepseekServer({
+      events: [
+        {
+          event: "turn.started",
+          data: { thread_id: "thr_test", turn_id: "turn_test", event: "turn.started" },
+        },
+        {
+          event: "item.started",
+          data: {
+            thread_id: "thr_test",
+            turn_id: "turn_test",
+            event: "item.started",
+            payload: {
+              item: {
+                id: "item_exec",
+                kind: "command_execution",
+                status: "in_progress",
+                summary: "exec_shell started",
+                detail: "{\"cmd\":\"date\"}",
+              },
+            },
+          },
+        },
+        {
+          event: "item.delta",
+          data: {
+            thread_id: "thr_test",
+            turn_id: "turn_test",
+            event: "item.delta",
+            payload: { kind: "agent_message", delta: "done" },
+          },
+        },
+        {
+          event: "turn.completed",
+          data: { thread_id: "thr_test", turn_id: "turn_test", event: "turn.completed" },
+        },
+      ],
+    });
+    try {
+      const { result, blocks, status } = runAdapter(server.baseUrl, server.token);
+      await expect(result).resolves.toMatchObject({ text: "done" });
+      expect(blocks).toEqual(expect.arrayContaining(["tool_use", "assistant_text"]));
+      expect(status).toContainEqual({ phase: "updated", label: "exec_shell" });
+    } finally {
+      await server.close();
+    }
+  });
+
   it("emits current DeepSeek agent_reasoning completions as thinking blocks", async () => {
     const server = await startMockDeepseekServer({
       events: [