@desplega.ai/agent-swarm 1.172.0 → 2.0.0

package/src/tests/swarm-config-export-to-env.test.ts

@@ -0,0 +1,267 @@
+import { Database } from "bun:sqlite";
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+import { unlink } from "node:fs/promises";
+import { createServer as createHttpServer, type Server } from "node:http";
+import { closeDb, createAgent, getSwarmConfigs, initDb, upsertSwarmConfig } from "../be/db";
+import { handleConfig } from "../http/config";
+import { getPathSegments, parseQueryParams } from "../http/utils";
+import { registerSetConfigTool } from "../tools/swarm-config/set-config";
+import { ENV_EXPORT_RESTRICTED_KEYS, envExportRestrictedError } from "../utils/config-env-export";
+import { setRequestAuth } from "../utils/request-auth-context";
+import { clearVolatileSecretsForTesting } from "../utils/secret-scrubber";
+import { listenOnFreePort } from "./test-net";
+
+const TEST_DB_PATH = "./test-swarm-config-export-to-env.sqlite";
+const LEAD_ID = "21111111-1111-1111-1111-111111111111";
+const MIGRATION = "src/be/migrations/215_swarm_config_export_to_env.sql";
+
+type ToolHandler = (args: unknown, meta: unknown) => Promise<unknown> | unknown;
+
+class MockMcpServer {
+  handlers = new Map<string, ToolHandler>();
+  registerTool(name: string, _config: unknown, handler: ToolHandler) {
+    this.handlers.set(name, handler);
+    return { name };
+  }
+}
+
+const requestInfo = {
+  sessionId: "test-session",
+  requestInfo: { headers: { "x-agent-id": LEAD_ID } },
+};
+
+describe("swarm_config exportToEnv", () => {
+  let server: Server;
+  let baseUrl = "";
+  const mcpServer = new MockMcpServer();
+
+  beforeAll(async () => {
+    initDb(TEST_DB_PATH);
+    await createAgent({
+      id: LEAD_ID,
+      name: "export-to-env-test-lead",
+      isLead: true,
+      status: "idle",
+      capabilities: [],
+    });
+    registerSetConfigTool(mcpServer as unknown as Parameters<typeof registerSetConfigTool>[0]);
+    server = createHttpServer(async (req, res) => {
+      setRequestAuth(req, { kind: "operator", fingerprint: "test" });
+      const handled = await handleConfig(
+        req,
+        res,
+        getPathSegments(req.url || ""),
+        parseQueryParams(req.url || ""),
+      );
+      if (!handled) {
+        res.writeHead(404);
+        res.end();
+      }
+    });
+    baseUrl = `http://localhost:${await listenOnFreePort(server)}`;
+  });
+
+  afterAll(async () => {
+    clearVolatileSecretsForTesting();
+    server.close();
+    closeDb();
+    for (const suffix of ["", "-wal", "-shm"]) {
+      await unlink(`${TEST_DB_PATH}${suffix}`).catch(() => {});
+    }
+  });
+
+  test("new rows export by default; an update without the flag keeps it", async () => {
+    const created = await upsertSwarmConfig({ scope: "global", key: "EXPORT_A", value: "1" });
+    expect(created.exportToEnv).toBe(true);
+
+    const off = await upsertSwarmConfig({
+      scope: "global",
+      key: "EXPORT_A",
+      value: "2",
+      isSecret: true,
+      exportToEnv: false,
+    });
+    expect(off.exportToEnv).toBe(false);
+
+    const kept = await upsertSwarmConfig({
+      scope: "global",
+      key: "EXPORT_A",
+      value: "3",
+      isSecret: true,
+    });
+    expect(kept.exportToEnv).toBe(false);
+
+    const on = await upsertSwarmConfig({
+      scope: "global",
+      key: "EXPORT_A",
+      value: "4",
+      exportToEnv: true,
+    });
+    expect(on.exportToEnv).toBe(true);
+  });
+
+  test("default-off keys start off on create but accept an explicit true", async () => {
+    const created = await upsertSwarmConfig({
+      scope: "global",
+      key: "KAPSO_WEBHOOK_HMAC_SECRET",
+      value: "k",
+      isSecret: true,
+    });
+    expect(created.exportToEnv).toBe(false);
+
+    const optedIn = await upsertSwarmConfig({
+      scope: "global",
+      key: "X_CLIENT_SECRET",
+      value: "x",
+      isSecret: true,
+      exportToEnv: true,
+    });
+    expect(optedIn.exportToEnv).toBe(true);
+  });
+
+  test("restricted keys store false and reject true through DB, HTTP, and MCP", async () => {
+    const key = "SLACK_SIGNING_SECRET";
+    const stored = await upsertSwarmConfig({ scope: "global", key, value: "s", isSecret: true });
+    expect(stored.exportToEnv).toBe(false);
+    const connection = await upsertSwarmConfig({
+      scope: "global",
+      key: "connection.example.secret",
+      value: "s",
+      isSecret: true,
+    });
+    expect(connection.exportToEnv).toBe(false);
+
+    const body = { scope: "global" as const, key, value: "s", isSecret: true, exportToEnv: true };
+    await expect(upsertSwarmConfig(body)).rejects.toThrow(envExportRestrictedError(key));
+
+    const res = await fetch(`${baseUrl}/api/config`, {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    });
+    expect(res.status).toBe(400);
+    expect(await res.json()).toMatchObject({ error: envExportRestrictedError(key) });
+
+    const result = (await mcpServer.handlers.get("set-config")!(body, requestInfo)) as {
+      structuredContent: { success: boolean; message: string };
+    };
+    expect(result.structuredContent.success).toBe(false);
+    expect(result.structuredContent.message).toBe(envExportRestrictedError(key));
+
+    const [row] = await getSwarmConfigs({ key });
+    expect(row?.exportToEnv).toBe(false);
+  });
+
+  test("the config API and /api/config/resolved carry the flag", async () => {
+    const put = await fetch(`${baseUrl}/api/config`, {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        scope: "global",
+        key: "EXPORT_B",
+        value: "b",
+        isSecret: true,
+        exportToEnv: false,
+      }),
+    });
+    expect(put.status).toBe(200);
+    expect(await put.json()).toMatchObject({ key: "EXPORT_B", exportToEnv: false });
+
+    const resolved = await fetch(`${baseUrl}/api/config/resolved?key=EXPORT_B`);
+    const { configs } = (await resolved.json()) as {
+      configs: Array<{ key: string; exportToEnv: boolean }>;
+    };
+    expect(configs).toEqual([expect.objectContaining({ key: "EXPORT_B", exportToEnv: false })]);
+  });
+
+  test("set-config accepts the flag and keeps it on a later write", async () => {
+    const handler = mcpServer.handlers.get("set-config")!;
+    await handler(
+      { scope: "global", key: "EXPORT_C", value: "c", isSecret: true, exportToEnv: false },
+      requestInfo,
+    );
+    await handler({ scope: "global", key: "EXPORT_C", value: "c2", isSecret: true }, requestInfo);
+    const [row] = await getSwarmConfigs({ key: "EXPORT_C" });
+    expect(row?.exportToEnv).toBe(false);
+  });
+});
+
+describe("migration 215", () => {
+  // Keys agents read from their own env today (PR #2156 review audit, plus
+  // harness, git and agent-fs credentials). None may land on the deny list.
+  const MUST_STAY_EXPORTED = [
+    "AGENTMAIL_API_KEY",
+    "ATTIO_API_KEY",
+    "DOKPLOY_API_KEY",
+    "ELEVENLABS_API_KEY",
+    "EXA_API_KEY",
+    "GSC_SERVICE_ACCOUNT_BASE64",
+    "HETZNER_API_KEY",
+    "IMGFLIP_PASSWORD",
+    "IMGFLIP_USERNAME",
+    "KAPSO_API_KEY",
+    "PLAUSIBLE_API_KEY",
+    "SPRITES_API_KEY",
+    "SUPERAGENT_API_KEY",
+    "TURSO_API_TOKEN",
+    "TURSO_DB_TOKEN",
+    "TURSO_X_POSTS_DB_TOKEN",
+    "WORKDIR_API_KEY",
+    "X_ACCESS_TOKEN",
+    "X_ACCESS_TOKEN_SECRET",
+    "X_API_KEY",
+    "X_API_SECRET",
+    "X_BEARER_TOKEN",
+    "CLAUDE_CODE_OAUTH_TOKEN",
+    "OPENROUTER_API_KEY",
+    "GITHUB_TOKEN",
+    "AGENT_FS_API_KEY",
+    "SLACK_BOT_TOKEN",
+    "SELF_DRIVING_WEBHOOK_SECRET",
+    "DESPLEGA_PROD_DATABASE_URL",
+    "GWS_CREDS_BASE64",
+    "codex_oauth_1",
+  ];
+  const DENY_ONLY = [
+    "KAPSO_WEBHOOK_HMAC_SECRET",
+    "SENTRY_TEST_APP_WEBHOOK_SECRET",
+    "TELEMETRY_CH_AUTH",
+    "HACK_AGENT_FS_ADMIN_KEY",
+    "X_CLIENT_SECRET",
+    "connection.example.secret",
+  ];
+
+  test("backfills true and turns off only the deny list", () => {
+    const db = new Database(":memory:");
+    try {
+      db.exec(`CREATE TABLE swarm_config (
+        id TEXT PRIMARY KEY, scope TEXT NOT NULL, scopeId TEXT, key TEXT NOT NULL,
+        value TEXT NOT NULL, isSecret INTEGER NOT NULL DEFAULT 0, envPath TEXT,
+        description TEXT, createdAt TEXT NOT NULL, lastUpdatedAt TEXT NOT NULL,
+        encrypted INTEGER NOT NULL DEFAULT 0)`);
+      const insert = db.prepare(
+        "INSERT INTO swarm_config (id, scope, key, value, isSecret, createdAt, lastUpdatedAt) VALUES (?, 'global', ?, 'v', 1, 'now', 'now')",
+      );
+      const keys = [...MUST_STAY_EXPORTED, ...DENY_ONLY, ...ENV_EXPORT_RESTRICTED_KEYS];
+      for (const key of keys) insert.run(crypto.randomUUID(), key);
+
+      db.exec(readFileSync(MIGRATION, "utf8"));
+
+      const flags = Object.fromEntries(
+        db
+          .query<{ key: string; exportToEnv: number }, []>(
+            "SELECT key, exportToEnv FROM swarm_config",
+          )
+          .all()
+          .map((row) => [row.key, row.exportToEnv]),
+      );
+      for (const key of MUST_STAY_EXPORTED) expect([key, flags[key]]).toEqual([key, 1]);
+      for (const key of [...DENY_ONLY, ...ENV_EXPORT_RESTRICTED_KEYS]) {
+        expect([key, flags[key]]).toEqual([key, 0]);
+      }
+    } finally {
+      db.close();
+    }
+  });
+});

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

@@ -6,6 +6,7 @@ import {
   createAgent,
   deleteSwarmConfig,
   getDbClient,
+  getInjectableGlobalConfigs,
   getSwarmConfigById,
   getSwarmConfigs,
   initDb,
@@ -94,6 +95,20 @@ function createTestServer(): Server {
   });
 }
 
+describe("Teams SDK env fallbacks", () => {
+  test("a global SERVICE_URL row is storable but never injected into env", async () => {
+    await upsertSwarmConfig({ scope: "global", key: "SERVICE_URL", value: "https://evil.example" });
+    try {
+      expect((await getSwarmConfigs({ scope: "global", key: "SERVICE_URL" })).length).toBe(1);
+      const injectable = await getInjectableGlobalConfigs();
+      expect(injectable.some((config) => config.key === "SERVICE_URL")).toBe(false);
+    } finally {
+      const rows = await getSwarmConfigs({ scope: "global", key: "SERVICE_URL" });
+      for (const row of rows) await deleteSwarmConfig(row.id);
+    }
+  });
+});
+
 describe("swarm-config reserved keys guard", () => {
   let server: Server;
   let baseUrl = "";
@@ -139,6 +154,7 @@ describe("swarm-config reserved keys guard", () => {
     "cors_allow_any_origin",
     "EXTENSION_ALLOW_LEAD_ACTIVATION",
     "extension_allow_lead_activation",
+    "CHAT_SDK_API_URL_OVERRIDES",
   ]) {
     test(`rejects deployment-only ${key} through DB, HTTP, and MCP`, async () => {
       const config = { scope: "global" as const, key, value: "true" };

package/src/tests/swarm-diff.test.ts

@@ -8,7 +8,7 @@
  * anchor ids, severity badges) without dragging in a real DOM lib.
  */
 import { describe, expect, test } from "bun:test";
-import { SWARM_UI_JS } from "../artifact-sdk/browser-sdk";
+import { SWARM_UI_JS } from "../pages/browser-sdk";
 
 const EXAMPLE_HUNK = {
   hunks: [

package/src/tests/task-model-effort-rerun.test.ts

@@ -0,0 +1,164 @@
+// What a task records about the model and effort it ran on, and what a re-run
+// of the same row carries over. Regression for: an agent's model/effort changed
+// in the dashboard, and the next run of a task kept the previous values.
+
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import {
+  closeDb,
+  createAgent,
+  createTaskExtended,
+  getTaskById,
+  initDb,
+  updateTaskClaudeSessionId,
+} from "../be/db";
+import { effectiveReasoningEffort } from "../providers/reasoning-effort";
+import { resumedTaskModelSelection, taskModelPin } from "../tasks/model-pin";
+
+const TEST_DB_PATH = "./test-task-model-effort-rerun.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;
+    }
+  }
+}
+
+beforeAll(async () => {
+  await removeDbFiles(TEST_DB_PATH);
+  initDb(TEST_DB_PATH);
+});
+
+afterAll(async () => {
+  closeDb();
+  await removeDbFiles(TEST_DB_PATH);
+});
+
+describe("taskModelPin", () => {
+  test("a model reported by a previous session is not a pin", () => {
+    expect(taskModelPin({ model: "claude-opus-5-5", claudeSessionId: "s1" })).toBeUndefined();
+  });
+
+  test("a model a tier layer chose is not a pin", () => {
+    expect(
+      taskModelPin({
+        model: "claude-opus-5-5",
+        modelTier: "smart",
+        resolvedModel: "claude-opus-5-5",
+        modelSource: "tier-default",
+      }),
+    ).toBeUndefined();
+  });
+
+  test("the creator's model on an unclaimed row is the pin", () => {
+    expect(taskModelPin({ model: "claude-sonnet-5-5" })).toBe("claude-sonnet-5-5");
+  });
+
+  test("a claimed pin keeps its alias", () => {
+    expect(
+      taskModelPin({
+        model: "claude-opus-5-5",
+        modelSource: "model",
+        modelAlias: "latest:anthropic/opus",
+        claudeSessionId: "s1",
+      }),
+    ).toBe("latest:anthropic/opus");
+  });
+});
+
+describe("resumedTaskModelSelection", () => {
+  test("a paused unpinned task resumes without the previous run's model or claim record", () => {
+    expect(
+      resumedTaskModelSelection({
+        model: "claude-opus-5-5",
+        resolvedModel: "claude-opus-5-5",
+        modelSource: "tier-config",
+        modelTier: "smart",
+        claudeSessionId: "s1",
+      }),
+    ).toEqual({ model: undefined, resolvedModel: undefined, modelSource: undefined });
+  });
+
+  test("a paused pinned task resumes on its pin", () => {
+    expect(
+      resumedTaskModelSelection({
+        model: "claude-sonnet-5-5",
+        resolvedModel: "claude-sonnet-5-5",
+        modelSource: "model",
+        claudeSessionId: "s1",
+      }),
+    ).toEqual({
+      model: "claude-sonnet-5-5",
+      resolvedModel: "claude-sonnet-5-5",
+      modelSource: "model",
+    });
+  });
+});
+
+describe("effectiveReasoningEffort", () => {
+  test("unset effort records nothing", () => {
+    expect(effectiveReasoningEffort("claude", "claude-opus-5-5", undefined)).toBeNull();
+  });
+
+  test("harnesses without effort support record nothing", () => {
+    expect(effectiveReasoningEffort("devin", "", "high")).toBeNull();
+  });
+
+  test("a level the model cannot take is dropped, the same as the adapter does", () => {
+    expect(effectiveReasoningEffort("claude", "not-a-reasoning-model", "high")).toBeNull();
+  });
+});
+
+describe("session report records the effort", () => {
+  test("the effort the session ran at lands on resolvedEffort, and a re-run replaces it", async () => {
+    const agent = await createAgent({ name: "effort-rerun", isLead: false, status: "idle" });
+    const task = await createTaskExtended("work", { agentId: agent.id });
+
+    // First run: the agent's REASONING_EFFORT_OVERRIDE was high.
+    await updateTaskClaudeSessionId(
+      task.id,
+      "run-1",
+      "claude",
+      undefined,
+      "claude-opus-5-5",
+      undefined,
+      undefined,
+      "high",
+    );
+    let row = await getTaskById(task.id);
+    expect(row?.resolvedEffort).toBe("high");
+    // The requested-effort column stays the creator's value, not a pin.
+    expect(row?.effort).toBeUndefined();
+
+    // Effort changed to low in the dashboard; the next run records low.
+    await updateTaskClaudeSessionId(
+      task.id,
+      "run-2",
+      "claude",
+      undefined,
+      "claude-opus-5-5",
+      undefined,
+      undefined,
+      "low",
+    );
+    row = await getTaskById(task.id);
+    expect(row?.resolvedEffort).toBe("low");
+
+    // Effort set back to Auto: the harness default applied, nothing to show.
+    await updateTaskClaudeSessionId(
+      task.id,
+      "run-3",
+      "claude",
+      undefined,
+      "claude-opus-5-5",
+      undefined,
+      undefined,
+      null,
+    );
+    row = await getTaskById(task.id);
+    expect(row?.resolvedEffort).toBeUndefined();
+  });
+});

package/src/tests/task-session-prompts.test.ts

@@ -0,0 +1,132 @@
+import { describe, expect, test } from "bun:test";
+import {
+  buildRequesterProfilePrompt,
+  buildTaskSessionPrompts,
+  type TaskSessionContext,
+} from "../commands/runner";
+import { type BasePromptArgs, getTaskContextPrompt } from "../prompts/base-prompt";
+import type { ProviderName } from "../types";
+
+// The provider caches the system prompt as a prefix, so any per-task byte in it
+// re-bills the whole prompt on the first call of every session. These tests pin
+// the split: one agent, different tasks, requesters and repos, same system
+// prompt; the per-task context still reaches the model, in the task prompt.
+
+const agentArgs = (
+  provider: ProviderName,
+  extra: Partial<BasePromptArgs> = {},
+): BasePromptArgs => ({
+  role: "worker",
+  agentId: "11111111-2222-3333-4444-555555555555",
+  name: "Ada",
+  provider,
+  traits: { hasMcp: true, hasLocalEnvironment: true, nativeSkillDiscovery: provider !== "codex" },
+  soulMd: "You are Ada.",
+  claudeMd: "# Agent: Ada\n\nAlways run the tests before you push.",
+  skillsSummary: [{ name: "commit", description: "Create a commit" }],
+  mcpServers: ["linear"],
+  ...extra,
+});
+
+const sessionA: TaskSessionContext = {
+  repoContext: {
+    clonePath: "/workspace/personal/repos/alpha",
+    claudeMd: "Alpha repo rules.",
+    warning: "Alpha is behind origin",
+    autoStashes: [{ ref: "stash@{0}", message: "WIP alpha" }],
+    guidelines: {
+      prChecks: ["bun run lint"],
+      mergeChecks: ["CI green"],
+      allowMerge: false,
+      review: ["Check the db boundary"],
+    },
+  },
+  slackContext: { channelId: "C0ALPHA", threadTs: "111.222" },
+  requestedBy: {
+    name: "Taras",
+    role: "CTO",
+    notes: "Lead with the answer.",
+    comms: { verbosity: "terse" },
+  },
+  cwdWarning: 'Note: The task requested working directory "/nope" but it does not exist.',
+};
+
+const sessionB: TaskSessionContext = {
+  repoContext: { clonePath: "/workspace/personal/repos/beta", guidelines: null },
+  requestedBy: { name: "Eze", role: "CEO", comms: { language: "Spanish" } },
+};
+
+// A heartbeat: no repository, no requester, no working directory.
+const sessionC: TaskSessionContext = {};
+
+async function build(args: BasePromptArgs, context: TaskSessionContext, taskPrompt: string) {
+  return buildTaskSessionPrompts({
+    basePromptArgs: args,
+    additionalSystemPrompt: "Operator note: be careful.",
+    taskPrompt,
+    context,
+  });
+}
+
+describe("buildTaskSessionPrompts", () => {
+  for (const provider of ["claude", "codex", "opencode", "pi"] as const) {
+    test(`${provider}: the system prompt is byte-identical across tasks, requesters and repos`, async () => {
+      const a = await build(agentArgs(provider), sessionA, "/work-on-task aaa\n\nTask: alpha");
+      const b = await build(agentArgs(provider), sessionB, "/work-on-task bbb\n\nTask: beta");
+      const c = await build(agentArgs(provider), sessionC, "/work-on-task ccc\n\nTask: heartbeat");
+
+      expect(a.systemPrompt).toBe(b.systemPrompt);
+      expect(a.systemPrompt).toBe(c.systemPrompt);
+      expect(a.systemPrompt).toEndWith("\n\nOperator note: be careful.");
+      for (const perTask of ["## Repository", "## Requester Profile", "Taras", "Eze", "/nope"]) {
+        expect(a.systemPrompt).not.toContain(perTask);
+      }
+    });
+  }
+
+  test("a scripts-only worker keeps the system prompt stable across Slack and non-Slack tasks", async () => {
+    const keys = ["SLACK_DISABLE", "SLACK_BOT_TOKEN", "SLACK_APP_TOKEN"] as const;
+    const saved = keys.map((key) => [key, process.env[key]] as const);
+    delete process.env.SLACK_DISABLE;
+    process.env.SLACK_BOT_TOKEN = "xoxb-test-token";
+    process.env.SLACK_APP_TOKEN = "xapp-test-token";
+    try {
+      const args = agentArgs("claude", { scriptsOnly: true });
+      const a = await build(args, sessionA, "task a");
+      const c = await build(args, sessionC, "task c");
+      expect(a.systemPrompt).toBe(c.systemPrompt);
+      expect(a.systemPrompt).not.toContain("C0ALPHA");
+      expect(a.prompt).toContain("## Slack (scripts-only)");
+      expect(a.prompt).toContain("C0ALPHA");
+    } finally {
+      for (const [key, value] of saved) {
+        if (value === undefined) delete process.env[key];
+        else process.env[key] = value;
+      }
+    }
+  });
+
+  test("the per-task context reaches the task prompt with the same text, after the task", async () => {
+    const args = agentArgs("opencode");
+    const taskPrompt = "/work-on-task aaa\n\nTask: alpha";
+    const { prompt } = await build(args, sessionA, taskPrompt);
+
+    const repoBlock = await getTaskContextPrompt({ ...args, repoContext: sessionA.repoContext });
+    const profile = await buildRequesterProfilePrompt(sessionA.requestedBy);
+    expect(repoBlock).toContain("## Repository");
+    expect(repoBlock).toContain("Alpha repo rules.");
+    expect(profile).toContain("This task was requested by Taras (CTO).");
+
+    expect(prompt).toStartWith(`${taskPrompt}\n\n`);
+    expect(prompt).toContain(repoBlock);
+    expect(prompt).toContain(profile);
+    expect(prompt).toEndWith(sessionA.cwdWarning ?? "");
+    expect(prompt.indexOf(repoBlock)).toBeLessThan(prompt.indexOf(profile));
+    expect(prompt).not.toMatch(/\n{3,}/);
+  });
+
+  test("a task with no per-task context keeps its prompt unchanged", async () => {
+    const { prompt } = await build(agentArgs("claude"), sessionC, "/work-on-task ccc");
+    expect(prompt).toBe("/work-on-task ccc");
+  });
+});

package/src/tests/task-tool-manifest.test.ts

@@ -27,6 +27,20 @@ describe("task tool manifests", () => {
     ]);
   });
 
+  test("chat-reply only preloads for a task carrying a chat-sdk contextKey", () => {
+    const manifest = parseTaskToolManifest('{"taskTypes":{"review":["chat-reply","script-run"]}}');
+    expect(selectTaskTools(manifest, { taskType: "review" })).toEqual(["script-run"]);
+    expect(
+      selectTaskTools(manifest, { taskType: "review", contextKey: "task:slack:C123:1700.1" }),
+    ).toEqual(["script-run"]);
+    expect(
+      selectTaskTools(manifest, {
+        taskType: "review",
+        contextKey: "task:chat-sdk:telegram:555001",
+      }),
+    ).toEqual(["chat-reply", "script-run"]);
+  });
+
   test("config writes reject unknown tools, invalid shapes, and oversized selections", () => {
     for (const value of [
       "not json",

package/src/tests/task-tools-ctx.test.ts

@@ -137,8 +137,10 @@ describe("task tool ctx", () => {
     });
     await updateAgentProfile(lead.id, { capabilities: ["merge"] });
     await updateAgentProfile(underprivilegedLead.id, { capabilities: ["typescript"] });
+    // The sender created the parent, so it may continue it (task.parent.attach).
     const parent = await createTaskExtended("privileged parent", {
       agentId: lead.id,
+      creatorAgentId: sender.id,
       routingAffinity: { capabilities: ["merge"], leadOnly: true },
     });
 

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

@@ -116,7 +116,6 @@ describe("Tool Annotations & Classification", () => {
       "delete-config",
       "delete-workflow",
       "delete-page",
-      "unregister-service",
       "slack-delete",
       "slack-archive-channel",
     ];
@@ -135,7 +134,6 @@ describe("Tool Annotations & Classification", () => {
       "get-tasks",
       "get-config",
       "list-channels",
-      "list-services",
       "list-schedules",
       "list-config",
       "memory-get",
@@ -350,7 +348,7 @@ describe("Tool Annotations & Classification", () => {
     expect(missing).toEqual([]);
   });
 
-  test("service tools are all deferred", () => {
+  test("the removed PM2 service registry tools stay gone", () => {
     const serviceTools = [
       "register-service",
       "unregister-service",
@@ -358,7 +356,8 @@ describe("Tool Annotations & Classification", () => {
       "update-service-status",
     ];
     for (const tool of serviceTools) {
-      expect(DEFERRED_TOOLS.has(tool)).toBe(true);
+      expect(DEFERRED_TOOLS.has(tool)).toBe(false);
+      expect(tools[tool]).toBeUndefined();
     }
   });
 
@@ -376,9 +375,10 @@ describe("Tool Annotations & Classification", () => {
     // We expect all tools to be registered when all capabilities are enabled
     // (this suite forces ALL_CAPABILITIES, including default-disabled ones).
     // Includes 11 skill tools, 7 MCP server tools, reusable script tools, and the
-    // native Kapso/WhatsApp tools (register/unregister number + send/reply message).
+    // native Kapso/WhatsApp tools (register/unregister number + send/reply message),
+    // and the six Chat SDK tools (chat-* + register/unregister-chat-channel).
     expect(count).toBeGreaterThanOrEqual(45);
-    expect(count).toBeLessThanOrEqual(157);
+    expect(count).toBeLessThanOrEqual(163);
   });
 
   test("core tools are fewer than deferred tools", () => {