@desplega.ai/agent-swarm 2.7.6 → 2.7.7

package/src/tests/profile-sync-stale-writeback.test.ts

@@ -0,0 +1,334 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  advanceIdentityBaselines,
+  bootIdentityBaselines,
+  CLAUDE_MD_LINEAGE_PATH,
+  CLAUDE_MD_PATH,
+  collectProfilePayloads,
+  contentSha256,
+  type FileReader,
+  HEARTBEAT_MD_PATH,
+  IDENTITY_BASELINES_PATH,
+  IDENTITY_MD_PATH,
+  type ProfileFileIO,
+  SETUP_SCRIPT_PATH,
+  SOUL_MD_PATH,
+  syncProfileFilesToServer,
+  TOOLS_MD_PATH,
+  WORKSPACE_CLAUDE_MD_PATH,
+} from "../commands/profile-sync";
+import {
+  type SwarmHooksConfig,
+  syncIdentityFilesToServer,
+  syncSetupScriptToServer,
+} from "../providers/pi-mono-extension";
+
+// A file the agent never touched still holds the copy written at boot. A sync
+// that sends it anyway writes that stale copy over any DB-side edit made since
+// (Lead's update-profile, a nightly profile edit). These tests hold the DB
+// edit in a fake profile API and check that it survives the agent's sync.
+
+const BOOT_IDENTITY = `# Identity\n\n${"boot ".repeat(120)}\n\n## Self-Evolution\n\nold section\n`;
+const EDITED_IDENTITY = `# Identity\n\n${"boot ".repeat(120)}\n`;
+
+/** In-memory stand-in for the worker's workspace and /tmp baselines. */
+function memoryIO(files: Record<string, string>): ProfileFileIO & {
+  files: Record<string, string>;
+} {
+  return {
+    files,
+    readFile: async (path) => files[path],
+    writeFile: async (path, content) => {
+      files[path] = content;
+    },
+    baselinesLockPath: join(tmpdir(), `identity-baselines-${crypto.randomUUID()}.lock`),
+  };
+}
+
+/**
+ * Holds each read of the baselines file until a second read arrives (or a
+ * short timeout), after both have captured the file as it was: the
+ * interleaving in which two unserialized updates drop one another's hashes.
+ */
+function pairBaselineReads(io: ReturnType<typeof memoryIO>): typeof io {
+  let waiting: (() => void) | null = null;
+  return {
+    ...io,
+    readFile: async (path) => {
+      const content = io.files[path];
+      if (path !== IDENTITY_BASELINES_PATH) return content;
+      if (waiting) {
+        const partner = waiting;
+        waiting = null;
+        partner();
+        return content;
+      }
+      await new Promise<void>((resolve) => {
+        waiting = resolve;
+        setTimeout(() => {
+          if (waiting === resolve) waiting = null;
+          resolve();
+        }, 300);
+      });
+      return content;
+    },
+  };
+}
+
+function baselinesOf(io: ReturnType<typeof memoryIO>): Record<string, string> {
+  return JSON.parse(io.files[IDENTITY_BASELINES_PATH] ?? "{}");
+}
+
+/** The workspace right after runner boot: files and baselines from the DB. */
+function bootedWorkspace(profile: Record<string, string>) {
+  const baselines: Record<string, string> = {};
+  for (const [field, content] of Object.entries(profile)) {
+    baselines[field] = contentSha256(content);
+  }
+  return memoryIO({
+    [IDENTITY_MD_PATH]: profile.identityMd ?? "",
+    [IDENTITY_BASELINES_PATH]: JSON.stringify(baselines),
+  });
+}
+
+describe("profile sync never writes an untouched file over a DB edit", () => {
+  let db: Record<string, string> = {};
+  let server: ReturnType<typeof Bun.serve>;
+  let config: SwarmHooksConfig;
+
+  beforeAll(() => {
+    server = Bun.serve({
+      port: 0,
+      async fetch(req) {
+        if (req.method !== "PUT") return new Response("not found", { status: 404 });
+        const body = (await req.json()) as Record<string, string>;
+        for (const [field, value] of Object.entries(body)) {
+          if (field !== "changeSource") db[field] = value;
+        }
+        return Response.json({ ok: true });
+      },
+    });
+    config = {
+      apiUrl: `http://localhost:${server.port}`,
+      apiKey: "test-key",
+      agentId: "agent-1",
+      taskId: "task-1",
+      isLead: false,
+    };
+  });
+
+  afterAll(() => {
+    server.stop(true);
+  });
+
+  test("opencode/pi session end keeps a DB edit made during the session when IDENTITY.md is untouched", async () => {
+    db = { identityMd: BOOT_IDENTITY };
+    const io = bootedWorkspace({ identityMd: BOOT_IDENTITY });
+
+    // Mid-session DB edit; the agent never touches /workspace/IDENTITY.md.
+    db.identityMd = EDITED_IDENTITY;
+
+    await syncIdentityFilesToServer(config, "session_sync", undefined, io);
+
+    expect(db.identityMd).toBe(EDITED_IDENTITY);
+  });
+
+  test("a synced local edit advances the baseline, so a later DB edit survives the next session end", async () => {
+    db = { identityMd: BOOT_IDENTITY };
+    const io = bootedWorkspace({ identityMd: BOOT_IDENTITY });
+    const agentEdit = `${BOOT_IDENTITY}\n## Learned\n\nagent edit\n`;
+
+    io.files[IDENTITY_MD_PATH] = agentEdit;
+    await syncIdentityFilesToServer(config, "self_edit", undefined, io);
+    expect(db.identityMd).toBe(agentEdit);
+
+    db.identityMd = EDITED_IDENTITY;
+    await syncIdentityFilesToServer(config, "session_sync", undefined, io);
+
+    expect(db.identityMd).toBe(EDITED_IDENTITY);
+  });
+
+  test("a real local edit still syncs", async () => {
+    db = { identityMd: BOOT_IDENTITY };
+    const io = bootedWorkspace({ identityMd: BOOT_IDENTITY });
+    io.files[IDENTITY_MD_PATH] = EDITED_IDENTITY;
+
+    await syncIdentityFilesToServer(config, "session_sync", undefined, io);
+
+    expect(db.identityMd).toBe(EDITED_IDENTITY);
+  });
+
+  test("an untouched start-up.sh does not overwrite a DB setupScript edit", async () => {
+    db = { setupScript: "echo boot" };
+    const io = memoryIO({
+      [SETUP_SCRIPT_PATH]: "#!/bin/bash\necho boot\n",
+      [IDENTITY_BASELINES_PATH]: JSON.stringify({ setupScript: contentSha256("echo boot") }),
+    });
+    db.setupScript = "echo edited";
+
+    await syncSetupScriptToServer(config, "session_sync", io);
+
+    expect(db.setupScript).toBe("echo edited");
+  });
+
+  const runnerSync = (
+    io: ProfileFileIO,
+    opts: Partial<Parameters<typeof syncProfileFilesToServer>[0]>,
+  ) =>
+    syncProfileFilesToServer({
+      agentId: config.agentId,
+      apiUrl: config.apiUrl,
+      apiKey: config.apiKey,
+      changeSource: "session_sync",
+      io,
+      ...opts,
+    });
+
+  test("an accepted workspace CLAUDE.md edit advances its baseline, so a later DB edit survives the next session end", async () => {
+    const boot = "# CLAUDE.md\n\nboot rules\n";
+    db = { claudeMd: boot };
+    const io = memoryIO({
+      [WORKSPACE_CLAUDE_MD_PATH]: boot,
+      [IDENTITY_BASELINES_PATH]: JSON.stringify({ claudeMd: contentSha256(boot) }),
+    });
+    const sync = () =>
+      runnerSync(io, { fields: ["claude"], claudeMdPath: WORKSPACE_CLAUDE_MD_PATH });
+
+    // Session 1: a codex/opencode agent edits /workspace/CLAUDE.md.
+    const agentEdit = `${boot}\n## Learned\n\nagent rule\n`;
+    io.files[WORKSPACE_CLAUDE_MD_PATH] = agentEdit;
+    await sync();
+    expect(db.claudeMd).toBe(agentEdit);
+
+    // Lead edits the DB; session 2 never touches the file.
+    db.claudeMd = "# CLAUDE.md\n\nlead rules\n";
+    await sync();
+
+    expect(db.claudeMd).toBe("# CLAUDE.md\n\nlead rules\n");
+  });
+
+  test("an accepted personal CLAUDE.md sync keeps the hook's lineage and the boot baseline", async () => {
+    const boot = "# CLAUDE.md\n\nboot rules\n";
+    const lineage = JSON.stringify({ written: contentSha256(boot), base: contentSha256(boot) });
+    const bootBaselines = JSON.stringify({ claudeMd: contentSha256(boot) });
+    db = { claudeMd: boot };
+    const io = memoryIO({
+      [CLAUDE_MD_PATH]: `${boot}\nagent rule\n`,
+      [CLAUDE_MD_LINEAGE_PATH]: lineage,
+      [IDENTITY_BASELINES_PATH]: bootBaselines,
+    });
+
+    await runnerSync(io, {
+      fields: ["claude"],
+      claudeMdPath: CLAUDE_MD_PATH,
+      claudeMdLock: { path: join(tmpdir(), `claude-md-${crypto.randomUUID()}.lock`) },
+    });
+
+    expect(db.claudeMd).toBe(`${boot}\nagent rule\n`);
+    expect(db.expectedHashes).toEqual({ claudeMd: contentSha256(boot) });
+    expect(io.files[CLAUDE_MD_LINEAGE_PATH]).toBe(lineage);
+    expect(io.files[IDENTITY_BASELINES_PATH]).toBe(bootBaselines);
+  });
+
+  test("two concurrent baseline updates both persist their hashes", async () => {
+    const io = memoryIO({
+      [IDENTITY_BASELINES_PATH]: JSON.stringify({ soulMd: contentSha256("soul") }),
+    });
+    const paired = pairBaselineReads(io);
+
+    await Promise.all([
+      advanceIdentityBaselines({ identityMd: "identity, edited" }, paired),
+      advanceIdentityBaselines({ setupScript: "echo edited" }, paired),
+    ]);
+
+    expect(baselinesOf(io)).toEqual({
+      soulMd: contentSha256("soul"),
+      identityMd: contentSha256("identity, edited"),
+      setupScript: contentSha256("echo edited"),
+    });
+  });
+
+  test("concurrent runner and pi syncs both advance their baselines, so neither file is re-sent over a later DB edit", async () => {
+    db = { identityMd: BOOT_IDENTITY, setupScript: "echo boot" };
+    const io = bootedWorkspace({ identityMd: BOOT_IDENTITY });
+    io.files[IDENTITY_BASELINES_PATH] = JSON.stringify({
+      identityMd: contentSha256(BOOT_IDENTITY),
+      setupScript: contentSha256("echo boot"),
+    });
+    io.files[IDENTITY_MD_PATH] = EDITED_IDENTITY;
+    io.files[SETUP_SCRIPT_PATH] = "#!/bin/bash\necho edited\n";
+    const paired = pairBaselineReads(io);
+
+    // The runner's session-end sync races the pi extension's on-edit sync.
+    await Promise.all([
+      runnerSync(paired, { fields: ["identity"] }),
+      syncSetupScriptToServer(config, "self_edit", paired),
+    ]);
+    expect(db).toEqual({ identityMd: EDITED_IDENTITY, setupScript: "echo edited" });
+
+    db = { identityMd: "lead identity", setupScript: "echo lead" };
+    await runnerSync(io, { fields: ["identity", "setup"] });
+    await syncIdentityFilesToServer(config, "session_sync", undefined, io);
+    await syncSetupScriptToServer(config, "session_sync", io);
+
+    expect(db).toEqual({ identityMd: "lead identity", setupScript: "echo lead" });
+  });
+
+  test("an empty HEARTBEAT.md that survives a restart is not sent over a later DB edit", async () => {
+    // Boot after a restart: the DB value is empty, so the runner leaves the
+    // surviving empty file in place and records the boot baselines.
+    db = { heartbeatMd: "" };
+    const io = memoryIO({ [HEARTBEAT_MD_PATH]: "" });
+    io.files[IDENTITY_BASELINES_PATH] = JSON.stringify(
+      bootIdentityBaselines({ heartbeatMd: db.heartbeatMd }, undefined),
+    );
+
+    db.heartbeatMd = "- check the queue";
+    await runnerSync(io, { fields: ["identity"] });
+    expect(db.heartbeatMd).toBe("- check the queue");
+
+    // A real edit of the empty file still syncs.
+    io.files[HEARTBEAT_MD_PATH] = "- agent checklist";
+    await runnerSync(io, { fields: ["identity"] });
+    expect(db.heartbeatMd).toBe("- agent checklist");
+  });
+});
+
+describe("collectProfilePayloads (claude hook + runner)", () => {
+  const reader =
+    (files: Record<string, string>): FileReader =>
+    async (path) =>
+      files[path];
+
+  test("Lead's self_edit of HEARTBEAT.md does not resend a stale IDENTITY.md", async () => {
+    const files = reader({
+      [SOUL_MD_PATH]: BOOT_IDENTITY,
+      [IDENTITY_MD_PATH]: BOOT_IDENTITY,
+      [TOOLS_MD_PATH]: "tools",
+      [HEARTBEAT_MD_PATH]: "heartbeat, edited",
+      [IDENTITY_BASELINES_PATH]: JSON.stringify({
+        soulMd: contentSha256(BOOT_IDENTITY),
+        identityMd: contentSha256(BOOT_IDENTITY),
+        toolsMd: contentSha256("tools"),
+        heartbeatMd: contentSha256("heartbeat"),
+      }),
+    });
+
+    const payloads = await collectProfilePayloads(["identity"], "self_edit", files);
+
+    expect(payloads.map((payload) => payload.body)).toEqual([
+      { heartbeatMd: "heartbeat, edited", changeSource: "self_edit" },
+    ]);
+  });
+
+  test("session_sync skips an untouched start-up.sh", async () => {
+    const files = reader({
+      [SETUP_SCRIPT_PATH]: "#!/bin/bash\necho boot\n",
+      [IDENTITY_BASELINES_PATH]: JSON.stringify({ setupScript: contentSha256("echo boot") }),
+    });
+
+    expect(await collectProfilePayloads(["setup"], "session_sync", files)).toEqual([]);
+  });
+});

package/src/tests/profile-sync.test.ts

@@ -439,7 +439,7 @@ describe("postProfileUpdate (non-2xx is surfaced, not swallowed)", () => {
       new Response("boom", { status: 500, statusText: "Server Error" })) as typeof fetch;
     try {
       // Must resolve (non-fatal), not reject.
-      await expect(postProfileUpdate({ ...opts, fetchImpl }, payload)).resolves.toBeUndefined();
+      await expect(postProfileUpdate({ ...opts, fetchImpl }, payload)).resolves.toBe(false);
       expect(warnSpy).toHaveBeenCalledTimes(1);
       const msg = String(warnSpy.mock.calls[0]?.[0]);
       expect(msg).toContain("setup sync failed");
@@ -455,7 +455,7 @@ describe("postProfileUpdate (non-2xx is surfaced, not swallowed)", () => {
       throw new Error("network down");
     }) as typeof fetch;
     try {
-      await expect(postProfileUpdate({ ...opts, fetchImpl }, payload)).resolves.toBeUndefined();
+      await expect(postProfileUpdate({ ...opts, fetchImpl }, payload)).resolves.toBe(false);
       expect(warnSpy).toHaveBeenCalledTimes(1);
       expect(String(warnSpy.mock.calls[0]?.[0])).toContain("setup sync errored");
     } finally {
@@ -634,27 +634,23 @@ describe("collectProfilePayloads (baseline integration)", () => {
     expect(payloads[0]?.body.identityMd).toBeUndefined();
   });
 
-  test("self_edit bypasses baselines (agent explicitly changed the file)", async () => {
-    const identityContent = LONG;
-
+  test("self_edit skips the identity files the agent did not edit", async () => {
+    // An edit to one file triggers a sync of all of them; the untouched ones
+    // still hold the boot-time copy, which may predate a DB-side edit.
     const files = reader({
-      [SOUL_MD_PATH]: identityContent,
-      [IDENTITY_MD_PATH]: identityContent,
-      [TOOLS_MD_PATH]: "tools",
+      [SOUL_MD_PATH]: LONG,
+      [IDENTITY_MD_PATH]: LONG,
+      [TOOLS_MD_PATH]: "edited tools",
       [IDENTITY_BASELINES_PATH]: JSON.stringify({
-        soulMd: contentSha256(identityContent),
-        identityMd: contentSha256(identityContent),
+        soulMd: contentSha256(LONG),
+        identityMd: contentSha256(LONG),
         toolsMd: contentSha256("tools"),
       }),
     });
 
     const payloads = await collectProfilePayloads(["identity"], "self_edit", files);
-    expect(payloads).toHaveLength(3);
-    // self_edit should include ALL files regardless of baselines, independently.
     expect(payloads.map((payload) => payload.body)).toEqual([
-      { soulMd: identityContent, changeSource: "self_edit" },
-      { identityMd: identityContent, changeSource: "self_edit" },
-      { toolsMd: "tools", changeSource: "self_edit" },
+      { toolsMd: "edited tools", changeSource: "self_edit" },
     ]);
   });
 

package/src/tests/scheduled-task-required-params-migration.test.ts

@@ -104,7 +104,9 @@ describe("scheduled task required params repair", () => {
   });
 
   test("keeps every requirement on genuinely tokenized fresh templates", async () => {
-    for (const name of canonicalNames.filter((name) => name !== "dream-daily")) {
+    // Migrations 141 and 151 still name these, but no template ships for them.
+    const unshipped = ["dream-daily", "daily-workflow-health-audit"];
+    for (const name of canonicalNames.filter((name) => !unshipped.includes(name))) {
       const template = new URL(`../../templates/schedules/${name}/content.md`, import.meta.url);
       insert(name, await Bun.file(template).text());
     }

package/src/tests/script-connections.test.ts

@@ -678,6 +678,8 @@ describe("script connections", () => {
       markMigrationApplied(database, "264_slack_thread_cover_index.sql");
       // 266 alters script_runs, which this migration-112-only fixture does not create.
       markMigrationApplied(database, "266_script_runs_source_task.sql");
+      // 269 alters pages, which this migration-112-only fixture does not create.
+      markMigrationApplied(database, "269_pages_design_system.sql");
 
       const id = crypto.randomUUID();
       const now = new Date().toISOString();

package/src/tests/seed-registry.test.ts

@@ -1,9 +1,17 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { unlink } from "node:fs/promises";
-import { closeDb, getScheduledTasks, initDb, listWorkflows } from "../be/db";
+import {
+  closeDb,
+  getScheduledTaskByName,
+  getScheduledTasks,
+  initDb,
+  listWorkflows,
+} from "../be/db";
+import { getScript } from "../be/scripts/db";
 import { runSeeder, SEEDERS } from "../be/seed";
 import { schedulesSeeder } from "../be/seed/schedules-seeder";
 import { workflowsSeeder } from "../be/seed/workflows-seeder";
+import { scriptsSeeder } from "../be/seed-scripts";
 
 const TEST_DB_PATH = "./test-seed-registry.sqlite";
 
@@ -58,15 +66,29 @@ describe("seeder registry", () => {
     }
   });
 
-  test("seeds all 23 automation templates on a fresh database and re-runs as a no-op", async () => {
+  test("seeds all 22 automation templates on a fresh database and re-runs as a no-op", async () => {
     expect(await listWorkflows()).toHaveLength(0);
     expect(await getScheduledTasks()).toHaveLength(0);
 
+    // Boot order: scripts seed before schedules, so a script-target schedule
+    // (daily-swarm-update-check) resolves its catalog script on a fresh install.
+    const order = SEEDERS.map((seeder) => seeder.kind);
+    expect(order.indexOf("script")).toBeLessThan(order.indexOf("schedule"));
+    expect(await getScript({ name: "swarm-update-check", scope: "global" })).toBeNull();
+    const scriptResult = await runSeeder(scriptsSeeder, {
+      quiet: true,
+      scriptEmbeddingMode: "skip",
+    });
     const workflowResult = await runSeeder(workflowsSeeder, { quiet: true });
     const scheduleResult = await runSeeder(schedulesSeeder, { quiet: true });
 
+    expect(scriptResult.failed).toEqual([]);
     expect(workflowResult).toMatchObject({ created: 11, failed: [] });
-    expect(scheduleResult).toMatchObject({ created: 12, failed: [] });
+    expect(scheduleResult).toMatchObject({ created: 11, failed: [] });
+    expect(await getScheduledTaskByName("daily-swarm-update-check")).toMatchObject({
+      targetType: "script",
+      scriptName: "swarm-update-check",
+    });
     expect((await listWorkflows()).map((workflow) => workflow.name).sort()).toEqual(
       workflowsSeeder.items().map((item) => item.key),
     );
@@ -83,10 +105,10 @@ describe("seeder registry", () => {
     expect(await runSeeder(schedulesSeeder, { quiet: true })).toMatchObject({
       created: 0,
       updated: 0,
-      skippedUnchanged: 12,
+      skippedUnchanged: 11,
       failed: [],
     });
     expect(await listWorkflows()).toHaveLength(11);
-    expect(await getScheduledTasks()).toHaveLength(12);
-  });
+    expect(await getScheduledTasks()).toHaveLength(11);
+  }, 60_000); // typechecks every catalog script with tsc
 });

package/src/tests/seed-schedules.test.ts

@@ -8,6 +8,7 @@ import {
   initDb,
   updateScheduledTask,
 } from "../be/db";
+import { upsertScriptByName } from "../be/scripts/db";
 import { runSeeder } from "../be/seed";
 import {
   createSchedulesSeeder,
@@ -15,6 +16,7 @@ import {
   type ScheduleTemplateSource,
 } from "../be/seed/schedules-seeder";
 import { createWorkflowsSeeder } from "../be/seed/workflows-seeder";
+import { SEED_SCRIPTS } from "../be/seed-scripts";
 
 const TEST_DB_PATH = "./test-seed-schedules.sqlite";
 
@@ -95,6 +97,23 @@ function targetScheduleSource(target: Record<string, unknown>, prompt?: string)
   } satisfies ScheduleTemplateSource;
 }
 
+/** Stand-in for the catalog script daily-swarm-update-check targets; boot seeds the real one first. */
+async function seedUpdateCheckScript() {
+  await upsertScriptByName({
+    name: "swarm-update-check",
+    scope: "global",
+    scopeId: null,
+    source: "export default async function main() { return {}; }",
+    description: "test stand-in",
+    intent: "seed-schedules test fixture",
+    signatureJson: "{}",
+    fsMode: "none",
+    agentId: null,
+    isScratch: false,
+    typeChecked: true,
+  });
+}
+
 async function makeWorkflow(name: string) {
   return createWorkflow({ name, definition: { nodes: [] } });
 }
@@ -118,9 +137,9 @@ afterEach(async () => {
 });
 
 describe("schedules seeder", () => {
-  test("loads all twelve schedule templates, including the unfenced schedule block", () => {
+  test("loads all eleven schedule templates, including the unfenced schedule block", () => {
     const schedules = loadSeedSchedules();
-    expect(schedules).toHaveLength(12);
+    expect(schedules).toHaveLength(11);
     // Zero-config, requires:[], placeholders:[], template enabled:true -> auto-enabled
     // under the default (unset -> on) SEED_AUTOMATIONS_ENABLED switch.
     expect(schedules.find((schedule) => schedule.name === "daily-status-report")).toMatchObject({
@@ -135,6 +154,11 @@ describe("schedules seeder", () => {
       enabled: true,
       requiredParams: [],
       requires: [],
+      // A script fire: no agent task, no prompt.
+      targetType: "script",
+      scriptName: "swarm-update-check",
+      scriptArgs: {},
+      taskTemplate: "",
     });
     expect(
       schedules.find((schedule) => schedule.name === "weekly-harness-upgrade-check"),
@@ -149,9 +173,10 @@ describe("schedules seeder", () => {
       "daily-blocker-digest",
       "daily-status-report",
       "daily-swarm-update-check",
-      "daily-workflow-health-audit",
       "dreaming-daily",
     ]);
+    // The status report absorbed the workflow-health audit's six queries.
+    expect(schedules.map((schedule) => schedule.name)).not.toContain("daily-workflow-health-audit");
     // dreaming replaces Daily Evolution, which seeds off even though it is zero-config.
     expect(
       schedules.find((schedule) => schedule.name === "daily-compounding-reflection"),
@@ -160,20 +185,22 @@ describe("schedules seeder", () => {
 
   test("SEED_AUTOMATIONS_ENABLED=false still seeds all schedules disabled", async () => {
     process.env.SEED_AUTOMATIONS_ENABLED = "false";
-    // dreaming-daily targets the seeded dreaming workflow.
+    // dreaming-daily targets the seeded dreaming workflow, daily-swarm-update-check a catalog script.
     await runSeeder(createWorkflowsSeeder(), { quiet: true });
+    await seedUpdateCheckScript();
     const result = await runSeeder(createSchedulesSeeder(), { quiet: true });
-    expect(result).toMatchObject({ created: 12, failed: [] });
+    expect(result).toMatchObject({ created: 11, failed: [] });
     const schedules = await getScheduledTasks();
-    expect(schedules).toHaveLength(12);
+    expect(schedules).toHaveLength(11);
     expect(schedules.every((schedule) => schedule.enabled === false)).toBe(true);
   });
 
   test("seeds a disabled schedule whose timezone still needs setup", async () => {
-    // dreaming-daily targets the seeded dreaming workflow.
+    // dreaming-daily targets the seeded dreaming workflow, daily-swarm-update-check a catalog script.
     await runSeeder(createWorkflowsSeeder(), { quiet: true });
+    await seedUpdateCheckScript();
     const result = await runSeeder(createSchedulesSeeder(), { quiet: true });
-    expect(result).toMatchObject({ created: 12, failed: [] });
+    expect(result).toMatchObject({ created: 11, failed: [] });
     expect(await getScheduledTaskByName("weekly-dependabot-triage")).toMatchObject({
       cronExpression: "40 3 * * 0",
       timezone: "{{TIMEZONE}}",
@@ -313,6 +340,32 @@ describe("schedules seeder", () => {
     expect(result.failed[0]?.error).toContain('Global script "no-such-script" not found');
   });
 
+  test("daily-swarm-update-check runs the catalog's swarm-update-check script, no agent task", async () => {
+    // The scripts catalog ships the target, so boot's script seeder creates it first.
+    expect(SEED_SCRIPTS.map((script) => script.name)).toContain("swarm-update-check");
+    const updateCheck = loadSeedSchedules().filter(
+      (schedule) => schedule.name === "daily-swarm-update-check",
+    );
+    expect(updateCheck).toHaveLength(1);
+
+    // Control: without the script the item fails instead of seeding an agent task.
+    const seeder = createSchedulesSeeder();
+    const before = await runSeeder(seeder, { quiet: true });
+    expect(before.failed.map((failure) => failure.key)).toContain("daily-swarm-update-check");
+    expect(await getScheduledTaskByName("daily-swarm-update-check")).toBeNull();
+
+    await seedUpdateCheckScript();
+    await runSeeder(seeder, { quiet: true });
+    const row = await getScheduledTaskByName("daily-swarm-update-check");
+    expect(row).toMatchObject({
+      targetType: "script",
+      scriptName: "swarm-update-check",
+      scriptArgs: {},
+      enabled: true,
+    });
+    expect(row?.taskTemplate).toBeUndefined();
+  });
+
   test("fails a workflow target whose workflow does not exist, without creating a row", async () => {
     const result = await runSeeder(
       createSchedulesSeeder([