@desplega.ai/agent-swarm 1.79.4 → 1.80.1

package/src/tests/workflow-swarm-script.test.ts

@@ -0,0 +1,273 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { z } from "zod";
+import {
+  closeDb,
+  createAgent,
+  createWorkflow,
+  getDb,
+  getWorkflowRun,
+  getWorkflowRunStepsByRunId,
+  initDb,
+} from "../be/db";
+import { upsertScriptByName } from "../be/scripts/db";
+import { setScriptEmbeddingProviderForTests } from "../be/scripts/embeddings";
+import type { Workflow, WorkflowDefinition } from "../types";
+import { startWorkflowExecution } from "../workflows/engine";
+import { InProcessEventBus } from "../workflows/event-bus";
+import {
+  BaseExecutor,
+  type ExecutorDependencies,
+  type ExecutorResult,
+} from "../workflows/executors/base";
+import { ExecutorRegistry } from "../workflows/executors/registry";
+import { SwarmScriptExecutor } from "../workflows/executors/swarm-script";
+import { interpolate } from "../workflows/template";
+
+const TEST_DB_PATH = "./test-workflow-swarm-script.sqlite";
+const API_KEY = "test-workflow-swarm-script-key-1234567890";
+
+const noOpEmbeddingProvider = {
+  name: "test/noop-workflow-script-embedding",
+  dimensions: 1,
+  async embed() {
+    return null;
+  },
+  async embedBatch(texts: string[]) {
+    return texts.map(() => null);
+  },
+};
+
+const signatureJson = JSON.stringify({
+  args: { type: "object" },
+  result: { type: "object" },
+});
+
+class EchoExecutor extends BaseExecutor<typeof EchoExecutor.schema, typeof EchoExecutor.outSchema> {
+  static readonly schema = z.object({ value: z.string() });
+  static readonly outSchema = z.object({ value: z.string() });
+
+  readonly type = "echo";
+  readonly mode = "instant" as const;
+  readonly configSchema = EchoExecutor.schema;
+  readonly outputSchema = EchoExecutor.outSchema;
+
+  protected async execute(
+    config: z.infer<typeof EchoExecutor.schema>,
+  ): Promise<ExecutorResult<z.infer<typeof EchoExecutor.outSchema>>> {
+    return { status: "success", output: { value: config.value } };
+  }
+}
+
+let savedEnv: NodeJS.ProcessEnv;
+let agentId: string;
+let deps: ExecutorDependencies;
+let registry: ExecutorRegistry;
+
+async function removeDbFiles(): Promise<void> {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      await unlink(TEST_DB_PATH + suffix);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+    }
+  }
+}
+
+function makeWorkflow(def: WorkflowDefinition): Workflow {
+  const wf = createWorkflow({
+    name: `swarm-script-test-${crypto.randomUUID()}`,
+    definition: def,
+    createdByAgentId: agentId,
+  });
+  return wf;
+}
+
+async function saveScript(name: string, source: string) {
+  return upsertScriptByName({
+    name,
+    scope: "agent",
+    scopeId: agentId,
+    source,
+    description: `${name} test script`,
+    intent: "workflow-swarm-script test fixture",
+    signatureJson,
+    agentId,
+    typeChecked: true,
+  });
+}
+
+beforeAll(async () => {
+  savedEnv = { ...process.env };
+  await removeDbFiles();
+  initDb(TEST_DB_PATH);
+  process.env.AGENT_SWARM_API_KEY = API_KEY;
+  delete process.env.API_KEY;
+  setScriptEmbeddingProviderForTests(noOpEmbeddingProvider);
+
+  const agent = createAgent({ name: "workflow-script-agent", isLead: true, status: "idle" });
+  agentId = agent.id;
+
+  const eventBus = new InProcessEventBus();
+  const db = await import("../be/db");
+  deps = {
+    db,
+    eventBus,
+    interpolate: (template, ctx) => interpolate(template, ctx).result,
+  };
+  registry = new ExecutorRegistry();
+  registry.register(new EchoExecutor(deps));
+  registry.register(new SwarmScriptExecutor(deps));
+});
+
+afterAll(async () => {
+  setScriptEmbeddingProviderForTests(null);
+  closeDb();
+  await removeDbFiles();
+  for (const key of Object.keys(process.env)) {
+    if (!(key in savedEnv)) delete process.env[key];
+  }
+  for (const [key, value] of Object.entries(savedEnv)) {
+    if (value === undefined) delete process.env[key];
+    else process.env[key] = value;
+  }
+});
+
+beforeEach(() => {
+  getDb().run("DELETE FROM workflow_run_steps");
+  getDb().run("DELETE FROM workflow_runs");
+  getDb().run("DELETE FROM scripts");
+  getDb().run("DELETE FROM workflows");
+});
+
+describe("SwarmScriptExecutor", () => {
+  test("A workflow with one swarm-script node resolves by name + runs + returns result", async () => {
+    await saveScript(
+      "add-one",
+      `export default async (args: { value: number }) => ({ value: args.value + 1 });`,
+    );
+
+    const executor = new SwarmScriptExecutor(deps);
+    const wf = makeWorkflow({ nodes: [] });
+    const result = await executor.run({
+      config: { scriptName: "add-one", args: { value: 6 } },
+      context: {},
+      meta: {
+        runId: crypto.randomUUID(),
+        stepId: crypto.randomUUID(),
+        nodeId: "script",
+        workflowId: wf.id,
+        dryRun: false,
+      },
+    });
+
+    expect(result.status).toBe("success");
+    expect(result.output?.result).toEqual({ value: 7 });
+    expect(result.output?.scriptName).toBe("add-one");
+  });
+
+  test("pinHash correctly resolves to a historic script_versions row", async () => {
+    const first = await saveScript("versioned", `export default async () => ({ version: "old" });`);
+    await saveScript("versioned", `export default async () => ({ version: "new" });`);
+
+    const executor = new SwarmScriptExecutor(deps);
+    const wf = makeWorkflow({ nodes: [] });
+    const result = await executor.run({
+      config: { scriptName: "versioned", pinHash: first.script.contentHash },
+      context: {},
+      meta: {
+        runId: crypto.randomUUID(),
+        stepId: crypto.randomUUID(),
+        nodeId: "script",
+        workflowId: wf.id,
+        dryRun: false,
+      },
+    });
+
+    expect(result.status).toBe("success");
+    expect(result.output?.result).toEqual({ version: "old" });
+    expect(result.output?.contentHash).toBe(first.script.contentHash);
+    expect(result.output?.version).toBe(1);
+  });
+
+  test("inputs mapping from a predecessor node correctly populates args", async () => {
+    await saveScript(
+      "from-input",
+      `export default async (args: { value: string }) => ({ seen: args.value });`,
+    );
+    const wf = makeWorkflow({
+      nodes: [
+        { id: "source", type: "echo", config: { value: "mapped-value" }, next: "script" },
+        {
+          id: "script",
+          type: "swarm-script",
+          inputs: { sourceValue: "source.value" },
+          config: { scriptName: "from-input", args: { value: "{{sourceValue}}" } },
+        },
+      ],
+    });
+
+    const runId = await startWorkflowExecution(wf, {}, registry);
+    const run = getWorkflowRun(runId);
+    const steps = getWorkflowRunStepsByRunId(runId);
+    const scriptStep = steps.find((step) => step.nodeId === "script");
+
+    expect(run?.status).toBe("completed");
+    expect(scriptStep?.status).toBe("completed");
+    expect(scriptStep?.output).toMatchObject({ result: { seen: "mapped-value" } });
+  });
+
+  test("fsMode workspace-rw is rejected at config validation with a clear error message", async () => {
+    await saveScript("noop", `export default async () => ({ ok: true });`);
+    const executor = new SwarmScriptExecutor(deps);
+    const wf = makeWorkflow({ nodes: [] });
+    const result = await executor.run({
+      config: { scriptName: "noop", fsMode: "workspace-rw" },
+      context: {},
+      meta: {
+        runId: crypto.randomUUID(),
+        stepId: crypto.randomUUID(),
+        nodeId: "script",
+        workflowId: wf.id,
+        dryRun: false,
+      },
+    });
+
+    expect(result.status).toBe("failed");
+    expect(result.error).toContain("workspace-rw");
+
+    const success = await executor.run({
+      config: { scriptName: "noop", fsMode: "none" },
+      context: {},
+      meta: {
+        runId: crypto.randomUUID(),
+        stepId: crypto.randomUUID(),
+        nodeId: "script",
+        workflowId: wf.id,
+        dryRun: false,
+      },
+    });
+    expect(success.status).toBe("success");
+  });
+
+  test("Failure in the script surfaces as a workflow-node failure", async () => {
+    await saveScript("throws", `export default async () => { throw new Error("boom"); };`);
+    const executor = new SwarmScriptExecutor(deps);
+    const wf = makeWorkflow({ nodes: [] });
+    const result = await executor.run({
+      config: { scriptName: "throws" },
+      context: {},
+      meta: {
+        runId: crypto.randomUUID(),
+        stepId: crypto.randomUUID(),
+        nodeId: "script",
+        workflowId: wf.id,
+        dryRun: false,
+      },
+    });
+
+    expect(result.status).toBe("failed");
+    expect(result.error).toContain("boom");
+    expect(result.output?.exitCode).not.toBe(0);
+  });
+});

package/src/tools/memory-rate.ts

@@ -2,6 +2,7 @@ import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import * as z from "zod";
 import { REFERENCES_SOURCE_MAX_LENGTH, sanitizeReferencesSource } from "@/be/memory/raters/types";
 import { createToolRegistrar } from "@/tools/utils";
+import { getApiKey } from "@/utils/api-key";
 
 /**
  * Plan: thoughts/taras/plans/2026-05-05-memory-rater-v1.5/step-5.md §1
@@ -92,7 +93,7 @@ export const registerMemoryRateTool = (server: McpServer) => {
       }
 
       const apiUrl = process.env.MCP_BASE_URL || `http://localhost:${process.env.PORT || "3013"}`;
-      const apiKey = process.env.API_KEY || "";
+      const apiKey = getApiKey();
 
       const event = {
         memoryId: id,

package/src/tools/script-common.ts

@@ -0,0 +1,88 @@
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import * as z from "zod";
+import { getApiKey } from "@/utils/api-key";
+import type { RequestInfo } from "./utils";
+
+export const SCRIPT_TRANSPORT_ERROR =
+  "script_* tools require HTTP MCP transport — agent identity is not available over stdio in this build. Switch to MCP_BASE_URL=http://... or invoke the HTTP API directly.";
+
+export const scriptNameSchema = z.string().min(1).max(200);
+export const scriptScopeSchema = z.enum(["agent", "global"]);
+export const scriptFsModeSchema = z.enum(["none", "workspace-rw"]);
+
+export const scriptToolOutputSchema = z.object({
+  success: z.boolean(),
+  status: z.number(),
+  data: z.unknown().optional(),
+  error: z.string().optional(),
+});
+
+export type ScriptToolStructuredContent = z.infer<typeof scriptToolOutputSchema>;
+
+function apiBaseUrl(): string {
+  return (process.env.MCP_BASE_URL || `http://localhost:${process.env.PORT || "3013"}`).replace(
+    /\/+$/,
+    "",
+  );
+}
+
+function toolError(message: string, status = 400): CallToolResult {
+  return {
+    isError: true,
+    content: [{ type: "text", text: message }],
+    structuredContent: {
+      success: false,
+      status,
+      error: message,
+    } satisfies ScriptToolStructuredContent,
+  };
+}
+
+export async function proxyScriptsApi(args: {
+  method: "GET" | "POST" | "DELETE";
+  path: string;
+  body?: unknown;
+  requestInfo: RequestInfo;
+  successMessage: (data: unknown) => string;
+}): Promise<CallToolResult> {
+  if (!args.requestInfo.agentId) return toolError(SCRIPT_TRANSPORT_ERROR);
+
+  const apiKey = getApiKey();
+  const res = await fetch(`${apiBaseUrl()}${args.path}`, {
+    method: args.method,
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      "X-Agent-ID": args.requestInfo.agentId,
+      "Content-Type": "application/json",
+    },
+    body: args.body === undefined ? undefined : JSON.stringify(args.body),
+  });
+
+  const text = await res.text();
+  let data: unknown;
+  if (text) {
+    try {
+      data = JSON.parse(text);
+    } catch {
+      data = { error: text };
+    }
+  }
+
+  const error =
+    typeof data === "object" && data !== null && "error" in data
+      ? String((data as { error: unknown }).error)
+      : undefined;
+
+  if (!res.ok) {
+    return toolError(error ?? `Scripts API request failed with ${res.status}`, res.status);
+  }
+
+  return {
+    content: [{ type: "text", text: args.successMessage(data) }],
+    structuredContent: {
+      success: true,
+      status: res.status,
+      data,
+    } satisfies ScriptToolStructuredContent,
+  };
+}

package/src/tools/script-delete.ts

@@ -0,0 +1,35 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as z from "zod";
+import { createToolRegistrar } from "@/tools/utils";
+import {
+  proxyScriptsApi,
+  scriptNameSchema,
+  scriptScopeSchema,
+  scriptToolOutputSchema,
+} from "./script-common";
+
+export const SCRIPT_DELETE_DESCRIPTION =
+  "Remove a swarm-shared script from the catalog. Versions table preserves history.";
+
+export const registerScriptDeleteTool = (server: McpServer) => {
+  createToolRegistrar(server)(
+    "script-delete",
+    {
+      title: "Script Delete",
+      description: SCRIPT_DELETE_DESCRIPTION,
+      annotations: { destructiveHint: true, openWorldHint: false },
+      inputSchema: z.object({
+        name: scriptNameSchema.describe("Script name to delete."),
+        scope: scriptScopeSchema.default("agent").describe("Script scope to delete from."),
+      }),
+      outputSchema: scriptToolOutputSchema,
+    },
+    async ({ name, scope }, requestInfo) =>
+      proxyScriptsApi({
+        method: "DELETE",
+        path: `/api/scripts/${encodeURIComponent(name)}?scope=${encodeURIComponent(scope)}`,
+        requestInfo,
+        successMessage: () => "Script delete completed.",
+      }),
+  );
+};

package/src/tools/script-query-types.ts

@@ -0,0 +1,37 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as z from "zod";
+import { createToolRegistrar } from "@/tools/utils";
+import {
+  proxyScriptsApi,
+  scriptNameSchema,
+  scriptScopeSchema,
+  scriptToolOutputSchema,
+} from "./script-common";
+
+export const SCRIPT_QUERY_TYPES_DESCRIPTION =
+  "Fetch the signature + the auto-generated `swarm-sdk.d.ts` (derived from the live MCP tool registry) + the `stdlib.d.ts` blobs — for IDE-style introspection before authoring or running a script. The same types are used by `script-upsert`'s typecheck pass, so they are authoritative.";
+
+export const registerScriptQueryTypesTool = (server: McpServer) => {
+  createToolRegistrar(server)(
+    "script-query-types",
+    {
+      title: "Script Query Types",
+      description: SCRIPT_QUERY_TYPES_DESCRIPTION,
+      annotations: { readOnlyHint: true, openWorldHint: false },
+      inputSchema: z.object({
+        name: scriptNameSchema.describe("Script name whose signature should be fetched."),
+        scope: scriptScopeSchema.optional().describe("Optional scope for script resolution."),
+      }),
+      outputSchema: scriptToolOutputSchema,
+    },
+    async ({ name, scope }, requestInfo) => {
+      const query = scope ? `?scope=${encodeURIComponent(scope)}` : "";
+      return proxyScriptsApi({
+        method: "GET",
+        path: `/api/scripts/${encodeURIComponent(name)}/types${query}`,
+        requestInfo,
+        successMessage: () => "Script type query completed.",
+      });
+    },
+  );
+};

package/src/tools/script-run.ts

@@ -0,0 +1,43 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as z from "zod";
+import { createToolRegistrar } from "@/tools/utils";
+import {
+  proxyScriptsApi,
+  scriptFsModeSchema,
+  scriptNameSchema,
+  scriptScopeSchema,
+  scriptToolOutputSchema,
+} from "./script-common";
+
+export const SCRIPT_RUN_DESCRIPTION =
+  "Run a named swarm-shared script (callable across agents and from workflow `swarm-script` nodes), OR inline source (auto-saved as scratch to the catalog). Use for swarm-visible, durable scripts. For local-only throwaway TS, use code-mode `run`.";
+
+export const registerScriptRunTool = (server: McpServer) => {
+  createToolRegistrar(server)(
+    "script-run",
+    {
+      title: "Script Run",
+      description: SCRIPT_RUN_DESCRIPTION,
+      annotations: { openWorldHint: true },
+      inputSchema: z.object({
+        name: scriptNameSchema.optional().describe("Name of a reusable script to run."),
+        source: z.string().min(1).optional().describe("Inline TypeScript source to run."),
+        args: z.unknown().optional().describe("JSON-serializable script arguments."),
+        intent: z.string().default("").describe("Why this script is being run."),
+        scope: scriptScopeSchema.optional().describe("Optional scope for named script resolution."),
+        fsMode: scriptFsModeSchema
+          .default("none")
+          .describe("Filesystem mode. v1 supports none only."),
+      }),
+      outputSchema: scriptToolOutputSchema,
+    },
+    async (args, requestInfo) =>
+      proxyScriptsApi({
+        method: "POST",
+        path: "/api/scripts/run",
+        body: args,
+        requestInfo,
+        successMessage: () => "Script run completed.",
+      }),
+  );
+};

package/src/tools/script-search.ts

@@ -0,0 +1,32 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as z from "zod";
+import { createToolRegistrar } from "@/tools/utils";
+import { proxyScriptsApi, scriptScopeSchema, scriptToolOutputSchema } from "./script-common";
+
+export const SCRIPT_SEARCH_DESCRIPTION =
+  "Semantic search over swarm-shared TypeScript scripts (catalog persisted in the agent-swarm DB; callable from agents and workflows). For ephemeral throwaway TS on your local machine, use code-mode instead.";
+
+export const registerScriptSearchTool = (server: McpServer) => {
+  createToolRegistrar(server)(
+    "script-search",
+    {
+      title: "Script Search",
+      description: SCRIPT_SEARCH_DESCRIPTION,
+      annotations: { readOnlyHint: true, openWorldHint: false },
+      inputSchema: z.object({
+        query: z.string().default("").describe("Search query for reusable scripts."),
+        scope: scriptScopeSchema.optional().describe("Optional script scope filter."),
+        limit: z.number().int().min(1).max(100).default(10).describe("Maximum results."),
+      }),
+      outputSchema: scriptToolOutputSchema,
+    },
+    async (args, requestInfo) =>
+      proxyScriptsApi({
+        method: "POST",
+        path: "/api/scripts/search",
+        body: args,
+        requestInfo,
+        successMessage: () => "Script search completed.",
+      }),
+  );
+};

package/src/tools/script-upsert.ts

@@ -0,0 +1,43 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as z from "zod";
+import { createToolRegistrar } from "@/tools/utils";
+import {
+  proxyScriptsApi,
+  scriptFsModeSchema,
+  scriptNameSchema,
+  scriptScopeSchema,
+  scriptToolOutputSchema,
+} from "./script-common";
+
+export const SCRIPT_UPSERT_DESCRIPTION =
+  "Persist a TypeScript script to the swarm catalog under your agent scope (or global if you're a lead). Other agents and workflow nodes will be able to find and run it. For local-only scripts, use code-mode `save`.";
+
+export const registerScriptUpsertTool = (server: McpServer) => {
+  createToolRegistrar(server)(
+    "script-upsert",
+    {
+      title: "Script Upsert",
+      description: SCRIPT_UPSERT_DESCRIPTION,
+      annotations: { openWorldHint: false },
+      inputSchema: z.object({
+        name: scriptNameSchema.describe("Stable script name within the selected scope."),
+        source: z.string().min(1).describe("TypeScript source with a default export function."),
+        description: z.string().default("").describe("Human-readable script description."),
+        intent: z.string().default("").describe("Why this script exists."),
+        scope: scriptScopeSchema.default("agent").describe("Persist under agent or global scope."),
+        fsMode: scriptFsModeSchema
+          .default("none")
+          .describe("Filesystem mode. v1 supports none only."),
+      }),
+      outputSchema: scriptToolOutputSchema,
+    },
+    async (args, requestInfo) =>
+      proxyScriptsApi({
+        method: "POST",
+        path: "/api/scripts/upsert",
+        body: args,
+        requestInfo,
+        successMessage: () => "Script upsert completed.",
+      }),
+  );
+};

package/src/tools/store-progress.ts

@@ -3,7 +3,6 @@ import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import * as z from "zod";
 import {
   completeTask,
-  createSessionCost,
   createTaskExtended,
   failTask,
   getAgentById,
@@ -24,32 +23,12 @@ import { AgentTaskSchema } from "@/types";
 import "./templates";
 import { validateJsonSchema } from "@/workflows/json-schema-validator";
 
-// Schema for optional cost data that agents can self-report.
-// In practice the harness adapter (claude/codex/opencode/etc.) is the
-// authoritative source of cost data — it gets written via
-// POST /api/session-costs from the runner. Agents calling store-progress
-// rarely know the real numbers and have been observed echoing the example
-// values from this schema (e.g. model="opus" on a gpt-5-nano run). The
-// handler below silently drops payloads where every numeric field is zero.
-const CostDataSchema = z
-  .object({
-    totalCostUsd: z.number().min(0).describe("Total cost in USD"),
-    inputTokens: z.number().int().min(0).optional().describe("Input tokens used"),
-    outputTokens: z.number().int().min(0).optional().describe("Output tokens used"),
-    cacheReadTokens: z.number().int().min(0).optional().describe("Cache read tokens"),
-    cacheWriteTokens: z.number().int().min(0).optional().describe("Cache write tokens"),
-    durationMs: z.number().int().min(0).optional().describe("Duration in milliseconds"),
-    numTurns: z.number().int().min(1).optional().describe("Number of turns/iterations"),
-    model: z
-      .string()
-      .optional()
-      .describe(
-        "Model identifier reported by the agent (only set if the agent has the real ID; do NOT echo the schema example).",
-      ),
-  })
-  .describe(
-    "Optional self-reported cost data. The harness adapter writes the authoritative cost record automatically — only pass this if you have real, non-zero numbers from a model that doesn't surface usage to the harness.",
-  );
+// Phase 11: the `cost` / `costData` field was removed from this tool's input
+// schema. Adapters (claude/codex/pi/opencode/devin/claude-managed) are the
+// sole writers of `session_costs` rows via `POST /api/session-costs`. Agents
+// calling `store-progress` rarely knew the real numbers and historically
+// echoed the schema example, producing noise rows keyed `mcp-<taskId>-<ts>`
+// that double-counted alongside the harness's authoritative entry.
 
 export const registerStoreProgressTool = (server: McpServer) => {
   createToolRegistrar(server)(
@@ -72,9 +51,10 @@ export const registerStoreProgressTool = (server: McpServer) => {
           .string()
           .optional()
           .describe("The reason for failure (used when failing)."),
-        costData: CostDataSchema.optional().describe(
-          "Optional cost data for tracking session costs. When provided, a session cost record will be created linked to this task.",
-        ),
+        // Phase 11: `costData` removed. The harness adapter is the sole
+        // writer of `session_costs` (see POST /api/session-costs in the
+        // runner). If a payload still includes the field, Zod's
+        // `unknownKeys` default drops it silently.
       }),
       outputSchema: z.object({
         success: z.boolean(),
@@ -89,7 +69,7 @@ export const registerStoreProgressTool = (server: McpServer) => {
           ),
       }),
     },
-    async ({ taskId, progress, status, output, failureReason, costData }, requestInfo, _meta) => {
+    async ({ taskId, progress, status, output, failureReason }, requestInfo, _meta) => {
       if (!requestInfo.agentId) {
         return {
           content: [
@@ -254,35 +234,11 @@ export const registerStoreProgressTool = (server: McpServer) => {
           }
         }
 
-        // Store cost data only if the agent provided non-trivial numbers.
-        // Agents observed copying the schema example (e.g. model="opus"
-        // on a gpt-5-nano run) with all-zero token/cost fields, producing
-        // duplicate noise rows in session_costs alongside the harness's
-        // authoritative entry. Drop those silently.
-        const hasRealCost =
-          costData &&
-          (costData.totalCostUsd > 0 ||
-            (costData.inputTokens ?? 0) > 0 ||
-            (costData.outputTokens ?? 0) > 0 ||
-            (costData.cacheReadTokens ?? 0) > 0 ||
-            (costData.cacheWriteTokens ?? 0) > 0);
-
-        if (hasRealCost && requestInfo.agentId) {
-          createSessionCost({
-            sessionId: `mcp-${taskId}-${Date.now()}`, // Generate unique session ID for MCP-based tasks
-            taskId,
-            agentId: requestInfo.agentId,
-            totalCostUsd: costData.totalCostUsd,
-            inputTokens: costData.inputTokens ?? 0,
-            outputTokens: costData.outputTokens ?? 0,
-            cacheReadTokens: costData.cacheReadTokens ?? 0,
-            cacheWriteTokens: costData.cacheWriteTokens ?? 0,
-            durationMs: costData.durationMs ?? 0,
-            numTurns: costData.numTurns ?? 1,
-            model: costData.model ?? "unknown",
-            isError: status === "failed",
-          });
-        }
+        // Phase 11: removed the per-call `session_costs` insert. The harness
+        // adapter is the sole writer of cost rows now (via the runner's
+        // `POST /api/session-costs`); store-progress historically wrote a
+        // duplicate row keyed `mcp-<taskId>-<ts>` whenever an agent
+        // hallucinated a `costData` payload.
 
         return {
           success: true,