@desplega.ai/agent-swarm 1.151.0 → 1.152.0

package/src/slack/render-v2.ts

@@ -44,6 +44,7 @@ import {
 import { buildAskClosure, type ClosureState, closureState } from "./closure";
 import { reactionName, type SlackReactionEvent } from "./reaction-shortcode";
 import { getAgentDisplayName, getAgentEmoji } from "./responses";
+import { isSlackEtaOnlyNotice, slackTaskOutput } from "./task-output";
 
 const TREE_UPDATE_DEBOUNCE_MS = 500;
 const TREE_UPDATE_MIN_INTERVAL_MS = 3_000;
@@ -757,7 +758,7 @@ async function outcomeContent(task: AgentTask, slackReplySent: boolean): Promise
       : "Agent";
     return `✅ ${agentName} completed`;
   }
-  return `✅\n\n${outcomeText(task.output, "Task completed.")}`;
+  return `✅\n\n${outcomeText(slackTaskOutput(task), "Task completed.")}`;
 }
 
 async function agentDisplayNameFor(task: AgentTask): Promise<string> {
@@ -786,7 +787,7 @@ export async function childOutcomeContent(
   if (slackReplySent && !task.tags?.includes("deferred")) {
     return `↳ ✅ ${agentName} completed`;
   }
-  return `↳ ✅ ${agentName} — result\n\n${outcomeText(task.output, "Task completed.")}`;
+  return `↳ ✅ ${agentName} — result\n\n${outcomeText(slackTaskOutput(task), "Task completed.")}`;
 }
 
 // A deferred wake continues a human conversation even though the scheduler
@@ -808,6 +809,7 @@ function isSlackContinuation(task: AgentTask): boolean {
  */
 function isChildCardCandidate(task: AgentTask, delegationActivatedAt: string): boolean {
   return (
+    !isSlackEtaOnlyNotice(task) &&
     task.source !== "slack" &&
     !isSlackContinuation(task) &&
     !!task.slackChannelId &&
@@ -821,6 +823,7 @@ function isChildCardCandidate(task: AgentTask, delegationActivatedAt: string): b
 
 function taskNeedsDirectOutcome(task: AgentTask, activatedAt: string): boolean {
   return (
+    !isSlackEtaOnlyNotice(task) &&
     ((task.source === "slack" && isAskOutcomeStatus(task.status)) ||
       (isSlackContinuation(task) && isOutcomeStatus(task.status))) &&
     task.createdAt >= activatedAt
@@ -839,7 +842,7 @@ async function conclusionResultsLines(closure: AgentTask[]): Promise<string[]> {
   const lines: string[] = [];
   for (const member of closure) {
     if (member.taskType === "follow-up" || member.taskType === "reroute-decision") continue;
-    if (!isOutcomeStatus(member.status)) continue;
+    if (!isOutcomeStatus(member.status) || isSlackEtaOnlyNotice(member)) continue;
     const glyph = await taskStateGlyph(member, new Date());
     const agentName = await agentDisplayNameFor(member);
     const card = await getSlackOutcomeMessage(member.id);
@@ -847,7 +850,10 @@ async function conclusionResultsLines(closure: AgentTask[]): Promise<string[]> {
       lines.push(`↳ ${glyph} ${agentName} — ${card.permalink}`);
       continue;
     }
-    const raw = outcomeText(member.status === "failed" ? member.failureReason : member.output, "");
+    const raw = outcomeText(
+      member.status === "failed" ? member.failureReason : slackTaskOutput(member),
+      "",
+    );
     const digest =
       raw.length > CONCLUSION_DIGEST_LENGTH
         ? `${raw.slice(0, CONCLUSION_DIGEST_LENGTH).trimEnd()}…`

package/src/slack/responses.ts

@@ -15,6 +15,7 @@ import {
   markdownToSlack,
   splitSlackSectionText,
 } from "./blocks";
+import { isSlackEtaOnlyNotice, slackTaskOutput } from "./task-output";
 
 // Re-export for backward compatibility
 export { markdownToSlack } from "./blocks";
@@ -56,7 +57,7 @@ export function shouldPostInlineCompletionOutput(task: AgentTask): boolean {
   if (!task.slackChannelId || !task.slackThreadTs) return false;
   if (task.slackReplySent) return false;
 
-  const output = task.output?.trim();
+  const output = slackTaskOutput(task)?.trim();
   return !!output && isTreeOutputTruncated(markdownToSlack(output));
 }
 
@@ -85,7 +86,7 @@ export async function sendInlineTaskOutput(task: AgentTask): Promise<boolean> {
   const chunks = formatInlineCompletionOutputChunks({
     agentName: agent.name,
     taskId: task.id,
-    output: task.output,
+    output: slackTaskOutput(task) ?? "",
   });
 
   try {
@@ -115,6 +116,7 @@ export async function sendInlineTaskOutput(task: AgentTask): Promise<boolean> {
  * Send a task completion message to Slack with the agent's persona.
  */
 export async function sendTaskResponse(task: AgentTask): Promise<boolean> {
+  if (isSlackEtaOnlyNotice(task)) return true;
   const app = getSlackApp();
   if (!app || !task.slackChannelId || !task.slackThreadTs) {
     return false;
@@ -136,7 +138,7 @@ export async function sendTaskResponse(task: AgentTask): Promise<boolean> {
 
   try {
     if (task.status === "completed") {
-      const output = task.output || "Task completed.";
+      const output = slackTaskOutput(task) || "Task completed.";
       const slackOutput = markdownToSlack(output);
       const attachmentsBlock = formatAttachmentsBlockForSlack(await getTaskAttachments(task.id));
       const body = slackOutput + attachmentsBlock;
@@ -285,6 +287,7 @@ export async function updateToFinal(
   task: AgentTask,
   messageTs: string,
 ): Promise<SlackUpdateResult> {
+  if (isSlackEtaOnlyNotice(task)) return "ok";
   const app = getSlackApp();
   if (!app || !task.slackChannelId || !task.agentId) return "failed";
 
@@ -297,7 +300,7 @@ export async function updateToFinal(
   let completionBlockBatches: unknown[][] | undefined;
 
   if (task.status === "completed") {
-    const output = task.output || "Task completed.";
+    const output = slackTaskOutput(task) || "Task completed.";
     const slackOutput = markdownToSlack(output);
     const attachmentsBlock = formatAttachmentsBlockForSlack(await getTaskAttachments(task.id));
     const body = slackOutput + attachmentsBlock;

package/src/slack/task-output.ts

@@ -0,0 +1,21 @@
+import type { AgentTask } from "../types";
+
+/** Keep the stored deferral ETA for task details, but omit it from Slack. */
+export function slackTaskOutput(
+  task: Pick<AgentTask, "output" | "tags" | "outputSchema" | "status">,
+): string | undefined {
+  const output = task.output ?? undefined;
+  if (task.status !== "completed" || task.outputSchema || !task.tags?.includes("deferred")) {
+    return output;
+  }
+  // Only match the engine-authored line from defer-task, not continuation results.
+  const notice = output?.match(/^Deferred until [^\n]+? \([^\n]+?\) -> (.*)$/);
+  if (!notice) return output;
+  const pending = notice[1]?.trim();
+  return pending ? `Pending: ${pending}` : "";
+}
+
+/** An ETA-only notice has no useful content left to post. */
+export function isSlackEtaOnlyNotice(task: AgentTask): boolean {
+  return !!task.output && slackTaskOutput(task) === "";
+}

package/src/slack/watcher.ts

@@ -28,6 +28,7 @@ import {
   updateToFinal,
   updateTreeMessage,
 } from "./responses";
+import { slackTaskOutput } from "./task-output";
 
 let watcherInterval: ReturnType<typeof setInterval> | null = null;
 let isProcessing = false;
@@ -169,7 +170,7 @@ export async function buildTreeNodes(tree: TreeMessageState): Promise<TreeNode[]
           progress: child.progress ?? undefined,
           duration: childDuration,
           slackReplySent: child.slackReplySent,
-          output: child.output ?? undefined,
+          output: slackTaskOutput(child),
           failureReason: child.failureReason ?? undefined,
           attachments: childAttachments,
           steered: childSteered,
@@ -192,7 +193,7 @@ export async function buildTreeNodes(tree: TreeMessageState): Promise<TreeNode[]
       progress: task.progress ?? undefined,
       duration,
       slackReplySent: task.slackReplySent,
-      output: task.output ?? undefined,
+      output: slackTaskOutput(task),
       failureReason: task.failureReason ?? undefined,
       attachments: rootAttachments,
       steered: rootSteered,

package/src/slack/work-objects.ts

@@ -4,6 +4,7 @@ import { getAgentById, getTaskById } from "../be/db";
 import { isEnvFlagEnabled } from "../utils/env-flag";
 import { getTaskUrl } from "./blocks";
 import { isUserAllowed } from "./handlers";
+import { slackTaskOutput } from "./task-output";
 
 type DetailsEvent = SlackEventMiddlewareArgs<"entity_details_requested">["event"];
 type Details = Omit<EntityPresentDetailsArguments, "trigger_id" | "token">;
@@ -36,7 +37,7 @@ async function getDetails(event: DetailsEvent, client: WebClient): Promise<Detai
   if (task.slackChannelId !== event.channel) return { error: { status: "restricted" } };
 
   const agent = task.agentId ? await getAgentById(task.agentId) : null;
-  const result = task.output || task.failureReason || task.progress;
+  const result = slackTaskOutput(task) || task.failureReason || task.progress;
   return {
     metadata: {
       entity_type: "slack#/entities/task",

package/src/tests/extensions-example-mcp-install.test.ts

@@ -7,7 +7,7 @@ type RegisteredTool = {
   handler: (args: unknown, extra: unknown) => Promise<unknown>;
 };
 
-test("a lead can draft the minimal bundle while an operator retains activation", async () => {
+test("a lead installs a disabled draft with explicit activation guidance", async () => {
   const previousBaseUrl = process.env.MCP_BASE_URL;
   const previousApiKey = process.env.AGENT_SWARM_API_KEY;
   const savedFetch = globalThis.fetch;
@@ -52,7 +52,7 @@ test("a lead can draft the minimal bundle while an operator retains activation",
 
     expect(result.isError).toBe(false);
     expect(result.structuredContent).toMatchObject({ enabled: false, status: "disabled" });
-    expect(String(result.structuredContent.message)).toContain("operator must enable it");
+    expect(String(result.structuredContent.message)).toContain("extension-enable");
   } finally {
     globalThis.fetch = savedFetch;
     if (previousBaseUrl === undefined) delete process.env.MCP_BASE_URL;

package/src/tests/extensions-http.test.ts

@@ -2,11 +2,18 @@ import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:tes
 import type { IncomingMessage, ServerResponse } from "node:http";
 import { Readable } from "node:stream";
 import { closeDb, createAgent, getDbClient, initDb } from "../be/db";
-import { getExtensionByName, insertExtensionRun, setExtensionState } from "../be/extensions/db";
+import {
+  getExtensionByName,
+  insertExtensionRun,
+  listExtensionRuns,
+  setExtensionState,
+} from "../be/extensions/db";
+import { enqueueAuditRow, flushAuditBuffer } from "../be/rbac-audit";
 import { stopExtensionRuntime } from "../extensions/lifecycle";
 import { handleCore } from "../http/core";
 import { handleExtensions } from "../http/extensions";
 import { getPathSegments, parseQueryParams } from "../http/utils";
+import { clearAuditSink, setAuditSink } from "../rbac";
 import type { User } from "../types";
 import { setRequestAuth } from "../utils/request-auth-context";
 import { refreshSecretScrubberCache } from "../utils/secret-scrubber";
@@ -124,6 +131,80 @@ beforeEach(async () => {
 });
 
 describe("/api/extensions HTTP", () => {
+  test("lead activation defaults on, is attributable, and the deployment gate denies lifecycle calls", async () => {
+    const original = process.env.EXTENSION_ALLOW_LEAD_ACTIVATION;
+    const auditDisabled = process.env.RBAC_AUDIT_DISABLED;
+    delete process.env.EXTENSION_ALLOW_LEAD_ACTIVATION;
+    delete process.env.RBAC_AUDIT_DISABLED;
+    setAuditSink(enqueueAuditRow);
+    try {
+      expect((await install("minimal", leadId)).status).toBe(200);
+      const extension = (await getExtensionByName("minimal"))!;
+      const path = `/api/extensions/${extension.id}`;
+      expect((await dispatch(`${path}/enable`, { method: "POST", agentId: leadId })).status).toBe(
+        200,
+      );
+      expect(await listExtensionRuns(extension.id)).toContainEqual(
+        expect.objectContaining({
+          event: "lifecycle.enable.requested",
+          agentId: leadId,
+          version: 1,
+        }),
+      );
+      for (const operation of ["activate-version", "disable"]) {
+        expect(
+          (
+            await dispatch(`${path}/${operation}`, {
+              method: "POST",
+              agentId: leadId,
+              body: JSON.stringify({ version: 1 }),
+            })
+          ).status,
+        ).toBe(200);
+        expect(await listExtensionRuns(extension.id)).toContainEqual(
+          expect.objectContaining({
+            event: `lifecycle.${operation}.requested`,
+            agentId: leadId,
+            version: 1,
+          }),
+        );
+      }
+      for (const value of ["false", "0"]) {
+        process.env.EXTENSION_ALLOW_LEAD_ACTIVATION = value;
+        for (const operation of ["enable", "disable", "activate-version"]) {
+          expect(
+            (
+              await dispatch(`${path}/${operation}`, {
+                method: "POST",
+                agentId: leadId,
+                body: JSON.stringify({ version: 1 }),
+              })
+            ).status,
+          ).toBe(403);
+        }
+      }
+      expect((await getExtensionByName("minimal"))!.enabled).toBe(false);
+      expect((await dispatch(`${path}/enable`, { method: "POST" })).status).toBe(200);
+      expect(
+        (await dispatch(`${path}/disable`, { method: "POST", asUser: crypto.randomUUID() })).status,
+      ).toBe(200);
+      await flushAuditBuffer();
+      const decisions = await getDbClient().query<{ decision: string }>(
+        "SELECT decision FROM permission_audit WHERE verb = ? AND principalId = ?",
+        ["extension.activate", leadId],
+      );
+      expect(decisions).toContainEqual({ decision: "allow" });
+      expect(decisions).toContainEqual({ decision: "deny" });
+    } finally {
+      await flushAuditBuffer();
+      clearAuditSink();
+      if (original === undefined) delete process.env.EXTENSION_ALLOW_LEAD_ACTIVATION;
+      else process.env.EXTENSION_ALLOW_LEAD_ACTIVATION = original;
+      if (auditDisabled === undefined) delete process.env.RBAC_AUDIT_DISABLED;
+      else process.env.RBAC_AUDIT_DISABLED = auditDisabled;
+    }
+  });
+
   test("operator install, list, get, versions, and changed hooks round-trip", async () => {
     const first = await install();
     expect(first.status).toBe(200);
@@ -251,7 +332,7 @@ describe("/api/extensions HTTP", () => {
     expect((await rejected.json()).error).toContain("Disable");
   });
 
-  test("type definitions are plain text and activation routes are operator-only", async () => {
+  test("type definitions are plain text and workers cannot activate extensions", async () => {
     await install();
     const extension = await getExtensionByName("minimal");
     const types = await dispatch("/api/extensions/type-defs");
@@ -262,7 +343,7 @@ describe("/api/extensions HTTP", () => {
       (
         await dispatch(`/api/extensions/${extension!.id}/enable`, {
           method: "POST",
-          agentId: leadId,
+          agentId: workerId,
         })
       ).status,
     ).toBe(403);

package/src/tests/extensions-lead-equivalence.test.ts

@@ -28,6 +28,27 @@ describe("extension agents act with lead privileges while registered", () => {
     expect(can(check).allow).toBe(false);
   });
 
+  test("the deployment activation gate also applies to lead-equivalent identities", () => {
+    const original = process.env.EXTENSION_ALLOW_LEAD_ACTIVATION;
+    grantLeadEquivalence(extensionAgentId);
+    try {
+      const check = {
+        principal: { kind: "agent" as const, agentId: extensionAgentId, isLead: false },
+        verb: "extension.activate" as const,
+        source: "mcp" as const,
+      };
+      delete process.env.EXTENSION_ALLOW_LEAD_ACTIVATION;
+      expect(can(check).allow).toBe(true);
+      process.env.EXTENSION_ALLOW_LEAD_ACTIVATION = "false";
+      expect(can(check).allow).toBe(false);
+      expect(can({ ...check, verb: "extension.write" }).allow).toBe(true);
+    } finally {
+      revokeLeadEquivalence(extensionAgentId);
+      if (original === undefined) delete process.env.EXTENSION_ALLOW_LEAD_ACTIVATION;
+      else process.env.EXTENSION_ALLOW_LEAD_ACTIVATION = original;
+    }
+  });
+
   test("operators and plain workers are unaffected", () => {
     expect(
       can({

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) =>