@desplega.ai/agent-swarm 1.157.0 → 1.158.0

package/src/server.ts

@@ -1,9 +1,8 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import pkg from "../package.json";
+import { ensurePricingSeeded, ensureRbacSeeded } from "./be/boot-seeds";
 import { initDb } from "./be/db";
 import { startPricingRefreshLoop } from "./be/pricing-refresh";
-import { ensureRbacSeedsSynced } from "./be/rbac-roles";
-import { seedPricingFromModelsDev } from "./be/seed-pricing";
 import { isSteeringEnabled } from "./be/steering";
 import { registerGithubTaskReactions } from "./github/task-reactions";
 import { loadGlobalConfigsIntoEnv } from "./http/core";
@@ -20,6 +19,7 @@ import { registerAppQueryTool } from "./tools/app-query";
 import { registerAppRollbackTool } from "./tools/app-rollback";
 import { registerAppSyncTool } from "./tools/app-sync";
 import { registerAppUpsertTool } from "./tools/app-upsert";
+import { registerCancelApprovalRequestTool } from "./tools/cancel-approval-request";
 import { registerCancelTaskTool } from "./tools/cancel-task";
 import { registerContextDiffTool } from "./tools/context-diff";
 import { registerContextHistoryTool } from "./tools/context-history";
@@ -307,14 +307,18 @@ export async function createServer(
   initDb(process.env.DATABASE_PATH);
 
   // Phase 2: project the vendored models.dev snapshot into the pricing table.
-  // Idempotent (INSERT OR IGNORE keyed on PK with effective_from=0); safe to
-  // call on every boot. See src/be/seed-pricing.ts for the projection logic
-  // and the manual-override constants for runtime-fee / ACU pricing.
-  seedPricingFromModelsDev();
+  // Idempotent (INSERT OR IGNORE keyed on PK with effective_from=0). This runs
+  // once per database handle, not once per MCP session: the seed is a
+  // synchronous 8.6 MB parse plus a write transaction, and createServer() runs
+  // on every `POST /mcp` session init. The HTTP boot path seeds first, so
+  // sessions normally skip it; standalone callers (stdio, tests) seed here.
+  // See src/be/seed-pricing.ts for the projection logic and the
+  // manual-override constants for runtime-fee / ACU pricing.
+  ensurePricingSeeded();
   startPricingRefreshLoop();
 
   try {
-    ensureRbacSeedsSynced();
+    ensureRbacSeeded();
   } catch (err) {
     console.error("[startup] Failed to sync RBAC seed rows:", err);
     // RBAC flag-on must fail closed; flag-off deployments should not be bricked
@@ -500,6 +504,7 @@ export async function createServer(
     registerRetryWorkflowRunTool(server);
     registerCancelWorkflowRunTool(server);
     registerRequestHumanInputTool(server);
+    registerCancelApprovalRequestTool(server);
   }
 
   // Skills capability - installable skill packages (create, search, install, publish)

package/src/slack/app.ts

@@ -1,12 +1,31 @@
-import { App, LogLevel } from "@slack/bolt";
+import { App, LogLevel, SocketModeReceiver } from "@slack/bolt";
 import { emitBuiltInIntegrationConnectedOnce, ensureSlackRenderV2Activation } from "../be/db";
 import { getSlackConfiguration } from "./config";
+import { type SlackConnectionState, setSlackConnectionState } from "./connection-state";
 import { getSlackSocketModeBlockReason, SLACK_DEV_SOCKET_MODE_OPT_IN } from "./socket-mode-guard";
 import { startTaskWatcher, stopTaskWatcher } from "./watcher";
 
 let app: App | null = null;
+let receiver: SocketModeReceiver | null = null;
 let initialized = false;
 
+const SOCKET_EVENT_STATES: Record<string, SlackConnectionState> = {
+  connecting: "connecting",
+  reconnecting: "connecting",
+  connected: "connected",
+  disconnecting: "disconnected",
+  disconnected: "disconnected",
+};
+
+function trackConnectionState(owner: SocketModeReceiver): void {
+  for (const [event, state] of Object.entries(SOCKET_EVENT_STATES)) {
+    owner.client.on(event, () => {
+      // Ignore late events from a receiver that stopSlackApp() already replaced.
+      if (receiver === owner) setSlackConnectionState(state);
+    });
+  }
+}
+
 export function getSlackApp(): App | null {
   return app;
 }
@@ -59,12 +78,22 @@ export async function initSlackApp(): Promise<App | null> {
 
   // SLACK_API_URL points Bolt (Web API and apps.connections.open) at a mock Slack server for e2e tests.
   const slackApiUrl = process.env.SLACK_API_URL;
+  const clientOptions = slackApiUrl ? { slackApiUrl } : undefined;
+  const logLevel = process.env.NODE_ENV === "development" ? LogLevel.DEBUG : LogLevel.INFO;
+  // Build the receiver ourselves so its SocketModeClient lifecycle events can
+  // feed /status. Bolt would otherwise forward clientOptions via installerOptions.
+  receiver = new SocketModeReceiver({
+    appToken,
+    logLevel,
+    installerOptions: clientOptions ? { clientOptions } : {},
+  });
+  trackConnectionState(receiver);
   app = new App({
     token: botToken,
-    appToken: appToken,
+    receiver,
     socketMode: true,
-    logLevel: process.env.NODE_ENV === "development" ? LogLevel.DEBUG : LogLevel.INFO,
-    ...(slackApiUrl ? { clientOptions: { slackApiUrl } } : {}),
+    logLevel,
+    ...(clientOptions ? { clientOptions } : {}),
   });
 
   // Failed validation must remain retryable without requiring stopSlackApp().
@@ -117,5 +146,7 @@ export async function stopSlackApp(): Promise<void> {
     app = null;
     console.log("[Slack] Bot disconnected");
   }
+  receiver = null;
+  setSlackConnectionState("disconnected");
   initialized = false;
 }

package/src/slack/connection-state.ts

@@ -0,0 +1,17 @@
+/**
+ * Live Socket Mode connection state, fed by the SocketModeClient lifecycle
+ * events in `app.ts` and read by `/status` to decide whether Slack is
+ * `verified`. Kept in its own module so status code can read it without
+ * importing the Bolt app (several tests mock `./app`).
+ */
+export type SlackConnectionState = "disconnected" | "connecting" | "connected";
+
+let state: SlackConnectionState = "disconnected";
+
+export function getSlackConnectionState(): SlackConnectionState {
+  return state;
+}
+
+export function setSlackConnectionState(next: SlackConnectionState): void {
+  state = next;
+}

package/src/tasks/context-key.ts

@@ -22,6 +22,7 @@
  *   task:workflow:{workflowRunId}
  *   task:agent:{agentId}                          (KV-only: per-agent scratchpad)
  *   task:page:{pageId}                            (KV-only: per-page state, proxy-enforced)
+ *   task:ui:{kind}:{ref}:{sessionNonce}           (UI-built by the contextual session panel; no server parser)
  *
  * Rules:
  *   - Fixed prefix tokens (`task`, family, sub-family, kind) are always lowercase.

package/src/tasks/worker-follow-up.ts

@@ -524,8 +524,9 @@ export async function createResumeFollowUp(args: {
 
   // Identity-shaped fields (dir, VCS provider/repo/number/url/etc.,
   // outputSchema, slack channel/thread/user, agentmail, mention, contextKey,
-  // requestedByUserId, followUpConfig) are auto-inherited from the parent by
-  // `createTaskExtended`'s parentTaskId block (see src/be/db.ts). `model` is
+  // requestedByUserId) are auto-inherited from the parent by
+  // `createTaskExtended`'s parentTaskId block (see src/be/db.ts);
+  // followUpConfig is opt-in and set below. `model` is
   // deliberately excluded there so the resume task resolves to the claiming
   // agent's own provider/model — never the parent's concrete model string.
   // We only override what's SPECIFIC to the resume task here.
@@ -564,6 +565,9 @@ export async function createResumeFollowUp(args: {
     tags,
     priority,
     parentTaskId: parent.id,
+    // Same work, new session: the creator's onCompleted/onFailed must still
+    // fire when this resume finishes.
+    inheritParentFollowUpConfig: true,
     routingAffinity,
   });
 

package/src/tests/agent-task-activity.test.ts

@@ -0,0 +1,74 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { createServer as createHttpServer, type Server } from "node:http";
+import { closeDb, createAgent, createTaskExtended, getDbClient, initDb } from "../be/db";
+import { handleAgentsRest } from "../http/agents";
+import { listenOnFreePort } from "./test-net";
+
+const TEST_DB_PATH = "./test-agent-task-activity.sqlite";
+
+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;
+    }
+  }
+}
+
+let server: Server;
+let baseUrl = "";
+
+beforeAll(async () => {
+  await removeDbFiles(TEST_DB_PATH);
+  initDb(TEST_DB_PATH);
+  server = createHttpServer(async (req, res) => {
+    const url = new URL(req.url ?? "/", "http://localhost");
+    const segments = url.pathname.split("/").filter(Boolean);
+    if (await handleAgentsRest(req, res, segments, url.searchParams, undefined)) return;
+    res.writeHead(404).end();
+  });
+  baseUrl = `http://localhost:${await listenOnFreePort(server)}`;
+});
+
+afterAll(async () => {
+  await new Promise<void>((resolve) => server.close(() => resolve()));
+  closeDb();
+  await removeDbFiles(TEST_DB_PATH);
+});
+
+describe("GET /api/agents/:id/task-activity", () => {
+  test("counts tasks per UTC day inside the window, for that agent only", async () => {
+    const agent = await createAgent({ name: "a", isLead: false, status: "idle", capabilities: [] });
+    const other = await createAgent({ name: "b", isLead: false, status: "idle", capabilities: [] });
+    const day = (offset: number) =>
+      new Date(Date.now() - offset * 86_400_000).toISOString().slice(0, 10);
+    const stamp = async (agentId: string, date: string) => {
+      const task = await createTaskExtended("t", { agentId });
+      await getDbClient().run("UPDATE agent_tasks SET createdAt = ? WHERE id = ?", [
+        `${date}T12:00:00.000Z`,
+        task.id,
+      ]);
+    };
+    await stamp(agent.id, day(1));
+    await stamp(agent.id, day(1));
+    await stamp(agent.id, day(3));
+    await stamp(agent.id, day(40));
+    await stamp(other.id, day(1));
+
+    const res = await fetch(`${baseUrl}/api/agents/${agent.id}/task-activity?days=30`);
+    expect(res.status).toBe(200);
+    expect(await res.json()).toEqual({
+      days: [
+        { date: day(3), count: 1 },
+        { date: day(1), count: 2 },
+      ],
+    });
+  });
+
+  test("404s for an unknown agent", async () => {
+    const res = await fetch(`${baseUrl}/api/agents/nope/task-activity`);
+    expect(res.status).toBe(404);
+  });
+});

package/src/tests/agents-list-model-display.test.ts

@@ -113,6 +113,11 @@ describe("agents list model display", () => {
       provider: "Anthropic",
       providerId: "anthropic",
     });
+    expect(getAgentModelPresentation("claude-sonnet-5-5")).toMatchObject({
+      label: "Claude Sonnet 5.5",
+      provider: "Anthropic",
+      providerId: "anthropic",
+    });
     expect(getAgentModelPresentation("claude-opus-5")).toMatchObject({
       label: "Claude Opus 5",
       provider: "Anthropic",
@@ -129,7 +134,7 @@ describe("agents list model display", () => {
       providerId: "anthropic",
     });
     expect(getAgentModelPresentation("sonnet")).toMatchObject({
-      label: "Claude Sonnet 5",
+      label: "Claude Sonnet 5.5",
       provider: "Anthropic",
       providerId: "anthropic",
     });

package/src/tests/approval-auto-cancellation-migration.test.ts

@@ -0,0 +1,104 @@
+import { Database } from "bun:sqlite";
+import { afterEach, describe, expect, test } from "bun:test";
+import { runMigrations } from "../be/migrations/runner";
+
+const DB_PATH = "./test-approval-auto-cancellation-migration.sqlite";
+
+async function removeDb(): Promise<void> {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      await Bun.file(DB_PATH + suffix).delete();
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+    }
+  }
+}
+
+afterEach(removeDb);
+
+type Row = {
+  id: string;
+  status: string;
+  resolvedBy: string | null;
+  resolvedAt: string | null;
+  resolutionReason: string | null;
+};
+
+function readRows(db: Database): Row[] {
+  return db
+    .query<Row, []>(
+      "SELECT id, status, resolvedBy, resolvedAt, resolutionReason FROM approval_requests ORDER BY id",
+    )
+    .all();
+}
+
+describe("migration 166 approval auto-cancellation index", () => {
+  test("adds the pending-created index and leaves the schema and rows intact", async () => {
+    await removeDb();
+    const db = new Database(DB_PATH, { create: true });
+    try {
+      runMigrations(db);
+      // Roll the database back to the state before migration 166.
+      db.run("DROP INDEX idx_approval_requests_pending_created");
+      db.run("DELETE FROM _migrations WHERE version = 166");
+      db.run(`INSERT INTO approval_requests
+        (id, title, questions, approvers, status, resolvedBy, resolvedAt, resolutionReason,
+         expiresAt, createdAt, updatedAt)
+        VALUES
+        ('a-pending', 'Pending', '[]', '{}', 'pending', NULL, NULL, NULL,
+         NULL, '2026-01-01', '2026-01-01'),
+        ('b-cancelled', 'Cancelled', '[]', '{}', 'cancelled', NULL, '2026-01-03', 'run cancelled',
+         NULL, '2026-01-01', '2026-01-03'),
+        ('c-timeout', 'Timeout', '[]', '{}', 'timeout', NULL, '2026-01-04', NULL,
+         '2026-01-02', '2026-01-01', '2026-01-04')`);
+      const before = readRows(db);
+
+      runMigrations(db);
+
+      expect(readRows(db)).toEqual(before);
+      const indexes = db
+        .query<{ name: string }, []>(
+          "SELECT name FROM sqlite_master WHERE type = 'index' AND tbl_name = 'approval_requests'",
+        )
+        .all()
+        .map((row) => row.name);
+      expect(indexes).toEqual(
+        expect.arrayContaining([
+          "idx_approval_requests_pending_created",
+          "idx_approval_requests_status",
+          "idx_approval_requests_created",
+          "idx_approval_requests_workflow",
+          "idx_approval_requests_task",
+          "idx_approval_requests_expires",
+        ]),
+      );
+
+      const tableSql = db
+        .query<{ sql: string }, []>(
+          "SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'approval_requests'",
+        )
+        .get()?.sql;
+      expect(tableSql).toContain("'cancelled'");
+      expect(tableSql).toContain("'timeout'");
+
+      const insert = (id: string, status: string) =>
+        db.run(
+          `INSERT INTO approval_requests (id, title, questions, approvers, status)
+           VALUES (?, 't', '[]', '{}', ?)`,
+          [id, status],
+        );
+      expect(() => insert("d-cancelled", "cancelled")).not.toThrow();
+      expect(() => insert("e-timeout", "timeout")).not.toThrow();
+      expect(() => insert("f-expired", "expired")).toThrow(/CHECK/);
+
+      // Assert 166 was re-recorded, not that it is the tail: later migrations
+      // land on top of it.
+      const reapplied = db
+        .query<{ version: number }, []>("SELECT version FROM _migrations WHERE version = 166")
+        .get();
+      expect(reapplied?.version).toBe(166);
+    } finally {
+      db.close();
+    }
+  });
+});