@desplega.ai/agent-swarm 2.7.4 → 2.7.5

package/src/tests/grok-adapter.test.ts

@@ -145,6 +145,8 @@ class FakeGrok {
   }
   async newSession(params) {
     capture.newSession = { meta: params._meta ?? null, mcpServers: params.mcpServers.map((s) => s.name) };
+    capture.newSessionKeys = Object.keys(params).sort();
+    capture.mcpUrls = params.mcpServers.map((s) => s.url);
     writeFileSync("capture.json", JSON.stringify(capture));
     if (${JSON.stringify(mode)} === "auth-required") throw RequestError.authRequired();
     return { sessionId: "grok-session-1" };
@@ -425,6 +427,40 @@ describe("GrokAdapter", () => {
     }
   });
 
+  test("the opt-in ACP hooks leave grok's session/new payload, MCP URL and steering unchanged", async () => {
+    const dir = makeTempDir();
+    const grok = writeFakeGrok(dir, "ok");
+    const { server, apiUrl } = await startTokenStub();
+    // Reachable but plain-HTTP and non-loopback: a target with requiresSecureMcpUrl would proxy it.
+    const publicStyleUrl = apiUrl.replace("127.0.0.1", "0.0.0.0");
+    try {
+      const config = baseConfig({
+        apiUrl: publicStyleUrl,
+        resumeSessionId: "ignored-without-a-resume-hook",
+        env: {
+          PATH: process.env.PATH ?? "",
+          HOME: makeTempDir(),
+          GROK_BINARY: grok,
+          XAI_API_KEY: "xai-test-key",
+        },
+      });
+      const adapter = new GrokAdapter();
+      const session = await adapter.createSession(config);
+      await session.waitForCompletion();
+      expect(session.deliverSteering).toBeUndefined();
+      expect(await adapter.canResume("grok-session-1")).toBe(false);
+      const capture = JSON.parse(await Bun.file(join(config.cwd, "capture.json")).text());
+      expect(capture.newSession).toEqual({
+        meta: { rules: "You are a swarm worker.", yoloMode: true },
+        mcpServers: ["swarm"],
+      });
+      expect(capture.newSessionKeys).toEqual(["_meta", "cwd", "mcpServers"]);
+      expect(capture.mcpUrls).toEqual([`${publicStyleUrl}/mcp`]);
+    } finally {
+      await new Promise<void>((resolve) => server.close(() => resolve()));
+    }
+  });
+
   test("runs an openrouter/ model as an OpenAI-compatible model on OPENROUTER_API_KEY", async () => {
     const dir = makeTempDir();
     // A BYOK route reports the endpoint's id and no ticks.

package/src/tests/mcp-loopback-proxy.test.ts

@@ -0,0 +1,193 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { secureMcpServers } from "../providers/acp-adapter";
+import {
+  type McpLoopbackProxy,
+  needsLoopbackProxy,
+  startMcpLoopbackProxy,
+} from "../providers/mcp-loopback-proxy";
+import { getFreePort } from "./test-net";
+
+type Upstream = ReturnType<typeof Bun.serve>;
+
+const cleanups: Array<() => Promise<void> | void> = [];
+
+afterEach(async () => {
+  for (const cleanup of cleanups.splice(0).reverse()) await cleanup();
+});
+
+function track(proxy: McpLoopbackProxy): McpLoopbackProxy {
+  cleanups.push(() => proxy.stop());
+  return proxy;
+}
+
+/** A stand-in MCP endpoint: JSON echo, a slow SSE stream and a redirect. */
+function startUpstream(): Upstream {
+  const server = Bun.serve({
+    hostname: "127.0.0.1",
+    port: 0,
+    idleTimeout: 0,
+    async fetch(req) {
+      const url = new URL(req.url);
+      if (url.pathname === "/prefix/mcp" && req.method === "POST") {
+        return Response.json({
+          path: url.pathname,
+          search: url.search,
+          method: req.method,
+          body: await req.json(),
+          authorization: req.headers.get("authorization"),
+          agentId: req.headers.get("x-agent-id"),
+          host: req.headers.get("host"),
+        });
+      }
+      if (url.pathname === "/prefix/sse") {
+        const encoder = new TextEncoder();
+        const stream = new ReadableStream<Uint8Array>({
+          async start(controller) {
+            for (const n of [1, 2, 3]) {
+              controller.enqueue(encoder.encode(`event: message\ndata: {"n":${n}}\n\n`));
+              await Bun.sleep(30);
+            }
+            controller.close();
+          },
+        });
+        return new Response(stream, { headers: { "Content-Type": "text/event-stream" } });
+      }
+      if (url.pathname === "/prefix/redirect") {
+        return new Response(null, { status: 302, headers: { Location: "https://example.test/" } });
+      }
+      return new Response("not found", { status: 404 });
+    },
+  });
+  cleanups.push(() => server.stop(true));
+  return server;
+}
+
+describe("needsLoopbackProxy", () => {
+  test("only plain HTTP to a non-loopback host needs the forwarder", () => {
+    expect(needsLoopbackProxy("http://api:3013/mcp")).toBe(true);
+    expect(needsLoopbackProxy("http://10.0.0.5/mcp")).toBe(true);
+    // fx accepts only these loopback names; 127.0.0.2 is rejected (fx 0.0.15).
+    expect(needsLoopbackProxy("http://127.0.0.2:3013/mcp")).toBe(true);
+    expect(needsLoopbackProxy("http://127.0.0.1:3013/mcp")).toBe(false);
+    expect(needsLoopbackProxy("http://localhost:3013/mcp")).toBe(false);
+    expect(needsLoopbackProxy("http://[::1]:3013/mcp")).toBe(false);
+    expect(needsLoopbackProxy("https://swarm.example/mcp")).toBe(false);
+    expect(needsLoopbackProxy("not a url")).toBe(false);
+  });
+});
+
+describe("startMcpLoopbackProxy", () => {
+  test("round-trips a JSON POST with its headers, under the upstream path prefix", async () => {
+    const upstream = startUpstream();
+    const proxy = track(await startMcpLoopbackProxy(`http://127.0.0.1:${upstream.port}/prefix/`));
+    expect(proxy.url).toMatch(/^http:\/\/127\.0\.0\.1:\d+$/);
+
+    const response = await fetch(`${proxy.url}/mcp?session=1`, {
+      method: "POST",
+      headers: {
+        Authorization: "Bearer aseph_proxytest",
+        "X-Agent-ID": "agent-1",
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/list" }),
+    });
+    expect(response.status).toBe(200);
+    expect(await response.json()).toEqual({
+      path: "/prefix/mcp",
+      search: "?session=1",
+      method: "POST",
+      body: { jsonrpc: "2.0", id: 1, method: "tools/list" },
+      authorization: "Bearer aseph_proxytest",
+      agentId: "agent-1",
+      // The upstream sees its own host, not the forwarder's.
+      host: `127.0.0.1:${upstream.port}`,
+    });
+  });
+
+  test("streams SSE events in order as they arrive", async () => {
+    const upstream = startUpstream();
+    const proxy = track(await startMcpLoopbackProxy(`http://127.0.0.1:${upstream.port}/prefix`));
+    const response = await fetch(`${proxy.url}/sse`);
+    expect(response.headers.get("content-type")).toContain("text/event-stream");
+    const reader = response.body!.getReader();
+    const decoder = new TextDecoder();
+    let text = "";
+    let reads = 0;
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      reads += 1;
+      text += decoder.decode(value, { stream: true });
+    }
+    expect([...text.matchAll(/"n":(\d)/g)].map((m) => m[1])).toEqual(["1", "2", "3"]);
+    // Delivered incrementally, not buffered into one body.
+    expect(reads).toBeGreaterThan(1);
+  });
+
+  test("passes a redirect through instead of following it", async () => {
+    const upstream = startUpstream();
+    const proxy = track(await startMcpLoopbackProxy(`http://127.0.0.1:${upstream.port}/prefix`));
+    const response = await fetch(`${proxy.url}/redirect`, { redirect: "manual" });
+    expect(response.status).toBe(302);
+    expect(response.headers.get("location")).toBe("https://example.test/");
+  });
+
+  test("answers 502 when the upstream is down", async () => {
+    const port = await getFreePort();
+    const proxy = track(await startMcpLoopbackProxy(`http://127.0.0.1:${port}`));
+    const response = await fetch(`${proxy.url}/mcp`, { method: "POST", body: "{}" });
+    expect(response.status).toBe(502);
+    expect(((await response.json()) as { error: string }).error).toContain(
+      "MCP loopback proxy: upstream failed",
+    );
+  });
+
+  test("stop() frees the port and is idempotent", async () => {
+    const upstream = startUpstream();
+    const proxy = await startMcpLoopbackProxy(`http://127.0.0.1:${upstream.port}/prefix`);
+    await proxy.stop();
+    await proxy.stop();
+    await expect(fetch(`${proxy.url}/sse`)).rejects.toThrow();
+  });
+});
+
+describe("secureMcpServers", () => {
+  test("forwards plain-HTTP non-loopback servers, one forwarder per origin, and drops SSE", async () => {
+    const proxies: McpLoopbackProxy[] = [];
+    cleanups.push(async () => {
+      for (const proxy of proxies) await proxy.stop();
+    });
+    const servers = await secureMcpServers(
+      [
+        { type: "http", name: "swarm", url: "http://api:3013/mcp", headers: [] },
+        { type: "http", name: "same-origin", url: "http://api:3013/other?x=1", headers: [] },
+        { type: "http", name: "secure", url: "https://mcp.example/mcp", headers: [] },
+        { type: "http", name: "local", url: "http://127.0.0.1:9/mcp", headers: [] },
+        { type: "sse", name: "legacy", url: "https://sse.example/sse", headers: [] },
+        { name: "stdio", command: "true", args: [], env: [] },
+      ],
+      false,
+      proxies,
+    );
+    expect(proxies).toHaveLength(1);
+    const forwarded = proxies[0]!.url;
+    expect(servers.map((server) => [server.name, "url" in server ? server.url : null])).toEqual([
+      ["swarm", `${forwarded}/mcp`],
+      ["same-origin", `${forwarded}/other?x=1`],
+      ["secure", "https://mcp.example/mcp"],
+      ["local", "http://127.0.0.1:9/mcp"],
+      ["stdio", null],
+    ]);
+  });
+
+  test("keeps SSE servers when the agent supports them", async () => {
+    const proxies: McpLoopbackProxy[] = [];
+    const servers = await secureMcpServers(
+      [{ type: "sse", name: "legacy", url: "https://sse.example/sse", headers: [] }],
+      true,
+      proxies,
+    );
+    expect(servers.map((server) => server.name)).toEqual(["legacy"]);
+    expect(proxies).toEqual([]);
+  });
+});

package/src/tests/model-tier-resolution.test.ts

@@ -674,8 +674,8 @@ describe("previewModelTiers", () => {
 
     // acp has no portable tier mapping, so it has nothing to preview.
     expect(rows.some((r) => r.provider === "acp")).toBe(false);
-    expect(new Set(rows.map((r) => r.provider)).size).toBe(10);
-    expect(rows).toHaveLength(40);
+    expect(new Set(rows.map((r) => r.provider)).size).toBe(11);
+    expect(rows).toHaveLength(44);
   });
 
   test("an alias that resolves to nothing reports the default it falls back to", async () => {
@@ -730,7 +730,7 @@ describe("GET /api/models-catalog/tiers", () => {
     expect(handled).toBe(true);
     expect(status).toBe(200);
     const body = JSON.parse(bodyStr) as { tiers: { provider: string; tier: string }[] };
-    expect(body.tiers).toHaveLength(40);
+    expect(body.tiers).toHaveLength(44);
     expect(body.tiers.find((t) => t.provider === "claude" && t.tier === "smart")).toMatchObject({
       key: "MODEL_TIER_CLAUDE_SMART",
       source: "tier-config",

package/src/tests/pricing-refresh.test.ts

@@ -102,14 +102,14 @@ describe("models.dev runtime pricing refresh", () => {
        VALUES ('codex', 'gpt-refresh-test', 'input', 0, 1, 0, 0)`,
     );
 
-    // codex, pi, cursor and amp each project the OpenAI rows: 4 providers x 2 token classes.
+    // codex, pi, cursor, amp and fx each project the OpenAI rows: 5 providers x 2 token classes.
     const first = await refreshPricingFromModelsDev({
       now: 1_000,
       fetchImpl: async () => responseFor(openAiCache(2, 8), '"etag-1"'),
     });
     expect(first.status).toBe("refreshed");
-    expect(first.candidateRows).toBe(8);
-    expect(first.inserted).toBe(8);
+    expect(first.candidateRows).toBe(10);
+    expect(first.inserted).toBe(10);
     expect(first.unchanged).toBe(0);
 
     const activeChanged = await getActivePricingRow("codex", "gpt-refresh-test", "input", 1_000);
@@ -121,7 +121,7 @@ describe("models.dev runtime pricing refresh", () => {
       fetchImpl: async () => responseFor(openAiCache(2, 8), '"etag-2"'),
     });
     expect(second.inserted).toBe(0);
-    expect(second.unchanged).toBe(8);
+    expect(second.unchanged).toBe(10);
 
     const rows = await getDbClient().query<{ effective_from: number }>(
       `SELECT effective_from FROM pricing
@@ -278,7 +278,7 @@ describe("models.dev runtime pricing refresh", () => {
 
     const logs = await getLogsByEventType("pricing.refresh");
     expect(logs).toHaveLength(1);
-    expect(logs[0]?.newValue).toContain("inserted=8");
+    expect(logs[0]?.newValue).toContain("inserted=10");
     expect(logs[0]?.metadata).toContain('"etag":"\\"etag-log\\""');
   });
 });

package/src/tests/prompt-template-session.test.ts

@@ -24,6 +24,7 @@ const SYSTEM_TEMPLATES = [
   "system.agent.compaction.goal_reminder",
   "system.agent.context.bound_note",
   "system.agent.cursor.first_message",
+  "system.agent.fx.system_prompt_file",
   "system.agent.lead",
   "system.agent.lead.docs",
   "system.agent.memory",
@@ -42,6 +43,7 @@ const SYSTEM_TEMPLATES = [
   "system.agent.tool_discovery.search",
   "system.agent.tool_discovery.amp",
   "system.agent.tool_discovery.codex",
+  "system.agent.tool_discovery.fx",
   "system.agent.tool_discovery.opencode",
   "system.agent.tool_discovery.direct",
   "system.agent.tools_skills",
@@ -121,11 +123,11 @@ describe("Session templates: registration", () => {
     expect(sessionSystemEventTypes("session")).toEqual([...SESSION_TEMPLATES].sort());
   });
 
-  test("registers 35 system and session templates in total", () => {
+  test("registers 37 system and session templates in total", () => {
     const all = getAllTemplateDefinitions();
     const sessionSystem = all.filter((d) => d.category === "system" || d.category === "session");
-    // 30 system blocks + 5 session composites.
-    expect(sessionSystem.length).toBe(35);
+    // 32 system blocks + 5 session composites.
+    expect(sessionSystem.length).toBe(37);
   });
 
   test("drops the v1 blocks that prompt v2 deleted", () => {

package/src/tests/provider-registration.test.ts

@@ -235,6 +235,7 @@ const BOOTSTRAP: Record<ProviderName, { expect: string } | { exempt: string }> =
   amp: { expect: "Warning: amp provider has no credentials yet" },
   cursor: { expect: "Warning: cursor provider has no credentials yet" },
   grok: { expect: "Warning: grok provider has no credentials yet" },
+  fx: { expect: "Warning: fx provider has no credentials yet" },
   pi: { expect: "Warning: pi provider has no credentials yet" },
   opencode: { expect: "Warning: opencode provider has no credentials yet" },
   "claude-managed": { expect: "Warning: claude-managed provider missing:" },
@@ -284,7 +285,7 @@ function extractMarkedBlock(name: string): string {
 /** Resolvable no-op stubs for every binary the verify chain may look up. */
 function makeBinaryStubDir(): string {
   const dir = mkdtempSync(join(tmpdir(), "provider-registration-bin-"));
-  for (const name of ["claude", "codex", "opencode", "dsh", "amp", "grok"]) {
+  for (const name of ["claude", "codex", "opencode", "dsh", "amp", "grok", "fx"]) {
     const file = join(dir, name);
     writeFileSync(file, "#!/bin/sh\nexit 0\n");
     chmodSync(file, 0o755);

package/src/tests/query-audit-plans.test.ts

@@ -152,8 +152,9 @@ const CASES: Array<{
     name: "countSessions by source",
     match: /COUNT/,
     run: () => countSessions({ source: ["slack"] }),
-    uses: ["COVERING INDEX idx_agent_tasks_parentTaskId_source (parentTaskId=? AND source=?)"],
-    revert: { dropIndex: "idx_agent_tasks_parentTaskId_source" },
+    // Counts read session_summaries since migration 259.
+    uses: ["COVERING INDEX idx_session_summaries_source (source=?)"],
+    revert: { dropIndex: "idx_session_summaries_source" },
   },
   {
     // Few hits: the page reads the agent_tasks_fts candidates by rowid. The

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

@@ -665,6 +665,8 @@ describe("script connections", () => {
       markMigrationApplied(database, "254_query_audit_indexes.sql");
       // 256 alters agents, which this migration-112-only fixture does not create.
       markMigrationApplied(database, "256_agent_slack_icon.sql");
+      // 259 alters session_summaries, which 253 (skipped above) creates.
+      markMigrationApplied(database, "259_session_summaries_open_tasks.sql");
 
       const id = crypto.randomUUID();
       const now = new Date().toISOString();

package/src/tests/seed-model-profiles.test.ts

@@ -62,9 +62,9 @@ beforeEach(async () => {
 
 describe("tier seeds", () => {
   test("one profile per harness and tier, copied from the tier map; none for acp", async () => {
-    expect(await seedModelProfiles()).toBe(40);
+    expect(await seedModelProfiles()).toBe(44);
     const profiles = await listModelProfiles();
-    expect(profiles).toHaveLength(40);
+    expect(profiles).toHaveLength(44);
     expect(profiles.some((p) => p.harness === "acp")).toBe(false);
     for (const profile of profiles) {
       const tier = profile.seededFrom?.replace("tier:", "") as (typeof MODEL_TIERS)[number];

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

@@ -2,6 +2,7 @@ import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { unlink } from "node:fs/promises";
 import {
   closeDb,
+  createWorkflow,
   getScheduledTaskByName,
   getScheduledTasks,
   initDb,
@@ -13,6 +14,7 @@ import {
   loadSeedSchedules,
   type ScheduleTemplateSource,
 } from "../be/seed/schedules-seeder";
+import { createWorkflowsSeeder } from "../be/seed/workflows-seeder";
 
 const TEST_DB_PATH = "./test-seed-schedules.sqlite";
 
@@ -72,6 +74,31 @@ function zeroConfigScheduleSource(opts?: {
   } satisfies ScheduleTemplateSource;
 }
 
+/** A schedule template with an explicit target block and an optional task prompt. */
+function targetScheduleSource(target: Record<string, unknown>, prompt?: string) {
+  return {
+    config: JSON.stringify({
+      name: "test-target-schedule",
+      title: "Test target schedule",
+      description: "Seeded schedule with a target.",
+      placeholders: [],
+      requires: [],
+      runAllSeedersCandidate: true,
+      autoEnableCandidate: true,
+    }),
+    content: `# Test\n\n## Schedule\n\n\`\`\`json\n${JSON.stringify({
+      cron: "0 9 * * *",
+      timezone: "UTC",
+      enabled: true,
+      ...target,
+    })}\n\`\`\`\n${prompt === undefined ? "" : `\n## Scheduled Task\n\n${prompt}`}`,
+  } satisfies ScheduleTemplateSource;
+}
+
+async function makeWorkflow(name: string) {
+  return createWorkflow({ name, definition: { nodes: [] } });
+}
+
 const ORIGINAL_SEED_AUTOMATIONS_ENABLED = process.env.SEED_AUTOMATIONS_ENABLED;
 
 beforeEach(async () => {
@@ -133,6 +160,8 @@ 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.
+    await runSeeder(createWorkflowsSeeder(), { quiet: true });
     const result = await runSeeder(createSchedulesSeeder(), { quiet: true });
     expect(result).toMatchObject({ created: 12, failed: [] });
     const schedules = await getScheduledTasks();
@@ -141,6 +170,8 @@ describe("schedules seeder", () => {
   });
 
   test("seeds a disabled schedule whose timezone still needs setup", async () => {
+    // dreaming-daily targets the seeded dreaming workflow.
+    await runSeeder(createWorkflowsSeeder(), { quiet: true });
     const result = await runSeeder(createSchedulesSeeder(), { quiet: true });
     expect(result).toMatchObject({ created: 12, failed: [] });
     expect(await getScheduledTaskByName("weekly-dependabot-triage")).toMatchObject({
@@ -245,6 +276,113 @@ describe("schedules seeder", () => {
     );
   });
 
+  test("dreaming-daily is a workflow schedule with no task prompt", async () => {
+    await runSeeder(createWorkflowsSeeder(), { quiet: true });
+    const dreaming = loadSeedSchedules().find((schedule) => schedule.name === "dreaming-daily");
+    expect(dreaming).toMatchObject({
+      targetType: "workflow",
+      workflow: "dreaming",
+      taskTemplate: "",
+    });
+    // Agent-task templates carry no target keys, so their seed hash is unchanged.
+    const digest = loadSeedSchedules().find((schedule) => schedule.name === "daily-blocker-digest");
+    expect(digest && "targetType" in digest).toBe(false);
+  });
+
+  test("seeds a workflow target by name and re-runs as a no-op", async () => {
+    const workflow = await makeWorkflow("test-target-workflow");
+    const seeder = createSchedulesSeeder([
+      targetScheduleSource({ targetType: "workflow", workflow: "test-target-workflow" }),
+    ]);
+    expect(await runSeeder(seeder, { quiet: true })).toMatchObject({ created: 1, failed: [] });
+    const row = await getScheduledTaskByName("test-target-schedule");
+    expect(row).toMatchObject({ targetType: "workflow", workflowId: workflow.id });
+    expect(row?.taskTemplate).toBeUndefined();
+    expect(await runSeeder(seeder, { quiet: true })).toMatchObject({
+      skippedUnchanged: 1,
+      updated: 0,
+    });
+  });
+
+  test("seeds a script target and fails on a missing script", async () => {
+    const seeder = createSchedulesSeeder([
+      targetScheduleSource({ targetType: "script", scriptName: "no-such-script", scriptArgs: {} }),
+    ]);
+    const result = await runSeeder(seeder, { quiet: true });
+    expect(result.created).toBe(0);
+    expect(result.failed[0]?.error).toContain('Global script "no-such-script" not found');
+  });
+
+  test("fails a workflow target whose workflow does not exist, without creating a row", async () => {
+    const result = await runSeeder(
+      createSchedulesSeeder([
+        targetScheduleSource({ targetType: "workflow", workflow: "missing" }),
+      ]),
+      { quiet: true },
+    );
+    expect(result.created).toBe(0);
+    expect(result.failed[0]?.error).toContain('Workflow "missing" not found');
+    expect(await getScheduledTaskByName("test-target-schedule")).toBeNull();
+  });
+
+  test("rejects target blocks that ship fields or prompts the target ignores", () => {
+    const cases: [Record<string, unknown>, string | undefined, string][] = [
+      [{ targetType: "workflow", workflow: "w" }, "Do it.", "ships a ## Scheduled Task prompt"],
+      [{ targetType: "script", scriptName: "s" }, "Do it.", "ships a ## Scheduled Task prompt"],
+      [{ targetType: "workflow" }, undefined, "has no workflow name"],
+      [{ targetType: "script" }, undefined, "has no scriptName"],
+      [{ targetType: "workflow", workflow: "w", scriptName: "s" }, undefined, "sets scriptName"],
+      [{ workflow: "w" }, "Do it.", "(targetType agent-task) sets workflow"],
+      [{ targetType: "lambda" }, undefined, 'unknown targetType "lambda"'],
+    ];
+    for (const [target, prompt, message] of cases) {
+      expect(() => loadSeedSchedules([targetScheduleSource(target, prompt)])).toThrow(message);
+    }
+  });
+
+  test("migrates a pristine agent-task schedule to a workflow target and clears its prompt", async () => {
+    const workflow = await makeWorkflow("test-target-workflow");
+    await runSeeder(createSchedulesSeeder([targetScheduleSource({}, "Trigger the workflow.")]), {
+      quiet: true,
+    });
+    expect(await getScheduledTaskByName("test-target-schedule")).toMatchObject({
+      targetType: "agent-task",
+      taskTemplate: "Trigger the workflow.",
+    });
+
+    const result = await runSeeder(
+      createSchedulesSeeder([
+        targetScheduleSource({ targetType: "workflow", workflow: "test-target-workflow" }),
+      ]),
+      { quiet: true },
+    );
+    expect(result).toMatchObject({ updated: 1, failed: [] });
+    const row = await getScheduledTaskByName("test-target-schedule");
+    expect(row).toMatchObject({ targetType: "workflow", workflowId: workflow.id });
+    expect(row?.taskTemplate).toBeUndefined();
+  });
+
+  test("preserves an operator-edited agent-task schedule when its template moves to a workflow", async () => {
+    await makeWorkflow("test-target-workflow");
+    await runSeeder(createSchedulesSeeder([targetScheduleSource({}, "Trigger the workflow.")]), {
+      quiet: true,
+    });
+    const seeded = await getScheduledTaskByName("test-target-schedule");
+    await updateScheduledTask(seeded!.id, { taskTemplate: "My own prompt." });
+
+    const result = await runSeeder(
+      createSchedulesSeeder([
+        targetScheduleSource({ targetType: "workflow", workflow: "test-target-workflow" }),
+      ]),
+      { quiet: true },
+    );
+    expect(result.skippedUserModified).toBe(1);
+    expect(await getScheduledTaskByName("test-target-schedule")).toMatchObject({
+      targetType: "agent-task",
+      taskTemplate: "My own prompt.",
+    });
+  });
+
   test("reports an invalid cron without creating a row", async () => {
     const result = await runSeeder(createSchedulesSeeder([scheduleSource("not a cron")]), {
       quiet: true,

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

@@ -261,3 +261,42 @@ describe("nan and helmcode sessions price at $0 from the seeded table", () => {
     }
   });
 });
+
+describe("pi on the ChatGPT subscription prices like codex on the same pool", () => {
+  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("openai-codex/<id> on pi records the codex <id> pricing-table cost", async () => {
+    // One request: 69,308 input tokens, 55,680 of them cached, 376 output.
+    // codex reports input including cache reads; pi-ai reports them disjoint.
+    const codex = await recomputeSessionCost(
+      {
+        ...BASE,
+        provider: "codex",
+        model: "gpt-5.6-luna",
+        inputTokens: 69_308,
+        cacheReadTokens: 55_680,
+        outputTokens: 376,
+      },
+      lookupFrom(book),
+    );
+    const pi = await recomputeSessionCost(
+      {
+        ...BASE,
+        provider: "pi",
+        model: "openai-codex/gpt-5.6-luna",
+        inputTokens: 69_308 - 55_680,
+        cacheReadTokens: 55_680,
+        outputTokens: 376,
+      },
+      lookupFrom(book),
+    );
+    expect(codex.costSource).toBe("pricing-table");
+    expect(pi.costSource).toBe("pricing-table");
+    expect(pi.totalCostUsd).toBeCloseTo(codex.totalCostUsd, 12);
+    expect(pi.totalCostUsd).toBeGreaterThan(0);
+  });
+});

package/src/tests/session-costs-golden.test.ts

@@ -361,6 +361,32 @@ describe("Phase 3 — session cost recompute golden fixtures", () => {
     expectExact(body.cost.totalCostUsd, expected);
   });
 
+  // Boot-seeded rows only: fx reports the swarm model string with its route
+  // prefix and no cache split, so input and output price at the table rate.
+  test("fx runs price from the seeded rates on each route", async () => {
+    const openRouter = await postCost({
+      sessionId: "fx-openrouter",
+      provider: "fx",
+      model: "openrouter/deepseek/deepseek-v4.1-flash",
+      totalCostUsd: 0,
+      inputTokens: 58_620,
+      outputTokens: 1_183,
+    });
+    expect(openRouter.cost.costSource).toBe("pricing-table");
+    expectExact(openRouter.cost.totalCostUsd, (58_620 * 0.14 + 1_183 * 0.42) / 1_000_000);
+
+    const openAi = await postCost({
+      sessionId: "fx-openai",
+      provider: "fx",
+      model: "gpt-5-mini",
+      totalCostUsd: 0,
+      inputTokens: 9_286,
+      outputTokens: 506,
+    });
+    expect(openAi.cost.costSource).toBe("pricing-table");
+    expectExact(openAi.cost.totalCostUsd, (9_286 * 0.25 + 506 * 2) / 1_000_000);
+  });
+
   test("legacy cache writes without a TTL split keep the 5m class", async () => {
     await seedModelRates("claude", "claude-legacy-cache-write", {
       input: 5,