@desplega.ai/agent-swarm 1.151.0 → 1.152.1

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

@@ -4,11 +4,16 @@ import type { IncomingMessage, ServerResponse } from "node:http";
 import { Readable } from "node:stream";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { closeDb, createAgent, getDbClient, initDb } from "../be/db";
-import { setExtensionState } from "../be/extensions/db";
+import { getExtensionById, setExtensionState } from "../be/extensions/db";
 import { typecheckScript } from "../be/scripts/typecheck";
+import { stopExtensionRuntime } from "../extensions/lifecycle";
 import { handleCore } from "../http/core";
 import { handleExtensions } from "../http/extensions";
 import { getPathSegments, parseQueryParams } from "../http/utils";
+import { registerExtensionActivateVersionTool } from "../tools/extension-activate-version";
+import { registerExtensionDeleteTool } from "../tools/extension-delete";
+import { registerExtensionDisableTool } from "../tools/extension-disable";
+import { registerExtensionEnableTool } from "../tools/extension-enable";
 import { registerExtensionInstallTool } from "../tools/extension-install";
 import { registerExtensionListTool } from "../tools/extension-list";
 import { refreshSecretScrubberCache } from "../utils/secret-scrubber";
@@ -40,11 +45,22 @@ async function removeDbFiles(): Promise<void> {
 
 function buildToolServer() {
   const server = new McpServer({ name: "extensions-mcp-tools", version: "1" });
+  registerExtensionDeleteTool(server);
+  registerExtensionEnableTool(server);
+  registerExtensionDisableTool(server);
+  registerExtensionActivateVersionTool(server);
   registerExtensionInstallTool(server);
   registerExtensionListTool(server);
   const tools = (server as unknown as { _registeredTools: Record<string, RegisteredTool> })
     ._registeredTools;
-  return { install: tools["extension-install"]!, list: tools["extension-list"]! };
+  return {
+    install: tools["extension-install"]!,
+    list: tools["extension-list"]!,
+    enable: tools["extension-enable"]!,
+    disable: tools["extension-disable"]!,
+    activate: tools["extension-activate-version"]!,
+    delete: tools["extension-delete"]!,
+  };
 }
 
 function meta(agentId: string) {
@@ -128,6 +144,7 @@ beforeAll(async () => {
 });
 
 afterAll(async () => {
+  await stopExtensionRuntime();
   globalThis.fetch = savedFetch;
   closeDb();
   await removeDbFiles();
@@ -142,11 +159,12 @@ afterAll(async () => {
 });
 
 beforeEach(async () => {
+  await stopExtensionRuntime();
   await getDbClient().run("DELETE FROM extensions");
 });
 
 describe("extension MCP HTTP proxy tools", () => {
-  test("script SDK typechecks extension install and list calls", async () => {
+  test("script SDK typechecks the full extension lifecycle", async () => {
     const result = await typecheckScript(`
       import type { ScriptContext } from "swarm-sdk";
       export default async (_args: unknown, ctx: ScriptContext) => {
@@ -154,6 +172,11 @@ describe("extension MCP HTTP proxy tools", () => {
           manifest: {},
           files: { "hooks.ts": "export default () => {}" },
         });
+        const id = "00000000-0000-4000-8000-000000000001";
+        await ctx.swarm.extension_enable({ id });
+        await ctx.swarm.extension_activate_version({ id, version: 1 });
+        await ctx.swarm.extension_disable({ id });
+        await ctx.swarm.extension_delete({ id });
         return await ctx.swarm.extension_list({ enabledOnly: true });
       };
     `);
@@ -243,3 +266,88 @@ describe("extension MCP HTTP proxy tools", () => {
     expect(enabledOnly.structuredContent).toMatchObject({ success: true, extensions: [] });
   });
 });
+
+describe("extension lifecycle MCP tools", () => {
+  test("lead enables, activates, disables, and deletes through the shared HTTP routes", async () => {
+    const tools = buildToolServer();
+    const installed = (await tools.install.handler(
+      await loadBundleFixture("minimal"),
+      meta(leadId),
+    )) as ToolResult;
+    const id = String(installed.structuredContent.id);
+    const enabled = (await tools.enable.handler({ id }, meta(leadId))) as ToolResult;
+    expect(enabled.structuredContent).toMatchObject({
+      success: true,
+      enabled: true,
+      activeVersion: 1,
+    });
+
+    const rejected = await dispatchExtensionsApi(`${API_URL}/api/extensions/${id}`, {
+      method: "DELETE",
+      headers: { "x-agent-id": leadId, authorization: `Bearer ${API_KEY}` },
+    });
+    expect(rejected.status).toBe(409);
+    const blocked = (await tools.delete.handler({ id }, meta(leadId))) as ToolResult;
+    expect(blocked.isError).toBe(true);
+    expect(blocked.structuredContent).toMatchObject({ success: false });
+    expect(blocked.content[0]?.text).toContain("Disable");
+    expect(await getExtensionById(id)).not.toBeNull();
+
+    const changed = await loadBundleFixture("minimal");
+    changed.files["hooks.ts"] += "\n// next lifecycle version\n";
+    await tools.install.handler(changed, meta(leadId));
+    const activated = (await tools.activate.handler(
+      { id, version: 2 },
+      meta(leadId),
+    )) as ToolResult;
+    expect(activated.structuredContent).toMatchObject({
+      success: true,
+      activeVersion: 2,
+      enabled: true,
+    });
+    const disabled = (await tools.disable.handler({ id }, meta(leadId))) as ToolResult;
+    expect(disabled.structuredContent).toMatchObject({ success: true, enabled: false });
+    const deleted = (await tools.delete.handler({ id }, meta(leadId))) as ToolResult;
+    expect(deleted.isError).toBe(false);
+    expect(deleted.structuredContent).toMatchObject({ success: true, id, deleted: true });
+    expect(await getExtensionById(id)).toBeNull();
+  });
+
+  test("workers cannot mutate the extension lifecycle", async () => {
+    const tools = buildToolServer();
+    const installed = (await tools.install.handler(
+      await loadBundleFixture("minimal"),
+      meta(leadId),
+    )) as ToolResult;
+    const id = String(installed.structuredContent.id);
+    for (const tool of [tools.enable, tools.disable, tools.activate, tools.delete]) {
+      const result = (await tool.handler({ id, version: 1 }, meta(workerId))) as ToolResult;
+      expect(result.isError).toBe(true);
+      expect(String(result.structuredContent.message)).toContain("Forbidden");
+    }
+    expect(await getExtensionById(id)).toMatchObject({ enabled: false, activeVersion: 1 });
+  });
+
+  test("missing extensions and versions return error envelopes", async () => {
+    const tools = buildToolServer();
+    const id = crypto.randomUUID();
+    for (const tool of [tools.enable, tools.disable, tools.activate, tools.delete]) {
+      const result = (await tool.handler({ id, version: 1 }, meta(leadId))) as ToolResult;
+      expect(result.isError).toBe(true);
+      expect(result.structuredContent.success).toBe(false);
+    }
+    const installed = (await tools.install.handler(
+      await loadBundleFixture("minimal"),
+      meta(leadId),
+    )) as ToolResult;
+    const result = (await tools.activate.handler(
+      { id: installed.structuredContent.id, version: 99 },
+      meta(leadId),
+    )) as ToolResult;
+    expect(result.isError).toBe(true);
+    expect(await getExtensionById(String(installed.structuredContent.id))).toMatchObject({
+      activeVersion: 1,
+      enabled: false,
+    });
+  });
+});

package/src/tests/fixtures/store-progress-malformed-output.json

@@ -0,0 +1,4 @@
+{
+  "sourceTaskId": "59811b57-05d4-47d1-9691-ad9013698a0a",
+  "output": "Replied in the thread: https://x.com/desplegalabs/status/2100595056939827590\n\nBuilt what Guli said nobody had shown and Jan asked to use: `jev-lead-qualifier`, a global swarm script anyone can drop into their own swarm, plus a live demo — https://api.desplega.agent-swarm.dev/p/556b11781dbb40bf9b1eb1b3315adae6\n\nIt scores ICP fit / intent / authority / urgency as calibrated Jev probabilities and abstains to human_review when genuinely unsure. Money shot: the student \"free trial\" lead reads 0.63 intent, 0.03 fit — eager, not a customer.\n\nOne cosmetic miss: X auto-prepends thread handles, so @ironcarbs and @GuliMoreno render twice. Not deleting a live post over it; say the word if you want it reposted clean.</output>\n<parameter name=\"attachments\">[{\"kind\": \"url\", \"url\": \"https://x.com/desplegalabs/status/2100595056939827590\", \"name\": \"X reply in the Jev thread\", \"description\": \"The @desplegalabs reply to @voidisomorphism tagging @ironcarbs and @GuliMoreno\", \"intent\": \"The deliverable Taras asked for: reply in that thread @ jan and guli\", \"isPrimary\": true}, {\"kind\": \"url\", \"url\": \"https://api.desplega.agent-swarm.dev/p/556b11781dbb40bf9b1eb1b3315adae6\", \"name\": \"Lead qualifier demo page\", \"description\": \"Public demo: 8 leads scored live, abstain band explained, copy-paste block to run it in your own swarm\", \"intent\": \"The demo Jan asked to see and the link the tweet points at\"}]"
+}

package/src/tests/rbac-admission-e2e.test.ts

@@ -13,13 +13,12 @@ import { join } from "node:path";
 import {
   api,
   makeScratchDir,
-  readAuditRows,
   registerAgent,
   removeScratchDir,
   type SwarmServer,
   spawnSwarmServer,
   WORKER_A,
-  waitForAuditCount,
+  waitForAuditRows,
 } from "./rbac-e2e-helpers";
 
 setDefaultTimeout(120_000);
@@ -358,8 +357,40 @@ describe("RBAC admission over real HTTP", () => {
     });
     expect(operatorCreate.status).toBe(201);
 
-    expect(await waitForAuditCount(dbPath, 2)).toBeGreaterThanOrEqual(2);
-    const userHttpRows = readAuditRows(dbPath).filter(
+    const userHttpRows = (
+      await waitForAuditRows(dbPath, (rows) => {
+        const userRows = rows.filter(
+          (row) =>
+            row.principalType === "user" &&
+            row.principalId === userId &&
+            row.source === "http" &&
+            row.resourceType === "http-route",
+        );
+        return (
+          [
+            "GET /api/agents/{id}/mcp-servers",
+            "GET /api/scripts/{id}/apis/{endpointId}/secret",
+            "PATCH /api/assets/app/{id}/key",
+            "POST /api/scripts/{id}/apis",
+            "POST /api/tasks",
+          ].every((resourceId) =>
+            userRows.some((row) => row.resourceId === resourceId && row.decision === "deny"),
+          ) &&
+          userRows.some(
+            (row) =>
+              row.resourceId === "PUT /api/favorites" &&
+              row.verb === "favorite.write.own" &&
+              row.decision === "allow",
+          ) &&
+          userRows.some(
+            (row) =>
+              row.resourceId === "PATCH /api/assets/app/{id}/key" &&
+              row.verb === "app.manage" &&
+              row.decision === "allow",
+          )
+        );
+      })
+    ).filter(
       (row) =>
         row.principalType === "user" &&
         row.principalId === userId &&

package/src/tests/rbac-e2e-helpers.ts

@@ -314,3 +314,21 @@ export async function waitForAuditCount(
   }
   return n;
 }
+
+/** Poll until audit rows satisfy `predicate` (writer flushes every 2s). */
+export async function waitForAuditRows(
+  dbPath: string,
+  predicate: (rows: AuditRow[]) => boolean,
+  deadlineMs = 8_000,
+): Promise<AuditRow[]> {
+  const start = Date.now();
+  let rows = readAuditRows(dbPath);
+  while (!predicate(rows)) {
+    if (Date.now() - start >= deadlineMs) {
+      throw new Error(`audit rows did not satisfy predicate within ${deadlineMs}ms`);
+    }
+    await Bun.sleep(250);
+    rows = readAuditRows(dbPath);
+  }
+  return rows;
+}

package/src/tests/rbac-engine.test.ts

@@ -81,8 +81,8 @@ const LEAD_ONLY_VERBS: PermissionVerb[] = [
   "script.api.delete",
 ];
 
-const OPERATOR_ONLY_VERBS: PermissionVerb[] = ["extension.activate"];
-const LEAD_OR_OPERATOR_VERBS: PermissionVerb[] = ["extension.write"];
+const OPERATOR_ONLY_VERBS: PermissionVerb[] = [];
+const LEAD_OR_OPERATOR_VERBS: PermissionVerb[] = ["extension.write", "extension.activate"];
 
 const LEAD_OR_RESOURCE_OWNER_VERBS: PermissionVerb[] = [
   "memory.edit.any",

package/src/tests/rbac-mcp-admission-e2e.test.ts

@@ -12,12 +12,11 @@ import {
   countAuditRows,
   LEAD,
   makeScratchDir,
-  readAuditRows,
   registerAgent,
   removeScratchDir,
   type SwarmServer,
   spawnSwarmServer,
-  waitForAuditCount,
+  waitForAuditRows,
 } from "./rbac-e2e-helpers";
 
 setDefaultTimeout(120_000);
@@ -312,8 +311,27 @@ describe("RBAC admission over /mcp-user", () => {
       }),
     );
 
-    expect(await waitForAuditCount(enabledDbPath, 10)).toBeGreaterThanOrEqual(10);
-    const mcpRows = readAuditRows(enabledDbPath).filter((row) => row.source === "mcp");
+    const mcpRows = (
+      await waitForAuditRows(enabledDbPath, (rows) => {
+        const auditRows = rows.filter((row) => row.source === "mcp");
+        return (
+          auditRows.some(
+            (row) =>
+              row.principalId === requester.userId &&
+              row.resourceType === "mcp-tool" &&
+              row.resourceId === "send-task" &&
+              row.verb === "task.create.own" &&
+              row.decision === "allow",
+          ) &&
+          ["task.create.own", "task.cancel.own", "task.action.own"].every((verb) =>
+            auditRows.some(
+              (row) =>
+                row.principalId === empty.userId && row.decision === "deny" && row.verb === verb,
+            ),
+          )
+        );
+      })
+    ).filter((row) => row.source === "mcp");
     expect(
       mcpRows.some(
         (row) =>

package/src/tests/reload-config.test.ts

@@ -227,6 +227,23 @@ describe("reload-config", () => {
     }
   });
 
+  test("stored lead activation gate cannot override the deployment at boot or reload", async () => {
+    const key = "EXTENSION_ALLOW_LEAD_ACTIVATION";
+    const original = process.env[key];
+    const rowId = await insertLegacyReservedRow(key, "true");
+    try {
+      process.env[key] = "false";
+      for (const override of [false, true]) {
+        expect(await loadGlobalConfigsIntoEnv(override)).not.toContain(key);
+        expect(process.env[key]).toBe("false");
+      }
+    } finally {
+      await deleteSwarmConfig(rowId);
+      if (original === undefined) delete process.env[key];
+      else process.env[key] = original;
+    }
+  });
+
   test("loadGlobalConfigsIntoEnv skips unreadable reserved secret rows before decrypting them", async () => {
     const id = await insertUnreadableReservedSecretRow("SECRETS_ENCRYPTION_KEY");
 

package/src/tests/scripts-only-gating.test.ts

@@ -17,6 +17,10 @@ import { listenOnFreePort } from "./test-net";
 
 const TEST_DB_PATH = "./test-scripts-only-gating.sqlite";
 const SCRIPT_TOOL_NAMES = [
+  "extension-delete",
+  "extension-enable",
+  "extension-disable",
+  "extension-activate-version",
   "extension-install",
   "extension-list",
   "get-script-run",

package/src/tests/slack-render-v2.test.ts

@@ -1789,7 +1789,7 @@ describe("Slack renderer v2", () => {
     expect(outcome?.finalizedAt).toBeDefined();
   });
 
-  test("keeps a deferral's human-facing line even when the agent already sent a slack-reply", async () => {
+  test("omits the deferral ETA even when the agent already sent a slack-reply", async () => {
     const lead = await createAgent({ name: "Deferring Lead", isLead: true, status: "idle" });
     const { channelId, threadTs } = uniqueSlackAddress("C_RENDER_DEFER_AFTER_REPLY");
     const ask = await createTaskExtended("defer after replying by hand", {
@@ -1814,10 +1814,32 @@ describe("Slack renderer v2", () => {
     await processSlackRenderV2();
 
     const started = calls.find((call) => call.method === "chat.startStream");
-    expect(started?.payload.markdown_text).toBe(`✅\n\n${deferralLine}`);
+    expect(started?.payload.markdown_text).toBe("✅\n\nPending: checking the new defer card");
+    expect(JSON.stringify(calls)).not.toContain("17:30:19");
+    expect(JSON.stringify(calls)).not.toContain("Deferred until");
+    expect((await getTaskById(ask.id))?.output).toBe(deferralLine);
     expect(started?.payload.markdown_text).not.toBe(`✅ ${lead.name} completed`);
   });
 
+  test("does not post an ETA-only deferral notice", async () => {
+    const { channelId, threadTs } = uniqueSlackAddress("C_ETA_ONLY");
+    const ask = await createTaskExtended("wait", {
+      source: "slack",
+      slackChannelId: channelId,
+      slackThreadTs: threadTs,
+    });
+    await startTask(ask.id);
+    await completeTask(
+      ask.id,
+      "Deferred until today 17:30 UTC ([12345678](https://example.com/schedules/12345678)) -> ",
+      { addTags: ["deferred"] },
+    );
+    calls.length = 0;
+    await processSlackRenderV2();
+    expect(calls.filter((call) => call.method === "chat.startStream")).toHaveLength(0);
+    expect(JSON.stringify(calls)).not.toContain("17:30");
+  });
+
   test("refreshes a stream started with stale content before finalizing it", async () => {
     const lead = await createAgent({ name: "Refresh Lead", isLead: true, status: "idle" });
     const { channelId, threadTs } = uniqueSlackAddress("C_RENDER_REFRESH_STALE");

package/src/tests/slack-task-output.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, test } from "bun:test";
+import { slackTaskOutput } from "../slack/task-output";
+
+const task = {
+  status: "completed" as const,
+  tags: ["deferred"],
+  output:
+    "Deferred until tomorrow 17:30 UTC ([12345678](https://example.com/schedules/12345678)) -> check the build",
+};
+
+describe("Slack deferral output", () => {
+  test("keeps the pending work without the ETA or schedule link", () => {
+    expect(slackTaskOutput(task)).toBe("Pending: check the build");
+    expect(task.output).toContain("tomorrow 17:30 UTC");
+  });
+
+  test("removes an ETA-only line and preserves punctuation in the pending description", () => {
+    expect(slackTaskOutput({ ...task, output: task.output.replace("check the build", "") })).toBe(
+      "",
+    );
+    expect(slackTaskOutput({ ...task, output: `${task.output} (CI) -> deploy` })).toBe(
+      "Pending: check the build (CI) -> deploy",
+    );
+  });
+
+  test("preserves final continuation results even with inherited deferred tags", () => {
+    expect(slackTaskOutput({ ...task, output: "Build passed." })).toBe("Build passed.");
+  });
+
+  test("preserves schema output and non-deferral output verbatim", () => {
+    expect(slackTaskOutput({ ...task, outputSchema: { type: "string" } })).toBe(task.output);
+    expect(slackTaskOutput({ ...task, tags: [] })).toBe(task.output);
+    expect(slackTaskOutput({ ...task, status: "in_progress" })).toBe(task.output);
+    expect(slackTaskOutput({ ...task, output: undefined })).toBeUndefined();
+  });
+});

package/src/tests/store-progress-attachments-handler.test.ts

@@ -17,7 +17,7 @@
  *      org/drive and credentials
  *   4. missing files and wrong drives both block attachment + task writes
  */
-import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { afterAll, beforeAll, describe, expect, spyOn, test } from "bun:test";
 import crypto from "node:crypto";
 import { unlink } from "node:fs/promises";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -34,6 +34,7 @@ import {
   upsertSwarmConfig,
 } from "../be/db";
 import { registerStoreProgressTool } from "../tools/store-progress";
+import malformedOutput from "./fixtures/store-progress-malformed-output.json";
 
 const TEST_DB_PATH = "./test-store-progress-attachments-handler.sqlite";
 const ORIGINAL_FETCH = globalThis.fetch;
@@ -137,6 +138,104 @@ describe("store-progress handler — attachments insert path", () => {
     };
   }
 
+  test("salvages the literal 59811b57 output and registers both URL attachments", async () => {
+    const task = await createTaskExtended("salvage leaked tool parameters", { agentId });
+    await startTask(task.id);
+    const result = (await buildServer().handler(
+      { taskId: task.id, status: "completed", output: malformedOutput.output },
+      buildMeta(),
+    )) as StoreProgressResult;
+
+    expect(result.structuredContent.success).toBe(true);
+    const saved = await getTaskById(task.id);
+    expect(saved?.output).toBe(malformedOutput.output.split("</output>")[0]);
+    expect(saved?.output?.endsWith("reposted clean.")).toBe(true);
+    const attachments = await getTaskAttachments(task.id);
+    expect(attachments).toHaveLength(2);
+    expect(attachments.every((a) => a.kind === "url")).toBe(true);
+    expect(attachments.map((a) => a.url).sort()).toEqual([
+      "https://api.desplega.agent-swarm.dev/p/556b11781dbb40bf9b1eb1b3315adae6",
+      "https://x.com/desplegalabs/status/2100595056939827590",
+    ]);
+    expect(attachments.find((a) => a.isPrimary)?.name).toBe("X reply in the Jev thread");
+  });
+
+  test("preserves clean output byte-for-byte", async () => {
+    const output = "The output is ready: 2 < 3.\n  Keep this whitespace.  ";
+    const task = await createTaskExtended("clean output control", { agentId });
+    await startTask(task.id);
+    const result = (await buildServer().handler(
+      { taskId: task.id, status: "completed", output },
+      buildMeta(),
+    )) as StoreProgressResult;
+    expect(result.structuredContent.success).toBe(true);
+    expect((await getTaskById(task.id))?.output).toBe(output);
+    expect(await getTaskAttachments(task.id)).toHaveLength(0);
+  });
+
+  test.each([
+    ["invalid JSON", '</output>\n<parameter name="attachments">[broken'],
+    ["invalid attachment schema", '</output><parameter name="attachments">[{"kind":"url"}]'],
+    ["unknown parameter", '</output><parameter name="status">"failed"'],
+    ["alternate closing tag", '</parameter>\n<parameter name="progress">Not JSON'],
+    ["bare opener", '<parameter name="progress">Not JSON'],
+    ["non-array JSON", '</output><parameter name="attachments">null'],
+  ])("strips %s without losing the clean result", async (_name, tail) => {
+    const task = await createTaskExtended("unrecoverable tail", { agentId });
+    await startTask(task.id);
+    const warning = spyOn(console, "warn").mockImplementation(() => {});
+    try {
+      const result = (await buildServer().handler(
+        { taskId: task.id, status: "completed", output: `Clean result.${tail}` },
+        buildMeta(),
+      )) as StoreProgressResult;
+      expect(result.structuredContent.success).toBe(true);
+      expect((await getTaskById(task.id))?.output).toBe("Clean result.");
+      expect((await getTaskById(task.id))?.status).toBe("completed");
+      expect(await getTaskAttachments(task.id)).toHaveLength(0);
+      expect(warning).toHaveBeenCalledTimes(1);
+      expect(warning.mock.calls[0]?.[0]).not.toContain(tail);
+    } finally {
+      warning.mockRestore();
+    }
+  });
+
+  test("appends recovered pointers to explicit attachments through the normal dedupe path", async () => {
+    const task = await createTaskExtended("mixed explicit and leaked attachments", { agentId });
+    await startTask(task.id);
+    const attachment = { kind: "url", name: "link", url: "https://example.com/link" };
+    const result = (await buildServer().handler(
+      {
+        taskId: task.id,
+        status: "completed",
+        output: `Done.<parameter name="attachments">${JSON.stringify([attachment])}</parameter>`,
+        attachments: [attachment],
+      },
+      buildMeta(),
+    )) as StoreProgressResult;
+    expect(result.structuredContent.success).toBe(true);
+    expect((await getTaskById(task.id))?.output).toBe("Done.");
+    expect(await getTaskAttachments(task.id)).toHaveLength(1);
+  });
+
+  test("recovered agent-fs pointers still require ordinary scope verification", async () => {
+    const task = await createTaskExtended("verify recovered pointer", { agentId });
+    await startTask(task.id);
+    const result = (await buildServer().handler(
+      {
+        taskId: task.id,
+        status: "completed",
+        output:
+          'Done.</output><parameter name="attachments">[{"kind":"agent-fs","name":"missing.md","path":"/missing.md"}]',
+      },
+      buildMeta(),
+    )) as StoreProgressResult;
+    expect(result.structuredContent.success).toBe(false);
+    expect(result.structuredContent.message).toContain("both orgId and driveId must resolve");
+    expect((await getTaskById(task.id))?.status).toBe("in_progress");
+    expect(await getTaskAttachments(task.id)).toHaveLength(0);
+  });
+
   test("inserts attachment row on an in-progress task (baseline)", async () => {
     const task = await createTaskExtended("handler in-progress baseline", {
       agentId,

package/src/tests/swarm-config-reserved-keys.test.ts

@@ -134,7 +134,12 @@ describe("swarm-config reserved keys guard", () => {
     await unlink(`${TEST_DB_PATH}-shm`).catch(() => {});
   });
 
-  for (const key of ["CORS_ALLOW_ANY_ORIGIN", "cors_allow_any_origin"]) {
+  for (const key of [
+    "CORS_ALLOW_ANY_ORIGIN",
+    "cors_allow_any_origin",
+    "EXTENSION_ALLOW_LEAD_ACTIVATION",
+    "extension_allow_lead_activation",
+  ]) {
     test(`rejects deployment-only ${key} through DB, HTTP, and MCP`, async () => {
       const config = { scope: "global" as const, key, value: "true" };
       await expect(upsertSwarmConfig(config)).rejects.toThrow(EXPECTED_MESSAGE(key));

package/src/tests/tool-annotations.test.ts

@@ -378,7 +378,7 @@ describe("Tool Annotations & Classification", () => {
     // Includes 11 skill tools, 7 MCP server tools, reusable script tools, and the
     // native Kapso/WhatsApp tools (register/unregister number + send/reply message).
     expect(count).toBeGreaterThanOrEqual(45);
-    expect(count).toBeLessThanOrEqual(143);
+    expect(count).toBeLessThanOrEqual(147);
   });
 
   test("core tools are fewer than deferred tools", () => {

package/src/tools/extension-activate-version.ts

@@ -0,0 +1,38 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as z from "zod";
+import { createToolRegistrar, toolOk } from "@/tools/utils";
+import {
+  coerceExtensionSummary,
+  extensionToolOutputSchema,
+  proxyExtensionsApi,
+} from "./extension-common";
+
+export const registerExtensionActivateVersionTool = (server: McpServer) => {
+  createToolRegistrar(server)(
+    "extension-activate-version",
+    {
+      title: "Extension Activate Version",
+      description:
+        "Activate a stored extension version, reloading it if enabled. Requires a lead, operator, or dashboard user.",
+      annotations: { openWorldHint: false },
+      inputSchema: z
+        .object({
+          id: z.string().uuid().describe("Installed extension ID from extension-list."),
+          version: z.number().int().min(1).describe("Stored version number to activate."),
+        })
+        .strict(),
+      outputSchema: extensionToolOutputSchema,
+    },
+    async (args, requestInfo) =>
+      proxyExtensionsApi({
+        method: "POST",
+        path: `/api/extensions/${args.id}/activate-version`,
+        body: { version: args.version },
+        requestInfo,
+        success: (data) =>
+          toolOk("Extension activated.", {
+            data: coerceExtensionSummary((data as { extension?: unknown }).extension),
+          }),
+      }),
+  );
+};

package/src/tools/extension-common.ts

@@ -26,6 +26,7 @@ export const extensionToolOutputSchema = swarmToolOutputSchema({
   priority: z.number().optional(),
   consecutiveFailures: z.number().optional(),
   contentDeduped: z.boolean().optional(),
+  deleted: z.boolean().optional(),
   extensions: z.array(extensionListItemSchema).optional(),
 });
 
@@ -61,7 +62,7 @@ function renderDiagnostics(data: unknown): string | undefined {
 }
 
 export async function proxyExtensionsApi<T>(args: {
-  method: "GET" | "POST";
+  method: "GET" | "POST" | "DELETE";
   path: string;
   body?: unknown;
   requestInfo: RequestInfo;

package/src/tools/extension-delete.ts

@@ -0,0 +1,29 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as z from "zod";
+import { createToolRegistrar, toolOk } from "@/tools/utils";
+import { extensionToolOutputSchema, proxyExtensionsApi } from "./extension-common";
+
+export const registerExtensionDeleteTool = (server: McpServer) => {
+  createToolRegistrar(server)(
+    "extension-delete",
+    {
+      title: "Extension Delete",
+      description:
+        "Uninstall a disabled extension and delete its stored history. Disable it first with extension-disable. Requires a lead, operator, or dashboard user.",
+      annotations: { openWorldHint: false, destructiveHint: true },
+      inputSchema: z
+        .object({
+          id: z.string().uuid().describe("Installed extension ID from extension-list."),
+        })
+        .strict(),
+      outputSchema: extensionToolOutputSchema,
+    },
+    async (args, requestInfo) =>
+      proxyExtensionsApi({
+        method: "DELETE",
+        path: `/api/extensions/${args.id}`,
+        requestInfo,
+        success: () => toolOk("Extension deleted.", { data: { id: args.id, deleted: true } }),
+      }),
+  );
+};