@desplega.ai/agent-swarm 1.84.0 → 1.84.1

package/src/tests/agentmail-sending-skill.test.ts

@@ -0,0 +1,75 @@
+import { describe, expect, test } from "bun:test";
+
+const skillPath = `${import.meta.dir}/../../templates/skills/agentmail-sending/SKILL.md`;
+const skill = await Bun.file(skillPath).text();
+const curlInboxVariable = "$" + "{INBOX}";
+const scriptApiKeyVariable = "$" + "{apiKey}";
+
+function requireMatch(pattern: RegExp, label: string): RegExpMatchArray {
+  const match = skill.match(pattern);
+  if (!match) {
+    throw new Error(`Missing ${label}`);
+  }
+  return match;
+}
+
+describe("agentmail-sending skill template", () => {
+  test("pins the canonical base URL and rejects the hallucinated host", () => {
+    expect(skill).toContain("```text\nhttps://api.agentmail.to/v0/\n```");
+    expect(skill).toContain("DO NOT use `api.agentmail.ai`");
+    expect(skill).not.toContain("https://api.agentmail.ai");
+  });
+
+  test("pins send-message field names and text-only guidance", () => {
+    expect(skill).toContain("```text\nto\nbcc\nsubject\ntext\n```");
+    expect(skill).toContain("Use `text`, NOT `text_body`, `body`, or `content`.");
+    expect(skill).toContain("Do NOT pass `html`.");
+  });
+
+  test("curl example uses the canonical endpoint, bearer auth, and exact JSON fields", () => {
+    expect(skill).toContain("https://api.agentmail.to/v0/inboxes/{inbox}/messages/send");
+    expect(skill).toContain(
+      [
+        'curl -sS -X POST "https://api.agentmail.to/v0/inboxes/',
+        curlInboxVariable,
+        '/messages/send"',
+      ].join(""),
+    );
+    expect(skill).toContain('-H "Authorization: Bearer $AGENTMAIL_API_KEY"');
+
+    const jsonBlock = requireMatch(
+      /--data-binary @- <<'JSON'\n([\s\S]*?)\nJSON/,
+      "curl JSON body",
+    )[1];
+    const payload = JSON.parse(jsonBlock);
+
+    expect(Object.keys(payload)).toEqual(["to", "bcc", "subject", "text"]);
+    expect(payload).not.toHaveProperty("text_body");
+    expect(payload).not.toHaveProperty("body");
+    expect(payload).not.toHaveProperty("content");
+    expect(payload).not.toHaveProperty("html");
+  });
+
+  test("script_upsert example uses fetch and resolves AGENTMAIL_API_KEY from swarm config", () => {
+    const scriptBlock = requireMatch(/```ts\n([\s\S]*?)\n```/, "script_upsert example")[1];
+
+    expect(scriptBlock).toContain("await script_upsert({");
+    expect(scriptBlock).toContain("ctx.swarm.config.get('AGENTMAIL_API_KEY')");
+    expect(scriptBlock).toContain("ctx.stdlib.fetch(");
+    expect(scriptBlock).toContain("https://api.agentmail.to/v0/inboxes/");
+    expect(scriptBlock).toContain("messages/send");
+    expect(scriptBlock).toContain(
+      ["Authorization: \\`Bearer \\", scriptApiKeyVariable, "\\`"].join(""),
+    );
+    expect(scriptBlock).toContain("text: args.text");
+    expect(scriptBlock).not.toContain("text_body");
+    expect(scriptBlock).not.toContain("html:");
+  });
+
+  test("common error table covers known AgentMail mistakes", () => {
+    expect(skill).toContain("404 on `/v0/inboxes/.../send`");
+    expect(skill).toContain('422 `{"detail":"text Field required"}`');
+    expect(skill).toContain("401");
+    expect(skill).toContain("HTML rendering bug");
+  });
+});

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

@@ -0,0 +1,33 @@
+import { describe, expect, test } from "bun:test";
+import { getAgentModelDisplay } from "../../ui/src/lib/agents-list-model-display";
+
+describe("agents list model display", () => {
+  test("shows configured and last-used models when they diverge", () => {
+    const display = getAgentModelDisplay("claude-opus-4-7", "claude-sonnet-4-6");
+
+    expect(display).toEqual({
+      configured: "claude-opus-4-7",
+      lastUsed: "claude-sonnet-4-6",
+      primary: "claude-opus-4-7",
+      diverged: true,
+    });
+  });
+
+  test("shows one model when configured and last-used match", () => {
+    const display = getAgentModelDisplay("claude-sonnet-4-6", "claude-sonnet-4-6");
+
+    expect(display).toEqual({
+      configured: "claude-sonnet-4-6",
+      lastUsed: "claude-sonnet-4-6",
+      primary: "claude-sonnet-4-6",
+      diverged: false,
+    });
+  });
+
+  test("shows configured model alone before an agent reports a last-used model", () => {
+    const display = getAgentModelDisplay("claude-opus-4-7", null);
+
+    expect(display.primary).toBe("claude-opus-4-7");
+    expect(display.diverged).toBe(false);
+  });
+});

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

@@ -1,4 +1,4 @@
-import { describe, expect, test } from "bun:test";
+import { afterEach, describe, expect, test } from "bun:test";
 import { type BasePromptArgs, getBasePrompt } from "../prompts/base-prompt";
 import type { ProviderTraits } from "../providers/types";
 
@@ -9,6 +9,39 @@ const minimalArgs: BasePromptArgs = {
   swarmUrl: "swarm.example.com",
 };
 
+const originalSlackDisable = process.env.SLACK_DISABLE;
+const originalSlackBotToken = process.env.SLACK_BOT_TOKEN;
+const originalSlackAppToken = process.env.SLACK_APP_TOKEN;
+
+afterEach(() => {
+  restoreEnv("SLACK_DISABLE", originalSlackDisable);
+  restoreEnv("SLACK_BOT_TOKEN", originalSlackBotToken);
+  restoreEnv("SLACK_APP_TOKEN", originalSlackAppToken);
+});
+
+function restoreEnv(
+  name: "SLACK_DISABLE" | "SLACK_BOT_TOKEN" | "SLACK_APP_TOKEN",
+  value: string | undefined,
+) {
+  if (value === undefined) {
+    delete process.env[name];
+  } else {
+    process.env[name] = value;
+  }
+}
+
+function enableSlackPromptTools() {
+  process.env.SLACK_DISABLE = "false";
+  process.env.SLACK_BOT_TOKEN = "xoxb-test-token";
+  process.env.SLACK_APP_TOKEN = "xapp-test-token";
+}
+
+function disableSlackPromptTools() {
+  process.env.SLACK_DISABLE = "true";
+  delete process.env.SLACK_BOT_TOKEN;
+  delete process.env.SLACK_APP_TOKEN;
+}
+
 // ---------------------------------------------------------------------------
 // Basic fields
 // ---------------------------------------------------------------------------
@@ -533,3 +566,59 @@ describe("getBasePrompt — local providers unaffected", () => {
     expect(result).toContain("/workspace");
   });
 });
+
+describe("getBasePrompt — conditional Slack templates", () => {
+  test("omits Slack tool templates when Slack is disabled", async () => {
+    disableSlackPromptTools();
+
+    const result = await getBasePrompt({
+      ...minimalArgs,
+      role: "lead",
+      slackContext: { channelId: "C123", threadTs: "123.456" },
+    });
+
+    expect(result).not.toMatch(/\bslack-[a-z-]+\b/);
+    expect(result).toContain("Task Routing");
+  });
+
+  test("includes Slack tool template for lead when Slack is enabled", async () => {
+    enableSlackPromptTools();
+
+    const result = await getBasePrompt({
+      ...minimalArgs,
+      role: "lead",
+    });
+
+    expect(result).toContain("#### Slack Tools");
+    expect(result).toContain("slack-reply");
+    expect(result).toContain("slack-read");
+    expect(result).toContain("slack-list-channels");
+  });
+
+  test("includes Slack tool template for worker when Slack is enabled", async () => {
+    enableSlackPromptTools();
+
+    const result = await getBasePrompt({
+      ...minimalArgs,
+      role: "worker",
+    });
+
+    expect(result).toContain("#### Slack Tools");
+    expect(result).toContain("slack-reply");
+    expect(result).toContain("slack-read");
+    expect(result).toContain("slack-list-channels");
+  });
+
+  test("includes worker Slack thread template when Slack is enabled", async () => {
+    enableSlackPromptTools();
+
+    const result = await getBasePrompt({
+      ...minimalArgs,
+      role: "worker",
+      slackContext: { channelId: "C123", threadTs: "123.456" },
+    });
+
+    expect(result).toContain("slack-reply");
+    expect(result).toContain("C123");
+  });
+});

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

@@ -439,6 +439,26 @@ describe("GET /api/users/unmapped", () => {
     expect(body.unmapped[0]!.count).toBe(5);
     expect(body.unmapped[1]!.externalId).toBe("U_LOW");
   });
+
+  test("default unmapped list includes Kapso sender identities", async () => {
+    const ns = "integration:unmapped:kapso";
+    upsertKv({
+      namespace: ns,
+      key: "34679077777:meta",
+      value: { lastSeenAt: "2026-05-20T00:00:00Z", sampleEventType: "kapso.message.received" },
+      valueType: "json",
+    });
+    upsertKv({ namespace: ns, key: "34679077777:count", value: 1, valueType: "integer" });
+
+    const r = await authedFetch("/api/users/unmapped");
+    expect(r.status).toBe(200);
+    const body = (await r.json()) as {
+      unmapped: Array<{ kind: string; externalId: string }>;
+    };
+    expect(body.unmapped).toContainEqual(
+      expect.objectContaining({ kind: "kapso", externalId: "34679077777" }),
+    );
+  });
 });
 
 describe("POST /api/users/unmapped/:kind/:externalId/resolve", () => {
@@ -482,6 +502,39 @@ describe("POST /api/users/unmapped/:kind/:externalId/resolve", () => {
     expect(user.identities).toContainEqual({ kind: "github", externalId: "ghuser" });
   });
 
+  test("create-new branch supports phone-only Kapso contacts without email", async () => {
+    const ns = "integration:unmapped:kapso";
+    upsertKv({
+      namespace: ns,
+      key: "34679077777:meta",
+      value: { lastSeenAt: "x", sampleEventType: "kapso.message.received" },
+      valueType: "json",
+    });
+    upsertKv({ namespace: ns, key: "34679077777:count", value: 1, valueType: "integer" });
+
+    const r = await authedFetch("/api/users/unmapped/kapso/34679077777/resolve", {
+      method: "POST",
+      body: JSON.stringify({
+        name: "Taras",
+        notes: "WhatsApp: +34 679 077 777 (E.164: 34679077777)",
+      }),
+    });
+    expect(r.status).toBe(200);
+    const { user } = (await r.json()) as {
+      user: {
+        id: string;
+        name: string;
+        email?: string;
+        notes?: string;
+        identities: Array<{ kind: string; externalId: string }>;
+      };
+    };
+    expect(user.name).toBe("Taras");
+    expect(user.email).toBeUndefined();
+    expect(user.notes).toContain("E.164: 34679077777");
+    expect(user.identities).toContainEqual({ kind: "kapso", externalId: "34679077777" });
+  });
+
   test("URL-encoded externalId is decoded — kv rows clear, identity stored decoded", async () => {
     // Mimics an AgentMail/Linear @handle entry that contains `@` (or any
     // URL-reserved char). Kv keys are written by the webhook with the literal

package/src/tests/kapso-inbound.test.ts

@@ -1,7 +1,8 @@
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import crypto from "node:crypto";
 import type { IncomingMessage, ServerResponse } from "node:http";
-import { closeDb, createAgent, getTaskById, initDb } from "../be/db";
+import { closeDb, createAgent, createUser, getKv, getTaskById, initDb } from "../be/db";
+import { findUserByExternalId, linkIdentity } from "../be/users";
 import { handleWebhooks } from "../http/webhooks";
 import { putKapsoNumberMapping } from "../integrations/kapso/config";
 import { routeKapsoInbound } from "../integrations/kapso/inbound";
@@ -107,6 +108,64 @@ describe("routeKapsoInbound", () => {
     expect(task!.task).toContain("## Source: WhatsApp (Kapso)");
   });
 
+  test("known Kapso sender → populates requestedByUserId and skips unmapped tracker", () => {
+    putKapsoNumberMapping({
+      phoneNumberId: "pn-known-sender",
+      agentId,
+      createdAt: new Date().toISOString(),
+    });
+    const user = createUser({ name: "Known WhatsApp Sender" });
+    linkIdentity(user.id, "kapso", "34679077778", { kind: "system", id: "test-fixture" });
+
+    const routing = routeKapsoInbound(
+      makePayload({
+        phoneNumberId: "pn-known-sender",
+        messageId: "wamid.KNOWN_SENDER",
+        from: "+34 679 077 778",
+        conversationId: "conv-known-sender",
+      }),
+    );
+
+    expect(routing.kind).toBe("task");
+    if (routing.kind !== "task") throw new Error("expected task");
+    const task = getTaskById(routing.taskId);
+    expect(task!.requestedByUserId).toBe(user.id);
+    expect(getKv("integration:unmapped:kapso", "34679077778:meta")).toBeNull();
+  });
+
+  test("unknown Kapso sender → records unmapped identity and leaves task unowned", () => {
+    putKapsoNumberMapping({
+      phoneNumberId: "pn-unknown-sender",
+      agentId,
+      createdAt: new Date().toISOString(),
+    });
+    expect(findUserByExternalId("kapso", "34679077779")).toBeNull();
+
+    const routing = routeKapsoInbound(
+      makePayload({
+        phoneNumberId: "pn-unknown-sender",
+        messageId: "wamid.UNKNOWN_SENDER",
+        from: "+34 679 077 779",
+        conversationId: "conv-unknown-sender",
+      }),
+    );
+
+    expect(routing.kind).toBe("task");
+    if (routing.kind !== "task") throw new Error("expected task");
+    const task = getTaskById(routing.taskId);
+    expect(task!.requestedByUserId).toBeUndefined();
+
+    const meta = getKv("integration:unmapped:kapso", "34679077779:meta");
+    expect(meta?.valueType).toBe("json");
+    expect(meta?.value).toMatchObject({
+      sampleEventType: "kapso.message.received",
+    });
+    expect(String(meta?.value.sampleContext)).toContain("contact=Taras");
+    expect(String(meta?.value.sampleContext)).toContain("message=wamid.UNKNOWN_SENDER");
+    const count = getKv("integration:unmapped:kapso", "34679077779:count");
+    expect(count?.value).toBe(1);
+  });
+
   test("no mapping → no_mapping (does not break, no task)", () => {
     const routing = routeKapsoInbound(makePayload({ phoneNumberId: "pn-unregistered" }));
     expect(routing.kind).toBe("no_mapping");

package/src/tests/kv-page-proxy.test.ts

@@ -52,6 +52,7 @@ beforeAll(async () => {
       ...process.env,
       PORT: String(TEST_PORT),
       DATABASE_PATH: TEST_DB_PATH,
+      AGENT_SWARM_API_KEY: API_KEY,
       API_KEY,
       PAGE_SESSION_SECRET: PAGE_SECRET,
       MCP_BASE_URL: `http://127.0.0.1:${TEST_PORT}`,

package/src/tests/pagination-metrics.test.ts

@@ -47,6 +47,8 @@ describe("pagination metrics", () => {
   });
 
   test("getTasksCount is filter-aware and independent of limit/offset", () => {
+    const totalBefore = getTasksCount();
+
     for (let i = 0; i < 7; i++) {
       createTaskExtended(`alpha task ${i}`, { tags: ["alpha"] });
     }
@@ -66,7 +68,7 @@ describe("pagination metrics", () => {
     expect(getTasksCount({ tags: ["alpha"], limit: 2, offset: 0 })).toBe(7);
 
     // The unfiltered count covers every task created above.
-    expect(getTasksCount()).toBe(10);
+    expect(getTasksCount() - totalBefore).toBe(10);
   });
 
   test("getTasksCount filter-aware on search", () => {
@@ -123,9 +125,7 @@ describe("pagination metrics", () => {
     expect(countSessions({ source: ["slack"] }) - slackBefore).toBe(2);
     expect(countSessions({ source: ["mcp", "slack"] }) - bothBefore).toBe(7);
     // q filter narrows on top of source.
-    expect(countSessions({ source: ["slack"], q: "slack session" })).toBe(
-      countSessions({ source: ["slack"] }),
-    );
+    expect(countSessions({ source: ["slack"], q: "slack session" }) - slackBefore).toBe(2);
     expect(countSessions({ q: "no-such-session-marker-zzz" })).toBe(0);
   });
 

package/src/tests/prompt-template-session.test.ts

@@ -54,11 +54,12 @@ describe("Session templates — registration", () => {
     await ensureTemplatesRegistered();
   });
 
-  test("all 13 system templates are registered", () => {
+  test("all 14 system templates are registered", () => {
     const systemTemplates = [
       "system.agent.role",
       "system.agent.register",
       "system.agent.lead",
+      "system.agent.slack",
       "system.agent.worker",
       "system.agent.worker.slack",
       "system.agent.filesystem",
@@ -89,10 +90,10 @@ describe("Session templates — registration", () => {
     }
   });
 
-  test("total of 18 session/system templates registered", () => {
+  test("total of 19 session/system templates registered", () => {
     const all = getAllTemplateDefinitions();
     const sessionSystem = all.filter((d) => d.category === "system" || d.category === "session");
-    expect(sessionSystem.length).toBe(18);
+    expect(sessionSystem.length).toBe(19);
   });
 });
 
@@ -150,6 +151,15 @@ describe("Session templates — individual resolution", () => {
     const result = resolveTemplate("system.agent.lead", {});
     expect(result.text).toContain("CRITICAL: You are a coordinator");
     expect(result.text).toContain("coordinator");
+    expect(result.text).not.toContain("slack-reply");
+  });
+
+  test("system.agent.slack contains Slack tool guidance", () => {
+    const result = resolveTemplate("system.agent.slack", {});
+    expect(result.text).toContain("Slack Tools");
+    expect(result.text).toContain("slack-reply");
+    expect(result.text).toContain("slack-read");
+    expect(result.text).toContain("slack-list-channels");
   });
 
   test("system.agent.worker contains worker tools", () => {

package/src/tests/runner-context-preamble.test.ts

@@ -0,0 +1,202 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { createServer, type Server } from "node:http";
+import {
+  buildContextPreamble,
+  CONTEXT_PREAMBLE_MAX_CHARS,
+  CONTEXT_PREAMBLE_MAX_TOKENS,
+  fetchTaskContextForPreamble,
+  type TaskContextForPreamble,
+} from "../commands/context-preamble";
+
+const TEST_PORT = 19091;
+const API_URL = `http://localhost:${TEST_PORT}`;
+const API_KEY = "test-key";
+
+// In-memory task store for the mock server
+const mockTasks: Record<string, TaskContextForPreamble> = {};
+
+let server: Server;
+
+beforeAll(async () => {
+  server = createServer((req, res) => {
+    const url = req.url ?? "";
+    const match = url.match(/^\/api\/tasks\/([^/?]+)/);
+    if (match) {
+      const id = match[1];
+      const task = mockTasks[id];
+      if (task) {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify(task));
+      } else {
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "not found" }));
+      }
+      return;
+    }
+    res.writeHead(404);
+    res.end();
+  });
+
+  await new Promise<void>((resolve) => server.listen(TEST_PORT, resolve));
+});
+
+afterAll(() => {
+  server.close();
+  // Clear mocks
+  for (const k of Object.keys(mockTasks)) delete mockTasks[k];
+});
+
+function seedTask(task: TaskContextForPreamble): void {
+  mockTasks[task.id] = task;
+}
+
+describe("fetchTaskContextForPreamble", () => {
+  test("returns null on 404", async () => {
+    const result = await fetchTaskContextForPreamble(API_URL, API_KEY, "missing-id");
+    expect(result).toBeNull();
+  });
+
+  test("fetches task context fields", async () => {
+    seedTask({
+      id: "task-a",
+      task: "Build the widget",
+      output: "Widget built successfully",
+      status: "completed",
+      attachments: [{ kind: "url", name: "Report", url: "https://example.com/report" }],
+    });
+
+    const result = await fetchTaskContextForPreamble(API_URL, API_KEY, "task-a");
+    expect(result).not.toBeNull();
+    expect(result?.id).toBe("task-a");
+    expect(result?.task).toBe("Build the widget");
+    expect(result?.output).toBe("Widget built successfully");
+    expect(result?.attachments).toHaveLength(1);
+    expect(result?.attachments?.[0].name).toBe("Report");
+  });
+});
+
+describe("buildContextPreamble", () => {
+  test("returns null when parent task not found", async () => {
+    const result = await buildContextPreamble(API_URL, API_KEY, "nonexistent-parent");
+    expect(result).toBeNull();
+  });
+
+  test("includes parent task subject and output in preamble", async () => {
+    seedTask({
+      id: "parent-1",
+      task: "Fix the auth bug in login flow",
+      output: "Fixed by patching jwt validation in auth.ts:42",
+      status: "completed",
+    });
+
+    const preamble = await buildContextPreamble(API_URL, API_KEY, "parent-1");
+    expect(preamble).not.toBeNull();
+    expect(preamble).toContain("parent-1");
+    expect(preamble).toContain("Fix the auth bug in login flow");
+    expect(preamble).toContain("Fixed by patching jwt validation");
+    expect(preamble).toContain("get-task-details");
+    expect(preamble).toContain("Prior Conversation Context");
+  });
+
+  test("includes attachment pointers in preamble", async () => {
+    seedTask({
+      id: "parent-2",
+      task: "Generate a report",
+      output: "Report generated",
+      status: "completed",
+      attachments: [
+        { kind: "url", name: "Final Report", url: "https://example.com/report.pdf" },
+        {
+          kind: "agent-fs",
+          name: "Raw Data",
+          path: "thoughts/agent/research/data.md",
+          orgId: "org-123",
+          driveId: "drv-456",
+        },
+      ],
+    });
+
+    const preamble = await buildContextPreamble(API_URL, API_KEY, "parent-2");
+    expect(preamble).toContain("Final Report");
+    expect(preamble).toContain("https://example.com/report.pdf");
+    expect(preamble).toContain("Raw Data");
+    expect(preamble).toContain("live.agent-fs.dev");
+    expect(preamble).toContain("org-123");
+    expect(preamble).toContain("drv-456");
+  });
+
+  test("shows 'no output recorded' when task has no output or progress", async () => {
+    seedTask({
+      id: "parent-no-output",
+      task: "A task with no output yet",
+      status: "in_progress",
+    });
+
+    const preamble = await buildContextPreamble(API_URL, API_KEY, "parent-no-output");
+    expect(preamble).toContain("no output recorded");
+  });
+
+  test("walks ancestor chain and includes older ancestors as pointers", async () => {
+    seedTask({
+      id: "grandparent-1",
+      task: "Initial research task",
+      output: "Research complete",
+      status: "completed",
+    });
+    seedTask({
+      id: "child-of-grandparent",
+      task: "Second task referencing research",
+      output: "Second task done",
+      status: "completed",
+      parentTaskId: "grandparent-1",
+    });
+
+    const preamble = await buildContextPreamble(API_URL, API_KEY, "child-of-grandparent");
+    expect(preamble).not.toBeNull();
+    // Immediate parent (child-of-grandparent) gets inline detail
+    expect(preamble).toContain("child-of-grandparent");
+    expect(preamble).toContain("Second task done");
+    // Grandparent gets pointer-only entry
+    expect(preamble).toContain("grandparent-1");
+    expect(preamble).toContain("Older Ancestor Tasks");
+    expect(preamble).toContain("Initial research task");
+  });
+
+  test("enforces token budget — truncates oversized output", async () => {
+    // Generate output that exceeds the budget
+    const hugeOutput = "x".repeat(CONTEXT_PREAMBLE_MAX_CHARS + 5000);
+    seedTask({
+      id: "parent-big",
+      task: "Task with very large output",
+      output: hugeOutput,
+      status: "completed",
+    });
+
+    const preamble = await buildContextPreamble(API_URL, API_KEY, "parent-big");
+    expect(preamble).not.toBeNull();
+    // Preamble must be within budget (some slack for the truncation suffix)
+    expect(preamble?.length ?? 0).toBeLessThanOrEqual(
+      CONTEXT_PREAMBLE_MAX_CHARS + 300, // 300 chars slack for the truncation message
+    );
+  });
+
+  test("preamble starts with context section and ends with separator", async () => {
+    seedTask({
+      id: "parent-structure",
+      task: "A well-structured task",
+      output: "Done",
+      status: "completed",
+    });
+
+    const preamble = await buildContextPreamble(API_URL, API_KEY, "parent-structure");
+    expect(preamble).toContain("---");
+    expect(preamble).toContain("Prior Conversation Context");
+    // Should end with trailing separator
+    expect(preamble?.trimEnd()).toMatch(/---\s*$/);
+  });
+
+  test("CONTEXT_PREAMBLE_MAX_TOKENS is 2000 by default", () => {
+    expect(CONTEXT_PREAMBLE_MAX_TOKENS).toBe(2000);
+    expect(CONTEXT_PREAMBLE_MAX_CHARS).toBe(8000);
+  });
+});

package/src/tools/cancel-task.ts

@@ -142,12 +142,20 @@ export async function cancelTaskHandler(
 
   if ("content" in result) return result;
 
+  const structuredContent = {
+    yourAgentId: agentId,
+    ...result,
+  };
+
   return {
-    content: [{ type: "text", text: result.message }],
-    structuredContent: {
-      yourAgentId: agentId,
-      ...result,
-    },
+    content: [
+      { type: "text", text: result.message },
+      {
+        type: "text",
+        text: JSON.stringify(structuredContent),
+      },
+    ],
+    structuredContent,
   };
 }