@desplega.ai/agent-swarm 1.79.4 → 1.80.1

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

@@ -319,11 +319,14 @@ describe("ClaudeManagedAdapter (Phase 3) — session lifecycle", () => {
     }
 
     // context_usage emitted on span.model_request_end.
+    // Phase 5 / Phase 9 unified formula = input + cache_read + cache_write + output.
     const ctx = emitted.find((e) => e.type === "context_usage");
     expect(ctx).toBeDefined();
     if (ctx && ctx.type === "context_usage") {
-      expect(ctx.contextUsedTokens).toBe(150); // 100 input + 50 output
+      expect(ctx.contextUsedTokens).toBe(165); // 100 + 10 + 5 + 50
       expect(ctx.outputTokens).toBe(50);
+      // Phase 9: every snapshot carries the formula tag.
+      expect(ctx.contextFormula).toBe("input-cache-output");
     }
 
     // result emitted with accumulated cost. Phase 3 leaves totalCostUsd at 0
@@ -345,6 +348,8 @@ describe("ClaudeManagedAdapter (Phase 3) — session lifecycle", () => {
       expect(resultEvent.cost.totalCostUsd).toBeGreaterThanOrEqual(0);
       expect(Number.isFinite(resultEvent.cost.totalCostUsd)).toBe(true);
       expect(resultEvent.output).toBe("Hello from managed agent");
+      // Phase 3 — provider tag is required so the API recompute path engages.
+      expect(resultEvent.cost.provider).toBe("claude-managed");
     }
 
     // ProviderResult.
@@ -644,17 +649,24 @@ describe("ClaudeManagedAdapter (Phase 4) — repo provisioning + cost data", ()
     process.env.ANTHROPIC_API_KEY = "sk-test";
     process.env.MANAGED_AGENT_ID = "agent_x";
     process.env.MANAGED_ENVIRONMENT_ID = "env_x";
+    // Defensive: vault env vars may leak in from the host .env (Bun auto-loads
+    // it); each vault-related test sets exactly what it asserts on.
+    delete process.env.MANAGED_GITHUB_TOKEN;
+    delete process.env.MANAGED_GITHUB_VAULT_ID;
+    delete process.env.MANAGED_MCP_VAULT_ID;
   });
 
   afterAll(() => {
     rmSync(tmpLogDir, { recursive: true, force: true });
     delete process.env.MANAGED_GITHUB_TOKEN;
     delete process.env.MANAGED_GITHUB_VAULT_ID;
+    delete process.env.MANAGED_MCP_VAULT_ID;
   });
 
   afterEach(() => {
     delete process.env.MANAGED_GITHUB_TOKEN;
     delete process.env.MANAGED_GITHUB_VAULT_ID;
+    delete process.env.MANAGED_MCP_VAULT_ID;
   });
 
   test("normalizeRepoUrl: passes through https URLs and expands owner/repo shorthand", () => {
@@ -1266,9 +1278,11 @@ describe("ClaudeManagedAdapter (Phase 6) — full happy-path integration", () =>
     const ctxUsage = emitted.find((e) => e.type === "context_usage");
     expect(ctxUsage?.type).toBe("context_usage");
     if (ctxUsage?.type === "context_usage") {
-      // 1M input + 200k output = 1.2M used; output = 200k.
-      expect(ctxUsage.contextUsedTokens).toBe(1_200_000);
+      // Phase 5 / Phase 9 unified: input + cache_read + cache_write + output.
+      // 1M + 50k + 25k + 200k = 1,275,000.
+      expect(ctxUsage.contextUsedTokens).toBe(1_275_000);
       expect(ctxUsage.outputTokens).toBe(200_000);
+      expect(ctxUsage.contextFormula).toBe("input-cache-output");
     }
 
     // The terminal `result` ProviderEvent — the contract Phase 4 hardened —

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

@@ -88,13 +88,22 @@ describe("runClaudeManagedSetupFlow — happy path", () => {
     const agentCallArgs = agentsCreate.mock.calls[0]?.[0] as {
       name: string;
       model: string;
-      tools: Array<{ type: string }>;
+      tools: Array<{
+        type: string;
+        default_config?: { permission_policy?: { type: string } };
+      }>;
       skills: Array<{ type: string; skill_id: string }>;
       mcp_servers: Array<{ name: string; type: string; url: string }>;
     };
     expect(agentCallArgs.name).toBe("swarm-worker");
     expect(agentCallArgs.model).toBe("claude-sonnet-4-6");
     expect(agentCallArgs.tools[0]?.type).toBe("agent_toolset_20260401");
+    // Headless workers can't approve interactively — both toolsets must be
+    // configured with `always_allow` so the sandbox executes tool calls
+    // without parking them in `awaiting approval`.
+    for (const tool of agentCallArgs.tools) {
+      expect(tool.default_config?.permission_policy?.type).toBe("always_allow");
+    }
     expect(agentCallArgs.skills.map((s) => s.skill_id)).toEqual([
       "skill_work-on-task",
       "skill_create-pr",

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

@@ -191,16 +191,16 @@ describe("CodexSession event mapping", () => {
       expect(messages[0].content).toBe("Hello from codex");
     }
 
-    // context_usage event fired with the *uncached + output* peak proxy
-    // (input=100, cached=25, output=50 → uncached=75 → peak=125)
-    // contextPercent is on a 0-100 scale (claude/pi convention).
+    // Phase 9: unified `input + output` formula (Codex `input_tokens` already
+    // includes cached input, so we don't add cache_read separately).
+    // input=100 + output=50 → contextUsed=150.
     const contextUsage = emitted.find((e) => e.type === "context_usage");
     expect(contextUsage).toBeDefined();
     if (contextUsage && contextUsage.type === "context_usage") {
-      expect(contextUsage.contextUsedTokens).toBe(125);
+      expect(contextUsage.contextUsedTokens).toBe(150);
       expect(contextUsage.contextTotalTokens).toBe(200_000);
-      // 125 / 200_000 × 100 = 0.0625
-      expect(contextUsage.contextPercent).toBeCloseTo((125 / 200_000) * 100, 6);
+      expect(contextUsage.contextPercent).toBeCloseTo((150 / 200_000) * 100, 6);
+      expect(contextUsage.contextFormula).toBe("input-cache-output");
     }
 
     // result event is final and non-error, with cost computed from token counts
@@ -225,14 +225,15 @@ describe("CodexSession event mapping", () => {
     expect(result.sessionId).toBe("thread-abc");
   });
 
-  test("chatty turn: peakContextPercent uses uncached + output, not raw input_tokens", async () => {
-    // Reproduces the verify-plan finding: a chatty turn where the SDK reports
-    // input_tokens far in excess of the model's context window because the
-    // total represents the SUM of every prompt across all model invocations
-    // in the turn (with cache reuses billed at every roundtrip). Without the
-    // peak-proxy fix this would clamp `contextPercent` to 1.0 even though no
-    // single model call hit the limit. Use realistic numbers from the actual
-    // E2E lead transcript captured during verification.
+  test("Phase 9: chatty turn clamps contextPercent to 100% under the unified formula", async () => {
+    // Phase 9 deliberately swapped Codex's per-adapter peak-proxy formula
+    // (`(input - cached) + output`) for the unified `input + output` formula
+    // shared with every other provider. The trade-off: a chatty Codex turn
+    // — where `input_tokens` is the SUM across every model call in the turn
+    // — over-reports compared to the peak-proxy variant. The clamp at 100%
+    // keeps the gauge sensible; downstream consumers reading the new
+    // `contextFormula='input-cache-output'` tag know it's apples-to-apples
+    // across providers. Numbers below are from the verify-plan transcript.
     const agentMsg: AgentMessageItem = {
       id: "msg-1",
       type: "agent_message",
@@ -262,12 +263,12 @@ describe("CodexSession event mapping", () => {
     const contextUsage = emitted.find((e) => e.type === "context_usage");
     expect(contextUsage).toBeDefined();
     if (contextUsage && contextUsage.type === "context_usage") {
-      // peak proxy = (357142 - 278912) + 2156 = 78230 + 2156 = 80386
-      expect(contextUsage.contextUsedTokens).toBe(80386);
+      // Phase 9 unified: input + output = 357142 + 2156 = 359298 (above 200k).
+      expect(contextUsage.contextUsedTokens).toBe(359298);
       expect(contextUsage.contextTotalTokens).toBe(200_000);
-      // 80386 / 200000 × 100 = 40.193 — on the 0-100 scale, NOT clamped to 100
-      expect(contextUsage.contextPercent).toBeCloseTo(40.193, 2);
-      expect(contextUsage.contextPercent).toBeLessThan(100);
+      // Above 100% raw → clamped to exactly 100.
+      expect(contextUsage.contextPercent).toBe(100);
+      expect(contextUsage.contextFormula).toBe("input-cache-output");
     }
 
     // Cost still uses the full input_tokens — billing semantics are

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

@@ -70,7 +70,7 @@ describe("resolveCodexLoginConfig", () => {
     expect(promptSecret).toHaveBeenCalledWith(
       "Swarm API key",
       "env-secret",
-      "Press Enter to use API_KEY from the environment",
+      "Press Enter to use AGENT_SWARM_API_KEY/API_KEY from the environment",
     );
   });
 

package/src/tests/context-snapshot.test.ts

@@ -82,7 +82,7 @@ describe("Context Snapshots", () => {
 
     // The summary should preserve the last known context usage, not null/0
     const summary = getContextSummaryByTaskId(taskId);
-    expect(summary.totalContextTokensUsed).toBe(80000);
+    expect(summary.peakContextTokens).toBe(80000);
     expect(summary.contextWindowSize).toBe(200000);
     expect(summary.peakContextPercent).toBe(40);
   });
@@ -113,7 +113,7 @@ describe("Context Snapshots", () => {
     });
 
     const summary = getContextSummaryByTaskId(task2.id);
-    expect(summary.totalContextTokensUsed).toBe(60000);
+    expect(summary.peakContextTokens).toBe(60000);
     expect(summary.contextWindowSize).toBe(200000);
   });
 

package/src/tests/context-window.test.ts

@@ -1,8 +1,15 @@
 import { describe, expect, test } from "bun:test";
-import { computeContextUsed, getContextWindowSize } from "../utils/context-window";
+import {
+  CONTEXT_FORMULA,
+  clampContextPercent,
+  computeContextUsed,
+  computeContextUsedUnified,
+  getContextWindowSize,
+} from "../utils/context-window";
 
 describe("getContextWindowSize", () => {
   test("returns 1M for opus models", () => {
+    expect(getContextWindowSize("claude-opus-4-7")).toBe(1_000_000);
     expect(getContextWindowSize("claude-opus-4-6")).toBe(1_000_000);
     expect(getContextWindowSize("opus")).toBe(1_000_000);
   });
@@ -26,6 +33,20 @@ describe("getContextWindowSize", () => {
   test("returns default entry value", () => {
     expect(getContextWindowSize("default")).toBe(200_000);
   });
+
+  test("Phase 4: dated full ids resolve via date-suffix stripping", () => {
+    // The regression this fixes: pre-Phase 4 these all fell to the 200k
+    // default, wildly understating opus/sonnet 4.x context.
+    expect(getContextWindowSize("claude-sonnet-4-6-20251004")).toBe(1_000_000);
+    expect(getContextWindowSize("claude-opus-4-7-20251201")).toBe(1_000_000);
+    expect(getContextWindowSize("claude-haiku-4-5-20251001")).toBe(200_000);
+  });
+
+  test("Phase 4: legacy 3.x family ids resolve", () => {
+    expect(getContextWindowSize("claude-3-5-sonnet")).toBe(200_000);
+    expect(getContextWindowSize("claude-3-5-sonnet-20241022")).toBe(200_000);
+    expect(getContextWindowSize("claude-3-opus")).toBe(200_000);
+  });
 });
 
 describe("computeContextUsed", () => {
@@ -64,3 +85,46 @@ describe("computeContextUsed", () => {
     ).toBe(5000);
   });
 });
+
+describe("computeContextUsedUnified (Phase 9 unified formula)", () => {
+  test("sums input + cache_read + cache_create + output", () => {
+    expect(
+      computeContextUsedUnified({
+        inputTokens: 1000,
+        cacheReadTokens: 200,
+        cacheCreateTokens: 300,
+        outputTokens: 500,
+      }),
+    ).toBe(2000);
+  });
+
+  test("treats missing/null fields as zero", () => {
+    expect(computeContextUsedUnified({})).toBe(0);
+    expect(computeContextUsedUnified({ inputTokens: 100, outputTokens: null })).toBe(100);
+  });
+});
+
+describe("clampContextPercent (Phase 9)", () => {
+  test("returns the clamped percent for valid inputs", () => {
+    expect(clampContextPercent(50_000, 200_000)).toBe(25);
+    expect(clampContextPercent(0, 200_000)).toBe(0);
+  });
+
+  test("clamps to [0, 100]", () => {
+    expect(clampContextPercent(500_000, 200_000)).toBe(100);
+    expect(clampContextPercent(-10, 200_000)).toBe(0);
+  });
+
+  test("returns null for missing/zero/negative total (no divide-by-zero NaN)", () => {
+    expect(clampContextPercent(100, 0)).toBeNull();
+    expect(clampContextPercent(100, null)).toBeNull();
+    expect(clampContextPercent(100, undefined)).toBeNull();
+    expect(clampContextPercent(100, -1)).toBeNull();
+  });
+});
+
+describe("CONTEXT_FORMULA constant", () => {
+  test("is 'input-cache-output' so adapters stamp the same value on snapshots", () => {
+    expect(CONTEXT_FORMULA).toBe("input-cache-output");
+  });
+});

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

@@ -598,6 +598,8 @@ describe("CostData mapping", () => {
       expect(resultEvent.cost.model).toBe("devin");
       expect(resultEvent.cost.inputTokens).toBe(0);
       expect(resultEvent.cost.outputTokens).toBe(0);
+      // Phase 3 — provider tag is required so the API recompute path engages.
+      expect(resultEvent.cost.provider).toBe("devin");
     }
   });
 

package/src/tests/http/context-routes.test.ts

@@ -0,0 +1,161 @@
+// Phase 10: HTTP context-route ingestion semantics.
+//
+// Asserts:
+//   * `agent_tasks.peakContextTokens` is monotonic-max (a dip on a later
+//     snapshot doesn't reduce the stored value).
+//   * `agent_tasks.contextWindowSize` is set on the FIRST snapshot that
+//     carries one, not gated on `eventType='completion'`.
+//   * `cumulativeInputTokens` round-trips through the route into the
+//     persisted snapshot row.
+//   * `contextFormula` round-trips into the snapshot.
+
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import {
+  createServer as createHttpServer,
+  type IncomingMessage,
+  type Server,
+  type ServerResponse,
+} from "node:http";
+import {
+  closeDb,
+  createAgent,
+  createTaskExtended,
+  getContextSnapshotsByTaskId,
+  getContextSummaryByTaskId,
+  initDb,
+} from "../../be/db";
+import { handleContext } from "../../http/context";
+import { handleCore } from "../../http/core";
+import { getPathSegments, parseQueryParams } from "../../http/utils";
+
+const TEST_DB_PATH = "./test-context-routes.sqlite";
+const API_KEY = "test-context-routes";
+
+async function removeDbFiles(path: string): Promise<void> {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      await unlink(path + suffix);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+    }
+  }
+}
+
+async function listen(server: Server): Promise<number> {
+  await new Promise<void>((resolve) => server.listen(0, resolve));
+  const addr = server.address();
+  if (!addr || typeof addr === "string") throw new Error("no port");
+  return addr.port;
+}
+
+function createTestServer(apiKey: string): Server {
+  return createHttpServer(async (req: IncomingMessage, res: ServerResponse) => {
+    const myAgentId = req.headers["x-agent-id"] as string | undefined;
+    const handled = await handleCore(req, res, myAgentId, apiKey);
+    if (handled) return;
+    const pathSegments = getPathSegments(req.url || "");
+    const queryParams = parseQueryParams(req.url || "");
+    const ok = await handleContext(req, res, pathSegments, queryParams, myAgentId);
+    if (!ok) {
+      res.writeHead(404);
+      res.end("Not Found");
+    }
+  });
+}
+
+let server: Server;
+let port: number;
+let testAgent: { id: string };
+let testTask: { id: string };
+
+beforeAll(async () => {
+  await removeDbFiles(TEST_DB_PATH);
+  initDb(TEST_DB_PATH);
+  testAgent = createAgent({ name: "context-route-test", isLead: false, status: "idle" });
+  testTask = createTaskExtended("phase-10 ingestion", { agentId: testAgent.id, source: "mcp" });
+  server = createTestServer(API_KEY);
+  port = await listen(server);
+});
+
+afterAll(async () => {
+  await new Promise<void>((resolve) => server.close(() => resolve()));
+  closeDb();
+  await removeDbFiles(TEST_DB_PATH);
+});
+
+function postSnapshot(body: Record<string, unknown>): Promise<Response> {
+  return fetch(`http://localhost:${port}/api/tasks/${testTask.id}/context`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${API_KEY}`,
+      "X-Agent-ID": testAgent.id,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify(body),
+  });
+}
+
+describe("Phase 10 — POST /api/tasks/:id/context", () => {
+  test("peakContextTokens is a monotonic max across snapshots", async () => {
+    const r1 = await postSnapshot({
+      eventType: "progress",
+      sessionId: "sess-1",
+      contextUsedTokens: 50_000,
+      contextTotalTokens: 200_000,
+      contextPercent: 25,
+    });
+    expect(r1.status).toBe(200);
+
+    const r2 = await postSnapshot({
+      eventType: "progress",
+      sessionId: "sess-1",
+      contextUsedTokens: 120_000,
+      contextTotalTokens: 200_000,
+      contextPercent: 60,
+    });
+    expect(r2.status).toBe(200);
+
+    // Dip — the unified formula occasionally undercounts on the next turn
+    // (e.g. when the SDK reuses cache more aggressively). The aggregate
+    // column must NOT regress to the dipped value.
+    const r3 = await postSnapshot({
+      eventType: "progress",
+      sessionId: "sess-1",
+      contextUsedTokens: 80_000,
+      contextTotalTokens: 200_000,
+      contextPercent: 40,
+    });
+    expect(r3.status).toBe(200);
+
+    const summary = getContextSummaryByTaskId(testTask.id);
+    expect(summary.peakContextTokens).toBe(120_000);
+  });
+
+  test("contextWindowSize is set on the first snapshot, not on completion", () => {
+    // The first POST in the previous test already set this; assert it stuck
+    // and a later POST with a different total doesn't overwrite it.
+    const summary = getContextSummaryByTaskId(testTask.id);
+    expect(summary.contextWindowSize).toBe(200_000);
+  });
+
+  test("cumulativeInputTokens + contextFormula round-trip into the row", async () => {
+    const res = await postSnapshot({
+      eventType: "progress",
+      sessionId: "sess-2",
+      contextUsedTokens: 30_000,
+      contextTotalTokens: 200_000,
+      contextPercent: 15,
+      cumulativeInputTokens: 1234,
+      cumulativeOutputTokens: 567,
+      contextFormula: "input-cache-output",
+    });
+    expect(res.status).toBe(200);
+
+    const snapshots = getContextSnapshotsByTaskId(testTask.id);
+    const last = snapshots[snapshots.length - 1];
+    expect(last.cumulativeInputTokens).toBe(1234);
+    expect(last.cumulativeOutputTokens).toBe(567);
+    expect(last.contextFormula).toBe("input-cache-output");
+  });
+});

package/src/tests/linear-outbound-sync.test.ts

@@ -3,6 +3,7 @@ import { unlink } from "node:fs/promises";
 import { closeDb, initDb } from "../be/db";
 import { createTrackerSync, getTrackerSync, updateTrackerSync } from "../be/db-queries/tracker";
 import { initLinearOutboundSync, teardownLinearOutboundSync } from "../linear/outbound";
+import { taskSessionMap } from "../linear/sync";
 import { workflowEventBus } from "../workflows/event-bus";
 
 const TEST_DB_PATH = "./test-linear-outbound-sync.sqlite";
@@ -17,6 +18,19 @@ mock.module("../linear/client", () => ({
   resetLinearClient: () => {},
 }));
 
+// Mock the AgentSession helpers in linear/sync so we can assert which activity type
+// the outbound handlers post (`action` vs `thought` vs `response`/`error`).
+const mockPostAgentSessionThought = mock(() => Promise.resolve());
+const mockPostAgentSessionAction = mock(() => Promise.resolve());
+const mockEndAgentSession = mock(() => Promise.resolve());
+
+mock.module("../linear/sync", () => ({
+  postAgentSessionThought: mockPostAgentSessionThought,
+  postAgentSessionAction: mockPostAgentSessionAction,
+  endAgentSession: mockEndAgentSession,
+  taskSessionMap,
+}));
+
 beforeAll(() => {
   initDb(TEST_DB_PATH);
 });
@@ -31,11 +45,16 @@ afterAll(async () => {
 describe("Linear Outbound Sync", () => {
   beforeEach(() => {
     mockCreateComment.mockClear();
+    mockPostAgentSessionThought.mockClear();
+    mockPostAgentSessionAction.mockClear();
+    mockEndAgentSession.mockClear();
+    taskSessionMap.clear();
     initLinearOutboundSync();
   });
 
   afterEach(() => {
     teardownLinearOutboundSync();
+    taskSessionMap.clear();
   });
 
   test("task.completed posts comment to Linear when mapping exists", async () => {
@@ -177,6 +196,96 @@ describe("Linear Outbound Sync", () => {
     expect(mockCreateComment).toHaveBeenCalledTimes(1);
   });
 
+  test("task.progress posts an action activity with both action AND parameter when sessionId is mapped", async () => {
+    const taskId = "outbound-task-progress";
+    taskSessionMap.set(taskId, "linear-session-123");
+
+    workflowEventBus.emit("task.progress", {
+      taskId,
+      progress: "📋 Reviewing task details",
+    });
+
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    // Posts as `action` so the update renders as a structured card in Linear's AgentSession
+    // panel. Linear's spec requires BOTH `action` AND `parameter` for action-type activities;
+    // the original bug was calling postAgentSessionAction with only a single string (parameter
+    // undefined), which Linear silently rejected.
+    expect(mockPostAgentSessionAction).toHaveBeenCalledTimes(1);
+    expect(mockPostAgentSessionThought).not.toHaveBeenCalled();
+
+    const args = mockPostAgentSessionAction.mock.calls[0] as unknown[];
+    expect(args[0]).toBe("linear-session-123");
+    // Both action label and parameter must be present and non-empty
+    expect(typeof args[1]).toBe("string");
+    expect((args[1] as string).length).toBeGreaterThan(0);
+    expect(typeof args[2]).toBe("string");
+    expect((args[2] as string).length).toBeGreaterThan(0);
+    // Parameter carries the actual progress text
+    expect(args[2] as string).toBe("📋 Reviewing task details");
+  });
+
+  test("task.progress slices long progress strings into the parameter (cap at 2000)", async () => {
+    const taskId = "outbound-task-progress-long";
+    taskSessionMap.set(taskId, "linear-session-long");
+
+    const longProgress = "x".repeat(5000);
+    workflowEventBus.emit("task.progress", { taskId, progress: longProgress });
+
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    expect(mockPostAgentSessionAction).toHaveBeenCalledTimes(1);
+    const args = mockPostAgentSessionAction.mock.calls[0] as unknown[];
+    expect((args[2] as string).length).toBe(2000);
+  });
+
+  test("task.progress is a no-op when no sessionId is mapped for the task", async () => {
+    workflowEventBus.emit("task.progress", {
+      taskId: "outbound-task-progress-no-session",
+      progress: "should be dropped",
+    });
+
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    expect(mockPostAgentSessionThought).not.toHaveBeenCalled();
+    expect(mockPostAgentSessionAction).not.toHaveBeenCalled();
+  });
+
+  test("task.progress is a no-op when progress string is missing", async () => {
+    taskSessionMap.set("outbound-task-progress-empty", "linear-session-empty");
+
+    workflowEventBus.emit("task.progress", {
+      taskId: "outbound-task-progress-empty",
+    });
+
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    expect(mockPostAgentSessionThought).not.toHaveBeenCalled();
+    expect(mockPostAgentSessionAction).not.toHaveBeenCalled();
+  });
+
+  test("task.created for Linear-sourced tasks still posts an action activity (with parameter)", async () => {
+    const taskId = "outbound-task-created-linear";
+    taskSessionMap.set(taskId, "linear-session-created");
+
+    workflowEventBus.emit("task.created", {
+      taskId,
+      source: "linear",
+    });
+
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    expect(mockPostAgentSessionAction).toHaveBeenCalledTimes(1);
+    expect(mockPostAgentSessionThought).not.toHaveBeenCalled();
+
+    const args = mockPostAgentSessionAction.mock.calls[0] as unknown[];
+    expect(args[0]).toBe("linear-session-created");
+    expect(args[1]).toBe("Processing");
+    // parameter (3rd positional arg) must be present for `action` activities to be valid
+    expect(typeof args[2]).toBe("string");
+    expect(args[2] as string).toContain(taskId);
+  });
+
   test("teardown removes event listeners", async () => {
     teardownLinearOutboundSync();
 

package/src/tests/mcp-tools.test.ts

@@ -0,0 +1,69 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { closeDb } from "../be/db";
+import { createServer } from "../server";
+
+const TEST_DB_PATH = "./test-mcp-tools.sqlite";
+
+type RegisteredTool = {
+  title?: string;
+  description?: string;
+  inputSchema?: unknown;
+  outputSchema?: unknown;
+  annotations?: Record<string, unknown>;
+};
+
+async function removeDbFiles(path: string): Promise<void> {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      await unlink(path + suffix);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+    }
+  }
+}
+
+describe("script MCP tools", () => {
+  let tools: Record<string, RegisteredTool>;
+  let savedDatabasePath: string | undefined;
+
+  beforeAll(async () => {
+    savedDatabasePath = process.env.DATABASE_PATH;
+    process.env.DATABASE_PATH = TEST_DB_PATH;
+    await removeDbFiles(TEST_DB_PATH);
+    const server = createServer();
+    tools = (server as unknown as { _registeredTools: Record<string, RegisteredTool> })
+      ._registeredTools;
+  });
+
+  afterAll(async () => {
+    closeDb();
+    if (savedDatabasePath === undefined) delete process.env.DATABASE_PATH;
+    else process.env.DATABASE_PATH = savedDatabasePath;
+    await removeDbFiles(TEST_DB_PATH);
+  });
+
+  test("registers all script tools with schemas and documented descriptions", () => {
+    const expected = {
+      "script-search":
+        "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.",
+      "script-run":
+        "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`.",
+      "script-upsert":
+        "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`.",
+      "script-delete":
+        "Remove a swarm-shared script from the catalog. Versions table preserves history.",
+      "script-query-types":
+        "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.",
+    };
+
+    for (const [name, description] of Object.entries(expected)) {
+      expect(tools[name]).toBeDefined();
+      expect(tools[name].title).toBeTruthy();
+      expect(tools[name].description).toBe(description);
+      expect(tools[name].inputSchema).toBeTruthy();
+      expect(tools[name].outputSchema).toBeTruthy();
+      expect(tools[name].annotations).toBeTruthy();
+    }
+  });
+});