@botcord/daemon 0.2.89 → 0.2.90

package/dist/skill-installer.js

@@ -0,0 +1,340 @@
+import { execFile } from "node:child_process";
+import { cpSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, realpathSync, renameSync, rmSync, writeFileSync, } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+import { agentCodexHomeDir, agentWorkspaceDir, } from "./agent-workspace.js";
+import { collectAgentSkillSnapshot, } from "./skill-index.js";
+const execFileAsync = promisify(execFile);
+const SAFE_SKILL_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]{0,79}$/;
+const MAX_INLINE_FILE_BYTES = 256 * 1024;
+const TRUSTED_VERCEL_PACKAGE_SPECS = new Set([
+    "https://github.com/vercel-labs/skills",
+    "github:vercel-labs/skills",
+    "vercel-labs/skills",
+]);
+export function normalizeSkillManifest(input) {
+    const rawName = input.name ?? input.id;
+    if (!rawName)
+        throw new Error("skill manifest requires name or id");
+    const name = assertSafeSkillName(rawName);
+    const description = sanitizeInline(input.description ?? "");
+    const skillMd = input.skillMd ?? input.markdown ?? renderSkillMarkdown(name, description);
+    if (!skillMd.trim())
+        throw new Error(`skill ${name} has empty SKILL.md content`);
+    return {
+        name,
+        ...(description ? { description } : {}),
+        skillMd,
+        files: input.files ?? [],
+        ...(input.targetRuntimes ? { targetRuntimes: normalizeTargets(input.targetRuntimes) } : {}),
+    };
+}
+export function installAgentSkillManifest(agentId, manifest, opts = {}) {
+    const normalized = normalizeSkillManifest(manifest);
+    const installed = [
+        installNormalizedSkill(agentId, normalized, opts),
+    ];
+    return {
+        agentId,
+        installed,
+        snapshot: collectAgentSkillSnapshot(agentId, { runtime: opts.runtime }),
+    };
+}
+export function installBotLearnArchiveManifest(agentId, archive, opts = {}) {
+    const skills = archive.skills && archive.skills.length > 0
+        ? archive.skills
+        : [archive];
+    const installed = skills.map((skill) => installNormalizedSkill(agentId, normalizeSkillManifest({
+        ...skill,
+        targetRuntimes: skill.targetRuntimes ?? archive.targetRuntimes,
+    }), opts));
+    return {
+        agentId,
+        installed,
+        snapshot: collectAgentSkillSnapshot(agentId, { runtime: opts.runtime }),
+    };
+}
+export async function installVercelSkillsForAgent(opts) {
+    const packageSpec = normalizeTrustedVercelPackageSpec(opts.packageSpec);
+    const workspace = agentWorkspaceDir(opts.agentId);
+    const tempHome = mkdtempSync(path.join(tmpdir(), "botcord-skills-"));
+    const targets = targetsForRuntime(opts.runtime);
+    const executor = opts.executor ?? defaultVercelSkillsExecutor;
+    const args = buildVercelSkillsArgs(packageSpec, opts.skills, targets);
+    try {
+        await executor("npx", args, {
+            cwd: workspace,
+            env: {
+                ...process.env,
+                HOME: tempHome,
+                USERPROFILE: tempHome,
+            },
+        });
+        const installed = importVercelInstalledSkills(opts.agentId, tempHome, targets);
+        return {
+            agentId: opts.agentId,
+            installed,
+            snapshot: collectAgentSkillSnapshot(opts.agentId, { runtime: opts.runtime }),
+        };
+    }
+    finally {
+        rmSync(tempHome, { recursive: true, force: true });
+    }
+}
+export function buildVercelSkillsArgs(packageSpec, skills, targets) {
+    const normalizedPackageSpec = normalizeTrustedVercelPackageSpec(packageSpec);
+    const args = ["--yes", "skills", "add", normalizedPackageSpec, "--global", "--copy", "--yes"];
+    for (const skill of skills ?? []) {
+        if (!skill.trim())
+            continue;
+        args.push("--skill", skill);
+    }
+    for (const target of targets) {
+        args.push("--agent", target === "codex" ? "codex" : "claude-code");
+    }
+    return args;
+}
+function installNormalizedSkill(agentId, manifest, opts) {
+    const targets = manifest.targetRuntimes ?? targetsForRuntime(opts.runtime);
+    validateSkillFiles(manifest.files, opts.sourceRoot);
+    const paths = [];
+    for (const target of targets) {
+        const skillDir = path.join(skillRootForTarget(agentId, target), manifest.name);
+        writeSkillDir(skillDir, manifest, opts.sourceRoot);
+        paths.push(skillDir);
+    }
+    return { name: manifest.name, targets, paths };
+}
+function writeSkillDir(skillDir, manifest, sourceRoot) {
+    const parent = path.dirname(skillDir);
+    mkdirSync(parent, { recursive: true, mode: 0o700 });
+    const tempDir = mkdtempSync(path.join(parent, `.${path.basename(skillDir)}-tmp-`));
+    try {
+        writeFileSync(path.join(tempDir, "SKILL.md"), manifest.skillMd, { mode: 0o600 });
+        for (const file of manifest.files) {
+            const relativePath = assertSafeRelativePath(file.path);
+            const dest = path.join(tempDir, relativePath);
+            mkdirSync(path.dirname(dest), { recursive: true, mode: 0o700 });
+            if (file.content !== undefined) {
+                writeFileSync(dest, file.content, { mode: 0o600 });
+                continue;
+            }
+            copySafeSourcePath(sourceRoot, file.sourcePath, dest);
+        }
+        rmSync(skillDir, { recursive: true, force: true });
+        renameSync(tempDir, skillDir);
+    }
+    catch (err) {
+        rmSync(tempDir, { recursive: true, force: true });
+        throw err;
+    }
+}
+function importVercelInstalledSkills(agentId, tempHome, targets) {
+    const byName = new Map();
+    for (const target of targets) {
+        const sourceRoot = target === "codex"
+            ? path.join(tempHome, ".codex", "skills")
+            : path.join(tempHome, ".claude", "skills");
+        if (!existsSync(sourceRoot))
+            continue;
+        for (const sourceSkillDir of findSkillDirs(sourceRoot)) {
+            const name = assertSafeSkillName(readSkillName(sourceSkillDir));
+            const dest = path.join(skillRootForTarget(agentId, target), name);
+            copySafeSkillDir(sourceSkillDir, dest);
+            const existing = byName.get(name);
+            if (existing) {
+                existing.targets.push(target);
+                existing.paths.push(dest);
+            }
+            else {
+                byName.set(name, { name, targets: [target], paths: [dest] });
+            }
+        }
+    }
+    return Array.from(byName.values()).sort((a, b) => a.name.localeCompare(b.name));
+}
+function findSkillDirs(root) {
+    const out = [];
+    const visit = (dir, depth) => {
+        if (depth > 3)
+            return;
+        const skillMd = path.join(dir, "SKILL.md");
+        if (existsSync(skillMd) && lstatSync(skillMd).isFile()) {
+            out.push(dir);
+            return;
+        }
+        let children;
+        try {
+            children = readdirSync(dir).sort((a, b) => a.localeCompare(b));
+        }
+        catch {
+            return;
+        }
+        for (const child of children) {
+            const childPath = path.join(dir, child);
+            try {
+                const childStat = lstatSync(childPath);
+                if (childStat.isSymbolicLink())
+                    continue;
+                if (childStat.isDirectory())
+                    visit(childPath, depth + 1);
+            }
+            catch {
+                /* skip unreadable entries */
+            }
+        }
+    };
+    visit(root, 0);
+    return out;
+}
+function readSkillName(skillDir) {
+    const fallback = path.basename(skillDir);
+    let raw = "";
+    try {
+        raw = readFileSync(path.join(skillDir, "SKILL.md"), "utf8").slice(0, 8192);
+    }
+    catch {
+        return fallback;
+    }
+    const fm = raw.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    const name = fm?.[1]?.match(/^name:\s*(.+?)\s*$/m)?.[1];
+    return name ? unquote(name).trim() : fallback;
+}
+function targetsForRuntime(runtime) {
+    if (runtime === "codex")
+        return ["codex"];
+    if (runtime === "claude-code")
+        return ["claude-code"];
+    return ["claude-code", "codex"];
+}
+function normalizeTargets(targets) {
+    const out = [];
+    for (const target of targets) {
+        if (target !== "claude-code" && target !== "codex") {
+            throw new Error(`unsupported skill target: ${String(target)}`);
+        }
+        if (!out.includes(target))
+            out.push(target);
+    }
+    if (out.length === 0)
+        throw new Error("at least one target runtime is required");
+    return out;
+}
+function normalizeTrustedVercelPackageSpec(packageSpec) {
+    const cleaned = packageSpec.trim();
+    if (!cleaned)
+        throw new Error("packageSpec is required");
+    if (!TRUSTED_VERCEL_PACKAGE_SPECS.has(cleaned)) {
+        throw new Error(`unsupported vercel skills packageSpec: ${cleaned}`);
+    }
+    return cleaned;
+}
+function validateSkillFiles(files, sourceRoot) {
+    for (const file of files) {
+        assertSafeRelativePath(file.path);
+        if (file.content !== undefined) {
+            if (Buffer.byteLength(file.content, "utf8") > MAX_INLINE_FILE_BYTES) {
+                throw new Error(`skill file too large: ${file.path}`);
+            }
+            continue;
+        }
+        if (!sourceRoot || !file.sourcePath) {
+            throw new Error(`skill file ${file.path} requires content or sourcePath with sourceRoot`);
+        }
+        resolveSafeSourcePath(sourceRoot, file.sourcePath);
+    }
+}
+function resolveSafeSourcePath(sourceRoot, relativeSourcePath) {
+    const safeRelativePath = assertSafeRelativePath(relativeSourcePath);
+    const rootReal = realpathSync(sourceRoot);
+    const sourcePath = path.resolve(sourceRoot, safeRelativePath);
+    if (lstatSync(sourcePath).isSymbolicLink()) {
+        throw new Error(`unsafe source path symlink: ${relativeSourcePath}`);
+    }
+    const sourceReal = realpathSync(sourcePath);
+    if (sourceReal !== rootReal && !sourceReal.startsWith(`${rootReal}${path.sep}`)) {
+        throw new Error(`unsafe source path: ${relativeSourcePath}`);
+    }
+    return sourceReal;
+}
+function copySafeSourcePath(sourceRoot, relativeSourcePath, dest) {
+    const source = resolveSafeSourcePath(sourceRoot, relativeSourcePath);
+    copyNoSymlinks(source, dest);
+}
+function copySafeSkillDir(sourceSkillDir, dest) {
+    const parent = path.dirname(dest);
+    mkdirSync(parent, { recursive: true, mode: 0o700 });
+    const tempDir = mkdtempSync(path.join(parent, `.${path.basename(dest)}-tmp-`));
+    try {
+        copyNoSymlinks(sourceSkillDir, tempDir);
+        rmSync(dest, { recursive: true, force: true });
+        renameSync(tempDir, dest);
+    }
+    catch (err) {
+        rmSync(tempDir, { recursive: true, force: true });
+        throw err;
+    }
+}
+function copyNoSymlinks(source, dest) {
+    const sourceStat = lstatSync(source);
+    if (sourceStat.isSymbolicLink()) {
+        throw new Error(`skill import rejects symlink: ${source}`);
+    }
+    if (sourceStat.isDirectory()) {
+        mkdirSync(dest, { recursive: true, mode: 0o700 });
+        for (const child of readdirSync(source)) {
+            copyNoSymlinks(path.join(source, child), path.join(dest, child));
+        }
+        return;
+    }
+    if (!sourceStat.isFile()) {
+        throw new Error(`skill import supports only files and directories: ${source}`);
+    }
+    cpSync(source, dest, { force: true, dereference: false });
+}
+function skillRootForTarget(agentId, target) {
+    return target === "codex"
+        ? path.join(agentCodexHomeDir(agentId), "skills")
+        : path.join(agentWorkspaceDir(agentId), ".claude", "skills");
+}
+function assertSafeSkillName(value) {
+    const name = value.trim();
+    if (!SAFE_SKILL_NAME.test(name) || name === "." || name === "..") {
+        throw new Error(`unsafe skill name: ${JSON.stringify(value)}`);
+    }
+    return name;
+}
+function assertSafeRelativePath(value) {
+    const normalized = path.normalize(value);
+    if (!value ||
+        path.isAbsolute(value) ||
+        normalized === "." ||
+        normalized.startsWith("..") ||
+        normalized.split(path.sep).includes("..")) {
+        throw new Error(`unsafe skill file path: ${JSON.stringify(value)}`);
+    }
+    return normalized;
+}
+function renderSkillMarkdown(name, description) {
+    const desc = description ? `description: "${description.replace(/"/g, '\\"')}"\n` : "";
+    return `---\nname: ${name}\n${desc}---\n\n# ${name}\n`;
+}
+function sanitizeInline(value) {
+    return value.replace(/\s+/g, " ").trim();
+}
+function unquote(value) {
+    const trimmed = value.trim();
+    if ((trimmed.startsWith("\"") && trimmed.endsWith("\"")) ||
+        (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+        return trimmed.slice(1, -1);
+    }
+    return trimmed;
+}
+async function defaultVercelSkillsExecutor(command, args, options) {
+    await execFileAsync(command, args, {
+        ...options,
+        encoding: "utf8",
+        maxBuffer: 1024 * 1024,
+    });
+}

package/dist/system-context.d.ts

@@ -26,6 +26,7 @@
  */
 import type { GatewayInboundMessage } from "./gateway/index.js";
 import type { ActivityTracker } from "./activity-tracker.js";
+import type { SkillIndexOptions } from "./skill-index.js";
 /**
  * Async per-turn room-context builder (see `room-context.ts`). Returns the
  * rendered `[BotCord Room Context]` block, or `null` when there is nothing
@@ -59,6 +60,11 @@ export interface SystemContextDeps {
      * dirs each turn. Return null to suppress the block.
      */
     skillIndexBuilder?: (message: GatewayInboundMessage) => string | null;
+    /**
+     * Runtime/profile options for the default soft skill scanner. Kept lazy so
+     * hot-provisioned runtime changes are visible without rebuilding this closure.
+     */
+    skillIndexOptions?: (message: GatewayInboundMessage) => SkillIndexOptions;
 }
 /**
  * Build a {@link SystemContextBuilder} for the gateway dispatcher.

package/dist/system-context.js

@@ -112,7 +112,7 @@ export function createDaemonSystemContextBuilder(deps) {
         try {
             if (deps.skillIndexBuilder)
                 return deps.skillIndexBuilder(message);
-            return buildSoftSkillIndexPrompt(deps.agentId);
+            return buildSoftSkillIndexPrompt(deps.agentId, deps.skillIndexOptions?.(message) ?? {});
         }
         catch (err) {
             log.warn("system-context: skill index build failed — skipping skill block", {

package/package.json

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

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

@@ -147,11 +147,14 @@ describe("collectRuntimeSnapshot", () => {
   });
 
   it("omits optional fields rather than emitting explicit undefineds", () => {
+    // Use a synthetic runtime id with no catalog strategy so the snapshot
+    // doesn't pick up a `models` field. Switching to "gemini" here would
+    // attach the built-in gemini model list.
     setRuntimes([
       {
-        id: "gemini",
-        displayName: "Gemini",
-        binary: "gemini",
+        id: "unknown-runtime",
+        displayName: "Unknown",
+        binary: "unknown",
         supportsRun: true,
         result: { available: true },
       },

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

@@ -380,4 +380,57 @@ describe("runtime model discovery parsers", () => {
       },
     ]);
   });
+
+  it("returns the built-in Gemini catalog and caches it under gemini.json", () => {
+    const tmp = mkdtempSync(path.join(tmpdir(), "daemon-gemini-catalog-"));
+    const prevHome = process.env.HOME;
+    const prevCacheDir = process.env.BOTCORD_RUNTIME_CATALOG_CACHE_DIR;
+    try {
+      const home = path.join(tmp, "home");
+      const cacheDir = path.join(tmp, "catalog-cache");
+      mkdirSync(home, { recursive: true });
+      process.env.HOME = home;
+      process.env.BOTCORD_RUNTIME_CATALOG_CACHE_DIR = cacheDir;
+
+      const catalog = discoverRuntimeModelCatalog({
+        id: "gemini",
+        displayName: "Gemini CLI",
+        binary: "gemini",
+        supportsRun: true,
+        result: { available: true, path: path.join(tmp, "missing-gemini") },
+      });
+
+      const ids = catalog.models?.map((m) => m.id) ?? [];
+      // `auto` is the default — wizard should pre-select it.
+      expect(catalog.models?.find((m) => m.isDefault)?.id).toBe("auto");
+      // Spot-check the documented family is present.
+      expect(ids).toEqual(
+        expect.arrayContaining([
+          "auto",
+          "pro",
+          "flash",
+          "flash-lite",
+          "gemini-2.5-pro",
+          "gemini-2.5-flash",
+          "gemini-3-pro-preview",
+          "gemini-3.1-pro-preview",
+        ]),
+      );
+      // No per-turn parameters yet (thinkingLevel / thinkingBudget aren't
+      // exposed as CLI flags; we can't safely route them through `extraArgs`).
+      expect(catalog.parameters ?? []).toEqual([]);
+
+      // Cache persisted so subsequent calls don't re-touch settings.json.
+      expect(readdirSync(cacheDir)).toEqual(["gemini.json"]);
+      const payload = JSON.parse(readFileSync(path.join(cacheDir, "gemini.json"), "utf8"));
+      expect(payload.runtimeId).toBe("gemini");
+      expect(payload.catalog.models.map((m: { id: string }) => m.id)).toContain("gemini-2.5-flash");
+    } finally {
+      if (prevHome === undefined) delete process.env.HOME;
+      else process.env.HOME = prevHome;
+      if (prevCacheDir === undefined) delete process.env.BOTCORD_RUNTIME_CATALOG_CACHE_DIR;
+      else process.env.BOTCORD_RUNTIME_CATALOG_CACHE_DIR = prevCacheDir;
+      rmSync(tmp, { recursive: true, force: true });
+    }
+  });
 });

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

@@ -4,8 +4,10 @@ import { tmpdir } from "node:os";
 import path from "node:path";
 import {
   agentCodexHomeDir,
+  agentHermesHomeDir,
   agentWorkspaceDir,
 } from "../agent-workspace.js";
+import { hermesProfileHomeDir } from "../gateway/runtimes/hermes-agent.js";
 import {
   buildSoftSkillIndexPrompt,
   collectAgentSkillSnapshot,
@@ -37,27 +39,40 @@ afterEach(() => {
 });
 
 describe("skill snapshots", () => {
-  it("scans agent workspace/runtime-global skills and maps UI source buckets", () => {
+  it("scopes scans to the selected runtime 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 claudePath = path.join(agentWorkspaceDir(agentId), ".claude", "skills");
+    const codexPath = path.join(agentCodexHomeDir(agentId), "skills");
+    writeSkill(claudePath, "claude-skill", "Claude skill");
+    writeSkill(codexPath, "codex-skill", "Codex skill");
+    writeSkill(path.join(tmpDir, ".claude", "skills"), "global-claude", "Global Claude");
+    writeSkill(path.join(tmpDir, ".codex", "skills"), "global-codex", "Global Codex");
 
-    const scanned = scanSoftSkills(agentId);
-    expect(scanned.map((s) => s.name).sort()).toEqual([
+    const claudeScanned = scanSoftSkills(agentId, { runtime: "claude-code" });
+    expect(claudeScanned.map((s) => s.name).sort()).toEqual([
+      "claude-skill",
+      "global-claude",
+    ]);
+    expect(claudeScanned.every((s) => s.runtime === "claude-code")).toBe(true);
+
+    const codexScanned = scanSoftSkills(agentId, { runtime: "codex" });
+    expect(codexScanned.map((s) => s.name).sort()).toEqual([
       "codex-skill",
-      "global-skill",
-      "workspace-skill",
+      "global-codex",
     ]);
+    expect(codexScanned.every((s) => s.runtime === "codex")).toBe(true);
 
-    const snapshot = collectAgentSkillSnapshot(agentId);
+    const snapshot = collectAgentSkillSnapshot(agentId, { runtime: "codex" });
     expect(snapshot.agentId).toBe(agentId);
-    expect(snapshot.skills).toHaveLength(3);
-    expect(snapshot.skills.find((s) => s.name === "workspace-skill")?.source)
-      .toBe("workspace");
+    expect(snapshot.runtime).toBe("codex");
+    expect(snapshot.skills).toHaveLength(2);
     expect(snapshot.skills.find((s) => s.name === "codex-skill")?.source)
       .toBe("workspace");
-    expect(snapshot.skills.find((s) => s.name === "global-skill")?.source)
+    expect(snapshot.skills.find((s) => s.name === "codex-skill")?.sourceDetail)
+      .toBe("agent-codex");
+    expect(snapshot.skills.find((s) => s.name === "codex-skill")?.path)
+      .toBe(path.join(codexPath, "codex-skill", "SKILL.md"));
+    expect(snapshot.skills.find((s) => s.name === "global-codex")?.source)
       .toBe("runtime-global");
     expect(snapshot.probedAt).toBeGreaterThan(0);
   });
@@ -101,6 +116,67 @@ describe("skill snapshots", () => {
       .toBe("runtime-global");
   });
 
+  it("scans Hermes home/profile skills without mixing Claude or Codex dirs", () => {
+    const agentId = "ag_hermes_skills";
+    writeSkill(path.join(agentWorkspaceDir(agentId), ".claude", "skills"), "claude-only", "Claude only");
+    writeSkill(path.join(agentCodexHomeDir(agentId), "skills"), "codex-only", "Codex only");
+    writeSkill(path.join(agentHermesHomeDir(agentId), "skills"), "hermes-only", "Hermes only");
+
+    const isolated = scanSoftSkills(agentId, { runtime: "hermes-agent" });
+    expect(isolated.map((s) => s.name)).toEqual(["hermes-only"]);
+    expect(isolated[0]).toMatchObject({
+      source: "agent-hermes",
+      runtime: "hermes-agent",
+    });
+
+    const profileAgentId = "ag_hermes_profile";
+    writeSkill(
+      path.join(hermesProfileHomeDir("writer"), "skills"),
+      "profile-skill",
+      "Hermes profile skill",
+    );
+    const profile = collectAgentSkillSnapshot(profileAgentId, {
+      runtime: "hermes-agent",
+      hermesProfile: "writer",
+    });
+    expect(profile.skills).toHaveLength(1);
+    expect(profile.skills[0]).toMatchObject({
+      name: "profile-skill",
+      source: "workspace",
+      sourceDetail: "agent-hermes-profile",
+      runtime: "hermes-agent",
+      profile: "writer",
+    });
+  });
+
+  it("keeps same-device workspace skills scoped by agent id", () => {
+    writeSkill(
+      path.join(agentWorkspaceDir("ag_workspace_a"), ".claude", "skills"),
+      "agent-local",
+      "Skill for agent A",
+    );
+    writeSkill(
+      path.join(agentWorkspaceDir("ag_workspace_b"), ".claude", "skills"),
+      "agent-local",
+      "Skill for agent B",
+    );
+
+    expect(scanSoftSkills("ag_workspace_a", { runtime: "claude-code" })).toEqual([
+      expect.objectContaining({
+        name: "agent-local",
+        description: "Skill for agent A",
+        source: "agent-claude",
+      }),
+    ]);
+    expect(scanSoftSkills("ag_workspace_b", { runtime: "claude-code" })).toEqual([
+      expect.objectContaining({
+        name: "agent-local",
+        description: "Skill for agent B",
+        source: "agent-claude",
+      }),
+    ]);
+  });
+
   it("returns complete snapshots while keeping the prompt soft index capped", () => {
     const agentId = "ag_manyskills";
     const workspaceSkills = path.join(agentWorkspaceDir(agentId), ".claude", "skills");