@desplega.ai/agent-swarm 1.88.0 → 1.89.0

package/src/prompts/base-prompt.ts

@@ -72,6 +72,7 @@ export type BasePromptArgs = {
     claudeMd?: string | null;
     clonePath: string;
     warning?: string | null;
+    autoStashes?: { ref: string; message: string }[];
     guidelines?: {
       prChecks: string[];
       mergeChecks: string[];
@@ -197,6 +198,13 @@ export const getBasePrompt = async (args: BasePromptArgs): Promise<string> => {
       } else if (!args.repoContext.warning) {
         prompt += `Repository is cloned at \`${args.repoContext.clonePath}\` but has no CLAUDE.md file.\n`;
       }
+
+      if (args.repoContext.autoStashes && args.repoContext.autoStashes.length > 0) {
+        const stashes = args.repoContext.autoStashes
+          .map((stash) => `- ${stash.ref}: ${stash.message}`)
+          .join("\n");
+        prompt += `\nPending auto-stashed work exists in this repo:\n${stashes}\nRestore if relevant with \`git stash apply <ref>\` or \`git stash pop <ref>\`.\n`;
+      }
     }
 
     // Inject repo guidelines

package/src/prompts/session-templates.ts

@@ -565,6 +565,29 @@ When working in a repository, your system prompt may include a **Repository Guid
   category: "system",
 });
 
+// ============================================================================
+// Per-task prompt templates (category: "task_lifecycle")
+// ============================================================================
+
+registerTemplate({
+  eventType: "task.requester.profile",
+  header: "",
+  defaultBody: `
+## Requester Profile
+This task was requested by {{requester_name}}{{requester_role_suffix}}.{{requester_notes_section}}
+Honor this requester profile in tone, depth, and format where it doesn't conflict with correctness or your operating rules.
+`,
+  variables: [
+    { name: "requester_name", description: "The requesting user's display name" },
+    { name: "requester_role_suffix", description: "Formatted role suffix, including parentheses" },
+    {
+      name: "requester_notes_section",
+      description: "Formatted notes section sourced from users.notes, or empty string",
+    },
+  ],
+  category: "task_lifecycle",
+});
+
 // ============================================================================
 // Composite session templates (category: "session")
 // ============================================================================

package/src/providers/opencode-adapter.ts

@@ -219,6 +219,7 @@ export class OpencodeSession implements ProviderSession {
   private completionPromise: Promise<ProviderResult>;
   private server: { url: string; close(): void };
   private aborted = false;
+  private completed = false;
 
   // Running cost accumulators
   private totalCostUsd = 0;
@@ -273,6 +274,10 @@ export class OpencodeSession implements ProviderSession {
     return this._sessionId;
   }
 
+  get isFinished(): boolean {
+    return this.completed;
+  }
+
   /** Emit the synthetic session_init event. Called by the adapter immediately
    * after construction; buffers if no listener is attached yet. */
   emitSessionInit(provider: "opencode"): void {
@@ -358,7 +363,7 @@ export class OpencodeSession implements ProviderSession {
 
   /** Process a single opencode SSE event */
   handleOpencodeEvent(ev: OpencodeEvent): void {
-    if (this.aborted) return;
+    if (this.aborted || this.completed) return;
 
     // Always emit the raw event as a scrubbed raw_log
     const rawContent = scrubSecrets(JSON.stringify(ev));
@@ -471,7 +476,7 @@ export class OpencodeSession implements ProviderSession {
         for (const l of this.listeners) l(resultEvent);
         const raw = scrubSecrets(JSON.stringify(resultEvent));
         this.emitDirect({ type: "raw_log", content: raw });
-        this.completionResolve({
+        void this.finish({
           exitCode: 0,
           sessionId: this._sessionId,
           cost,
@@ -515,7 +520,7 @@ export class OpencodeSession implements ProviderSession {
     const raw = scrubSecrets(JSON.stringify(errorEvent));
     this.emitDirect({ type: "raw_log", content: raw });
     const cost = this.buildCostData(true);
-    this.completionResolve({
+    void this.finish({
       exitCode: 1,
       sessionId: this._sessionId,
       cost,
@@ -546,12 +551,22 @@ export class OpencodeSession implements ProviderSession {
     return this.completionPromise;
   }
 
+  private async finish(result: ProviderResult): Promise<void> {
+    if (this.completed) return;
+    this.completed = true;
+    try {
+      this.server.close();
+    } catch {
+      // best-effort
+    }
+    await this.cleanupFiles();
+    this.completionResolve(result);
+  }
+
   async abort(): Promise<void> {
     if (this.aborted) return;
     this.aborted = true;
-    this.server.close();
-    await this.cleanupFiles();
-    this.completionResolve({
+    await this.finish({
       exitCode: 1,
       sessionId: this._sessionId,
       isError: true,
@@ -760,6 +775,7 @@ export class OpencodeAdapter implements ProviderAdapter {
       .then(async ({ stream }) => {
         for await (const event of stream) {
           session.handleOpencodeEvent(event as OpencodeEvent);
+          if (session.isFinished) break;
         }
         // Stream ended without session.idle — treat as completion
       })

package/src/server.ts

@@ -6,6 +6,7 @@ import { registerCancelTaskTool } from "./tools/cancel-task";
 import { registerContextDiffTool } from "./tools/context-diff";
 import { registerContextHistoryTool } from "./tools/context-history";
 import { registerCreateChannelTool } from "./tools/create-channel";
+import { registerCreateMetricTool } from "./tools/create-metric";
 import { registerCreatePageTool } from "./tools/create-page";
 import { registerDbQueryTool } from "./tools/db-query";
 import { registerDeleteChannelTool } from "./tools/delete-channel";
@@ -109,6 +110,7 @@ import {
   registerListConfigTool,
   registerSetConfigTool,
 } from "./tools/swarm-config";
+import { registerSwarmXTool } from "./tools/swarm-x";
 // Task pool capability
 import { registerTaskActionTool } from "./tools/task-action";
 // Tracker capability
@@ -146,7 +148,7 @@ import {
 // Capability-based feature flags
 // Default: all capabilities enabled
 const DEFAULT_CAPABILITIES =
-  "core,task-pool,profiles,services,scheduling,memory,workflows,pages,kv";
+  "core,task-pool,profiles,services,scheduling,memory,workflows,pages,metrics,kv";
 const CAPABILITIES = new Set(
   (process.env.CAPABILITIES || DEFAULT_CAPABILITIES).split(",").map((s) => s.trim()),
 );
@@ -226,6 +228,9 @@ export function createServer() {
   registerScriptDeleteTool(server);
   registerScriptQueryTypesTool(server);
 
+  // External command routes - mirrors the `agent-swarm x ...` CLI surface.
+  registerSwarmXTool(server);
+
   // Slack integration tools (always registered, will no-op if Slack not configured)
   registerSlackReplyTool(server);
   registerSlackReadTool(server);
@@ -338,6 +343,10 @@ export function createServer() {
     registerCreatePageTool(server);
   }
 
+  if (hasCapability("metrics")) {
+    registerCreateMetricTool(server);
+  }
+
   // KV capability — namespaced Redis-like key/value (see src/be/migrations/061_kv_store.sql).
   // Enabled by default; opt out via `CAPABILITIES=...` without `kv`.
   if (hasCapability("kv")) {

package/src/tests/base-prompt.test.ts

@@ -272,6 +272,41 @@ describe("getBasePrompt — repoContext", () => {
     expect(result).toContain("Repository Guidelines (MANDATORY)");
     expect(result).toContain("Auto-merge: Allowed");
   });
+
+  test("surfaces swarm-autostash entries when present", async () => {
+    const result = await getBasePrompt({
+      ...minimalArgs,
+      repoContext: {
+        claudeMd: "Rules",
+        clonePath: "/workspace/my-repo",
+        autoStashes: [
+          {
+            ref: "stash@{0}",
+            message: "On main: swarm-autostash main 2026-06-01T13:00:00.000Z",
+          },
+        ],
+      },
+    });
+
+    expect(result).toContain("Pending auto-stashed work exists in this repo");
+    expect(result).toContain("stash@{0}: On main: swarm-autostash main");
+    expect(result).toContain("git stash apply <ref>");
+    expect(result).toContain("git stash pop <ref>");
+  });
+
+  test("does not mention auto-stashed work when no swarm-autostash entries exist", async () => {
+    const result = await getBasePrompt({
+      ...minimalArgs,
+      repoContext: {
+        claudeMd: "Rules",
+        clonePath: "/workspace/my-repo",
+        autoStashes: [],
+      },
+    });
+
+    expect(result).not.toContain("Pending auto-stashed work exists in this repo");
+    expect(result).not.toContain("git stash apply <ref>");
+  });
 });
 
 // ---------------------------------------------------------------------------

package/src/tests/budget-claim-gate.test.ts

@@ -11,6 +11,7 @@ import {
   createAgent,
   createSessionCost,
   createTaskExtended,
+  createUser,
   getAgentById,
   getDb,
   incrementEmptyPollCount,
@@ -129,6 +130,31 @@ describe("Phase 3 — /api/poll budget admission gate", () => {
     expect((body.trigger as { taskId: string }).taskId).toBe(task.id);
   });
 
+  test("pending task trigger includes requester role and notes", async () => {
+    const worker = createAgent({ name: "w-requester", isLead: false, status: "idle", maxTasks: 1 });
+    const requester = createUser({
+      name: "Requester One",
+      email: "requester@example.com",
+      role: "engineering manager",
+      notes: "Include implementation detail and test coverage.",
+    });
+    createTaskExtended("profile-aware task", {
+      agentId: worker.id,
+      requestedByUserId: requester.id,
+    });
+
+    const { status, body } = await callPoll(worker.id);
+    expect(status).toBe(200);
+    if ("error" in body) throw new Error("unexpected error response");
+    expect(body.trigger?.type).toBe("task_assigned");
+    expect(body.trigger?.requestedBy).toEqual({
+      name: "Requester One",
+      email: "requester@example.com",
+      role: "engineering manager",
+      notes: "Include implementation detail and test coverage.",
+    });
+  });
+
   test("no budgets configured + no work → trigger=null", async () => {
     const worker = createAgent({ name: "w-empty", isLead: false, status: "idle", maxTasks: 1 });
     const { status, body } = await callPoll(worker.id);

package/src/tests/core-auth.test.ts

@@ -135,8 +135,15 @@ describe("handleCore auth middleware (no API_KEY configured)", () => {
     server.close();
   });
 
-  test("authed routes pass without Bearer when API_KEY is empty", async () => {
+  test("authed routes fail closed without Bearer when API_KEY is empty", async () => {
     const res = await fetch(`http://localhost:${port}/api/mcp-oauth/some-id/status`);
+    expect(res.status).toBe(401);
+    const body = await res.json();
+    expect(body.error).toBe("Unauthorized");
+  });
+
+  test("public routes still pass when API_KEY is empty", async () => {
+    const res = await fetch(`http://localhost:${port}/api/mcp-oauth/callback`);
     expect(res.status).not.toBe(401);
   });
 });

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

@@ -5,6 +5,7 @@ import type { Subprocess } from "bun";
 const TEST_PORT = 13033;
 const TEST_DB_PATH = `/tmp/test-events-http-${Date.now()}.sqlite`;
 const BASE = `http://localhost:${TEST_PORT}`;
+const TEST_API_KEY = "test-events-http-key";
 
 let serverProc: Subprocess;
 
@@ -15,7 +16,10 @@ async function api(
 ): Promise<{ status: number; body: Record<string, unknown> }> {
   const res = await fetch(`${BASE}${path}`, {
     method,
-    headers: { "Content-Type": "application/json" },
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${TEST_API_KEY}`,
+    },
     body: opts.body !== undefined ? JSON.stringify(opts.body) : undefined,
   });
   const text = await res.text();
@@ -54,7 +58,7 @@ beforeAll(async () => {
       ...process.env,
       PORT: String(TEST_PORT),
       DATABASE_PATH: TEST_DB_PATH,
-      API_KEY: "",
+      API_KEY: TEST_API_KEY,
       CAPABILITIES: "core",
       SLACK_BOT_TOKEN: "",
       GITHUB_WEBHOOK_SECRET: "",

package/src/tests/github-handlers-cancel-config.test.ts

@@ -0,0 +1,262 @@
+/**
+ * Tests for the runtime-config flags that control whether GitHub unassign and
+ * review-request-removed events terminate the linked swarm task.
+ *
+ * Flags (scope "global"):
+ *   github.cancelOnUnassign              — PR unassigned + issue unassigned
+ *   github.cancelOnReviewRequestRemoved  — PR review_request_removed
+ *
+ * Absent / any value ≠ "false" → cancel (current behavior, default).
+ * Value "false" → leave task untouched, return { created: false }.
+ */
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import {
+  closeDb,
+  createAgent,
+  createTaskExtended,
+  deleteSwarmConfig,
+  getDb,
+  getSwarmConfigs,
+  getTaskById,
+  initDb,
+  upsertSwarmConfig,
+} from "../be/db";
+import { handleIssue, handlePullRequest } from "../github/handlers";
+import { GITHUB_BOT_NAME } from "../github/mentions";
+import type { IssueEvent, PullRequestEvent } from "../github/types";
+
+const TEST_DB_PATH = "./test-github-handlers-cancel-config.sqlite";
+
+const BASE_REPO = { full_name: "test/repo", html_url: "https://github.com/test/repo" };
+const BASE_PR = {
+  number: 1,
+  title: "Test PR",
+  body: null as string | null,
+  html_url: "https://github.com/test/repo/pull/1",
+  user: { login: "sender" },
+  head: { ref: "feature", sha: "abc1234567890" },
+  base: { ref: "main" },
+  merged: false,
+  merged_by: undefined,
+};
+const BASE_ISSUE = {
+  number: 10,
+  title: "Test Issue",
+  body: null as string | null,
+  html_url: "https://github.com/test/repo/issues/10",
+  user: { login: "sender" },
+};
+
+// ── Setup ──
+
+beforeAll(async () => {
+  await unlink(TEST_DB_PATH).catch(() => {});
+  await unlink(`${TEST_DB_PATH}-wal`).catch(() => {});
+  await unlink(`${TEST_DB_PATH}-shm`).catch(() => {});
+  initDb(TEST_DB_PATH);
+  createAgent({
+    id: "lead-cancel-config-test",
+    name: "CancelConfigTestLead",
+    status: "idle",
+    isLead: true,
+  });
+});
+
+afterAll(async () => {
+  closeDb();
+  await unlink(TEST_DB_PATH).catch(() => {});
+  await unlink(`${TEST_DB_PATH}-wal`).catch(() => {});
+  await unlink(`${TEST_DB_PATH}-shm`).catch(() => {});
+});
+
+// Clear tasks and config rows between tests.
+beforeEach(() => {
+  const db = getDb();
+  db.prepare("DELETE FROM agent_tasks").run();
+  // Remove both flag rows so each test starts from a clean slate.
+  for (const key of ["github.cancelOnUnassign", "github.cancelOnReviewRequestRemoved"]) {
+    const rows = getSwarmConfigs({ scope: "global", key });
+    for (const row of rows) deleteSwarmConfig(row.id);
+  }
+});
+
+// ── Helpers ──
+
+function seedTask(vcsNumber: number, kind: "pr" | "issue"): string {
+  const task = createTaskExtended("test task", {
+    agentId: "lead-cancel-config-test",
+    source: "github",
+    vcsProvider: "github",
+    vcsRepo: BASE_REPO.full_name,
+    vcsNumber,
+    vcsEventType: kind === "pr" ? "pull_request" : "issues",
+  });
+  return task.id;
+}
+
+function setConfigFlag(key: string, value: string) {
+  upsertSwarmConfig({ scope: "global", key, value });
+}
+
+function getTaskStatus(taskId: string): string | undefined {
+  return getTaskById(taskId)?.status;
+}
+
+// ── github.cancelOnUnassign — PR unassigned ──
+
+describe("PR unassigned — github.cancelOnUnassign", () => {
+  test("default (no config row): unassign cancels the task", async () => {
+    const taskId = seedTask(BASE_PR.number, "pr");
+    expect(getTaskStatus(taskId)).toBe("pending");
+
+    const event: PullRequestEvent = {
+      action: "unassigned",
+      pull_request: { ...BASE_PR },
+      repository: BASE_REPO,
+      sender: { login: "someone" },
+      assignee: { login: GITHUB_BOT_NAME, id: 1 },
+    };
+    const result = await handlePullRequest(event);
+
+    expect(result.created).toBe(false);
+    expect(getTaskStatus(taskId)).toBe("failed");
+  });
+
+  test("config = 'false': unassign leaves task untouched", async () => {
+    setConfigFlag("github.cancelOnUnassign", "false");
+    const taskId = seedTask(BASE_PR.number, "pr");
+    expect(getTaskStatus(taskId)).toBe("pending");
+
+    const event: PullRequestEvent = {
+      action: "unassigned",
+      pull_request: { ...BASE_PR },
+      repository: BASE_REPO,
+      sender: { login: "someone" },
+      assignee: { login: GITHUB_BOT_NAME, id: 1 },
+    };
+    const result = await handlePullRequest(event);
+
+    expect(result.created).toBe(false);
+    // Task must NOT have been failed — still pending.
+    expect(getTaskStatus(taskId)).toBe("pending");
+  });
+});
+
+// ── github.cancelOnUnassign — issue unassigned ──
+
+describe("issue unassigned — github.cancelOnUnassign", () => {
+  test("default (no config row): unassign cancels the task", async () => {
+    const taskId = seedTask(BASE_ISSUE.number, "issue");
+    expect(getTaskStatus(taskId)).toBe("pending");
+
+    const event: IssueEvent = {
+      action: "unassigned",
+      issue: { ...BASE_ISSUE },
+      repository: BASE_REPO,
+      sender: { login: "someone" },
+      assignee: { login: GITHUB_BOT_NAME, id: 1 },
+    };
+    const result = await handleIssue(event);
+
+    expect(result.created).toBe(false);
+    expect(getTaskStatus(taskId)).toBe("failed");
+  });
+
+  test("config = 'false': unassign leaves task untouched", async () => {
+    setConfigFlag("github.cancelOnUnassign", "false");
+    const taskId = seedTask(BASE_ISSUE.number, "issue");
+    expect(getTaskStatus(taskId)).toBe("pending");
+
+    const event: IssueEvent = {
+      action: "unassigned",
+      issue: { ...BASE_ISSUE },
+      repository: BASE_REPO,
+      sender: { login: "someone" },
+      assignee: { login: GITHUB_BOT_NAME, id: 1 },
+    };
+    const result = await handleIssue(event);
+
+    expect(result.created).toBe(false);
+    expect(getTaskStatus(taskId)).toBe("pending");
+  });
+});
+
+// ── github.cancelOnReviewRequestRemoved ──
+
+describe("PR review_request_removed — github.cancelOnReviewRequestRemoved", () => {
+  test("default (no config row): review removal cancels the task", async () => {
+    const taskId = seedTask(BASE_PR.number, "pr");
+    expect(getTaskStatus(taskId)).toBe("pending");
+
+    const event: PullRequestEvent = {
+      action: "review_request_removed",
+      pull_request: { ...BASE_PR },
+      repository: BASE_REPO,
+      sender: { login: "someone" },
+      requested_reviewer: { login: GITHUB_BOT_NAME, id: 1 },
+    };
+    const result = await handlePullRequest(event);
+
+    expect(result.created).toBe(false);
+    expect(getTaskStatus(taskId)).toBe("failed");
+  });
+
+  test("config = 'false': review removal leaves task untouched", async () => {
+    setConfigFlag("github.cancelOnReviewRequestRemoved", "false");
+    const taskId = seedTask(BASE_PR.number, "pr");
+    expect(getTaskStatus(taskId)).toBe("pending");
+
+    const event: PullRequestEvent = {
+      action: "review_request_removed",
+      pull_request: { ...BASE_PR },
+      repository: BASE_REPO,
+      sender: { login: "someone" },
+      requested_reviewer: { login: GITHUB_BOT_NAME, id: 1 },
+    };
+    const result = await handlePullRequest(event);
+
+    expect(result.created).toBe(false);
+    expect(getTaskStatus(taskId)).toBe("pending");
+  });
+});
+
+// ── Independence: flags do not bleed into each other ──
+
+describe("flag independence", () => {
+  test("cancelOnUnassign=false does NOT affect review_request_removed (still cancels)", async () => {
+    // Only disable the unassign flag; leave review-request flag absent (default = cancel).
+    setConfigFlag("github.cancelOnUnassign", "false");
+    const taskId = seedTask(BASE_PR.number, "pr");
+
+    const event: PullRequestEvent = {
+      action: "review_request_removed",
+      pull_request: { ...BASE_PR },
+      repository: BASE_REPO,
+      sender: { login: "someone" },
+      requested_reviewer: { login: GITHUB_BOT_NAME, id: 1 },
+    };
+    await handlePullRequest(event);
+
+    // review_request_removed STILL cancels because its own flag is absent (default true).
+    expect(getTaskStatus(taskId)).toBe("failed");
+  });
+
+  test("cancelOnReviewRequestRemoved=false does NOT affect unassign (still cancels)", async () => {
+    // Only disable the review-request flag; leave unassign flag absent (default = cancel).
+    setConfigFlag("github.cancelOnReviewRequestRemoved", "false");
+    const taskId = seedTask(BASE_PR.number, "pr");
+
+    const event: PullRequestEvent = {
+      action: "unassigned",
+      pull_request: { ...BASE_PR },
+      repository: BASE_REPO,
+      sender: { login: "someone" },
+      assignee: { login: GITHUB_BOT_NAME, id: 1 },
+    };
+    await handlePullRequest(event);
+
+    // unassigned STILL cancels because its own flag is absent (default true).
+    expect(getTaskStatus(taskId)).toBe("failed");
+  });
+});