@desplega.ai/agent-swarm 2.5.1 → 2.5.2

package/src/scheduler/scheduler.ts

@@ -25,7 +25,7 @@ import {
 } from "@/be/script-connections";
 import { buildScriptCredentialBindingsWithFailures } from "@/be/script-credential-broker";
 import { getScript } from "@/be/scripts/db";
-import { runScript } from "@/scripts-runtime/loader";
+import { runScriptWithRunCredential } from "@/be/scripts/run-credential";
 import { telemetry } from "@/telemetry";
 import type { AgentTask, ScheduledTask } from "@/types";
 import { getExecutorRegistry as getWorkflowExecutorRegistry } from "@/workflows";
@@ -72,7 +72,7 @@ function resolveExecutorRegistry(): ExecutorRegistry | null {
 
 /**
  * Execute a schedule's `targetType='script'` target directly via the
- * scripts-runtime — no agent/LLM in the loop. Reuses the same `runScript()`
+ * scripts-runtime — no agent/LLM in the loop. Reuses the same `runScriptWithRunCredential()`
  * path as the `swarm-script` workflow executor.
  */
 async function executeScheduleScript(schedule: ScheduledTask): Promise<void> {
@@ -98,10 +98,10 @@ async function executeScheduleScript(schedule: ScheduledTask): Promise<void> {
     startedAt: new Date().toISOString(),
   };
 
-  let output: Awaited<ReturnType<typeof runScript>>;
+  let output: Awaited<ReturnType<typeof runScriptWithRunCredential>>;
   try {
     const credentials = await buildScriptCredentialBindingsWithFailures({ agentId });
-    output = await runScript({
+    output = await runScriptWithRunCredential({
       source: script.source,
       args,
       fsMode: "none",

package/src/scripts-runtime/loader.ts

@@ -40,6 +40,13 @@ export type RunScriptInput = {
   args?: unknown;
   fsMode?: ScriptFsMode;
   agentId: string;
+  /**
+   * Bearer for the run's `ctx.swarm` SDK calls. Api-side callers pass a
+   * per-run token bound to the executing agent (`runScriptWithRunCredential`
+   * in `src/be/scripts/run-credential.ts`, which also revokes it). Omitted, the
+   * run presents the swarm API key.
+   */
+  apiKey?: string;
   /** Per-boot runtime identity of the invoking worker; system context, never script input. */
   runtimeInstanceId?: string;
   signal?: AbortSignal;
@@ -74,7 +81,7 @@ export function scriptEgressPolicy(env: NodeJS.ProcessEnv = process.env): Egress
 }
 
 async function buildConfigPayload(input: RunScriptInput): Promise<SwarmConfigPayload> {
-  const apiKey = getApiKey();
+  const apiKey = input.apiKey ?? getApiKey();
   if (!apiKey) throw new Error("Swarm API key is required to run scripts");
 
   return {

package/src/slack/ack.ts

@@ -1,5 +1,6 @@
 import type { WebClient } from "@slack/web-api";
 import { getLogsByTaskIdChronological, getSlackTasksInThread, getTaskById } from "../be/db";
+import { terminalReactionEvent } from "../integrations/reaction-events";
 import { recordSlackReactionInvalidName } from "../otel";
 import { type AgentTask, isTerminalTaskStatus } from "../types";
 import { scrubSecrets } from "../utils/secret-scrubber";
@@ -143,7 +144,7 @@ export type SlackReactionChoice = { name: string; event?: SlackReactionEvent };
 
 /** The reaction choice for a task's terminal outcome, honouring operator config. */
 export function terminalReactionChoice(task: AgentTask): SlackReactionChoice {
-  const event: SlackReactionEvent = task.status === "completed" ? "completed" : "failed";
+  const event = terminalReactionEvent(task.status);
   return { name: reactionName(event), event };
 }
 

package/src/slack/reaction-shortcode.ts

@@ -1,10 +1,7 @@
-export type SlackReactionEvent =
-  | "accepted"
-  | "buffered"
-  | "now"
-  | "steered"
-  | "completed"
-  | "failed";
+import type { ReactionEvent } from "@/integrations/reaction-events";
+
+/** The shared lifecycle events; Slack maps each one to a shortcode below. */
+export type SlackReactionEvent = ReactionEvent;
 
 export const SLACK_REACTION_DEFAULTS: Record<SlackReactionEvent, string> = {
   accepted: "eyes",

package/src/tasks/worker-follow-up.ts

@@ -33,6 +33,7 @@ import {
 } from "../types";
 import { isEnvFlagEnabled } from "../utils/env-flag";
 import { taskAttachmentDisplayUrl } from "../utils/task-attachment-links";
+import { chatThreadOfContextKey } from "./context-key";
 import { taskModelPin } from "./model-pin";
 import { createTaskWithSiblingAwareness } from "./sibling-awareness";
 // Side-effect import: registers task lifecycle templates in the in-memory registry.
@@ -386,6 +387,7 @@ export async function createWorkerTaskFollowUp(args: {
       taskType: "follow-up",
       priority: changes.priority,
       parentTaskId: task.id,
+      contextKey: await deferredWorkChatContextKey(task),
       slackChannelId: task.slackChannelId,
       slackThreadTs: task.slackThreadTs,
       slackUserId: task.slackUserId,
@@ -398,6 +400,34 @@ export async function createWorkerTaskFollowUp(args: {
   );
 }
 
+/** Hop cap for `deferredWorkChatContextKey`; a defer/resume chain is short. */
+const MAX_CONTINUATION_HOPS = 32;
+
+/**
+ * The chat thread a worker's deferred work answers in, for its Lead follow-up.
+ * A worker's defer-task wake-up (and any resume of it) runs on its schedule's
+ * contextKey, so the worker stays out of the chat (`scheduleTaskContextKey`).
+ * The Lead follow-up still answers the original ask: walk back through the
+ * wake-up and resume chain to the deferred task and report on its chat thread.
+ * Undefined when the task already has a chat key or the chain leads to none,
+ * so the follow-up inherits the task's own key as before.
+ */
+async function deferredWorkChatContextKey(task: AgentTask): Promise<string | undefined> {
+  if (chatThreadOfContextKey(task.contextKey)) return undefined;
+  const seen = new Set<string>();
+  let current: AgentTask | null = task;
+  while (current && !seen.has(current.id) && seen.size < MAX_CONTINUATION_HOPS) {
+    if (chatThreadOfContextKey(current.contextKey)) return current.contextKey;
+    const continuation =
+      (current.source === "schedule" && current.taskType === "deferred") ||
+      (current.source === "system" && current.taskType === "resume");
+    if (!continuation || !current.parentTaskId) return undefined;
+    seen.add(current.id);
+    current = await getTaskById(current.parentTaskId);
+  }
+  return undefined;
+}
+
 /** Result of `createResumeFollowUp`. */
 export type CreateResumeFollowUpResult =
   | { kind: "created"; task: AgentTask }

package/src/tests/approval-requests-notifications.test.ts

@@ -0,0 +1,189 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, mock, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { createServer as createHttpServer, type Server } from "node:http";
+
+const postMessage = mock(async (_args: Record<string, unknown>) => ({ ts: "1700000000.000100" }));
+const conversationsInfo = mock(async (_args: { channel: string }) => ({
+  channel: { is_ext_shared: false },
+}));
+mock.module("../slack/app", () => ({
+  getSlackApp: () => ({
+    client: { chat: { postMessage }, conversations: { info: conversationsInfo } },
+  }),
+}));
+
+import {
+  closeDb,
+  createAgent,
+  getApprovalRequestById,
+  initDb,
+  listApprovalRequests,
+} from "../be/db";
+import { handleApprovalRequests } from "../http/approval-requests";
+import { resetExternalChannelStateForTesting } from "../slack/external-channel";
+import { listenOnFreePort } from "./test-net";
+
+const TEST_DB_PATH = "./test-approval-requests-notifications.sqlite";
+
+let server: Server;
+let baseUrl = "";
+let leadId = "";
+let workerId = "";
+
+function postRequest(body: Record<string, unknown>, agentId: string | null): Promise<Response> {
+  return fetch(`${baseUrl}/api/approval-requests`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...(agentId ? { "X-Agent-ID": agentId } : {}),
+    },
+    body: JSON.stringify({
+      title: "Ship it?",
+      questions: [{ id: "q1", type: "approval", label: "Approve the deploy?" }],
+      approvers: { policy: "any" },
+      ...body,
+    }),
+  });
+}
+
+async function createRequest(body: Record<string, unknown>, agentId = leadId): Promise<string> {
+  const res = await postRequest(body, agentId);
+  expect(res.status).toBe(201);
+  const json = (await res.json()) as { approvalRequest: { id: string } };
+  return json.approvalRequest.id;
+}
+
+async function waitFor(check: () => Promise<boolean>): Promise<void> {
+  for (let i = 0; i < 100; i++) {
+    if (await check()) return;
+    await Bun.sleep(10);
+  }
+}
+
+describe("POST /api/approval-requests notifications", () => {
+  beforeAll(async () => {
+    try {
+      await unlink(TEST_DB_PATH);
+    } catch {}
+    initDb(TEST_DB_PATH);
+    leadId = (await createAgent({ name: "notify-lead", isLead: true, status: "idle" })).id;
+    workerId = (await createAgent({ name: "notify-worker", isLead: false, status: "idle" })).id;
+    server = createHttpServer(async (req, res) => {
+      const url = new URL(req.url ?? "/", "http://localhost");
+      const handled = await handleApprovalRequests(
+        req,
+        res,
+        url.pathname.split("/").filter(Boolean),
+        url.searchParams,
+      );
+      if (!handled) {
+        res.writeHead(404);
+        res.end();
+      }
+    });
+    baseUrl = `http://127.0.0.1:${await listenOnFreePort(server)}`;
+  });
+
+  afterAll(async () => {
+    await new Promise<void>((resolve) => server.close(() => resolve()));
+    closeDb();
+    for (const suffix of ["", "-wal", "-shm"]) {
+      try {
+        await unlink(`${TEST_DB_PATH}${suffix}`);
+      } catch {}
+    }
+  });
+
+  beforeEach(() => {
+    postMessage.mockClear();
+    conversationsInfo.mockClear();
+    resetExternalChannelStateForTesting();
+    delete process.env.SLACK_BLOCK_EXTERNAL_CHANNELS;
+  });
+
+  test("posts one Slack card and stores its messageTs", async () => {
+    const id = await createRequest({
+      title: "Ship <!channel> & go?",
+      timeoutSeconds: 3600,
+      notifications: [{ channel: "slack", target: "C123" }],
+    });
+
+    await waitFor(async () => {
+      const row = await getApprovalRequestById(id);
+      const channels = row?.notificationChannels as Array<{ messageTs?: string }> | null;
+      return Boolean(channels?.[0]?.messageTs);
+    });
+
+    expect(postMessage).toHaveBeenCalledTimes(1);
+    const args = postMessage.mock.calls[0]![0];
+    expect(args.channel).toBe("C123");
+    expect(args.text).toContain(`/approval-requests/${id}`);
+    const blocks = JSON.stringify(args.blocks);
+    expect(blocks).toContain("Approval Required: Ship &lt;!channel&gt; &amp; go?");
+    expect(blocks).not.toContain("<!channel>");
+    expect(blocks).toContain("Approve the deploy?");
+    expect(blocks).toContain("Review & Respond");
+    expect(blocks).toContain("times out if not responded");
+
+    const row = await getApprovalRequestById(id);
+    expect(row?.notificationChannels).toEqual([
+      { channel: "slack", target: "C123", messageTs: "1700000000.000100" },
+    ]);
+  });
+
+  test("posts nothing without notifications", async () => {
+    const id = await createRequest({});
+    await Bun.sleep(50);
+
+    expect(postMessage).not.toHaveBeenCalled();
+    expect((await getApprovalRequestById(id))?.notificationChannels).toBeNull();
+  });
+
+  test("skips email targets without posting", async () => {
+    const id = await createRequest({
+      notifications: [{ channel: "email", target: "ops@example.com" }],
+    });
+    await Bun.sleep(50);
+
+    expect(postMessage).not.toHaveBeenCalled();
+    expect((await getApprovalRequestById(id))?.notificationChannels).toEqual([
+      { channel: "email", target: "ops@example.com" },
+    ]);
+  });
+
+  test("refuses Slack notifications from a non-lead caller and creates nothing", async () => {
+    for (const agentId of [workerId, null]) {
+      const before = (await listApprovalRequests()).length;
+      const res = await postRequest(
+        { notifications: [{ channel: "slack", target: "C123" }] },
+        agentId,
+      );
+
+      expect(res.status).toBe(403);
+      expect((await listApprovalRequests()).length).toBe(before);
+    }
+    expect(postMessage).not.toHaveBeenCalled();
+  });
+
+  test("lets a non-lead caller create a request without Slack notifications", async () => {
+    await createRequest(
+      { notifications: [{ channel: "email", target: "ops@example.com" }] },
+      workerId,
+    );
+  });
+
+  test("skips a channel shared with another org when the external-channel block is on", async () => {
+    process.env.SLACK_BLOCK_EXTERNAL_CHANNELS = "true";
+    conversationsInfo.mockImplementationOnce(async () => ({ channel: { is_ext_shared: true } }));
+
+    const id = await createRequest({ notifications: [{ channel: "slack", target: "CEXT" }] });
+    await waitFor(async () => conversationsInfo.mock.calls.length > 0);
+    await Bun.sleep(50);
+
+    expect(conversationsInfo).toHaveBeenCalledWith({ channel: "CEXT" });
+    expect(postMessage).not.toHaveBeenCalled();
+    expect((await getApprovalRequestById(id))?.notificationChannels).toEqual([
+      { channel: "slack", target: "CEXT" },
+    ]);
+  });
+});

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

@@ -84,6 +84,18 @@ describe("Chat SDK slash commands", () => {
     expect(await chatTasks(3001)).toHaveLength(0);
   });
 
+  test("/start in a fresh DM answers with the welcome and stays out of the / menu", async () => {
+    await postTelegramUpdate(commandUpdate(dm(3003), "/start"));
+    const texts = sentTexts(3003);
+    expect(texts).toHaveLength(1);
+    expect(texts[0]).toContain("Each answer arrives as a reply to your message.");
+    expect(texts[0]).toContain("/help");
+    expect(texts[0]).not.toContain("Unknown command");
+    expect(CHAT_COMMANDS.map((c) => c.command)).not.toContain("start");
+    await flushChatBuffers();
+    expect(await chatTasks(3003)).toHaveLength(0);
+  });
+
   test("an unknown command gets the list instead of silence", async () => {
     await postTelegramUpdate(commandUpdate(dm(3002), "/deploy"));
     const texts = sentTexts(3002);

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

@@ -7,6 +7,7 @@ import {
   closeDb,
   completeTask,
   createAgent,
+  createScheduledTask,
   createTaskExtended,
   createUser,
   getDbClient,
@@ -20,10 +21,12 @@ import {
 import { linkIdentity } from "../be/users";
 import { resetFileStorageProviderForTests } from "../fs/registry";
 import { drainBackground } from "../integrations/chat-sdk/background";
-import { formatChatRelayText } from "../integrations/chat-sdk/relay";
+import { CHAT_CHANNEL_SETTINGS_NAMESPACE } from "../integrations/chat-sdk/reactions";
+import { formatChatRelayText, formatChatTaskTag } from "../integrations/chat-sdk/relay";
 import { CHAT_CHANNELS_NAMESPACE, routeChatMessage } from "../integrations/chat-sdk/router";
 import { getChatInstance } from "../integrations/chat-sdk/runtime";
 import { isChatThreadBuffered } from "../integrations/chat-sdk/thread-buffer";
+import { createStandaloneScheduleTask } from "../scheduler/schedule-task";
 import { chatSdkContextKey } from "../tasks/context-key";
 import { registerDeferTaskTool } from "../tools/defer-task";
 import type { Agent } from "../types";
@@ -144,6 +147,25 @@ function buildDeferTaskTool(): DeferTaskTool {
 const dm = (id: number): TelegramChat => ({ id, type: "private" });
 const group = (id: number): TelegramChat => ({ id, type: "group" });
 
+const messageIdOf = (update: Record<string, unknown>) =>
+  (update.message as { message_id: number }).message_id;
+
+/** Every `setMessageReaction` call on one message, as the emoji it set (`""` = cleared). */
+function reactionsOn(chatId: number, update: Record<string, unknown>): string[] {
+  return harness.mock.calls
+    .filter((call) => call.method === "setMessageReaction")
+    .map((call) => call.body as { chat_id: unknown; message_id: unknown; reaction: unknown })
+    .filter(
+      (body) =>
+        String(body.chat_id) === String(chatId) && Number(body.message_id) === messageIdOf(update),
+    )
+    .map((body) => {
+      const reaction =
+        typeof body.reaction === "string" ? JSON.parse(body.reaction) : body.reaction;
+      return (reaction as Array<{ emoji?: string }>).map((r) => r.emoji ?? "").join("");
+    });
+}
+
 describe("Chat SDK inbound pipeline", () => {
   test("two messages inside the buffer window become one task", async () => {
     await postTelegramUpdate(telegramUpdate(dm(2001), "first part of the request"));
@@ -233,19 +255,101 @@ describe("Chat SDK inbound pipeline", () => {
       first!.id,
     ]);
 
-    const acksBefore = harness.mock.calls.filter((call) =>
-      /^send(Rich)?Message$/.test(call.method),
-    ).length;
-    await postTelegramUpdate(telegramUpdate(group(-2005), "also add the charts"));
+    const sendCount = () =>
+      harness.mock.calls.filter((call) => /^send(Rich)?Message$/.test(call.method)).length;
+    const sendsBefore = sendCount();
+    const steer = telegramUpdate(group(-2005), "also add the charts");
+    await postTelegramUpdate(steer);
     await flushChatBuffers();
 
     expect(await chatTasks(-2005)).toHaveLength(1);
     expect(await steeringRows(first!.id)).toEqual([
       { body: "also add the charts", source: "chat" },
     ]);
-    expect(
-      harness.mock.calls.filter((call) => /^send(Rich)?Message$/.test(call.method)).length,
-    ).toBe(acksBefore + 1);
+    // A reaction acknowledges the steering message; no text reply.
+    expect(reactionsOn(-2005, steer)).toEqual(["✍"]);
+    expect(sendCount()).toBe(sendsBefore);
+  });
+
+  test("a channel that opts into text acks also gets the steering reply", async () => {
+    await upsertKv({
+      namespace: CHAT_CHANNEL_SETTINGS_NAMESPACE,
+      key: "telegram:-2015",
+      value: { textAcks: true },
+      valueType: "json",
+    });
+    await postTelegramUpdate(telegramUpdate(group(-2015), "@swarm_test_bot draft the report"));
+    await flushChatBuffers();
+    const [first] = await chatTasks(-2015);
+    await getDbClient().run("UPDATE agent_tasks SET status = 'in_progress' WHERE id = ?", [
+      first!.id,
+    ]);
+
+    const steer = telegramUpdate(group(-2015), "also add the charts");
+    await postTelegramUpdate(steer);
+
+    expect(reactionsOn(-2015, steer)).toEqual(["✍"]);
+    const sends = harness.mock.calls.filter((call) => /^send(Rich)?Message$/.test(call.method));
+    // The acknowledgement replies to the steering message.
+    expect(sends.at(-1)?.body.reply_parameters).toEqual({
+      message_id: messageIdOf(steer),
+      allow_sending_without_reply: true,
+    });
+  });
+
+  test("an ask gets one reaction at a time; earlier buffered messages are cleared at flush", async () => {
+    const firstPart = telegramUpdate(dm(2016), "first part");
+    const secondPart = telegramUpdate(dm(2016), "second part");
+    await postTelegramUpdate(firstPart);
+    expect(reactionsOn(2016, firstPart)).toEqual(["👀"]);
+    await postTelegramUpdate(secondPart);
+    await flushChatBuffers();
+
+    expect(await chatTasks(2016)).toHaveLength(1);
+    // The task answers the newest message, which keeps 👀; the earlier one is cleared.
+    expect(reactionsOn(2016, secondPart)).toEqual(["👀"]);
+    expect(reactionsOn(2016, firstPart)).toEqual(["👀", ""]);
+
+    const quick = telegramUpdate(dm(2017), "!now ship it");
+    await postTelegramUpdate(quick);
+    expect(reactionsOn(2017, quick)).toEqual(["⚡"]);
+  });
+
+  test("a REACTION_INVALID answer is logged and the ask still becomes a task", async () => {
+    const warn = spyOn(console, "warn");
+    harness.mock.failReactions(1);
+    try {
+      const ask = telegramUpdate(dm(2018), "!now plan the sprint");
+      await postTelegramUpdate(ask);
+      expect(await chatTasks(2018)).toHaveLength(1);
+      expect(reactionsOn(2018, ask)).toHaveLength(1);
+      expect(
+        warn.mock.calls.some((args) => String(args[0]).includes("Could not set the now reaction")),
+      ).toBe(true);
+    } finally {
+      harness.mock.failReactions(0);
+      warn.mockRestore();
+    }
+  });
+
+  test("two asks back to back each anchor to their own message, not the parent's", async () => {
+    const firstAsk = telegramUpdate(group(-2010), "@swarm_test_bot !now summarize the PR");
+    await postTelegramUpdate(firstAsk);
+    const secondAsk = telegramUpdate(group(-2010), "@swarm_test_bot !now and list the risks");
+    await postTelegramUpdate(secondAsk);
+    await flushChatBuffers();
+
+    const rows = await chatTasks(-2010);
+    expect(rows).toHaveLength(2);
+    const [first, second] = await Promise.all(rows.map((row) => getTaskById(row.id)));
+    const idOf = (update: Record<string, unknown>) =>
+      `-2010:${(update.message as { message_id: number }).message_id}`;
+    expect(first?.mentionMessageId).toBe(idOf(firstAsk));
+    // The second task is a child of the first; `createTask` would copy the
+    // parent's anchor if inbound did not set its own.
+    expect(second?.parentTaskId).toBe(first!.id);
+    expect(second?.mentionMessageId).toBe(idOf(secondAsk));
+    expect(second?.mentionChannelId).toBeTruthy();
   });
 
   test("a Telegram private-chat DM steers too (DMs never reach onSubscribedMessage)", async () => {
@@ -282,6 +386,52 @@ describe("Chat SDK inbound pipeline", () => {
     expect(followUp?.task).toContain("include the changelog");
   });
 
+  test("a deferred wake-up is the thread's chat task: steering, a follow-up dependency and /cancel reach it", async () => {
+    await postTelegramUpdate(telegramUpdate(dm(2040), "check the deploy"));
+    await flushChatBuffers();
+    const [first] = await chatTasks(2040);
+    await completeTask(first!.id, "Deferred.", { deferredAt: new Date().toISOString() });
+    const schedule = await createScheduledTask({
+      name: `deferred-${first!.id.slice(0, 8)}-${crypto.randomUUID()}`,
+      taskTemplate: "Check the deploy and answer.",
+      targetType: "agent-task",
+      scheduleType: "one_time",
+      nextRunAt: new Date().toISOString(),
+      targetAgentId: lead.id,
+      createdByAgentId: lead.id,
+      taskType: "deferred",
+      parentTaskId: first!.id,
+    });
+    const wakeUp = await createStandaloneScheduleTask(schedule);
+    expect(wakeUp.source).toBe("schedule");
+    expect(wakeUp.contextKey).toBe(chatSdkContextKey("telegram:2040"));
+
+    // In progress: a plain message steers the wake-up.
+    await startTask(wakeUp.id);
+    await postTelegramUpdate(telegramUpdate(dm(2040), "use the staging cluster"));
+    await flushChatBuffers();
+    expect(await chatTasks(2040)).toHaveLength(1);
+    expect(await steeringRows(wakeUp.id)).toEqual([
+      { body: "use the staging cluster", source: "chat" },
+    ]);
+
+    // Pending: a new message becomes a follow-up that waits for it.
+    await getDbClient().run("UPDATE agent_tasks SET status = 'pending' WHERE id = ?", [wakeUp.id]);
+    await postTelegramUpdate(telegramUpdate(dm(2040), "and the canary"));
+    await flushChatBuffers();
+    const tasks = await chatTasks(2040);
+    expect(tasks).toHaveLength(2);
+    expect((await getTaskById(tasks[1]!.id))?.dependsOn).toEqual([wakeUp.id]);
+
+    // /cancel stops the follow-up and the wake-up.
+    const cancel = telegramUpdate(dm(2040), "/cancel", {
+      entities: [{ type: "bot_command", offset: 0, length: "/cancel".length }],
+    });
+    await postTelegramUpdate(cancel);
+    expect((await getTaskById(wakeUp.id))?.status).toBe("cancelled");
+    expect((await getTaskById(tasks[1]!.id))?.status).toBe("cancelled");
+  });
+
   test("a document attachment becomes a task attachment and a [File: ...] line", async () => {
     const bytes = new TextEncoder().encode("meeting notes\n");
     harness.mock.addFile("documents/notes.txt", bytes);
@@ -451,7 +601,11 @@ describe("Chat SDK requester and group addressing", () => {
     const deferred = await getTaskById(task!.id);
     expect(deferred?.output).toMatch(new RegExp(`at ${madrid}$`));
     expect(deferred?.output).not.toContain("UTC");
-    expect(formatChatRelayText(deferred!)).toBe(deferred!.output!);
+    // The relay posts the placeholder text after the task tag (here the trigger
+    // drops it: a deferral posts nothing).
+    expect(formatChatRelayText(deferred!)).toBe(
+      `${formatChatTaskTag(deferred!)}\n\n${deferred!.output!}`,
+    );
   });
 
   test("an unknown sender gets no requester and lands in the Unmapped tracker", async () => {

package/src/tests/chat-sdk-outbound-files.test.ts

@@ -25,7 +25,11 @@ import {
 import { recordTaskAttachmentUpload } from "../be/task-attachment-store";
 import { getFileStorageProvider, resetFileStorageProviderForTests } from "../fs/registry";
 import { formatUnsentFilesNote, telegramAttachmentType } from "../integrations/chat-sdk/outbound";
-import { processPendingChatRelays, stopChatRelayWatcher } from "../integrations/chat-sdk/relay";
+import {
+  formatChatTaskTag,
+  processPendingChatRelays,
+  stopChatRelayWatcher,
+} from "../integrations/chat-sdk/relay";
 import { chatSdkContextKey } from "../tasks/context-key";
 import { registerChatPostTool } from "../tools/chat-post";
 import { registerChatReplyTool } from "../tools/chat-reply";
@@ -646,7 +650,10 @@ describe("relay of output attachments", () => {
       expect.stringMatching(/^send(Rich)?Message$/),
       "sendDocument",
     ]);
-    expect(textOf(calls[0]!.body)).toBe("Done, report attached.");
+    // The line-leading tag is escaped so Telegram does not render it as a heading.
+    expect(textOf(calls[0]!.body)).toBe(
+      `\\${formatChatTaskTag(task, lead.name)}\n\nDone, report attached.`,
+    );
     expect((calls[1]!.body.document as TelegramMockFilePart).filename).toBe("result.pdf");
   });
 });