@desplega.ai/agent-swarm 1.173.0 → 2.0.0

package/src/tests/seed-skills-bundled-files.test.ts

@@ -1,7 +1,8 @@
 /**
  * Multi-file (bundled) seeded skills.
  *
- * Regression coverage for the collision that shipped `artifacts` twice — once
+ * Regression coverage for the collision that shipped the since-retired
+ * `artifacts` skill twice — once
  * baked into the worker image with an `examples/` directory, once seeded from
  * `templates/skills/` as a simple skill. The DB copy won at runtime, dropped a
  * `.swarm-managed` marker, and the next reconcile pass deleted the baked
@@ -58,17 +59,9 @@ describe("seeded skills with bundled files", () => {
     await removeDbFiles(TEST_DB_PATH);
   });
 
-  test("embedded manifest exposes bundled files for artifacts and pages", async () => {
+  test("embedded manifest exposes bundled files for pages", async () => {
     const skills = await loadSeedSkills();
 
-    const artifacts = skills.find((skill) => skill.name === "artifacts");
-    expect(artifacts?.files.map((file) => file.path).sort()).toEqual([
-      "examples/approval-flow.ts",
-      "examples/hono-dashboard.ts",
-      "examples/multi-artifact.ts",
-      "examples/static-report.sh",
-    ]);
-
     const pages = skills.find((skill) => skill.name === "pages");
     expect(pages?.files.map((file) => file.path).sort()).toEqual([
       "examples/annotated-pr.html",
@@ -84,7 +77,7 @@ describe("seeded skills with bundled files", () => {
     const embedded = await loadSeedSkills();
     const fromDisk = await loadSeedSkills(TEMPLATES_DIR);
 
-    for (const name of ["artifacts", "pages"]) {
+    for (const name of ["pages", "script-builder"]) {
       const a = embedded.find((skill) => skill.name === name);
       const b = fromDisk.find((skill) => skill.name === name);
       expect(a?.files).toEqual(b?.files ?? []);
@@ -107,18 +100,17 @@ describe("seeded skills with bundled files", () => {
   });
 
   test("seeding writes skill_files rows and marks the skill complex", async () => {
-    const artifacts = await getSkillByName("artifacts", "swarm");
-    expect(artifacts).toBeTruthy();
-    if (!artifacts) return;
+    const pages = await getSkillByName("pages", "swarm");
+    expect(pages).toBeTruthy();
+    if (!pages) return;
 
-    expect(artifacts.isComplex).toBe(true);
+    expect(pages.isComplex).toBe(true);
 
-    const files = await getSkillFiles(artifacts.id);
+    const files = await getSkillFiles(pages.id);
     expect(files.map((file) => file.path).sort()).toEqual([
-      "examples/approval-flow.ts",
-      "examples/hono-dashboard.ts",
-      "examples/multi-artifact.ts",
-      "examples/static-report.sh",
+      "examples/annotated-pr.html",
+      "examples/multiplayer-board.html",
+      "examples/report-page.html",
     ]);
     expect(files.every((file) => file.content.length > 0)).toBe(true);
   });
@@ -131,24 +123,24 @@ describe("seeded skills with bundled files", () => {
   });
 
   test("a bundled-file edit registers as drift and is preserved", async () => {
-    const item = (await skillsSeeder.items()).find((candidate) => candidate.key === "artifacts");
+    const item = (await skillsSeeder.items()).find((candidate) => candidate.key === "pages");
     expect(item).toBeDefined();
     if (!item) return;
 
     // Freshly seeded and untouched: upstream hashes to exactly the source.
     expect(await skillsSeeder.upstreamHash(item)).toBe(item.contentHash);
 
-    const artifacts = await getSkillByName("artifacts", "swarm");
-    if (!artifacts) throw new Error("artifacts skill missing");
-    const original = (await getSkillFiles(artifacts.id)).find(
-      (file) => file.path === "examples/hono-dashboard.ts",
+    const pages = await getSkillByName("pages", "swarm");
+    if (!pages) throw new Error("pages skill missing");
+    const original = (await getSkillFiles(pages.id)).find(
+      (file) => file.path === "examples/report-page.html",
     );
     if (!original) throw new Error("bundled example missing");
 
     // Simulate a user editing a bundled file through the skills API.
-    await upsertSkillFile(artifacts.id, {
+    await upsertSkillFile(pages.id, {
       path: original.path,
-      content: `${original.content}\n// edited by a user`,
+      content: `${original.content}\n<!-- edited by a user -->`,
     });
 
     // The edit must move the upstream hash — otherwise the seeder would think
@@ -159,11 +151,11 @@ describe("seeded skills with bundled files", () => {
     expect(result.failed).toEqual([]);
     expect(result.skippedUserModified).toBeGreaterThan(0);
 
-    const after = (await getSkillFiles(artifacts.id)).find((file) => file.path === original.path);
-    expect(after?.content).toContain("// edited by a user");
+    const after = (await getSkillFiles(pages.id)).find((file) => file.path === original.path);
+    expect(after?.content).toContain("<!-- edited by a user -->");
 
     // Restore so later tests see a pristine skill.
-    await upsertSkillFile(artifacts.id, { path: original.path, content: original.content });
+    await upsertSkillFile(pages.id, { path: original.path, content: original.content });
   });
 
   test("a userInvocable flip registers as drift and is preserved", async () => {
@@ -195,24 +187,24 @@ describe("seeded skills with bundled files", () => {
     // format (no bundled-file section). The new seeder must still recognise it
     // as pristine and update it — not misread it as user-modified and skip it
     // forever, which would mean the merged content never reaches production.
-    const artifacts = await getSkillByName("artifacts", "swarm");
-    if (!artifacts) throw new Error("artifacts skill missing");
+    const pages = await getSkillByName("pages", "swarm");
+    if (!pages) throw new Error("pages skill missing");
 
-    const legacyContent = "---\nname: artifacts\ndescription: old\n---\n\nold body\n";
-    await updateSkill(artifacts.id, { content: legacyContent, isComplex: false });
-    for (const file of await getSkillFiles(artifacts.id)) {
-      await deleteSkillFile(artifacts.id, file.path);
+    const legacyContent = "---\nname: pages\ndescription: old\n---\n\nold body\n";
+    await updateSkill(pages.id, { content: legacyContent, isComplex: false });
+    for (const file of await getSkillFiles(pages.id)) {
+      await deleteSkillFile(pages.id, file.path);
     }
 
     // Old-format hash: base only, no file section. The flag mirrors the seeded
-    // config so the test does not pin artifacts' systemDefault value.
+    // config so the test does not pin pages' systemDefault value.
     const legacyHash = computeContentHash(
-      `${legacyContent}\n\n# seed:systemDefault=${artifacts.systemDefault ? 1 : 0}\n`,
+      `${legacyContent}\n\n# seed:systemDefault=${pages.systemDefault ? 1 : 0}\n`,
     );
-    await recordSeedState("skill", "artifacts", legacyHash);
+    await recordSeedState("skill", "pages", legacyHash);
 
-    const item = (await skillsSeeder.items()).find((candidate) => candidate.key === "artifacts");
-    if (!item) throw new Error("artifacts seed item missing");
+    const item = (await skillsSeeder.items()).find((candidate) => candidate.key === "pages");
+    if (!item) throw new Error("pages seed item missing");
 
     // Pristine: upstream (file-less) still hashes in the old format.
     expect(await skillsSeeder.upstreamHash(item)).toBe(legacyHash);
@@ -221,10 +213,10 @@ describe("seeded skills with bundled files", () => {
     expect(result.failed).toEqual([]);
     expect(result.skippedUserModified).toBe(0);
 
-    const upgraded = await getSkillByName("artifacts", "swarm");
+    const upgraded = await getSkillByName("pages", "swarm");
     expect(upgraded?.isComplex).toBe(true);
     expect(upgraded?.content).not.toBe(legacyContent);
-    expect((await getSkillFiles(upgraded?.id ?? "")).length).toBe(4);
+    expect((await getSkillFiles(upgraded?.id ?? "")).length).toBe(3);
 
     // And it settles: the next run is a clean no-op.
     const second = await runSeeder(skillsSeeder, { quiet: true });
@@ -273,18 +265,18 @@ describe("seeded skills with bundled files", () => {
   });
 
   test("bundled files survive repeated filesystem syncs (the reconcile bug)", async () => {
-    const artifacts = await getSkillByName("artifacts", "swarm");
-    expect(artifacts).toBeTruthy();
-    if (!artifacts) return;
+    const pages = await getSkillByName("pages", "swarm");
+    expect(pages).toBeTruthy();
+    if (!pages) return;
 
     const entry: SkillFsEntry = {
-      id: artifacts.id,
-      name: artifacts.name,
-      content: artifacts.content,
-      isComplex: artifacts.isComplex,
+      id: pages.id,
+      name: pages.name,
+      content: pages.content,
+      isComplex: pages.isComplex,
       isEnabled: true,
       isActive: true,
-      files: (await getSkillFiles(artifacts.id)).map((file) => ({
+      files: (await getSkillFiles(pages.id)).map((file) => ({
         path: file.path,
         content: file.content,
         isBinary: file.isBinary,
@@ -297,9 +289,9 @@ describe("seeded skills with bundled files", () => {
       FAKE_HOME,
       ".claude",
       "skills",
-      "artifacts",
+      "pages",
       "examples",
-      "hono-dashboard.ts",
+      "report-page.html",
     );
     expect(existsSync(examplePath)).toBe(true);
 

package/src/tests/seed-skills-retire.test.ts

@@ -0,0 +1,182 @@
+/**
+ * Retiring a seeded skill whose template was removed.
+ *
+ * Dropping `templates/skills/<name>/` alone leaves the last seeded row live on
+ * every existing install. `retireSeedSkills` deletes it, but only while the
+ * seeder still owns it: a recorded `seed_state` hash that the live copy
+ * matches and every metadata column still holds what the seeder wrote.
+ * Unrecorded and user-edited skills stay, including metadata-only edits.
+ */
+
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import {
+  closeDb,
+  computeContentHash,
+  createAgent,
+  createSkill,
+  getAgentSkills,
+  getSkillByName,
+  getSkillFiles,
+  initDb,
+  installSkill,
+  updateSkill,
+  upsertSkillFiles,
+} from "../be/db";
+import { getSeedState, recordSeedState, runSeeder } from "../be/seed";
+import { RETIRED_SEED_SKILLS, retireSeedSkills, skillsSeeder } from "../be/seed-skills";
+
+const TEST_DB_PATH = `./test-seed-skills-retire-${process.pid}.sqlite`;
+
+async function removeDbFiles(path: string): Promise<void> {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    await unlink(path + suffix).catch(() => {});
+  }
+}
+
+const BUNDLED_FILE = { path: "examples/serve.ts", content: "pm2 start serve.ts\n" };
+
+/**
+ * Seed a swarm skill the way the seeder does (frontmatter description equal to
+ * the description column, isComplex set from the file count) and record the
+ * hash it would have written.
+ */
+async function seedLegacySkill(name: string, withFile = false): Promise<string> {
+  const content = `---\nname: ${name}\ndescription: old\n---\n\nRun pm2 start.\n`;
+  const skill = await createSkill({
+    name,
+    description: "old",
+    content,
+    type: "personal",
+    scope: "swarm",
+    ownerAgentId: undefined,
+    systemDefault: false,
+    isComplex: withFile,
+  });
+  let hashed = `${content}\n\n# seed:systemDefault=0\n`;
+  if (withFile) {
+    await upsertSkillFiles(skill.id, [BUNDLED_FILE]);
+    hashed += `# seed:files\n${BUNDLED_FILE.path}\n${BUNDLED_FILE.content}\n`;
+  }
+  await recordSeedState("skill", name, computeContentHash(hashed));
+  return skill.id;
+}
+
+describe("retiring seeded skills", () => {
+  let agentId: string;
+
+  beforeAll(async () => {
+    await removeDbFiles(TEST_DB_PATH);
+    initDb(TEST_DB_PATH);
+    agentId = (
+      await createAgent({ name: "retire-test", isLead: false, status: "idle", capabilities: [] })
+    ).id;
+  });
+
+  afterAll(async () => {
+    closeDb();
+    await removeDbFiles(TEST_DB_PATH);
+  });
+
+  test("artifacts is retired and no longer seeded", async () => {
+    expect(RETIRED_SEED_SKILLS).toContain("artifacts");
+    const keys = (await skillsSeeder.items()).map((item) => item.key);
+    expect(keys).not.toContain("artifacts");
+  });
+
+  test("the seeder run deletes a pristine retired skill and its seed state", async () => {
+    const id = await seedLegacySkill("artifacts", true);
+    await installSkill(agentId, id);
+
+    const result = await runSeeder(skillsSeeder, { quiet: true });
+    expect(result.failed).toEqual([]);
+    expect(result.retired).toBe(1);
+    expect(await getSkillByName("artifacts", "swarm")).toBeNull();
+    expect(await getSkillFiles(id)).toEqual([]);
+    expect((await getAgentSkills(agentId, false)).map((s) => s.id)).not.toContain(id);
+    expect(await getSeedState("skill", "artifacts")).toBeNull();
+
+    // Settled: nothing left to retire on the next boot.
+    expect((await runSeeder(skillsSeeder, { quiet: true })).retired).toBe(0);
+  });
+
+  test("the seeder run keeps a retired skill with metadata-only edits, with its installs and files", async () => {
+    const id = await seedLegacySkill("artifacts", true);
+    await installSkill(agentId, id);
+    await updateSkill(id, {
+      allowedTools: "Read",
+      model: "user-selected-model",
+      description: "my edited description",
+    });
+
+    const result = await runSeeder(skillsSeeder, { quiet: true });
+    expect(result.failed).toEqual([]);
+    expect(result.retired).toBe(0);
+
+    const kept = await getSkillByName("artifacts", "swarm");
+    expect(kept?.id).toBe(id);
+    expect(kept?.model).toBe("user-selected-model");
+    expect((await getSkillFiles(id)).map((file) => file.path)).toEqual([BUNDLED_FILE.path]);
+    expect((await getAgentSkills(agentId, false)).map((s) => s.id)).toContain(id);
+  });
+
+  // Every column updateSkill can write outside the seed hash. Each one alone
+  // marks the row as user-edited.
+  const METADATA_EDITS: [string, Parameters<typeof updateSkill>[1]][] = [
+    ["description", { description: "mine" }],
+    ["allowedTools", { allowedTools: "Read" }],
+    ["model", { model: "opus" }],
+    ["effort", { effort: "high" }],
+    ["context", { context: "fork" }],
+    ["agent", { agent: "reviewer" }],
+    ["disableModelInvocation", { disableModelInvocation: true }],
+    ["isEnabled", { isEnabled: false }],
+    ["isComplex", { isComplex: true }],
+    ["sourceUrl", { sourceUrl: "https://example.com/SKILL.md" }],
+    ["sourceRepo", { sourceRepo: "me/skills" }],
+    ["sourcePath", { sourcePath: "skills/artifacts" }],
+    ["sourceBranch", { sourceBranch: "dev" }],
+    ["sourceHash", { sourceHash: "abc123" }],
+    ["lastFetchedAt", { lastFetchedAt: "2026-01-01T00:00:00.000Z" }],
+  ];
+
+  test.each(METADATA_EDITS)("a retired skill with an edited %s is kept", async (field, edit) => {
+    const name = `zz-retired-meta-${field.toLowerCase()}`;
+    const id = await seedLegacySkill(name);
+    await updateSkill(id, edit);
+
+    expect(await retireSeedSkills([name])).toEqual([]);
+    expect(await getSkillByName(name, "swarm")).not.toBeNull();
+  });
+
+  test("a pristine retired skill touched by a no-op update is still retired", async () => {
+    const id = await seedLegacySkill("zz-retired-noop");
+    await updateSkill(id, {});
+
+    expect(await retireSeedSkills(["zz-retired-noop"])).toEqual(["zz-retired-noop"]);
+    expect(await getSkillByName("zz-retired-noop", "swarm")).toBeNull();
+  });
+
+  test("a retired skill edited since it was seeded is kept", async () => {
+    const id = await seedLegacySkill("zz-retired-edited");
+    await updateSkill(id, { content: "---\nname: zz-retired-edited\n---\n\nmine\n" });
+
+    expect(await retireSeedSkills(["zz-retired-edited"])).toEqual([]);
+    expect(await getSkillByName("zz-retired-edited", "swarm")).not.toBeNull();
+  });
+
+  test("a same-name skill the seeder never recorded is kept", async () => {
+    await createSkill({
+      name: "zz-retired-unrecorded",
+      description: "user authored",
+      content: "---\nname: zz-retired-unrecorded\n---\n\nmine\n",
+      type: "personal",
+      scope: "swarm",
+      ownerAgentId: undefined,
+      systemDefault: false,
+    });
+
+    expect(await retireSeedSkills(["zz-retired-unrecorded"])).toEqual([]);
+    expect(await getSkillByName("zz-retired-unrecorded", "swarm")).not.toBeNull();
+  });
+});

package/src/tests/send-task-requester-gate.test.ts

@@ -2,6 +2,7 @@
  * A task's requester drives attribution, cost reporting and admission. A non-lead agent may omit
  * `requestedByUserId` or pass the requester of its own current task. Only a lead, the operator or
  * a user may name any other registered user. Covers the send-task tool and POST /api/tasks.
+ * POST /api/tasks also refuses an agent a foreign parent or a chat thread it does not own.
  */
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import { unlink } from "node:fs/promises";
@@ -18,6 +19,7 @@ import {
   initDb,
 } from "../be/db";
 import { handleTasks } from "../http/tasks";
+import { chatSdkContextKey } from "../tasks/context-key";
 import { registerSendTaskTool } from "../tools/send-task";
 import { type HttpRequestAuth, setRequestAuth } from "../utils/request-auth-context";
 
@@ -258,3 +260,59 @@ describe("POST /api/tasks with an X-Agent-ID on the swarm key", () => {
     expect(lead.body.requestedByUserId).toBe(userBId);
   });
 });
+
+describe("POST /api/tasks parent and chat-thread binding for an agent caller", () => {
+  test("a worker cannot attach a child to a task it neither owns nor created", async () => {
+    const foreign = await createTaskExtended("lead chat task (http)", {
+      agentId: LEAD_ID,
+      source: "chat",
+      contextKey: chatSdkContextKey("telegram:552222"),
+    });
+    const before = await taskCount();
+    const result = await postTask(
+      { agentId: WORKER_ID },
+      { parentTaskId: foreign.id, agentId: WORKER_ID, routingReason: "skill" },
+    );
+    expect(result.status).toBe(403);
+    expect(await taskCount()).toBe(before);
+  });
+
+  test("a worker cannot bind a new task to a chat thread by contextKey", async () => {
+    const before = await taskCount();
+    const result = await postTask(
+      { agentId: WORKER_ID },
+      {
+        contextKey: chatSdkContextKey("telegram:552222"),
+        agentId: WORKER_ID,
+        routingReason: "skill",
+      },
+    );
+    expect(result.status).toBe(403);
+    expect(await taskCount()).toBe(before);
+  });
+
+  test("a worker may attach under its own task, and the operator and a lead keep access", async () => {
+    const own = await createTaskExtended("worker chat task (http)", {
+      agentId: WORKER_ID,
+      source: "chat",
+      contextKey: chatSdkContextKey("telegram:551111"),
+    });
+    const child = await postTask(
+      { agentId: WORKER_ID },
+      { parentTaskId: own.id, agentId: OTHER_WORKER_ID, routingReason: "skill" },
+    );
+    expect(child.status).toBe(201);
+
+    const foreign = await createTaskExtended("lead chat task (http, open)", {
+      agentId: LEAD_ID,
+      source: "chat",
+      contextKey: chatSdkContextKey("telegram:553333"),
+    });
+    expect((await postTask({}, { parentTaskId: foreign.id })).status).toBe(201);
+    expect((await postTask({ agentId: LEAD_ID }, { parentTaskId: foreign.id })).status).toBe(201);
+    expect(
+      (await postTask({ agentId: LEAD_ID }, { contextKey: chatSdkContextKey("telegram:554444") }))
+        .status,
+    ).toBe(201);
+  });
+});

package/src/tests/session-cost-recompute-unit.test.ts

@@ -3,6 +3,8 @@
 // behavior that is uneconomical to express through a server round-trip.
 
 import { describe, expect, test } from "bun:test";
+import { loadModelsDevCache } from "../be/modelsdev-cache";
+import { buildModelsDevSeedRows } from "../be/seed-pricing";
 import { recomputeSessionCost } from "../http/session-cost-recompute";
 import type { PricingProvider, PricingTokenClass } from "../types";
 
@@ -215,3 +217,47 @@ describe("recomputeSessionCost — pure branch behavior", () => {
     expect(result.costSource).toBe("pricing-table");
   });
 });
+
+describe("nan and helmcode sessions price at $0 from the seeded table", () => {
+  // Rows projected from the vendored snapshot, exactly as the boot seeder and
+  // the runtime refresh insert them.
+  const cache = loadModelsDevCache();
+  const rows = cache ? buildModelsDevSeedRows(cache) : [];
+  const book: RateBook = Object.fromEntries(
+    rows.map((row) => [`${row.provider}:${row.model}:${row.tokenClass}`, row.pricePerMillionUsd]),
+  );
+
+  test("pi on nan/glm5.3-flash and opencode on helmcode/qwen3.6 record pricing-table, total 0", async () => {
+    for (const [provider, model] of [
+      ["pi", "nan/glm5.3-flash"],
+      ["opencode", "helmcode/qwen3.6"],
+    ] as const) {
+      const result = await recomputeSessionCost(
+        {
+          ...BASE,
+          provider,
+          model,
+          harnessCostUsd: 0,
+          inputTokens: 50_000,
+          outputTokens: 2_000,
+          cacheReadTokens: 10_000,
+        },
+        lookupFrom(book),
+      );
+      expect(result.costSource).toBe("pricing-table");
+      expect(result.totalCostUsd).toBe(0);
+    }
+  });
+
+  test("nan/qwen3.6 and helmcode/qwen3.6 are separate pricing keys", () => {
+    for (const harness of ["pi", "opencode"]) {
+      const keys = new Set(
+        rows
+          .filter((row) => row.provider === harness && row.model.endsWith("/qwen3.6"))
+          .map((row) => row.model),
+      );
+      expect(keys.has("nan/qwen3.6")).toBe(true);
+      expect(keys.has("helmcode/qwen3.6")).toBe(true);
+    }
+  });
+});

package/src/tests/skill-get-name-resolution.test.ts

@@ -0,0 +1,137 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { closeDb, createAgent, createSkill, initDb } from "../be/db";
+import { skillsSeeder } from "../be/seed-skills";
+import { registerSkillGetTool } from "../tools/skills/skill-get";
+
+const TEST_DB_PATH = "./test-skill-get-name-resolution.sqlite";
+
+const CALLER_ID = "aaaa0000-0000-4000-8000-000000000031";
+const OTHER_ID = "bbbb0000-0000-4000-8000-000000000032";
+const THIRD_ID = "cccc0000-0000-4000-8000-000000000033";
+
+type StructuredContent = {
+  success: boolean;
+  message: string;
+  skill?: { id: string; ownerAgentId: string | null };
+};
+
+async function callSkillGet(
+  server: McpServer,
+  callerAgentId: string | undefined,
+  args: Record<string, unknown>,
+): Promise<StructuredContent> {
+  // biome-ignore lint/complexity/noBannedTypes: accessing internal MCP SDK type for test
+  const tools = (server as unknown as { _registeredTools: Record<string, { handler: Function }> })
+    ._registeredTools;
+  const result = await tools["skill-get"].handler(args, {
+    sessionId: "test-session",
+    requestInfo: { headers: { "x-agent-id": callerAgentId ?? "" } },
+  });
+  return (result as { structuredContent: StructuredContent }).structuredContent;
+}
+
+function swarmSkill(name: string, ownerAgentId: string | null) {
+  return createSkill({
+    name,
+    description: `${name} description`,
+    content: `---\nname: ${name}\ndescription: ${name} description\n---\n\nBody.`,
+    type: "personal",
+    scope: "swarm",
+    ownerAgentId: ownerAgentId ?? undefined,
+  });
+}
+
+describe("skill-get swarm name resolution", () => {
+  let server: McpServer;
+
+  beforeAll(async () => {
+    for (const suffix of ["", "-wal", "-shm"]) {
+      try {
+        await unlink(TEST_DB_PATH + suffix);
+      } catch {
+        // File doesn't exist
+      }
+    }
+    closeDb();
+    initDb(TEST_DB_PATH);
+    for (const [id, name] of [
+      [CALLER_ID, "Caller"],
+      [OTHER_ID, "Other"],
+      [THIRD_ID, "Third"],
+    ] as const) {
+      await createAgent({ id, name, isLead: false, status: "idle" });
+    }
+    server = new McpServer({ name: "test-skill-get-name-resolution", version: "1.0.0" });
+    registerSkillGetTool(server);
+  });
+
+  afterAll(async () => {
+    closeDb();
+    for (const suffix of ["", "-wal", "-shm"]) {
+      try {
+        await unlink(TEST_DB_PATH + suffix);
+      } catch {
+        // ignore
+      }
+    }
+  });
+
+  test("an owned-only swarm skill resolves by name", async () => {
+    const owned = await swarmSkill("owned-only-skill", OTHER_ID);
+
+    const withCaller = await callSkillGet(server, CALLER_ID, { name: "owned-only-skill" });
+    expect(withCaller.success).toBe(true);
+    expect(withCaller.skill?.id).toBe(owned.id);
+
+    const anonymous = await callSkillGet(server, undefined, { name: "owned-only-skill" });
+    expect(anonymous.success).toBe(true);
+    expect(anonymous.skill?.id).toBe(owned.id);
+  });
+
+  test("the ownerless row beats owned rows, including the caller's own", async () => {
+    // Live shape: qa-loom has an ownerless row and an agent-owned twin.
+    const owned = await swarmSkill("shadowed-skill", CALLER_ID);
+    const ownerless = await swarmSkill("shadowed-skill", null);
+    expect(owned.createdAt <= ownerless.createdAt).toBe(true);
+
+    const result = await callSkillGet(server, CALLER_ID, { name: "shadowed-skill" });
+    expect(result.success).toBe(true);
+    expect(result.skill?.id).toBe(ownerless.id);
+  });
+
+  test("the caller's own row beats another agent's row", async () => {
+    await swarmSkill("two-owner-skill", OTHER_ID);
+    const mine = await swarmSkill("two-owner-skill", CALLER_ID);
+
+    const result = await callSkillGet(server, CALLER_ID, { name: "two-owner-skill" });
+    expect(result.success).toBe(true);
+    expect(result.skill?.id).toBe(mine.id);
+  });
+
+  test("two foreign-owned rows return an error naming both ids", async () => {
+    const first = await swarmSkill("foreign-pair-skill", OTHER_ID);
+    const second = await swarmSkill("foreign-pair-skill", THIRD_ID);
+
+    const result = await callSkillGet(server, CALLER_ID, { name: "foreign-pair-skill" });
+    expect(result.success).toBe(false);
+    expect(result.message).toContain(first.id);
+    expect(result.message).toContain(second.id);
+    expect(result.message).toContain("skillId");
+
+    const byId = await callSkillGet(server, CALLER_ID, { skillId: second.id });
+    expect(byId.success).toBe(true);
+    expect(byId.skill?.id).toBe(second.id);
+  });
+
+  test("the seed path still matches ownerless rows only", async () => {
+    await swarmSkill("seed-owned-only", OTHER_ID);
+
+    const item = { key: "seed-owned-only", contentHash: "" } as never;
+    expect(await skillsSeeder.upstreamHash(item)).toBeNull();
+
+    await swarmSkill("seed-owned-only", null);
+    expect(await skillsSeeder.upstreamHash(item)).not.toBeNull();
+  });
+});

package/src/tests/sonnet-5-5-registry.test.ts

@@ -23,10 +23,11 @@ describe("Sonnet 5.5 registry", () => {
             .filter((row) => row.provider === provider && row.model === model)
             .map((row) => [row.tokenClass, row.pricePerMillionUsd]),
         );
+        // Sonnet 5.5 cache hits cost 0.05x input, not the usual 0.1x.
         expect(rates).toEqual({
           input: 2,
           output: 10,
-          cached_input: 0.2,
+          cached_input: 0.1,
           cache_write: 2.5,
           cache_write_1h: 4,
         });
@@ -41,4 +42,11 @@ describe("Sonnet 5.5 registry", () => {
       ).toBe(2);
     }
   });
+
+  test("the shortname fallback seeds the same cache-read rate when the snapshot lacks the model", () => {
+    const row = buildModelsDevSeedRows({ anthropic: { models: {} } }).find(
+      (r) => r.provider === "claude" && r.model === "sonnet" && r.tokenClass === "cached_input",
+    );
+    expect(row?.pricePerMillionUsd).toBe(0.1);
+  });
 });