@desplega.ai/agent-swarm 1.131.0 → 1.133.1

package/src/scripts-runtime/loader.ts

@@ -19,6 +19,8 @@ export type RunScriptInput = {
   args?: unknown;
   fsMode?: ScriptFsMode;
   agentId: string;
+  /** Per-boot runtime identity of the invoking worker; system context, never script input. */
+  runtimeInstanceId?: string;
   signal?: AbortSignal;
   timeoutMs?: number;
   mcpBaseUrl?: string;
@@ -50,6 +52,9 @@ async function buildConfigPayload(input: RunScriptInput): Promise<SwarmConfigPay
         value: input.mcpBaseUrl ?? process.env.MCP_BASE_URL ?? "http://localhost:3013",
         isSecret: false,
       },
+      ...(input.runtimeInstanceId
+        ? { runtimeInstanceId: { value: input.runtimeInstanceId, isSecret: false as const } }
+        : {}),
     },
     user: input.userConfig ?? {},
     egressSecrets: input.egressSecrets ?? (await buildEgressSecrets()),

package/src/scripts-runtime/swarm-config.ts

@@ -5,6 +5,8 @@ export class SwarmConfig {
   readonly apiKey: RedactedValue<string>;
   readonly agentId: RedactedValue<string>;
   readonly mcpBaseUrl: RedactedValue<string>;
+  /** Per-boot runtime identity of the invoking worker; system context, never script input. */
+  readonly runtimeInstanceId: RedactedValue<string> | undefined;
 
   private readonly userValues: Map<string, RedactedValue<string>>;
 
@@ -21,6 +23,12 @@ export class SwarmConfig {
       type: "system",
       isSecret: payload.system.mcpBaseUrl.isSecret,
     });
+    this.runtimeInstanceId = payload.system.runtimeInstanceId
+      ? Redacted.make(payload.system.runtimeInstanceId.value, {
+          type: "system",
+          isSecret: payload.system.runtimeInstanceId.isSecret,
+        })
+      : undefined;
     this.userValues = new Map(
       Object.entries(payload.user ?? {}).map(([key, value]) => [
         key,

package/src/scripts-runtime/swarm-sdk.ts

@@ -14,6 +14,12 @@ function headers(config: SwarmConfig): Record<string, string> {
   return {
     Authorization: `Bearer ${Redacted.value(config.apiKey)}`,
     "X-Agent-ID": Redacted.value(config.agentId),
+    // Per-boot identity of the invoking worker process (system context, not
+    // script input) — work-acquisition endpoints gate on it in multi-runtime
+    // mode.
+    ...(config.runtimeInstanceId
+      ? { "X-Runtime-Instance-ID": Redacted.value(config.runtimeInstanceId) }
+      : {}),
     "Content-Type": "application/json",
   };
 }
@@ -168,6 +174,7 @@ function bridgeRequestFor(name: string, args: unknown): BridgeRequest | null {
           hideCompleted: body.hideCompleted,
           consecutiveErrorsMin: body.consecutiveErrorsMin,
           lastRunStatus: body.lastRunStatus,
+          fields: body.includeFull ? "full" : undefined,
         }),
       };
     case "schedule_create":

package/src/scripts-runtime/types/stdlib.d.ts

@@ -158,6 +158,7 @@ declare module "swarm-sdk" {
       hideCompleted?: boolean;
       consecutiveErrorsMin?: number;
       lastRunStatus?: "failed" | "succeeded";
+      includeFull?: boolean;
     }): Promise<unknown>;
     // --- scripts ---
     script_search(args: { query?: string; scope?: ScriptScope; limit?: number }): Promise<unknown>;

package/src/scripts-runtime/types/swarm-sdk.d.ts

@@ -140,6 +140,7 @@ declare module "swarm-sdk" {
       hideCompleted?: boolean;
       consecutiveErrorsMin?: number;
       lastRunStatus?: "failed" | "succeeded";
+      includeFull?: boolean;
     }): Promise<unknown>;
     // --- scripts ---
     script_search(args: { query?: string; scope?: ScriptScope; limit?: number }): Promise<unknown>;

package/src/tests/budget-claim-gate.test.ts

@@ -128,6 +128,7 @@ describe("Phase 3 — /api/poll budget admission gate", () => {
     if ("error" in body) throw new Error("unexpected error response");
     expect(body.trigger?.type).toBe("task_assigned");
     expect((body.trigger as { taskId: string }).taskId).toBe(task.id);
+    expect(getAgentById(worker.id)?.status).toBe("busy");
   });
 
   test("pending task trigger includes requester role and notes", async () => {
@@ -272,6 +273,25 @@ describe("Phase 3 — /api/poll budget admission gate", () => {
     expect(claimedTriggers).toHaveLength(1);
     expect(nullTriggers).toHaveLength(1);
   });
+
+  test("pool claim marks the agent busy before the poll transaction returns", async () => {
+    const worker = createAgent({
+      name: "claim-status",
+      isLead: false,
+      status: "idle",
+      maxTasks: 1,
+    });
+    const pooled = createTaskExtended("claim status task", {});
+
+    expect(getAgentById(worker.id)?.status).toBe("idle");
+
+    const { body } = await callPoll(worker.id);
+
+    if ("error" in body) throw new Error("unexpected error response");
+    expect(body.trigger?.type).toBe("task_assigned");
+    expect((body.trigger as { taskId: string }).taskId).toBe(pooled.id);
+    expect(getAgentById(worker.id)?.status).toBe("busy");
+  });
 });
 
 // ─── MCP task-action accept tests ───────────────────────────────────────────

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

@@ -687,6 +687,38 @@ describe("mergeMcpConfig (issue #369)", () => {
     expect((entry.headers as Record<string, string>)["X-Source-Task-Id"]).toBe(TASK_ID);
   });
 
+  test("agent-swarm server gets X-Runtime-Instance-ID when a runtime identity is given", () => {
+    const base = {
+      mcpServers: {
+        "agent-swarm": {
+          type: "http",
+          url: "http://localhost:3013/mcp",
+          headers: { Authorization: "Bearer KEY", "X-Agent-ID": "a1" },
+        },
+      },
+    };
+    const merged = mergeMcpConfig(base, null, TASK_ID, undefined, "runtime-boot-1");
+    const agentSwarm = merged.mcpServers["agent-swarm"] as Record<string, unknown>;
+    expect((agentSwarm.headers as Record<string, string>)["X-Runtime-Instance-ID"]).toBe(
+      "runtime-boot-1",
+    );
+  });
+
+  test("no runtime identity → no X-Runtime-Instance-ID header", () => {
+    const base = {
+      mcpServers: {
+        "agent-swarm": {
+          type: "http",
+          url: "http://localhost:3013/mcp",
+          headers: { Authorization: "Bearer KEY", "X-Agent-ID": "a1" },
+        },
+      },
+    };
+    const merged = mergeMcpConfig(base, null, TASK_ID);
+    const agentSwarm = merged.mcpServers["agent-swarm"] as Record<string, unknown>;
+    expect((agentSwarm.headers as Record<string, string>)["X-Runtime-Instance-ID"]).toBeUndefined();
+  });
+
   test("does not mutate the input baseConfig", () => {
     const base = {
       mcpServers: {

package/src/tests/claude-managed-adapter.test.ts

@@ -831,11 +831,33 @@ describe("ClaudeManagedAdapter (Phase 4) — repo provisioning + cost data", ()
     expect(cost).toBeCloseTo(4.5, 10);
   });
 
-  test("computeClaudeManagedCostUsd returns expected USD for sonnet-5 against list rate", () => {
+  test("computeClaudeManagedCostUsd uses sonnet-5 introductory rate through 2026-08-31", () => {
+    // 1M input tokens × $2.00/Mtok = $2.00
+    // 100k output tokens × $10.00/Mtok = $1.00
+    // total = $3.00. The introductory rate applies through 2026-08-31.
+    const cost = computeClaudeManagedCostUsd(
+      "claude-sonnet-5",
+      1_000_000,
+      100_000,
+      0,
+      0,
+      Date.parse("2026-08-31T23:59:59.999Z"),
+    );
+    expect(cost).toBeCloseTo(3.0, 10);
+  });
+
+  test("computeClaudeManagedCostUsd uses sonnet-5 standard rate from 2026-09-01", () => {
     // 1M input tokens × $3.00/Mtok = $3.00
     // 100k output tokens × $15.00/Mtok = $1.50
-    // total = $4.50. Intro $2/$10 pricing is intentionally not used here.
-    const cost = computeClaudeManagedCostUsd("claude-sonnet-5", 1_000_000, 100_000, 0, 0);
+    // total = $4.50 from the first instant of 2026-09-01 UTC.
+    const cost = computeClaudeManagedCostUsd(
+      "claude-sonnet-5",
+      1_000_000,
+      100_000,
+      0,
+      0,
+      Date.parse("2026-09-01T00:00:00.000Z"),
+    );
     expect(cost).toBeCloseTo(4.5, 10);
   });
 
@@ -882,10 +904,19 @@ describe("ClaudeManagedAdapter (Phase 4) — repo provisioning + cost data", ()
       cacheWritePerMillion: 12.5,
     });
     expect(CLAUDE_MANAGED_MODEL_PRICING["claude-sonnet-5"]).toEqual({
-      inputPerMillion: 3.0,
-      outputPerMillion: 15.0,
-      cacheReadPerMillion: 0.3,
-      cacheWritePerMillion: 3.75,
+      inputPerMillion: 2.0,
+      outputPerMillion: 10.0,
+      cacheReadPerMillion: 0.2,
+      cacheWritePerMillion: 2.5,
+      scheduledChange: {
+        effectiveAt: "2026-09-01T00:00:00.000Z",
+        pricing: {
+          inputPerMillion: 3.0,
+          outputPerMillion: 15.0,
+          cacheReadPerMillion: 0.3,
+          cacheWritePerMillion: 3.75,
+        },
+      },
     });
     expect(CLAUDE_MANAGED_MODEL_PRICING["claude-sonnet-4-6"]).toBeDefined();
     expect(CLAUDE_MANAGED_MODEL_PRICING["claude-opus-4-7"]).toBeDefined();

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

@@ -1011,6 +1011,36 @@ describe("buildCodexConfig", () => {
     expect(emitted.filter((e) => e.type === "raw_stderr")).toHaveLength(0);
   });
 
+  test("forwards the per-boot runtime identity to the swarm MCP headers", async () => {
+    globalThis.fetch = stubFetch({ servers: [], total: 0 });
+    const prev = process.env.SWARM_RUNTIME_INSTANCE_ID;
+    process.env.SWARM_RUNTIME_INSTANCE_ID = "codex-runtime-1";
+    try {
+      const merged = await buildCodexConfig(cfg(), "gpt-5.4", () => {});
+      const headers = (merged.mcp_servers as Record<string, Record<string, unknown>>)["agent-swarm"]
+        ?.http_headers as Record<string, string>;
+      expect(headers["X-Runtime-Instance-ID"]).toBe("codex-runtime-1");
+    } finally {
+      if (prev === undefined) delete process.env.SWARM_RUNTIME_INSTANCE_ID;
+      else process.env.SWARM_RUNTIME_INSTANCE_ID = prev;
+    }
+  });
+
+  test("no runtime identity in the environment → no runtime header", async () => {
+    globalThis.fetch = stubFetch({ servers: [], total: 0 });
+    const prev = process.env.SWARM_RUNTIME_INSTANCE_ID;
+    delete process.env.SWARM_RUNTIME_INSTANCE_ID;
+    try {
+      const merged = await buildCodexConfig(cfg(), "gpt-5.4", () => {});
+      const headers = (merged.mcp_servers as Record<string, Record<string, unknown>>)["agent-swarm"]
+        ?.http_headers as Record<string, string>;
+      expect(headers["X-Runtime-Instance-ID"]).toBeUndefined();
+    } finally {
+      if (prev === undefined) delete process.env.SWARM_RUNTIME_INSTANCE_ID;
+      else process.env.SWARM_RUNTIME_INSTANCE_ID = prev;
+    }
+  });
+
   test("one HTTP-transport installed server → both 'agent-swarm' and installed server present", async () => {
     globalThis.fetch = stubFetch({
       servers: [

package/src/tests/create-task-validation.test.ts

@@ -0,0 +1,128 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlinkSync } from "node:fs";
+import {
+  createServer as createHttpServer,
+  type IncomingMessage,
+  type Server,
+  type ServerResponse,
+} from "node:http";
+import { type CreateTaskOptions, closeDb, createTaskExtended, getDb, initDb } from "../be/db";
+import { handleMcpBridge } from "../http/mcp-bridge";
+import { getPathSegments } from "../http/utils";
+
+const TEST_DB_PATH = "./test-create-task-validation.sqlite";
+
+let server: Server;
+let baseUrl: string;
+
+function taskCount(): number {
+  return (getDb().prepare("SELECT COUNT(*) AS c FROM agent_tasks").get() as { c: number }).c;
+}
+
+beforeAll(async () => {
+  initDb(TEST_DB_PATH);
+  server = createHttpServer(async (req: IncomingMessage, res: ServerResponse) => {
+    const myAgentId = req.headers["x-agent-id"] as string | undefined;
+    const pathSegments = getPathSegments(req.url || "");
+    const ok = await handleMcpBridge(req, res, pathSegments, undefined, myAgentId);
+    if (!ok) {
+      res.writeHead(404);
+      res.end("Not Found");
+    }
+  });
+  await new Promise<void>((resolve) => server.listen(0, resolve));
+  const addr = server.address();
+  if (!addr || typeof addr === "string") throw new Error("no port");
+  baseUrl = `http://127.0.0.1:${addr.port}`;
+});
+
+afterAll(() => {
+  server.close();
+  closeDb();
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      unlinkSync(TEST_DB_PATH + suffix);
+    } catch {
+      // ignore
+    }
+  }
+});
+
+describe("scripts-bridge input validation", () => {
+  // REGRESSION TEST for the 2026-08-18 incident: an inline script POSTed
+  // priority: "high" to /api/mcp-bridge; the bridge invoked the send-task
+  // handler without parsing args, the TEXT value landed in the INTEGER
+  // priority column, and response validation then 500'd every task listing.
+  test("raw priority:'high' through the bridge returns 400 and writes no row", async () => {
+    const before = taskCount();
+    const res = await fetch(`${baseUrl}/api/mcp-bridge`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "x-agent-id": "test-agent" },
+      body: JSON.stringify({
+        tool: "send-task",
+        args: { task: "incident regression probe", priority: "high" },
+      }),
+    });
+    expect(res.status).toBe(400);
+    const body = (await res.json()) as { error?: string };
+    expect(body.error).toContain("Invalid arguments for tool 'send-task'");
+    expect(taskCount()).toBe(before);
+  });
+});
+
+describe("createTaskExtended input validation", () => {
+  test("string priority throws and writes no row", () => {
+    const before = taskCount();
+    expect(() =>
+      createTaskExtended("bad priority", { priority: "high" } as unknown as CreateTaskOptions),
+    ).toThrow();
+    expect(taskCount()).toBe(before);
+  });
+
+  test("priority 101 throws", () => {
+    expect(() => createTaskExtended("too high", { priority: 101 })).toThrow();
+  });
+
+  test("priority -1 throws", () => {
+    expect(() => createTaskExtended("too low", { priority: -1 })).toThrow();
+  });
+
+  test("non-integer priority throws", () => {
+    expect(() => createTaskExtended("fractional", { priority: 49.5 })).toThrow();
+  });
+
+  test("absent priority defaults to 50", () => {
+    const t = createTaskExtended("default priority");
+    expect(t.priority).toBe(50);
+  });
+
+  test("explicit priority 0 stays 0", () => {
+    const t = createTaskExtended("zero priority", { priority: 0 });
+    expect(t.priority).toBe(0);
+  });
+
+  test("unknown keys are stripped and the task is still created", () => {
+    const t = createTaskExtended("extra keys", {
+      priority: 10,
+      nonsense: true,
+    } as unknown as CreateTaskOptions);
+    expect(t.priority).toBe(10);
+  });
+
+  test("empty task throws", () => {
+    expect(() => createTaskExtended("")).toThrow();
+  });
+
+  test("valid full options pass through unchanged", () => {
+    const t = createTaskExtended("full options", {
+      priority: 90,
+      tags: ["urgent"],
+      taskType: "bug",
+      status: "backlog",
+      source: "api",
+    });
+    expect(t.priority).toBe(90);
+    expect(t.status).toBe("backlog");
+    expect(t.tags).toEqual(["urgent"]);
+  });
+});

package/src/tests/credential-wait.test.ts

@@ -1,5 +1,9 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { awaitCredentials, BootMaxWaitExceededError } from "../commands/credential-wait";
+import {
+  awaitCredentials,
+  BootMaxWaitExceededError,
+  retryBootStep,
+} from "../commands/credential-wait";
 
 /**
  * Capture-only logger so test output stays clean and we can assert on
@@ -280,3 +284,65 @@ describe("awaitCredentials", () => {
     expect(probedPaths).toContain("/home/worker/.codex/auth.json");
   });
 });
+
+describe("retryBootStep", () => {
+  test("returns after the first success without sleeping", async () => {
+    const sleeper = makeSleeper();
+    let calls = 0;
+    await retryBootStep(
+      async () => {
+        calls++;
+      },
+      { sleep: sleeper.fn, log: () => {} },
+    );
+    expect(calls).toBe(1);
+    expect(sleeper.calls).toEqual([]);
+  });
+
+  test("retries with exponential backoff until success", async () => {
+    const sleeper = makeSleeper();
+    const logger = makeLogger();
+    let calls = 0;
+    await retryBootStep(
+      async () => {
+        calls++;
+        if (calls < 3) throw new Error(`transient ${calls}`);
+      },
+      { sleep: sleeper.fn, log: logger.fn, initialDelayMs: 100, maxDelayMs: 1000 },
+    );
+    expect(calls).toBe(3);
+    expect(sleeper.calls).toEqual([100, 200]);
+    expect(logger.lines).toHaveLength(2);
+    expect(logger.lines[0]).toContain("attempt 1/5");
+  });
+
+  test("propagates the last error once attempts are exhausted", async () => {
+    const sleeper = makeSleeper();
+    let calls = 0;
+    await expect(
+      retryBootStep(
+        async () => {
+          calls++;
+          throw new Error(`down ${calls}`);
+        },
+        { attempts: 3, sleep: sleeper.fn, log: () => {} },
+      ),
+    ).rejects.toThrow("down 3");
+    expect(calls).toBe(3);
+    // No sleep after the final attempt.
+    expect(sleeper.calls).toHaveLength(2);
+  });
+
+  test("caps the backoff at maxDelayMs", async () => {
+    const sleeper = makeSleeper();
+    let calls = 0;
+    await retryBootStep(
+      async () => {
+        calls++;
+        if (calls < 5) throw new Error("transient");
+      },
+      { sleep: sleeper.fn, log: () => {}, initialDelayMs: 400, maxDelayMs: 1000 },
+    );
+    expect(sleeper.calls).toEqual([400, 800, 1000, 1000]);
+  });
+});