@botcord/daemon 0.2.48 → 0.2.50

package/dist/gateway/runtimes/kimi.js

@@ -0,0 +1,204 @@
+import { randomUUID } from "node:crypto";
+import { buildCliEnv } from "../cli-resolver.js";
+import { NdjsonStreamAdapter } from "./ndjson-stream.js";
+import { readCommandVersion, resolveCommandOnPath, } from "./probe.js";
+function isValidKimiSessionId(sessionId) {
+    if (sessionId.length === 0 || sessionId.length > 512)
+        return false;
+    if (sessionId.startsWith("-"))
+        return false;
+    for (const ch of sessionId) {
+        const code = ch.codePointAt(0);
+        if (code === undefined || code < 0x20 || code === 0x7f)
+            return false;
+    }
+    return true;
+}
+function invalidKimiSessionIdError() {
+    return "kimi-cli: invalid sessionId (expected non-control text not starting with '-')";
+}
+/** Resolve the Kimi CLI executable on PATH. */
+export function resolveKimiCommand(deps = {}) {
+    return resolveCommandOnPath("kimi", deps);
+}
+/** Probe whether the Kimi CLI is installed and report its version. */
+export function probeKimi(deps = {}) {
+    const command = resolveKimiCommand(deps);
+    if (!command)
+        return { available: false };
+    return {
+        available: true,
+        path: command,
+        version: readCommandVersion(command, [], deps) ?? undefined,
+    };
+}
+/**
+ * Kimi CLI adapter — spawns:
+ *
+ *   kimi --work-dir <cwd> --print --output-format stream-json --session <sid> --prompt <text>
+ *
+ * `--session <sid>` resumes an existing session or creates a new session with
+ * that id, so the adapter generates a UUID on first turn and persists it for
+ * later turns. Kimi does not expose a Codex-style per-invocation AGENTS.md
+ * carrier, so dynamic `systemContext` is sent as a system-reminder prefix on
+ * the user prompt.
+ */
+export class KimiAdapter extends NdjsonStreamAdapter {
+    id = "kimi-cli";
+    explicitBinary;
+    resolvedBinary = null;
+    constructor(opts) {
+        super();
+        this.explicitBinary = opts?.binary ?? process.env.BOTCORD_KIMI_CLI_BIN;
+    }
+    probe() {
+        return probeKimi();
+    }
+    async run(opts) {
+        if (opts.sessionId && !isValidKimiSessionId(opts.sessionId)) {
+            return { text: "", newSessionId: "", error: invalidKimiSessionIdError() };
+        }
+        const sessionId = opts.sessionId || randomUUID();
+        return super.run({ ...opts, sessionId });
+    }
+    resolveBinary() {
+        if (this.explicitBinary)
+            return this.explicitBinary;
+        if (this.resolvedBinary)
+            return this.resolvedBinary;
+        this.resolvedBinary = resolveKimiCommand() ?? "kimi";
+        return this.resolvedBinary;
+    }
+    buildArgs(opts) {
+        const sessionId = opts.sessionId || randomUUID();
+        if (!isValidKimiSessionId(sessionId))
+            throw new Error(invalidKimiSessionIdError());
+        const args = [
+            "--work-dir",
+            opts.cwd,
+            "--print",
+            "--output-format",
+            "stream-json",
+            "--session",
+            sessionId,
+            "--afk",
+        ];
+        if (opts.extraArgs?.length)
+            args.push(...opts.extraArgs);
+        args.push("--prompt", promptWithSystemContext(opts.text, opts.systemContext));
+        return args;
+    }
+    spawnEnv(opts) {
+        const cliEnv = buildCliEnv({
+            hubUrl: opts.hubUrl,
+            accountId: opts.accountId,
+            basePath: process.env.PATH,
+        });
+        return {
+            ...process.env,
+            ...cliEnv,
+            FORCE_COLOR: "0",
+            NO_COLOR: "1",
+        };
+    }
+    handleEvent(raw, ctx) {
+        const obj = raw;
+        const status = kimiStatusEvent(obj);
+        if (status)
+            ctx.emitStatus(status);
+        ctx.emitBlock(normalizeBlock(obj, ctx.seq));
+        const sessionId = kimiSessionId(obj);
+        if (sessionId)
+            ctx.state.newSessionId = sessionId;
+        if (obj.role === "assistant") {
+            const text = extractText(obj.content);
+            if (text) {
+                ctx.appendAssistantText(text);
+                ctx.state.finalText = text;
+            }
+            return;
+        }
+        const err = kimiErrorText(obj);
+        if (err)
+            ctx.state.errorText = err;
+    }
+}
+function promptWithSystemContext(text, systemContext) {
+    if (!systemContext)
+        return text;
+    return `<system-reminder>\n${systemContext}\n</system-reminder>\n\n${text}`;
+}
+function extractText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .filter((part) => part?.type === "text" && typeof part.text === "string")
+        .map((part) => part.text)
+        .join("");
+}
+function hasThinking(content) {
+    return Array.isArray(content)
+        ? content.some((part) => part?.type === "think" && typeof part.think === "string" && part.think)
+        : false;
+}
+function firstToolName(toolCalls) {
+    const name = toolCalls?.find((t) => typeof t.function?.name === "string")?.function?.name;
+    return name || "tool";
+}
+function kimiSessionId(obj) {
+    return typeof obj.session_id === "string" && obj.session_id ? obj.session_id : undefined;
+}
+function kimiErrorText(obj) {
+    if (typeof obj.error === "string" && obj.error)
+        return obj.error;
+    if (obj.error && typeof obj.error === "object") {
+        const message = obj.error.message;
+        if (typeof message === "string" && message)
+            return message;
+    }
+    if (obj.type === "error" && typeof obj.message === "string" && obj.message) {
+        return obj.message;
+    }
+    if (obj.severity === "error") {
+        return [obj.title, obj.body].filter(Boolean).join(": ") || "kimi-cli error";
+    }
+    return undefined;
+}
+function kimiStatusEvent(obj) {
+    if (obj.role === "assistant" && hasThinking(obj.content)) {
+        return { kind: "thinking", phase: "started", label: "Thinking" };
+    }
+    if (obj.role === "assistant" && obj.tool_calls?.length) {
+        return { kind: "thinking", phase: "updated", label: firstToolName(obj.tool_calls) };
+    }
+    if (obj.role === "assistant" && extractText(obj.content)) {
+        return { kind: "thinking", phase: "stopped" };
+    }
+    if (obj.role === "tool") {
+        return { kind: "thinking", phase: "updated", label: "Tool result" };
+    }
+    return undefined;
+}
+function normalizeBlock(obj, seq) {
+    let kind = "other";
+    if (obj.role === "assistant") {
+        if (obj.tool_calls?.length)
+            kind = "tool_use";
+        else if (extractText(obj.content))
+            kind = "assistant_text";
+        else if (hasThinking(obj.content))
+            kind = "other";
+    }
+    else if (obj.role === "tool") {
+        kind = "tool_result";
+    }
+    else if (obj.file_path && typeof obj.content === "string") {
+        kind = "other";
+    }
+    else if (obj.category || obj.severity) {
+        kind = "system";
+    }
+    return { raw: obj, kind, seq };
+}

package/dist/gateway/runtimes/registry.d.ts

@@ -33,6 +33,10 @@ export interface RuntimeModule {
 export declare const claudeCodeModule: RuntimeModule;
 /** Built-in runtime module entry for Codex. */
 export declare const codexModule: RuntimeModule;
+/** Built-in runtime module entry for DeepSeek TUI. */
+export declare const deepseekTuiModule: RuntimeModule;
+/** Built-in runtime module entry for Kimi CLI. */
+export declare const kimiModule: RuntimeModule;
 /** Built-in runtime module entry for Hermes Agent (ACP stdio). */
 export declare const hermesAgentModule: RuntimeModule;
 /** Built-in runtime module entry for Gemini (probe-only stub). */

package/dist/gateway/runtimes/registry.js

@@ -1,7 +1,9 @@
 import { ClaudeCodeAdapter, probeClaude } from "./claude-code.js";
 import { CodexAdapter, probeCodex } from "./codex.js";
+import { DeepseekTuiAdapter, probeDeepseekTui } from "./deepseek-tui.js";
 import { GeminiAdapter, probeGemini } from "./gemini.js";
 import { HermesAgentAdapter, probeHermesAgent } from "./hermes-agent.js";
+import { KimiAdapter, probeKimi } from "./kimi.js";
 import { OpenclawAcpAdapter, probeOpenclaw } from "./openclaw-acp.js";
 /** Built-in runtime module entry for Claude Code. */
 export const claudeCodeModule = {
@@ -20,6 +22,25 @@ export const codexModule = {
     probe: () => probeCodex(),
     create: () => new CodexAdapter(),
 };
+/** Built-in runtime module entry for DeepSeek TUI. */
+export const deepseekTuiModule = {
+    id: "deepseek-tui",
+    displayName: "DeepSeek TUI",
+    binary: "deepseek",
+    envVar: "BOTCORD_DEEPSEEK_TUI_BIN",
+    probe: () => probeDeepseekTui(),
+    create: () => new DeepseekTuiAdapter(),
+    installHint: "Install DeepSeek TUI and ensure the `deepseek` dispatcher is on PATH, or set BOTCORD_DEEPSEEK_TUI_BIN.",
+};
+/** Built-in runtime module entry for Kimi CLI. */
+export const kimiModule = {
+    id: "kimi-cli",
+    displayName: "Kimi CLI",
+    binary: "kimi",
+    envVar: "BOTCORD_KIMI_CLI_BIN",
+    probe: () => probeKimi(),
+    create: () => new KimiAdapter(),
+};
 /** Built-in runtime module entry for Hermes Agent (ACP stdio). */
 export const hermesAgentModule = {
     id: "hermes-agent",
@@ -57,6 +78,8 @@ export const openclawAcpModule = {
 export const RUNTIME_MODULES = [
     claudeCodeModule,
     codexModule,
+    deepseekTuiModule,
+    kimiModule,
     hermesAgentModule,
     geminiModule,
     openclawAcpModule,

package/dist/mention-scan.js

@@ -17,9 +17,13 @@ export function scanMention(text, targets) {
     if (!text)
         return false;
     const lower = text.toLowerCase();
+    const normalizedAgentId = targets.agentId?.trim().toLowerCase();
+    if (normalizedAgentId && lower.includes("(" + normalizedAgentId + ")")) {
+        return true;
+    }
     const candidates = [];
-    if (targets.agentId)
-        candidates.push(targets.agentId.toLowerCase());
+    if (normalizedAgentId)
+        candidates.push(normalizedAgentId);
     if (targets.displayName) {
         const trimmed = targets.displayName.trim();
         if (trimmed)

package/dist/skill-index.d.ts

@@ -0,0 +1,17 @@
+export interface SoftSkillEntry {
+    name: string;
+    path: string;
+    source: string;
+    description?: string;
+    mtimeMs: number;
+}
+export interface SkillIndexOptions {
+    extraDirs?: string[];
+    includeGlobal?: boolean;
+}
+export declare function defaultSkillDirs(agentId: string, opts?: SkillIndexOptions): Array<{
+    dir: string;
+    source: string;
+}>;
+export declare function scanSoftSkills(agentId: string, opts?: SkillIndexOptions): SoftSkillEntry[];
+export declare function buildSoftSkillIndexPrompt(agentId: string, opts?: SkillIndexOptions): string | null;

package/dist/skill-index.js

@@ -0,0 +1,177 @@
+import { existsSync, readdirSync, readFileSync, statSync, } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+import { agentCodexHomeDir, agentWorkspaceDir, } from "./agent-workspace.js";
+const MAX_SKILLS = 24;
+const MAX_DESCRIPTION_CHARS = 260;
+const MAX_SKILL_MD_READ_CHARS = 8192;
+export function defaultSkillDirs(agentId, opts = {}) {
+    const includeGlobal = opts.includeGlobal !== false;
+    const dirs = [
+        {
+            dir: path.join(agentWorkspaceDir(agentId), ".claude", "skills"),
+            source: "agent-claude",
+        },
+        {
+            dir: path.join(agentCodexHomeDir(agentId), "skills"),
+            source: "agent-codex",
+        },
+    ];
+    if (includeGlobal) {
+        dirs.push({ dir: path.join(homedir(), ".claude", "skills"), source: "global-claude" }, { dir: path.join(homedir(), ".codex", "skills"), source: "global-codex" });
+    }
+    const envDirs = parseSkillDirsEnv(process.env.BOTCORD_SKILL_DIRS);
+    for (const dir of [...envDirs, ...(opts.extraDirs ?? [])]) {
+        dirs.push({ dir, source: "external" });
+    }
+    return dedupeDirs(dirs);
+}
+export function scanSoftSkills(agentId, opts = {}) {
+    const byName = new Map();
+    const byPath = new Set();
+    for (const root of defaultSkillDirs(agentId, opts)) {
+        if (!existsSync(root.dir))
+            continue;
+        let children;
+        try {
+            children = readdirSync(root.dir);
+        }
+        catch {
+            continue;
+        }
+        for (const child of children) {
+            const skillDir = path.join(root.dir, child);
+            const skillMd = path.join(skillDir, "SKILL.md");
+            if (byPath.has(skillMd) || !existsSync(skillMd))
+                continue;
+            byPath.add(skillMd);
+            let st;
+            try {
+                st = statSync(skillMd);
+                if (!st.isFile())
+                    continue;
+            }
+            catch {
+                continue;
+            }
+            const parsed = parseSkillFile(skillMd, child);
+            const existing = byName.get(parsed.name);
+            const entry = {
+                name: parsed.name,
+                path: skillMd,
+                source: root.source,
+                description: parsed.description,
+                mtimeMs: st.mtimeMs,
+            };
+            if (!existing || priority(root.source) < priority(existing.source)) {
+                byName.set(entry.name, entry);
+            }
+        }
+    }
+    return Array.from(byName.values())
+        .sort((a, b) => a.name.localeCompare(b.name))
+        .slice(0, MAX_SKILLS);
+}
+export function buildSoftSkillIndexPrompt(agentId, opts = {}) {
+    const skills = scanSoftSkills(agentId, opts);
+    if (skills.length === 0)
+        return null;
+    const lines = [
+        "[BotCord Daemon Skill Index]",
+        "The daemon scanned these SKILL.md files on disk this turn. This is a soft skill index for runtimes whose native skill registry may not hot-reload during resumed sessions.",
+        "If the user's request matches a listed skill and the native skill is not already active, read that SKILL.md file directly and follow its workflow manually. Do not assume this index creates new native tools; use only tools and CLIs that are actually available.",
+        "",
+    ];
+    for (const skill of skills) {
+        const desc = skill.description ? ` - ${skill.description}` : "";
+        lines.push(`- ${skill.name} (${skill.source}): ${skill.path}${desc}`);
+    }
+    return lines.join("\n");
+}
+function parseSkillFile(skillMd, fallbackName) {
+    let raw = "";
+    try {
+        raw = readFileSync(skillMd, "utf8").slice(0, MAX_SKILL_MD_READ_CHARS);
+    }
+    catch {
+        return { name: fallbackName };
+    }
+    const fm = raw.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    const frontmatter = fm?.[1] ?? "";
+    const name = readYamlScalar(frontmatter, "name") ?? fallbackName;
+    const description = readYamlScalar(frontmatter, "description") ??
+        readMarkdownDescription(raw) ??
+        undefined;
+    return {
+        name: sanitizeInline(name) || fallbackName,
+        description: description ? truncate(sanitizeInline(description), MAX_DESCRIPTION_CHARS) : undefined,
+    };
+}
+function readYamlScalar(frontmatter, key) {
+    const re = new RegExp(`^${key}:\\s*(.+?)\\s*$`, "m");
+    const match = frontmatter.match(re);
+    if (!match)
+        return null;
+    return unquote(match[1] ?? "");
+}
+function readMarkdownDescription(raw) {
+    const purpose = raw.match(/\*\*Purpose:\*\*\s*([^\n]+)/i);
+    if (purpose?.[1])
+        return purpose[1];
+    const firstParagraph = raw
+        .replace(/^---\r?\n[\s\S]*?\r?\n---/, "")
+        .split(/\n\s*\n/)
+        .map((s) => s.trim())
+        .find((s) => s && !s.startsWith("#"));
+    return firstParagraph ?? null;
+}
+function parseSkillDirsEnv(value) {
+    if (!value)
+        return [];
+    return value
+        .split(path.delimiter)
+        .map((s) => s.trim())
+        .filter(Boolean);
+}
+function dedupeDirs(dirs) {
+    const seen = new Set();
+    const out = [];
+    for (const entry of dirs) {
+        const resolved = path.resolve(entry.dir);
+        if (seen.has(resolved))
+            continue;
+        seen.add(resolved);
+        out.push({ dir: resolved, source: entry.source });
+    }
+    return out;
+}
+function priority(source) {
+    switch (source) {
+        case "agent-claude":
+            return 0;
+        case "agent-codex":
+            return 1;
+        case "global-claude":
+            return 2;
+        case "global-codex":
+            return 3;
+        default:
+            return 4;
+    }
+}
+function unquote(value) {
+    const trimmed = value.trim();
+    if ((trimmed.startsWith("\"") && trimmed.endsWith("\"")) ||
+        (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+        return trimmed.slice(1, -1);
+    }
+    return trimmed;
+}
+function sanitizeInline(value) {
+    return value.replace(/\s+/g, " ").trim();
+}
+function truncate(value, max) {
+    if (value.length <= max)
+        return value;
+    return `${value.slice(0, Math.max(0, max - 3))}...`;
+}

package/dist/system-context.d.ts

@@ -11,6 +11,7 @@
  *   3. `[BotCord Working Memory]`
  *   4. `[BotCord Room Context]` (group rooms, via optional async fetcher)
  *   5. `[BotCord Cross-Room Awareness]` (optional activity tracker)
+ *   6. `[BotCord Daemon Skill Index]` (soft skill hot-reload index)
  *
  * Behavior:
  *   - Working memory is loaded fresh per turn, so a `memory set` from another
@@ -53,6 +54,11 @@ export interface SystemContextDeps {
      * + cheap — consulted every turn even when roomContextBuilder is absent.
      */
     loopRiskBuilder?: (message: GatewayInboundMessage) => string | null;
+    /**
+     * Optional soft skill index builder. Defaults to scanning daemon-known skill
+     * dirs each turn. Return null to suppress the block.
+     */
+    skillIndexBuilder?: (message: GatewayInboundMessage) => string | null;
 }
 /**
  * Build a {@link SystemContextBuilder} for the gateway dispatcher.

package/dist/system-context.js

@@ -3,6 +3,7 @@ import { buildWorkingMemoryPrompt, readWorkingMemory } from "./working-memory.js
 import { readIdentity } from "./agent-workspace.js";
 import { classifyActivitySender } from "./sender-classify.js";
 import { log } from "./log.js";
+import { buildSoftSkillIndexPrompt } from "./skill-index.js";
 /**
  * Scene prompt injected when the inbound turn comes from the owner's
  * dashboard chat. Mirrors `plugin/src/room-context.ts#buildOwnerChatSceneContext`
@@ -96,14 +97,30 @@ export function createDaemonSystemContextBuilder(deps) {
             return null;
         }
     };
+    const buildSkillIndex = (message) => {
+        try {
+            if (deps.skillIndexBuilder)
+                return deps.skillIndexBuilder(message);
+            return buildSoftSkillIndexPrompt(deps.agentId);
+        }
+        catch (err) {
+            log.warn("system-context: skill index build failed — skipping skill block", {
+                agentId: deps.agentId,
+                roomId: message.conversation.id,
+                err: err instanceof Error ? err.message : String(err),
+            });
+            return null;
+        }
+    };
     if (!deps.roomContextBuilder) {
         const syncBuilder = (message) => {
             const { identity, ownerScene, memory, digest } = gatherSyncBlocks(message);
             // Loop-risk sits at the end so its "reply NO_REPLY unless…" guidance
             // is the last thing the model sees before the user turn body.
             // Identity sits at the very front so it frames every other block.
+            const skillIndex = buildSkillIndex(message);
             const loopRisk = runLoopRisk(message);
-            return assemble([identity, ownerScene, memory, digest, loopRisk]);
+            return assemble([identity, ownerScene, memory, digest, skillIndex, loopRisk]);
         };
         // Compile-time witness that the narrower sync signature still satisfies
         // `SystemContextBuilder` (which allows async). Prevents the two contracts
@@ -131,8 +148,9 @@ export function createDaemonSystemContextBuilder(deps) {
                 err: err instanceof Error ? err.message : String(err),
             });
         }
+        const skillIndex = buildSkillIndex(message);
         const loopRisk = runLoopRisk(message);
-        return assemble([identity, ownerScene, memory, roomBlock, digest, loopRisk]);
+        return assemble([identity, ownerScene, memory, roomBlock, digest, skillIndex, loopRisk]);
     };
     const _typecheck = asyncBuilder;
     void _typecheck;

package/dist/turn-text.js

@@ -73,6 +73,35 @@ function entryText(e) {
         return e.envelope.payload.text;
     return "";
 }
+function formatRoomContext(raw, fallback) {
+    const r = raw && typeof raw === "object" ? raw : {};
+    const roomId = typeof r.room_id === "string" && r.room_id ? r.room_id : fallback.id;
+    const roomName = typeof r.room_name === "string" && r.room_name ? r.room_name : fallback.title;
+    const memberCount = typeof r.room_member_count === "number" && Number.isFinite(r.room_member_count)
+        ? r.room_member_count
+        : undefined;
+    const memberNames = Array.isArray(r.room_member_names)
+        ? r.room_member_names.filter((n) => typeof n === "string" && n.length > 0)
+        : [];
+    const role = typeof r.my_role === "string" && r.my_role ? r.my_role : undefined;
+    const canSend = typeof r.my_can_send === "boolean" ? r.my_can_send : undefined;
+    const parts = [`id: ${sanitizeSenderName(roomId)}`];
+    if (roomName)
+        parts.push(`name: ${sanitizeSenderName(roomName)}`);
+    if (memberCount !== undefined) {
+        const names = memberNames.slice(0, 10).map(sanitizeSenderName).join(", ");
+        parts.push(names ? `members: ${memberCount}: ${names}` : `members: ${memberCount}`);
+    }
+    if (role)
+        parts.push(`role: ${sanitizeSenderName(role)}`);
+    if (canSend !== undefined)
+        parts.push(`can_send: ${canSend ? "true" : "false"}`);
+    const lines = [`[BotCord Room] | ${parts.join(" | ")}`];
+    if (typeof r.room_rule === "string" && r.room_rule.trim()) {
+        lines.push(`[Room Rule] ${sanitizeUntrustedContent(r.room_rule.trim())}`);
+    }
+    return lines;
+}
 /**
  * Compose the user-turn text for a BotCord inbound message.
  *
@@ -133,6 +162,7 @@ export function composeBotCordUserTurn(msg) {
         : null;
     const lines = [
         headerFields.join(" | "),
+        ...(isGroup ? formatRoomContext(msg.raw, { id: conversation.id, title: roomTitle }) : []),
         `<${tag} sender="${sanitizedSenderLabel}" sender_kind="${senderKindAttr}">`,
         trimmed,
         `</${tag}>`,
@@ -186,6 +216,7 @@ function composeBatchedTurn(msg, batch) {
     const hint = isGroup ? GROUP_HINT : DIRECT_HINT;
     const lines = [
         header.join(" | "),
+        ...(isGroup ? formatRoomContext(msg.raw, { id: conversation.id, title: roomTitle }) : []),
         blocks.join("\n"),
         "",
         hint,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botcord/daemon",
-  "version": "0.2.48",
+  "version": "0.2.50",
   "description": "BotCord local daemon — bridges Hub inbox push to local Claude Code / Codex / Gemini CLIs",
   "type": "module",
   "bin": {

package/src/__tests__/mention-scan.test.ts

@@ -0,0 +1,16 @@
+import { describe, expect, it } from "vitest";
+import { scanMention } from "../mention-scan.js";
+
+describe("scanMention", () => {
+  it("matches the exact agent id in structured @Name(agentId) mentions", () => {
+    expect(
+      scanMention("@Harry(ag_973dfb9193eb) 今天的AI日报发一下呢", {
+        agentId: "ag_973dfb9193eb",
+      }),
+    ).toBe(true);
+  });
+
+  it("still matches display-name mentions", () => {
+    expect(scanMention("@Harry 今天的AI日报发一下呢", { displayName: "Harry" })).toBe(true);
+  });
+});

package/src/__tests__/system-context.test.ts

@@ -1,5 +1,5 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { mkdtempSync, rmSync } from "node:fs";
+import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import type { GatewayInboundMessage } from "../gateway/index.js";
@@ -130,8 +130,35 @@ describe("createDaemonSystemContextBuilder", () => {
   it("skips the identity block when identity.md is blank", () => {
     ensureAgentWorkspace("ag_me", { displayName: "X" });
     writeFileSync(path.join(agentWorkspaceDir("ag_me"), "identity.md"), "");
+    const builder = createDaemonSystemContextBuilder({ agentId: "ag_me" });
+    const out = builder(makeMessage()) as string;
+    expect(out).not.toContain("[BotCord Identity]");
+    expect(out).toContain("[BotCord Daemon Skill Index]");
+  });
+
+  it("detects a newly added global Claude skill on the next turn", () => {
     const builder = createDaemonSystemContextBuilder({ agentId: "ag_me" });
     expect(builder(makeMessage())).toBeUndefined();
+
+    const skillDir = path.join(tmpDir, ".claude", "skills", "digest-query");
+    mkdirSync(skillDir, { recursive: true });
+    writeFileSync(
+      path.join(skillDir, "SKILL.md"),
+      [
+        "---",
+        "name: digest-query",
+        "description: \"Search archived conversation digests with the local digest_query CLI.\"",
+        "---",
+        "",
+        "# Digest Query",
+      ].join("\n"),
+    );
+
+    const out = builder(makeMessage()) as string;
+    expect(out).toContain("[BotCord Daemon Skill Index]");
+    expect(out).toContain("digest-query (global-claude)");
+    expect(out).toContain(path.join(skillDir, "SKILL.md"));
+    expect(out).toContain("Search archived conversation digests");
   });
 
   it("emits the 'memory is currently empty' notice when the memory file exists but is blank", () => {