@desplega.ai/agent-swarm 2.5.2 → 2.5.3

package/src/tests/sessions-tree.test.ts

@@ -4,6 +4,7 @@ import { keyPrefixRange, sessionGroupKey } from "../assets/key";
 import {
   closeDb,
   countSessions,
+  createSteeringMessage,
   createTaskExtended,
   createUser,
   getDbClient,
@@ -58,6 +59,7 @@ beforeAll(async () => {
 });
 beforeEach(async () => {
   await getDbClient().run("DELETE FROM approval_requests");
+  await getDbClient().run("DELETE FROM task_steering_messages");
   await getDbClient().run("DELETE FROM inbox_item_state");
   await getDbClient().run("DELETE FROM session_shares");
   await getDbClient().run("DELETE FROM agent_tasks");
@@ -195,7 +197,8 @@ describe("chain-wide read state", () => {
       { activity: "2026-10-14T12:00:00.000Z", expected: "read" },
       { status: "dismissed", updated: OLD, expected: "done" },
       { status: "done", updated: NOW, expected: "done" },
-      { status: "done", updated: OLD, expected: "unread" },
+      // Agent activity after the Done mark keeps it Done.
+      { status: "done", updated: OLD, expected: "done" },
       { status: "snoozed", snoozeUntil: "2026-10-22T12:00:00.000Z", expected: "later" },
       { status: "snoozed", snoozeUntil: NOW, expected: "unread" },
       { status: "snoozed", expected: "unread" },
@@ -259,6 +262,145 @@ describe("chain-wide read state", () => {
   });
 });
 
+describe("Done holds until the session needs the user", () => {
+  const DONE_AT = "2026-10-21T11:00:00.000Z";
+  const BEFORE = "2026-10-21T10:30:00.000Z";
+  const AFTER = "2026-10-21T11:30:00.000Z";
+  const readState = async (id: string) =>
+    (await listRecentSessions(filters({ limit: 100 }))).find((s) => s.root.id === id)?.readState;
+  const doneSession = async () => {
+    const root = await task("shared/", { source: "ui" }, BEFORE);
+    await getDbClient().run(
+      "UPDATE agent_tasks SET createdAt = ?, status = 'in_progress' WHERE id = ?",
+      [BEFORE, root.id],
+    );
+    await state(root.id, "done", DONE_AT);
+    expect(await readState(root.id)).toBe("done");
+    return root;
+  };
+  const child = async (
+    parentTaskId: string,
+    extra: Parameters<typeof createTaskExtended>[1],
+    createdAt = AFTER,
+  ) => {
+    const row = await createTaskExtended("Child", { parentTaskId, key: "shared/", ...extra });
+    await getDbClient().run(
+      "UPDATE agent_tasks SET createdAt = ?, lastUpdatedAt = ?, status = 'completed' WHERE id = ?",
+      [createdAt, createdAt, row.id],
+    );
+    return row;
+  };
+  const approval = async (taskId: string, createdAt: string, status = "pending") =>
+    getDbClient().run(
+      `INSERT INTO approval_requests (id, sourceTaskId, title, questions, approvers, status, createdAt)
+      VALUES (?, ?, 'Approve deploy', '[]', '{}', ?, ?)`,
+      [crypto.randomUUID(), taskId, status, createdAt],
+    );
+
+  test("agent progress and a status change keep it Done", async () => {
+    const root = await doneSession();
+    await getDbClient().run(
+      "UPDATE agent_tasks SET lastUpdatedAt = ?, status = 'completed' WHERE id = ?",
+      [AFTER, root.id],
+    );
+    expect(await readState(root.id)).toBe("done");
+    const tree = await getSessionTree(actor(), NOW);
+    expect(tree.done.total).toBe(1);
+    expect(tree.inbox.total).toBe(0);
+  });
+
+  test("agent-created child and delegated tasks keep it Done", async () => {
+    const root = await doneSession();
+    // Inherits the requester from its parent.
+    const inherited = await child(root.id, { source: "mcp" });
+    // Lead delegation, a deferred wake-up and a follow-up name the requester explicitly.
+    await child(inherited.id, { source: "mcp", requestedByUserId: owner.id });
+    await child(root.id, { source: "schedule", requestedByUserId: owner.id });
+    await child(root.id, { source: "system", requestedByUserId: owner.id });
+    await child(root.id, { source: "workflow", requestedByUserId: owner.id });
+    expect(await readState(root.id)).toBe("done");
+  });
+
+  test("a pending approval created after Done returns it to the Inbox", async () => {
+    const before = await doneSession();
+    await approval(before.id, BEFORE);
+    const resolved = await doneSession();
+    await approval(resolved.id, AFTER, "approved");
+    expect(await readState(before.id)).toBe("done");
+    expect(await readState(resolved.id)).toBe("done");
+
+    const root = await doneSession();
+    const agent = await child(root.id, { source: "mcp" });
+    await approval(agent.id, AFTER);
+    expect(await readState(root.id)).toBe("unread");
+    expect(await ids({ triage: "inbox" })).toEqual([root.id]);
+  });
+
+  test("a human follow-up after Done returns it to the Inbox", async () => {
+    const earlier = await doneSession();
+    await child(earlier.id, { source: "ui", requestedByUserId: owner.id }, BEFORE);
+    expect(await readState(earlier.id)).toBe("done");
+
+    const root = await doneSession();
+    await child(root.id, { source: "ui", requestedByUserId: owner.id });
+    expect(await readState(root.id)).toBe("unread");
+    const slack = await doneSession();
+    await child(slack.id, { source: "slack", requestedByUserId: other.id });
+    expect(await readState(slack.id)).toBe("unread");
+    const tree = await getSessionTree(actor(), NOW);
+    expect(tree.inbox.total).toBe(2);
+    expect(tree.done.total).toBe(1);
+  });
+
+  test("a person's steer or queued message after Done returns it to the Inbox", async () => {
+    // The real writer stamps created_at with the column default, after DONE_AT.
+    const steered = await doneSession();
+    await createSteeringMessage({
+      taskId: steered.id,
+      body: "Change course",
+      mode: "steer",
+      source: "ui",
+      createdByKind: "user",
+      createdByUserId: owner.id,
+    });
+    expect(await readState(steered.id)).toBe("unread");
+
+    const queued = await doneSession();
+    const agent = await child(queued.id, { source: "mcp" });
+    await createSteeringMessage({
+      taskId: agent.id,
+      body: "Also check this",
+      mode: "queue",
+      source: "slack",
+      createdByKind: "user",
+      createdByUserId: owner.id,
+    });
+    expect(await readState(queued.id)).toBe("unread");
+    expect((await ids({ triage: "inbox" })).sort()).toEqual([steered.id, queued.id].sort());
+  });
+
+  test("agent, system, cancelled and earlier steering keep it Done", async () => {
+    const steer = async (
+      taskId: string,
+      createdByKind: "user" | "agent" | "system",
+      createdAt = AFTER,
+      status = "pending",
+    ) =>
+      getDbClient().run(
+        `INSERT INTO task_steering_messages
+          (id, task_id, body, mode, status, source, created_by_kind, created_at)
+        VALUES (?, ?, 'Steer', 'queue', ?, 'mcp', ?, ?)`,
+        [crypto.randomUUID(), taskId, status, createdByKind, createdAt],
+      );
+    const root = await doneSession();
+    await steer(root.id, "agent");
+    await steer(root.id, "system");
+    await steer(root.id, "user", AFTER, "cancelled");
+    await steer(root.id, "user", BEFORE, "handled");
+    expect(await readState(root.id)).toBe("done");
+  });
+});
+
 test("needs attention uses the latest failed status and pending approvals anywhere in the chain", async () => {
   const failed = await task();
   const child = await task("shared/a/", { parentTaskId: failed.id }, NOW);
@@ -591,6 +733,31 @@ describe("source filter and list triage", () => {
     );
   });
 
+  test("showSource keeps only the listed sources, and an empty list keeps none", async () => {
+    await task("shared/", { source: "slack" });
+    const ui = await task("shared/a/", { source: "ui" });
+    await task("shared/", { source: "github" });
+
+    const full = await treeOf();
+    const shown = await treeOf("showSource=ui");
+    expect(shown.inbox.total).toBe(1);
+    expect(shown.groups.map((g) => g.key)).toEqual(["shared/a/"]);
+    expect(shown.sources).toEqual(full.sources);
+    const inbox = await listOf("triage=inbox&showSource=ui");
+    expect(inbox.total).toBe(1);
+    expect(inbox.sessions.map((s) => s.root.id)).toEqual([ui.id]);
+
+    const none = await treeOf("showSource=");
+    expect(none.inbox.total).toBe(0);
+    expect(none.sources).toEqual(full.sources);
+    expect((await listOf("triage=inbox&showSource=")).total).toBe(0);
+
+    expect((await triage({ action: "done", triage: "inbox", showSource: ["ui"] })).status).toBe(
+      200,
+    );
+    expect((await listOf("triage=done")).sessions.map((s) => s.root.id)).toEqual([ui.id]);
+  });
+
   test("triage by list writes every matching session, honoring the list and the filters", async () => {
     const a = await task("shared/", { source: "ui" });
     const b = await task("shared/", { source: "ui" }, OLD);

package/src/tests/skill-search-long-content.test.ts

@@ -0,0 +1,193 @@
+import { Database } from "bun:sqlite";
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import {
+  closeDb,
+  createSkill,
+  deleteSkill,
+  getDb,
+  initDb,
+  searchSkills,
+  updateSkill,
+} from "../be/db";
+
+// Natural-language probes that missed on the live catalog: the obvious skill
+// has a long SKILL.md body, and a shorter skill repeats the query words in
+// its content. bm25 over the whole row buried the name/description hit.
+const TEST_DB_PATH = `./test-skill-search-long-content-${process.pid}.sqlite`;
+
+async function removeDbFiles(path: string): Promise<void> {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    await unlink(path + suffix).catch(() => {});
+  }
+}
+
+async function topNames(query: string): Promise<string[]> {
+  return (await searchSkills(query, 10, false)).map((skill) => skill.name);
+}
+
+// A long body of words that no probe uses, like a full SKILL.md.
+const longBody = (topic: string) =>
+  `${topic}\n${"Each step lists its inputs, outputs and the checks to run afterwards. ".repeat(60)}`;
+
+describe("searchSkills on long skill bodies", () => {
+  beforeAll(async () => {
+    await removeDbFiles(TEST_DB_PATH);
+    initDb(TEST_DB_PATH);
+
+    const fixture = [
+      {
+        name: "pages",
+        description: "Publish hosted HTML pages with share links for outside readers.",
+        content: longBody("Hosted artifacts."),
+      },
+      {
+        name: "newsletter-sources",
+        description: "Weekly AI newsletter source list and reading picks.",
+        content: "Publish a short note for a page you read, then publish the page list. ".repeat(6),
+      },
+      {
+        name: "browser-interaction",
+        description: "Drive a headless browser.",
+        content: "Open a page, wait for a page to load, then read a page. ".repeat(6),
+      },
+      {
+        name: "scheduling",
+        description: "Recurring jobs with cron expressions: create, pause or resume a schedule.",
+        content: longBody("Cron jobs."),
+      },
+      {
+        name: "social-content",
+        description: "Draft social posts for the brand accounts.",
+        content: "How do I create a post? Create a draft, then schedule a post for a slot. ".repeat(
+          6,
+        ),
+      },
+      {
+        name: "code-quality",
+        description: "Checks to run before you push or open a pull request, and how to review one.",
+        content: longBody("Pre-push gate."),
+      },
+      {
+        name: "customer-ops",
+        description: "Operations runbook for one customer deployment.",
+        content:
+          "Open a pull request, ask a reviewer, review a pull request, request a fix. ".repeat(6),
+      },
+      // "get" is a stopword, and "aaa-get-helper" sorts first by name.
+      { name: "get", description: "Fetch API resources.", content: "fetch resources" },
+      { name: "aaa-get-helper", description: "Get helper instructions", content: "get content" },
+      { name: "what is it", description: "Release notes digest.", content: "notes" },
+      { name: "aaa-what-is-it", description: "What is it for, in short.", content: "notes" },
+    ];
+    for (const skill of fixture) await createSkill({ ...skill, scope: "swarm" });
+  });
+
+  afterAll(async () => {
+    closeDb();
+    await removeDbFiles(TEST_DB_PATH);
+  });
+
+  test.each([
+    ["publish a page", "pages"],
+    ["how do I create a schedule", "scheduling"],
+    ["how do I review a pull request", "code-quality"],
+  ])("%p ranks %p first over content that repeats the query words", async (query, expected) => {
+    expect((await topNames(query))[0]).toBe(expected);
+  });
+
+  test("stopwords do not match every skill", async () => {
+    // Every fixture body contains "a"; only skills about pages may match.
+    expect(await topNames("publish a page")).not.toContain("code-quality");
+  });
+
+  test("a query of only stopwords falls back to the substring match", async () => {
+    const names = await topNames("how do I");
+    expect(names).toContain("social-content");
+    expect(names).not.toContain("pages");
+  });
+
+  test.each([
+    "get",
+    "GET",
+    " Get ",
+  ])("an exact-name query of only stopwords (%p) ranks that skill first", async (query) => {
+    expect((await searchSkills(query, 1, false)).map((skill) => skill.name)).toEqual(["get"]);
+    expect((await topNames(query)).slice(0, 2)).toEqual(["get", "aaa-get-helper"]);
+  });
+
+  test("a multi-word exact name of only stopwords ranks first", async () => {
+    expect((await searchSkills("What Is It", 1, false)).map((skill) => skill.name)).toEqual([
+      "what is it",
+    ]);
+  });
+
+  test("keeps the name/description index in sync on update and delete", async () => {
+    const skill = await createSkill({
+      name: "meta-sync-probe",
+      description: "Starts with gammaword.",
+      content: "",
+      scope: "swarm",
+    });
+    const metaRows = (term: string) =>
+      getDb()
+        .query<{ skill_id: string }, [string]>(
+          "SELECT skill_id FROM skills_meta_fts WHERE skills_meta_fts MATCH ?",
+        )
+        .all(`"${term}"`)
+        .map((row) => row.skill_id);
+    expect(metaRows("gammaword")).toEqual([skill.id]);
+
+    await updateSkill(skill.id, { description: "Now about deltaword." });
+    expect(metaRows("gammaword")).toEqual([]);
+    expect(metaRows("deltaword")).toEqual([skill.id]);
+
+    await deleteSkill(skill.id);
+    expect(metaRows("deltaword")).toEqual([]);
+  });
+
+  test("migrated schema carries the name/description sync triggers", () => {
+    const triggers = getDb()
+      .query<{ name: string }, []>(
+        "SELECT name FROM sqlite_master WHERE type = 'trigger' AND tbl_name = 'skills' AND name LIKE 'skills_meta_fts_%' ORDER BY name",
+      )
+      .all()
+      .map((row) => row.name);
+    expect(triggers).toEqual([
+      "skills_meta_fts_delete",
+      "skills_meta_fts_insert",
+      "skills_meta_fts_update",
+    ]);
+  });
+});
+
+test("migration 241 backfills skills that existed before it ran", async () => {
+  const db = new Database(":memory:");
+  try {
+    db.exec(await Bun.file("src/be/migrations/019_skills.sql").text());
+    db.run(
+      "INSERT INTO skills (id, name, description, content, type, scope, createdAt, lastUpdatedAt) VALUES ('s1', 'legacy-skill', 'Old description', 'old body', 'remote', 'swarm', '2026-01-01', '2026-01-01')",
+    );
+    const migration = await Bun.file("src/be/migrations/241_skills_meta_fts.sql").text();
+    db.exec(migration);
+
+    const match = (term: string) =>
+      db
+        .query<{ skill_id: string }, [string]>(
+          "SELECT skill_id FROM skills_meta_fts WHERE skills_meta_fts MATCH ?",
+        )
+        .all(term)
+        .map((row) => row.skill_id);
+    expect(match('"description"')).toEqual(["s1"]);
+    // Content is not indexed here.
+    expect(match('"body"')).toEqual([]);
+
+    // Re-running the migration does not duplicate backfilled rows.
+    db.exec(migration);
+    expect(db.query<{ n: number }, []>("SELECT count(*) AS n FROM skills_meta_fts").get()?.n).toBe(
+      1,
+    );
+  } finally {
+    db.close();
+  }
+});

package/src/tests/skill-search.test.ts

@@ -1,6 +1,15 @@
+import { Database } from "bun:sqlite";
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import { unlink } from "node:fs/promises";
-import { closeDb, createSkill, initDb, searchSkills } from "../be/db";
+import {
+  closeDb,
+  createSkill,
+  deleteSkill,
+  getDb,
+  initDb,
+  searchSkills,
+  updateSkill,
+} from "../be/db";
 
 const TEST_DB_PATH = `./test-skill-search-${process.pid}.sqlite`;
 
@@ -10,22 +19,69 @@ async function removeDbFiles(path: string): Promise<void> {
   }
 }
 
+async function topNames(query: string, limit?: number): Promise<string[]> {
+  return (await searchSkills(query, limit)).map((skill) => skill.name);
+}
+
 describe("searchSkills", () => {
   beforeAll(async () => {
     await removeDbFiles(TEST_DB_PATH);
     initDb(TEST_DB_PATH);
 
+    const fixture = [
+      {
+        name: "pr-review-fix-loop",
+        description: "Run review fix rounds on a pull request until CI is green.",
+        content: "Reply to each review thread, push the fix, wait for checks.",
+      },
+      {
+        name: "code-quality",
+        description: "Pre-push checklist for any code change.",
+        content: "Run lint, typecheck and tests, then read the diff as a reviewer would.",
+      },
+      {
+        name: "swarm-scripts",
+        description: "Author and run reusable TypeScript in the swarm.",
+        content: "script-upsert, script-run, credential bindings and secrets stay server-side.",
+      },
+      {
+        name: "agent-fs",
+        description: "Shared drive for documents between agents and people.",
+        content: "Upload markdown and create share links for outside readers.",
+      },
+      {
+        name: "scheduling",
+        description: "Create recurring jobs with cron expressions.",
+        content: "Pick a timezone, set the next run, pause or resume a schedule.",
+      },
+      {
+        name: "schedule-audit",
+        description: "Audit scheduling drift and missed schedules.",
+        content: "Compare each schedule's last run with its cron.",
+      },
+      {
+        name: "memory",
+        description: "Store, search and rate learnings from past sessions.",
+        content: "Use memory-store for a fix that will come back.",
+      },
+      {
+        name: "call-time-trap-placement",
+        description: "Decide where operational rules belong.",
+        content: "Use toolsMd and claudeMd to document the delivery surface.",
+      },
+      {
+        name: "content-search-example",
+        description: "A skill with a content-only term.",
+        content: "This body contains the needle-token.",
+      },
+    ];
+    for (const skill of fixture) await createSkill({ ...skill, scope: "swarm" });
     await createSkill({
-      name: "call-time-trap-placement",
-      description: "Decide where operational rules belong.",
-      content: "Use toolsMd and claudeMd to document the delivery surface.",
-      scope: "swarm",
-    });
-    await createSkill({
-      name: "content-search-example",
-      description: "A skill with a content-only term.",
-      content: "This body contains the needle-token.",
+      name: "disabled-cron-helper",
+      description: "Recurring cron jobs, the old way.",
+      content: "cron cron cron schedule",
       scope: "swarm",
+      isEnabled: false,
     });
   });
 
@@ -34,27 +90,122 @@ describe("searchSkills", () => {
     await removeDbFiles(TEST_DB_PATH);
   });
 
-  test("matches every whitespace-separated token across searchable fields", async () => {
-    const skills = await searchSkills("call-time trap placement toolsMd claudeMd delivery surface");
+  test("ranks a name match first", async () => {
+    expect((await topNames("scheduling"))[0]).toBe("scheduling");
+    expect((await topNames("code quality"))[0]).toBe("code-quality");
+  });
+
+  test("ranks a description-only match first", async () => {
+    expect((await topNames("recurring cron jobs"))[0]).toBe("scheduling");
+  });
+
+  test("ranks a content-only match first", async () => {
+    expect((await topNames("credential bindings"))[0]).toBe("swarm-scripts");
+    expect(await topNames("needle-token")).toEqual(["content-search-example"]);
+  });
+
+  test("ranks natural-language queries by relevance instead of requiring every word", async () => {
+    expect((await topNames("how do I review a pull request"))[0]).toBe("pr-review-fix-loop");
+    expect((await topNames("where to share a document with people"))[0]).toBe("agent-fs");
+  });
 
-    expect(skills.map((skill) => skill.name)).toContain("call-time-trap-placement");
+  test("a query equal to a skill name ranks that skill first", async () => {
+    // On bm25 alone schedule-audit outscores scheduling for this query: its
+    // name and description both stem to "schedul". The exact-name boost wins.
+    expect((await topNames("Scheduling")).slice(0, 2)).toEqual(["scheduling", "schedule-audit"]);
+    expect((await topNames("MEMORY"))[0]).toBe("memory");
+    expect((await topNames("call-time-trap-placement"))[0]).toBe("call-time-trap-placement");
   });
 
-  test("matches terms that appear only in content", async () => {
-    const skills = await searchSkills("needle-token");
+  test("quotes FTS5 syntax in user text instead of executing it", async () => {
+    for (const query of [
+      '"',
+      "*",
+      "NEAR",
+      "-",
+      'cron" OR "x',
+      "cron NEAR/2 jobs",
+      "-cron",
+      "name:cron",
+      "cron*",
+    ]) {
+      await expect(searchSkills(query)).resolves.toBeArray();
+    }
+    expect((await topNames('timezone" OR "x'))[0]).toBe("scheduling");
+    expect((await topNames("-timezone"))[0]).toBe("scheduling");
+    // As a column filter, name:timezone would match nothing: "timezone" is
+    // only in the scheduling skill's content.
+    expect((await topNames("name:timezone"))[0]).toBe("scheduling");
+  });
 
-    expect(skills.map((skill) => skill.name)).toEqual(["content-search-example"]);
+  test("excludes disabled skills", async () => {
+    expect(await topNames("cron")).not.toContain("disabled-cron-helper");
+    expect(await topNames("disabled-cron-helper")).not.toContain("disabled-cron-helper");
   });
 
-  test("returns no results when any token matches nothing", async () => {
-    const skills = await searchSkills("call-time nonexistent-token");
+  test("respects the limit and the includeContent flag", async () => {
+    expect(await topNames("the", 2)).toHaveLength(2);
+    const slim = await searchSkills("scheduling", 5, false);
+    expect(slim[0]?.name).toBe("scheduling");
+    expect(slim[0]?.content).toBe("");
+  });
 
-    expect(skills).toEqual([]);
+  test("keeps the substring fallback for partial words", async () => {
+    expect(await topNames("needle-tok")).toEqual(["content-search-example"]);
   });
 
-  test("keeps single-word searches working", async () => {
-    const skills = await searchSkills("call-time");
+  test("keeps the index in sync on update and delete", async () => {
+    const skill = await createSkill({
+      name: "sync-probe",
+      description: "Starts with alphaword.",
+      content: "",
+      scope: "swarm",
+    });
+    expect(await topNames("alphaword")).toEqual(["sync-probe"]);
+
+    await updateSkill(skill.id, { description: "Now about betaword." });
+    expect(await topNames("betaword")).toEqual(["sync-probe"]);
+    expect(await topNames("alphaword")).toEqual([]);
+
+    await deleteSkill(skill.id);
+    expect(await topNames("betaword")).toEqual([]);
+    const ftsRows = getDb()
+      .query<{ n: number }, [string]>("SELECT count(*) AS n FROM skills_fts WHERE skill_id = ?")
+      .get(skill.id);
+    expect(ftsRows?.n).toBe(0);
+  });
 
-    expect(skills.map((skill) => skill.name)).toContain("call-time-trap-placement");
+  test("migrated schema carries the sync triggers", () => {
+    const triggers = getDb()
+      .query<{ name: string }, []>(
+        "SELECT name FROM sqlite_master WHERE type = 'trigger' AND tbl_name = 'skills' AND name LIKE 'skills_fts_%' ORDER BY name",
+      )
+      .all()
+      .map((row) => row.name);
+    expect(triggers).toEqual(["skills_fts_delete", "skills_fts_insert", "skills_fts_update"]);
   });
 });
+
+test("migration 239 backfills skills that existed before it ran", async () => {
+  const db = new Database(":memory:");
+  try {
+    db.exec(await Bun.file("src/be/migrations/019_skills.sql").text());
+    db.run(
+      "INSERT INTO skills (id, name, description, content, type, scope, createdAt, lastUpdatedAt) VALUES ('s1', 'legacy-skill', 'Old description', 'old body', 'remote', 'swarm', '2026-01-01', '2026-01-01')",
+    );
+    db.exec(await Bun.file("src/be/migrations/239_skills_fts.sql").text());
+
+    const rows = db
+      .query<{ skill_id: string }, [string]>(
+        "SELECT skill_id FROM skills_fts WHERE skills_fts MATCH ?",
+      )
+      .all('"body"');
+    expect(rows.map((row) => row.skill_id)).toEqual(["s1"]);
+
+    // Re-running the migration does not duplicate backfilled rows.
+    db.exec(await Bun.file("src/be/migrations/239_skills_fts.sql").text());
+    expect(db.query<{ n: number }, []>("SELECT count(*) AS n FROM skills_fts").get()?.n).toBe(1);
+  } finally {
+    db.close();
+  }
+});