@desplega.ai/agent-swarm 1.173.0 → 2.0.0

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

@@ -1,5 +1,10 @@
 import { afterAll, beforeEach, describe, expect, test } from "bun:test";
-import { type BasePromptArgs, getBasePrompt, truncateRepoClaudeMd } from "../prompts/base-prompt";
+import {
+  type BasePromptArgs,
+  getBasePrompt,
+  getTaskContextPrompt,
+  truncateRepoClaudeMd,
+} from "../prompts/base-prompt";
 import { generateDefaultClaudeMd, generateDefaultIdentityMd } from "../prompts/defaults";
 import type { ProviderTraits } from "../providers/types";
 
@@ -377,7 +382,7 @@ describe("getBasePrompt: persona injection", () => {
 });
 
 // ---------------------------------------------------------------------------
-// 4. Agent notes (CLAUDE.md): codex, opencode, pi only, only when edited
+// 4. Agent notes (CLAUDE.md): local providers, only when edited
 // ---------------------------------------------------------------------------
 
 describe("getBasePrompt: agent notes section", () => {
@@ -385,18 +390,9 @@ describe("getBasePrompt: agent notes section", () => {
   const EDITED = "# Agent: Ada\n\nAlways run `bun run tsc:check` before you push.";
   const notesAgent = { name: "Ada", role: "worker" };
 
-  test("claude never gets the section, even when the notes are edited", async () => {
-    const result = await getBasePrompt({
-      ...minimalArgs,
-      name: "Ada",
-      provider: "claude",
-      claudeMd: EDITED,
-    });
-    expect(result).not.toContain(NOTES_HEADER);
-    expect(result).not.toContain("Always run `bun run tsc:check` before you push.");
-  });
-
-  for (const provider of ["codex", "opencode", "pi"] as const) {
+  // Claude excludes ~/.claude/CLAUDE.md from its memory load
+  // (claude-flag-settings.ts), so the system prompt is its only copy.
+  for (const provider of ["claude", "codex", "opencode", "pi"] as const) {
     test(`${provider} gets the section when the notes are edited`, async () => {
       const result = await getBasePrompt({
         ...minimalArgs,
@@ -409,6 +405,17 @@ describe("getBasePrompt: agent notes section", () => {
     });
   }
 
+  test("claude truncates notes over 20k characters and points at its own file", async () => {
+    const result = await getBasePrompt({
+      ...minimalArgs,
+      name: "Ada",
+      provider: "claude",
+      claudeMd: "x".repeat(25_000),
+    });
+    expect(result).toContain("[...truncated, see ~/.claude/CLAUDE.md for full content]");
+    expect(result).not.toContain("x".repeat(20_000));
+  });
+
   test("codex skips notes that equal the generated default", async () => {
     const result = await getBasePrompt({
       ...minimalArgs,
@@ -598,11 +605,15 @@ describe("getBasePrompt: slack section", () => {
 
   test("a scripts-only worker with a Slack task gets the scripts-only variant only", async () => {
     enableSlack();
-    const result = await getBasePrompt({
+    const system = await getBasePrompt({ ...minimalArgs, scriptsOnly: true });
+    const result = await getTaskContextPrompt({
       ...minimalArgs,
       scriptsOnly: true,
       slackContext: { channelId: "C0SAMPLE", threadTs: "123.456" },
     });
+    // The channel id is per task, so the note rides in the task prompt.
+    expect(system).not.toContain(SCRIPTS_ONLY_SLACK_HEADER);
+    expect(system).not.toContain(SLACK_HEADER);
     expect(result).toContain(SCRIPTS_ONLY_SLACK_HEADER);
     expect(result).toContain("C0SAMPLE");
     expect(result).not.toContain(SLACK_HEADER);
@@ -610,7 +621,7 @@ describe("getBasePrompt: slack section", () => {
 
   test("a scripts-only lead with a Slack task gets neither variant", async () => {
     enableSlack();
-    const result = await getBasePrompt({
+    const result = await getTaskContextPrompt({
       ...minimalArgs,
       role: "lead",
       scriptsOnly: true,
@@ -786,14 +797,14 @@ describe("getBasePrompt: tools and skills section", () => {
 // 10. Repository
 // ---------------------------------------------------------------------------
 
-describe("getBasePrompt: repository section", () => {
+describe("getTaskContextPrompt: repository section", () => {
   const CLONE_PATH = "/workspace/repos/my-repo";
   const CLONE_SENTENCE = "This task's repository is cloned locally. `get-repos` returns the path.";
   const CODE_QUALITY_LINE =
     "You MUST use the `code-quality` skill before you push, open a PR, or review one.";
 
   test("a local claude worker gets the clone sentence and no clone path literal", async () => {
-    const result = await getBasePrompt({
+    const result = await getTaskContextPrompt({
       ...minimalArgs,
       traits: localTraits,
       repoContext: { claudeMd: "Repo rules here.", clonePath: CLONE_PATH },
@@ -804,7 +815,7 @@ describe("getBasePrompt: repository section", () => {
   });
 
   test("claude does not get the repo CLAUDE.md inlined", async () => {
-    const result = await getBasePrompt({
+    const result = await getTaskContextPrompt({
       ...minimalArgs,
       provider: "claude",
       traits: localTraits,
@@ -814,7 +825,7 @@ describe("getBasePrompt: repository section", () => {
   });
 
   test("opencode inlines the repo CLAUDE.md with the clone path", async () => {
-    const result = await getBasePrompt({
+    const result = await getTaskContextPrompt({
       ...minimalArgs,
       provider: "opencode",
       traits: localTraits,
@@ -826,7 +837,7 @@ describe("getBasePrompt: repository section", () => {
 
   test("opencode truncates a repo CLAUDE.md over 12k with an on-disk pointer", async () => {
     const huge = "x".repeat(30_000);
-    const result = await getBasePrompt({
+    const result = await getTaskContextPrompt({
       ...minimalArgs,
       provider: "opencode",
       traits: localTraits,
@@ -838,7 +849,7 @@ describe("getBasePrompt: repository section", () => {
 
   test("opencode keeps a repo CLAUDE.md under the cap verbatim", async () => {
     const small = "y".repeat(5_000);
-    const result = await getBasePrompt({
+    const result = await getTaskContextPrompt({
       ...minimalArgs,
       provider: "opencode",
       traits: localTraits,
@@ -849,7 +860,7 @@ describe("getBasePrompt: repository section", () => {
   });
 
   test("shows the repo warning when one is set", async () => {
-    const result = await getBasePrompt({
+    const result = await getTaskContextPrompt({
       ...minimalArgs,
       repoContext: { clonePath: CLONE_PATH, warning: "Repo is stale" },
     });
@@ -857,7 +868,7 @@ describe("getBasePrompt: repository section", () => {
   });
 
   test("surfaces auto-stashed work when entries exist", async () => {
-    const result = await getBasePrompt({
+    const result = await getTaskContextPrompt({
       ...minimalArgs,
       traits: localTraits,
       repoContext: {
@@ -871,7 +882,7 @@ describe("getBasePrompt: repository section", () => {
   });
 
   test("says nothing about stashes when the list is empty", async () => {
-    const result = await getBasePrompt({
+    const result = await getTaskContextPrompt({
       ...minimalArgs,
       traits: localTraits,
       repoContext: { clonePath: CLONE_PATH, autoStashes: [] },
@@ -880,7 +891,7 @@ describe("getBasePrompt: repository section", () => {
   });
 
   test("null guidelines tell the agent to ask the lead", async () => {
-    const result = await getBasePrompt({
+    const result = await getTaskContextPrompt({
       ...minimalArgs,
       repoContext: { clonePath: CLONE_PATH, guidelines: null },
     });
@@ -889,7 +900,7 @@ describe("getBasePrompt: repository section", () => {
   });
 
   test("full guidelines render PR checks, merge policy, and review guidance", async () => {
-    const result = await getBasePrompt({
+    const result = await getTaskContextPrompt({
       ...minimalArgs,
       repoContext: {
         clonePath: CLONE_PATH,
@@ -911,7 +922,7 @@ describe("getBasePrompt: repository section", () => {
   });
 
   test("all-empty guidelines render no guidelines block", async () => {
-    const result = await getBasePrompt({
+    const result = await getTaskContextPrompt({
       ...minimalArgs,
       repoContext: {
         clonePath: CLONE_PATH,
@@ -923,7 +934,7 @@ describe("getBasePrompt: repository section", () => {
   });
 
   test("allowMerge true renders the merge policy even with empty arrays", async () => {
-    const result = await getBasePrompt({
+    const result = await getTaskContextPrompt({
       ...minimalArgs,
       repoContext: {
         clonePath: CLONE_PATH,
@@ -935,7 +946,7 @@ describe("getBasePrompt: repository section", () => {
   });
 
   test("a remote worker keeps the guidelines but loses the clone sentence", async () => {
-    const result = await getBasePrompt({
+    const result = await getTaskContextPrompt({
       ...minimalArgs,
       provider: "devin",
       traits: remoteTraits,
@@ -957,7 +968,7 @@ describe("getBasePrompt: repository section", () => {
   });
 
   test("the code-quality pointer is present with MCP", async () => {
-    const result = await getBasePrompt({
+    const result = await getTaskContextPrompt({
       ...minimalArgs,
       traits: localTraits,
       repoContext: { clonePath: CLONE_PATH },
@@ -966,7 +977,7 @@ describe("getBasePrompt: repository section", () => {
   });
 
   test("the code-quality pointer is absent for a remote worker", async () => {
-    const result = await getBasePrompt({
+    const result = await getTaskContextPrompt({
       ...minimalArgs,
       traits: remoteTraits,
       repoContext: { clonePath: CLONE_PATH },
@@ -1033,18 +1044,6 @@ describe("getBasePrompt: size budget", () => {
       claudeMd: big(40_000),
       skillsSummary: [{ name: "commit", description: "Create a commit" }],
       mcpServers: ["linear"],
-      slackContext: { channelId: "C0SAMPLE" },
-      repoContext: {
-        claudeMd: big(60_000),
-        clonePath: "/workspace/repos/big-repo",
-        warning: "Repo is stale",
-        guidelines: {
-          prChecks: ["bun run lint"],
-          mergeChecks: ["CI green"],
-          allowMerge: true,
-          review: ["Read the runbook"],
-        },
-      },
     });
     expect(result.length).toBeLessThan(120_000);
   });
@@ -1070,7 +1069,7 @@ describe("getBasePrompt: output hygiene", () => {
       args: { ...minimalArgs, name: "Ada", traits: remoteTraits, provider: "devin" },
     },
     {
-      label: "codex worker with skills and a repo",
+      label: "codex worker with skills",
       args: {
         ...minimalArgs,
         name: "Ada",
@@ -1078,20 +1077,25 @@ describe("getBasePrompt: output hygiene", () => {
         traits: { ...localTraits, nativeSkillDiscovery: false, steerModes: ["queue"] },
         skillsSummary: [{ name: "commit", description: "Create a commit" }],
         mcpServers: ["linear"],
-        repoContext: {
-          clonePath: "/workspace/repos/my-repo",
-          guidelines: {
-            prChecks: ["bun run lint"],
-            mergeChecks: [],
-            allowMerge: false,
-            review: [],
-          },
-        },
       },
     },
     { label: "scripts-only worker", args: { ...minimalArgs, name: "Ada", scriptsOnly: true } },
   ];
 
+  test("the task context renders no em dash and no triple newline", async () => {
+    const result = await getTaskContextPrompt({
+      ...minimalArgs,
+      provider: "codex",
+      traits: localTraits,
+      repoContext: {
+        clonePath: "/workspace/repos/my-repo",
+        guidelines: { prChecks: ["bun run lint"], mergeChecks: [], allowMerge: false, review: [] },
+      },
+    });
+    expect(result).not.toContain(EM_DASH);
+    expect(result).not.toMatch(/\n{3,}/);
+  });
+
   for (const variant of hygieneVariants) {
     test(`${variant.label} renders no em dash`, async () => {
       const result = await getBasePrompt(variant.args);

package/src/tests/chat-sdk-commands.test.ts

@@ -0,0 +1,191 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { closeDb, createAgent, getDbClient, getTaskById, initDb } from "../be/db";
+import { CHAT_COMMANDS } from "../integrations/chat-sdk/commands";
+import { startChatSdk, stopChatSdk } from "../integrations/chat-sdk/runtime";
+import { readPersistedThreadHistory } from "../integrations/chat-sdk/state";
+import { chatSdkContextKey } from "../tasks/context-key";
+import {
+  flushChatBuffers,
+  postTelegramUpdate,
+  startTelegramHarness,
+  type TelegramChat,
+  type TelegramHarness,
+  telegramUpdate,
+} from "./chat-sdk-harness";
+
+const TEST_DB_PATH = "./test-chat-sdk-commands.sqlite";
+
+let harness: TelegramHarness;
+
+type TaskRow = { id: string; task: string; status: string; parentTaskId: string | null };
+
+async function chatTasks(chatId: number): Promise<TaskRow[]> {
+  return getDbClient().query<TaskRow>(
+    `SELECT id, task, status, parentTaskId FROM agent_tasks
+       WHERE source = 'chat' AND contextKey = ? ORDER BY createdAt, rowid`,
+    [chatSdkContextKey(`telegram:${chatId}`)],
+  );
+}
+
+async function removeDbFiles(): Promise<void> {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    await unlink(`${TEST_DB_PATH}${suffix}`).catch(() => {});
+  }
+}
+
+const dm = (id: number): TelegramChat => ({ id, type: "private" });
+
+/** A `/command` update: Telegram marks the command with a `bot_command` entity at offset 0. */
+function commandUpdate(chat: TelegramChat, command: string): Record<string, unknown> {
+  return telegramUpdate(chat, command, {
+    entities: [{ type: "bot_command", offset: 0, length: command.length }],
+  });
+}
+
+/** Text of every message the bot sent to `chatId`, in order. */
+function sentTexts(chatId: number): string[] {
+  return harness.mock.calls
+    .filter((call) => /^send(Rich)?Message$/.test(call.method))
+    .filter((call) => String(call.body.chat_id) === String(chatId))
+    .map((call) => {
+      const rich = call.body.rich_message as { markdown?: string } | undefined;
+      return String(call.body.text ?? rich?.markdown ?? "");
+    });
+}
+
+beforeAll(async () => {
+  await removeDbFiles();
+  initDb(TEST_DB_PATH);
+  await createAgent({ id: crypto.randomUUID(), name: "CmdLead", isLead: true, status: "idle" });
+  harness = await startTelegramHarness();
+});
+
+afterAll(async () => {
+  await harness.stop();
+  closeDb();
+  await removeDbFiles();
+});
+
+describe("Chat SDK slash commands", () => {
+  test("the command list is published to Telegram at adapter start", () => {
+    const call = harness.mock.calls.find((c) => c.method === "setMyCommands");
+    expect(call).toBeDefined();
+    const names = (call!.body.commands as { command: string }[]).map((c) => c.command);
+    expect(names).toEqual(CHAT_COMMANDS.map((c) => c.command));
+  });
+
+  test("/help answers with the list and creates no task", async () => {
+    await postTelegramUpdate(commandUpdate(dm(3001), "/help"));
+    const texts = sentTexts(3001);
+    expect(texts).toHaveLength(1);
+    for (const spec of CHAT_COMMANDS) expect(texts[0]).toContain(`/${spec.command}`);
+    await flushChatBuffers();
+    expect(await chatTasks(3001)).toHaveLength(0);
+  });
+
+  test("an unknown command gets the list instead of silence", async () => {
+    await postTelegramUpdate(commandUpdate(dm(3002), "/deploy"));
+    const texts = sentTexts(3002);
+    expect(texts).toHaveLength(1);
+    expect(texts[0]).toContain("Unknown command /deploy");
+    expect(texts[0]).toContain("/help");
+    await flushChatBuffers();
+    expect(await chatTasks(3002)).toHaveLength(0);
+  });
+
+  test("/status reports the latest task and /cancel cancels the active one", async () => {
+    await postTelegramUpdate(commandUpdate(dm(3003), "/status"));
+    expect(sentTexts(3003).at(-1)).toContain("No task yet");
+
+    await postTelegramUpdate(telegramUpdate(dm(3003), "please look into the build"));
+    await flushChatBuffers();
+    const [task] = await chatTasks(3003);
+    expect(task).toBeDefined();
+    expect(task!.status).toBe("pending");
+
+    await postTelegramUpdate(commandUpdate(dm(3003), "/status"));
+    const status = sentTexts(3003).at(-1)!;
+    expect(status).toContain(task!.id.slice(0, 8));
+    expect(status).toContain("pending");
+    expect(status).toContain("/cancel");
+
+    await postTelegramUpdate(commandUpdate(dm(3003), "/cancel"));
+    expect(sentTexts(3003).at(-1)).toContain(`Cancelled task ${task!.id.slice(0, 8)}`);
+    const cancelled = await getTaskById(task!.id);
+    expect(cancelled?.status).toBe("cancelled");
+    expect(cancelled?.failureReason).toContain("Cancelled from chat by tester");
+
+    await postTelegramUpdate(commandUpdate(dm(3003), "/cancel"));
+    expect(sentTexts(3003).at(-1)).toContain("No running task");
+  });
+
+  test("/reset starts a new conversation: no parent task and no older context", async () => {
+    await postTelegramUpdate(telegramUpdate(dm(3004), "the first request"));
+    await flushChatBuffers();
+    await postTelegramUpdate(telegramUpdate(dm(3004), "a follow-up"));
+    await flushChatBuffers();
+    let tasks = await chatTasks(3004);
+    expect(tasks).toHaveLength(2);
+    expect(tasks[1]!.parentTaskId).toBe(tasks[0]!.id);
+    expect(tasks[1]!.task).toContain("<thread_context>");
+    expect(tasks[1]!.task).toContain("the first request");
+
+    // Reset while a task still runs: the mark is set, and the reply says so.
+    await postTelegramUpdate(commandUpdate(dm(3004), "/reset"));
+    expect(sentTexts(3004).at(-1)).toContain("Context reset");
+    expect(sentTexts(3004).at(-1)).toContain("still running");
+
+    // The usual case: the thread's tasks are done when the user resets.
+    await getDbClient().run("UPDATE agent_tasks SET status = 'completed' WHERE contextKey = ?", [
+      chatSdkContextKey("telegram:3004"),
+    ]);
+    await postTelegramUpdate(commandUpdate(dm(3004), "/reset"));
+    expect(sentTexts(3004).at(-1)).not.toContain("still running");
+    // The reset mark is compared to message timestamps with second precision.
+    await Bun.sleep(1_100);
+
+    await postTelegramUpdate(telegramUpdate(dm(3004), "a brand new topic"));
+    await flushChatBuffers();
+    tasks = await chatTasks(3004);
+    expect(tasks).toHaveLength(3);
+    expect(tasks[2]!.parentTaskId).toBeNull();
+    expect(tasks[2]!.task).not.toContain("<thread_context>");
+    expect(tasks[2]!.task).not.toContain("the first request");
+
+    await postTelegramUpdate(telegramUpdate(dm(3004), "more on the new topic"));
+    await flushChatBuffers();
+    tasks = await chatTasks(3004);
+    expect(tasks).toHaveLength(4);
+    expect(tasks[3]!.parentTaskId).toBe(tasks[2]!.id);
+    expect(tasks[3]!.task).toContain("a brand new topic");
+    expect(tasks[3]!.task).not.toContain("the first request");
+    expect(tasks[3]!.task).not.toContain("a follow-up");
+  });
+});
+
+describe("Chat SDK thread context across an adapter restart", () => {
+  test("the SDK persists Telegram history under the pinned key prefix", async () => {
+    await postTelegramUpdate(telegramUpdate(dm(3005), "remember this one"));
+    await flushChatBuffers();
+    const history = await readPersistedThreadHistory("telegram:3005");
+    expect(history.map((m) => m.text)).toContain("remember this one");
+  });
+
+  test("a message after a restart still carries the earlier thread messages", async () => {
+    await postTelegramUpdate(telegramUpdate(dm(3006), "before the restart"));
+    await flushChatBuffers();
+
+    // Same as a config reload or an API restart: the adapter's memory is gone.
+    await stopChatSdk();
+    await startChatSdk();
+
+    await postTelegramUpdate(telegramUpdate(dm(3006), "after the restart"));
+    await flushChatBuffers();
+    const tasks = await chatTasks(3006);
+    expect(tasks).toHaveLength(2);
+    expect(tasks[1]!.parentTaskId).toBe(tasks[0]!.id);
+    expect(tasks[1]!.task).toContain("<thread_context>");
+    expect(tasks[1]!.task).toContain("before the restart");
+  });
+});