@desplega.ai/agent-swarm 1.49.0 → 1.52.0

package/src/http/index.ts

@@ -16,6 +16,7 @@ import { startSlackApp, stopSlackApp } from "../slack";
 import { initWorkflows } from "../workflows";
 import { handleActiveSessions } from "./active-sessions";
 import { handleAgentRegister, handleAgentsRest } from "./agents";
+import { handleApprovalRequests } from "./approval-requests";
 import { handleConfig } from "./config";
 import { handleCore, loadGlobalConfigsIntoEnv } from "./core";
 import { handleDbQuery } from "./db-query";
@@ -24,9 +25,11 @@ import { handleEpics } from "./epics";
 import { handleMcp } from "./mcp";
 import { handleMemory } from "./memory";
 import { handlePoll } from "./poll";
+import { handlePromptTemplates } from "./prompt-templates";
 import { handleRepos } from "./repos";
 import { handleSchedules } from "./schedules";
 import { handleSessionData } from "./session-data";
+import { handleSkills } from "./skills";
 import { handleStats } from "./stats";
 import { handleTasks } from "./tasks";
 import { handleTrackers } from "./trackers";
@@ -91,7 +94,7 @@ const httpServer = createHttpServer(async (req, res) => {
   // ── Route handlers (order matters — first match wins) ──
   const handlers: (() => Promise<boolean>)[] = [
     () => handleAgentRegister(req, res, pathSegments, myAgentId),
-    () => handlePoll(req, res, pathSegments, myAgentId),
+    () => handlePoll(req, res, pathSegments, queryParams, myAgentId),
     () => handleSessionData(req, res, pathSegments, queryParams, myAgentId),
     () => handleEcosystem(req, res, pathSegments, myAgentId),
     () => handleTrackers(req, res, pathSegments),
@@ -103,9 +106,12 @@ const httpServer = createHttpServer(async (req, res) => {
     () => handleEpics(req, res, pathSegments, queryParams, myAgentId),
     () => handleSchedules(req, res, pathSegments, queryParams, myAgentId),
     () => handleWorkflows(req, res, pathSegments, queryParams, myAgentId),
+    () => handleApprovalRequests(req, res, pathSegments, queryParams),
     () => handleConfig(req, res, pathSegments, queryParams),
+    () => handlePromptTemplates(req, res, pathSegments, queryParams),
     () => handleDbQuery(req, res, pathSegments, queryParams),
     () => handleRepos(req, res, pathSegments, queryParams),
+    () => handleSkills(req, res, pathSegments, queryParams, myAgentId),
     () => handleMemory(req, res, pathSegments, myAgentId),
     () => handleMcp(req, res, transports),
   ];
@@ -197,8 +203,9 @@ httpServer
     // Start scheduler (if enabled)
     if (hasCapability("scheduling")) {
       const { startScheduler } = await import("../scheduler");
+      const { getExecutorRegistry } = await import("../workflows");
       const intervalMs = Number(process.env.SCHEDULER_INTERVAL_MS) || 10000;
-      startScheduler(intervalMs);
+      startScheduler(getExecutorRegistry(), intervalMs);
     }
 
     // Start heartbeat triage (unless disabled)

package/src/http/poll.ts

@@ -1,18 +1,23 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
+import { z } from "zod";
 import {
   claimMentions,
   claimOfferedTask,
+  claimTask,
   getAgentById,
+  getAllChannelActivityCursors,
   getDb,
   getEpicsWithProgressUpdates,
   getInboxSummary,
   getOfferedTasksForAgent,
   getPendingTaskForAgent,
-  getUnassignedTasksCount,
+  getUnassignedTaskIds,
   hasCapacity,
   markEpicsProgressNotified,
   startTask,
+  upsertChannelActivityCursor,
 } from "../be/db";
+import { fetchChannelActivity } from "../slack/channel-activity";
 import { route } from "./route-def";
 import { json, jsonError } from "./utils";
 
@@ -32,14 +37,56 @@ const pollTriggers = route({
   },
 });
 
+// ─── Channel Activity Throttle ──────────────────────────────────────────────
+
+const CHANNEL_ACTIVITY_INTERVAL_MS = 60_000; // Check at most once per 60s
+let lastChannelActivityCheckAt = 0;
+
+// ─── Cursor Commit Endpoint ─────────────────────────────────────────────────
+
+const commitCursorsRoute = route({
+  method: "post",
+  path: "/api/channel-activity/commit-cursors",
+  pattern: ["api", "channel-activity", "commit-cursors"],
+  summary: "Commit channel activity cursors after successful processing",
+  tags: ["Poll"],
+  auth: { apiKey: true },
+  body: z.object({
+    cursorUpdates: z.array(
+      z.object({
+        channelId: z.string(),
+        ts: z.string(),
+      }),
+    ),
+  }),
+  responses: {
+    200: { description: "Cursors committed" },
+    400: { description: "Invalid request" },
+  },
+});
+
 // ─── Handler ─────────────────────────────────────────────────────────────────
 
 export async function handlePoll(
   req: IncomingMessage,
   res: ServerResponse,
   pathSegments: string[],
+  queryParams: URLSearchParams,
   myAgentId: string | undefined,
 ): Promise<boolean> {
+  // Handle cursor commit endpoint
+  if (commitCursorsRoute.match(req.method, pathSegments)) {
+    const parsed = await commitCursorsRoute.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+    for (const { channelId, ts } of parsed.body.cursorUpdates) {
+      if (channelId && ts) {
+        upsertChannelActivityCursor(channelId, ts);
+      }
+    }
+    json(res, { success: true, committed: parsed.body.cursorUpdates.length });
+    return true;
+  }
+
   if (pollTriggers.match(req.method, pathSegments)) {
     if (!myAgentId) {
       jsonError(res, "Missing X-Agent-ID header", 400);
@@ -135,19 +182,26 @@ export async function handlePoll(
         } else {
           // === WORKER-SPECIFIC TRIGGERS ===
 
-          // Check for unassigned tasks in pool (workers can claim)
-          // NOTE: This trigger is intentionally unprotected from duplicate processing.
-          // Multiple workers should all receive this notification so they can compete
-          // to claim tasks. The actual claiming happens via task-action tool with
-          // atomic SQL guards in claimTask().
-          const unassignedCount = getUnassignedTasksCount();
-          if (unassignedCount > 0) {
-            return {
-              trigger: {
-                type: "pool_tasks_available",
-                count: unassignedCount,
-              },
-            };
+          // Auto-claim: atomically claim an unassigned task for this worker.
+          // claimTask() uses an atomic UPDATE WHERE status='unassigned', so only
+          // one worker wins if multiple poll simultaneously.
+          // This ensures session logs are correctly associated with the real task ID
+          // from the start (no reassociation needed).
+          if (hasCapacity(myAgentId)) {
+            const unassignedIds = getUnassignedTaskIds(5);
+            for (const candidateId of unassignedIds) {
+              const claimed = claimTask(candidateId, myAgentId);
+              if (claimed) {
+                return {
+                  trigger: {
+                    type: "task_assigned",
+                    taskId: claimed.id,
+                    task: claimed,
+                  },
+                };
+              }
+              // Claim failed (another worker got it) — try next
+            }
           }
         }
 
@@ -170,6 +224,73 @@ export async function handlePoll(
       return true;
     }
 
+    // If no trigger found and agent is lead, check for Slack channel activity.
+    // This is the lowest-priority trigger, checked AFTER all others.
+    // Runs outside the transaction because it requires async Slack API calls.
+    // Throttled to avoid Slack API rate limits (~50 calls/min).
+    if (
+      result.trigger === null &&
+      process.env.LEAD_MONITOR_CHANNELS === "true" &&
+      Date.now() - lastChannelActivityCheckAt >= CHANNEL_ACTIVITY_INTERVAL_MS
+    ) {
+      const agent = getAgentById(myAgentId);
+      if (agent?.isLead) {
+        lastChannelActivityCheckAt = Date.now();
+        try {
+          const cursors = getAllChannelActivityCursors();
+          const cursorMap = new Map(cursors.map((c) => [c.channelId, c.lastSeenTs]));
+
+          // Parse optional channel allowlist from env
+          const allowedIds = process.env.LEAD_MONITOR_CHANNEL_IDS
+            ? process.env.LEAD_MONITOR_CHANNEL_IDS.split(",")
+                .map((s) => s.trim())
+                .filter(Boolean)
+            : undefined;
+
+          const { messages, seedCursors } = await fetchChannelActivity(cursorMap, allowedIds);
+
+          // Commit seed cursors immediately (cold-start initialization, no trigger)
+          for (const [channelId, ts] of seedCursors) {
+            upsertChannelActivityCursor(channelId, ts);
+          }
+
+          if (messages.length > 0) {
+            // Compute cursor updates but DON'T commit them yet.
+            // They're included in the trigger payload so the runner can commit
+            // them after the lead successfully processes the messages.
+            const latestPerChannel = new Map<string, string>();
+            for (const msg of messages) {
+              const existing = latestPerChannel.get(msg.channelId);
+              if (!existing || Number.parseFloat(msg.ts) > Number.parseFloat(existing)) {
+                latestPerChannel.set(msg.channelId, msg.ts);
+              }
+            }
+
+            result = {
+              trigger: {
+                type: "channel_activity",
+                count: messages.length,
+                messages: messages.map((m) => ({
+                  channelId: m.channelId,
+                  channelName: m.channelName,
+                  ts: m.ts,
+                  user: m.user,
+                  text: m.text.slice(0, 500),
+                })),
+                cursorUpdates: Array.from(latestPerChannel.entries()).map(([channelId, ts]) => ({
+                  channelId,
+                  ts,
+                })),
+              },
+            };
+          }
+        } catch (err) {
+          console.warn("[/api/poll] Channel activity check failed:", err);
+          // Don't fail the poll — just skip this trigger
+        }
+      }
+    }
+
     json(res, result);
     return true;
   }

package/src/http/prompt-templates.ts

@@ -0,0 +1,412 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { z } from "zod";
+import {
+  checkoutPromptTemplate,
+  deletePromptTemplate,
+  getPromptTemplateById,
+  getPromptTemplateHistory,
+  getPromptTemplates,
+  resetPromptTemplateToDefault,
+  resolvePromptTemplate,
+  upsertPromptTemplate,
+} from "../be/db";
+import { getAllTemplateDefinitions, getTemplateDefinition } from "../prompts/registry";
+import { resolveTemplate } from "../prompts/resolver";
+import { interpolate } from "../workflows/template";
+import { route } from "./route-def";
+import { json, jsonError } from "./utils";
+
+// ─── Route Definitions ───────────────────────────────────────────────────────
+
+const resolvedRoute = route({
+  method: "get",
+  path: "/api/prompt-templates/resolved",
+  pattern: ["api", "prompt-templates", "resolved"],
+  summary: "Resolve a prompt template for a given event type and scope chain",
+  tags: ["PromptTemplates"],
+  query: z.object({
+    eventType: z.string(),
+    agentId: z.string().optional(),
+    repoId: z.string().optional(),
+  }),
+  responses: {
+    200: { description: "Resolved template info" },
+    400: { description: "Missing eventType" },
+  },
+  auth: { apiKey: true },
+});
+
+const eventsRoute = route({
+  method: "get",
+  path: "/api/prompt-templates/events",
+  pattern: ["api", "prompt-templates", "events"],
+  summary: "List all registered event types with their available variables",
+  tags: ["PromptTemplates"],
+  responses: {
+    200: { description: "List of event template definitions" },
+  },
+  auth: { apiKey: true },
+});
+
+const previewRoute = route({
+  method: "post",
+  path: "/api/prompt-templates/preview",
+  pattern: ["api", "prompt-templates", "preview"],
+  summary: "Dry-run render a template with provided variables",
+  tags: ["PromptTemplates"],
+  body: z.object({
+    eventType: z.string(),
+    body: z.string().optional(),
+    variables: z.record(z.string(), z.unknown()).optional(),
+  }),
+  responses: {
+    200: { description: "Rendered template preview" },
+    400: { description: "Validation error" },
+  },
+  auth: { apiKey: true },
+});
+
+const renderRoute = route({
+  method: "post",
+  path: "/api/prompt-templates/render",
+  pattern: ["api", "prompt-templates", "render"],
+  summary: "Full scope-aware template resolution with interpolation (used by workers via HTTP)",
+  tags: ["PromptTemplates"],
+  body: z.object({
+    eventType: z.string(),
+    variables: z.record(z.string(), z.unknown()).optional(),
+    agentId: z.string().optional(),
+    repoId: z.string().optional(),
+  }),
+  responses: {
+    200: { description: "Fully resolved and interpolated template" },
+    400: { description: "Validation error" },
+  },
+  auth: { apiKey: true },
+});
+
+const checkoutRoute = route({
+  method: "post",
+  path: "/api/prompt-templates/{id}/checkout",
+  pattern: ["api", "prompt-templates", null, "checkout"],
+  summary: "Checkout a specific version of a prompt template from history",
+  tags: ["PromptTemplates"],
+  params: z.object({ id: z.string() }),
+  body: z.object({ version: z.number() }),
+  responses: {
+    200: { description: "Checked-out template" },
+    400: { description: "Validation error" },
+    404: { description: "Template or version not found" },
+  },
+  auth: { apiKey: true },
+});
+
+const resetRoute = route({
+  method: "post",
+  path: "/api/prompt-templates/{id}/reset",
+  pattern: ["api", "prompt-templates", null, "reset"],
+  summary: "Reset a prompt template to its code-defined default",
+  tags: ["PromptTemplates"],
+  params: z.object({ id: z.string() }),
+  responses: {
+    200: { description: "Reset template" },
+    404: { description: "Template not found or no code default available" },
+  },
+  auth: { apiKey: true },
+});
+
+const getByIdRoute = route({
+  method: "get",
+  path: "/api/prompt-templates/{id}",
+  pattern: ["api", "prompt-templates", null],
+  summary: "Get a single prompt template with its version history",
+  tags: ["PromptTemplates"],
+  params: z.object({ id: z.string() }),
+  responses: {
+    200: { description: "Template with history" },
+    404: { description: "Template not found" },
+  },
+  auth: { apiKey: true },
+});
+
+const deleteByIdRoute = route({
+  method: "delete",
+  path: "/api/prompt-templates/{id}",
+  pattern: ["api", "prompt-templates", null],
+  summary: "Delete a prompt template override",
+  tags: ["PromptTemplates"],
+  params: z.object({ id: z.string() }),
+  responses: {
+    200: { description: "Template deleted" },
+    400: { description: "Cannot delete default template" },
+    404: { description: "Template not found" },
+  },
+  auth: { apiKey: true },
+});
+
+const listRoute = route({
+  method: "get",
+  path: "/api/prompt-templates",
+  pattern: ["api", "prompt-templates"],
+  summary: "List prompt templates with optional filters",
+  tags: ["PromptTemplates"],
+  query: z.object({
+    eventType: z.string().optional(),
+    scope: z.string().optional(),
+    scopeId: z.string().optional(),
+    isDefault: z.enum(["true", "false"]).optional(),
+  }),
+  responses: {
+    200: { description: "List of prompt templates" },
+  },
+  auth: { apiKey: true },
+});
+
+const upsertRoute = route({
+  method: "put",
+  path: "/api/prompt-templates",
+  pattern: ["api", "prompt-templates"],
+  summary: "Create or update a prompt template override",
+  tags: ["PromptTemplates"],
+  body: z.object({
+    eventType: z.string().min(1),
+    scope: z.enum(["global", "agent", "repo"]).optional(),
+    scopeId: z.string().optional(),
+    state: z.enum(["enabled", "default_prompt_fallback", "skip_event"]).optional(),
+    body: z.string(),
+    changedBy: z.string().optional(),
+    changeReason: z.string().optional(),
+  }),
+  responses: {
+    200: { description: "Upserted template" },
+    400: { description: "Validation error" },
+  },
+  auth: { apiKey: true },
+});
+
+// ─── Handler ─────────────────────────────────────────────────────────────────
+
+export async function handlePromptTemplates(
+  req: IncomingMessage,
+  res: ServerResponse,
+  pathSegments: string[],
+  queryParams: URLSearchParams,
+): Promise<boolean> {
+  // 3-segment literal: /api/prompt-templates/resolved
+  if (resolvedRoute.match(req.method, pathSegments)) {
+    const parsed = await resolvedRoute.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+
+    const { eventType, agentId, repoId } = parsed.query;
+    if (!eventType) {
+      jsonError(res, "eventType query parameter is required", 400);
+      return true;
+    }
+
+    const result = resolveTemplate(eventType, {}, { agentId, repoId });
+    const dbResult = resolvePromptTemplate(eventType, agentId, repoId);
+    const definition = getTemplateDefinition(eventType);
+
+    json(res, {
+      resolution: result,
+      dbResult,
+      definition: definition
+        ? {
+            eventType: definition.eventType,
+            header: definition.header,
+            defaultBody: definition.defaultBody,
+            variables: definition.variables,
+            category: definition.category,
+          }
+        : null,
+    });
+    return true;
+  }
+
+  // 3-segment literal: /api/prompt-templates/events
+  if (eventsRoute.match(req.method, pathSegments)) {
+    const parsed = await eventsRoute.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+
+    const definitions = getAllTemplateDefinitions();
+    json(res, {
+      events: definitions.map((d) => ({
+        eventType: d.eventType,
+        header: d.header,
+        defaultBody: d.defaultBody,
+        variables: d.variables,
+        category: d.category,
+      })),
+    });
+    return true;
+  }
+
+  // 3-segment literal: /api/prompt-templates/preview
+  if (previewRoute.match(req.method, pathSegments)) {
+    const parsed = await previewRoute.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+
+    const { eventType, body: customBody, variables } = parsed.body;
+    const definition = getTemplateDefinition(eventType);
+    const templateBody = customBody ?? definition?.defaultBody ?? "";
+    const header = definition?.header ?? "";
+    const composed = header ? `${header}\n\n${templateBody}` : templateBody;
+    const { result: rendered, unresolved } = interpolate(composed, variables ?? {});
+
+    json(res, { rendered, unresolved });
+    return true;
+  }
+
+  // 3-segment literal: /api/prompt-templates/render
+  if (renderRoute.match(req.method, pathSegments)) {
+    const parsed = await renderRoute.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+
+    const { eventType, variables, agentId, repoId } = parsed.body;
+    const result = resolveTemplate(eventType, variables ?? {}, { agentId, repoId });
+    json(res, result);
+    return true;
+  }
+
+  // 4-segment with param: /api/prompt-templates/{id}/checkout
+  if (checkoutRoute.match(req.method, pathSegments)) {
+    const parsed = await checkoutRoute.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+
+    try {
+      const template = checkoutPromptTemplate(parsed.params.id, parsed.body.version);
+      json(res, { template });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      if (message.includes("not found")) {
+        jsonError(res, message, 404);
+      } else {
+        jsonError(res, message, 400);
+      }
+    }
+    return true;
+  }
+
+  // 4-segment with param: /api/prompt-templates/{id}/reset
+  if (resetRoute.match(req.method, pathSegments)) {
+    const parsed = await resetRoute.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+
+    const existing = getPromptTemplateById(parsed.params.id);
+    if (!existing) {
+      jsonError(res, `Prompt template ${parsed.params.id} not found`, 404);
+      return true;
+    }
+
+    const definition = getTemplateDefinition(existing.eventType);
+    if (!definition) {
+      jsonError(res, `No code default found for event type "${existing.eventType}"`, 404);
+      return true;
+    }
+
+    try {
+      const template = resetPromptTemplateToDefault(parsed.params.id, definition.defaultBody);
+      json(res, { template });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      jsonError(res, message, 400);
+    }
+    return true;
+  }
+
+  // 3-segment with param: GET /api/prompt-templates/{id}
+  if (getByIdRoute.match(req.method, pathSegments)) {
+    const parsed = await getByIdRoute.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+
+    const template = getPromptTemplateById(parsed.params.id);
+    if (!template) {
+      jsonError(res, "Prompt template not found", 404);
+      return true;
+    }
+
+    const history = getPromptTemplateHistory(parsed.params.id);
+    json(res, { template, history });
+    return true;
+  }
+
+  // 3-segment with param: DELETE /api/prompt-templates/{id}
+  if (deleteByIdRoute.match(req.method, pathSegments)) {
+    const parsed = await deleteByIdRoute.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+
+    try {
+      const deleted = deletePromptTemplate(parsed.params.id);
+      if (!deleted) {
+        jsonError(res, "Prompt template not found", 404);
+        return true;
+      }
+      json(res, { deleted: true });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      jsonError(res, message, 400);
+    }
+    return true;
+  }
+
+  // 2-segment: GET /api/prompt-templates
+  if (listRoute.match(req.method, pathSegments)) {
+    const parsed = await listRoute.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+
+    const templates = getPromptTemplates({
+      eventType: parsed.query.eventType || undefined,
+      scope: parsed.query.scope || undefined,
+      scopeId: parsed.query.scopeId || undefined,
+      isDefault: parsed.query.isDefault ? parsed.query.isDefault === "true" : undefined,
+    });
+
+    json(res, { templates });
+    return true;
+  }
+
+  // 2-segment: PUT /api/prompt-templates
+  if (upsertRoute.match(req.method, pathSegments)) {
+    const parsed = await upsertRoute.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+
+    const {
+      eventType,
+      scope: rawScope,
+      scopeId,
+      state,
+      body,
+      changedBy,
+      changeReason,
+    } = parsed.body;
+    const scope = rawScope ?? "global";
+
+    if (scope === "global" && scopeId) {
+      jsonError(res, "Global scope must not have scopeId", 400);
+      return true;
+    }
+    if ((scope === "agent" || scope === "repo") && !scopeId) {
+      jsonError(res, "Agent/repo scope requires scopeId", 400);
+      return true;
+    }
+
+    try {
+      const template = upsertPromptTemplate({
+        eventType,
+        scope,
+        scopeId: scopeId || null,
+        state,
+        body,
+        changedBy,
+        changeReason,
+      });
+      json(res, { template });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      jsonError(res, message, 500);
+    }
+    return true;
+  }
+
+  return false;
+}