fix: thread accountId through subagent announce delivery

Co-authored-by: Adam Holt <adam91holt@users.noreply.github.com>

src/agents/subagent-announce.format.test.ts

@@ -153,4 +153,42 @@ describe("subagent announce formatting", () => {
     );
     expect(agentSpy).not.toHaveBeenCalled();
   });
+
+  it("queues announce delivery with origin account routing", async () => {
+    const { runSubagentAnnounceFlow } = await import("./subagent-announce.js");
+    embeddedRunMock.isEmbeddedPiRunActive.mockReturnValue(true);
+    embeddedRunMock.isEmbeddedPiRunStreaming.mockReturnValue(false);
+    sessionStore = {
+      "agent:main:main": {
+        sessionId: "session-456",
+        lastChannel: "whatsapp",
+        lastTo: "+1555",
+        lastAccountId: "kev",
+        queueMode: "collect",
+        queueDebounceMs: 0,
+      },
+    };
+
+    const didAnnounce = await runSubagentAnnounceFlow({
+      childSessionKey: "agent:main:subagent:test",
+      childRunId: "run-999",
+      requesterSessionKey: "main",
+      requesterDisplayKey: "main",
+      task: "do thing",
+      timeoutMs: 1000,
+      cleanup: "keep",
+      waitForCompletion: false,
+      startedAt: 10,
+      endedAt: 20,
+      outcome: { status: "ok" },
+    });
+
+    expect(didAnnounce).toBe(true);
+    await new Promise((r) => setTimeout(r, 5));
+
+    const call = agentSpy.mock.calls[0]?.[0] as { params?: Record<string, unknown> };
+    expect(call?.params?.channel).toBe("whatsapp");
+    expect(call?.params?.to).toBe("+1555");
+    expect(call?.params?.accountId).toBe("kev");
+  });
 });

src/agents/subagent-announce.ts

@@ -16,6 +16,10 @@ import {
 } from "../auto-reply/reply/queue.js";
 import { callGateway } from "../gateway/call.js";
 import { defaultRuntime } from "../runtime.js";
+import {
+  type DeliveryContext,
+  normalizeDeliveryContext,
+} from "../utils/delivery-context.js";
 import { isEmbeddedPiRunActive, queueEmbeddedPiMessage } from "./pi-embedded.js";
 import { readLatestAssistantReply } from "./tools/agent-step.js";
 
@@ -89,9 +93,7 @@ type AnnounceQueueItem = {
   summaryLine?: string;
   enqueuedAt: number;
   sessionKey: string;
-  originatingChannel?: string;
-  originatingTo?: string;
-  originatingAccountId?: string;
+  origin?: DeliveryContext;
 };
 
 type AnnounceQueueState = {
@@ -225,9 +227,10 @@ function hasCrossChannelItems(items: AnnounceQueueItem[]): boolean {
   const keys = new Set<string>();
   let hasUnkeyed = false;
   for (const item of items) {
-    const channel = item.originatingChannel;
-    const to = item.originatingTo;
-    const accountId = item.originatingAccountId;
+    const origin = item.origin;
+    const channel = origin?.channel;
+    const to = origin?.to;
+    const accountId = origin?.accountId;
     if (!channel && !to && !accountId) {
       hasUnkeyed = true;
       continue;
@@ -301,14 +304,15 @@ function scheduleAnnounceDrain(key: string) {
 }
 
 async function sendAnnounce(item: AnnounceQueueItem) {
+  const origin = item.origin;
   await callGateway({
     method: "agent",
     params: {
       sessionKey: item.sessionKey,
       message: item.prompt,
-      channel: item.originatingChannel,
-      accountId: item.originatingAccountId,
-      to: item.originatingTo,
+      channel: origin?.channel,
+      accountId: origin?.accountId,
+      to: origin?.to,
       deliver: true,
       idempotencyKey: crypto.randomUUID(),
     },
@@ -377,6 +381,11 @@ async function maybeQueueSubagentAnnounce(params: {
     queueSettings.mode === "steer-backlog" ||
     queueSettings.mode === "interrupt";
   if (isActive && (shouldFollowup || queueSettings.mode === "steer")) {
+    const origin = normalizeDeliveryContext({
+      channel: entry?.lastChannel,
+      to: entry?.lastTo,
+      accountId: entry?.lastAccountId ?? params.requesterAccountId,
+    });
     enqueueAnnounce(
       canonicalKey,
       {
@@ -384,9 +393,7 @@ async function maybeQueueSubagentAnnounce(params: {
         summaryLine: params.summaryLine,
         enqueuedAt: Date.now(),
         sessionKey: canonicalKey,
-        originatingChannel: entry?.lastChannel,
-        originatingTo: entry?.lastTo,
-        originatingAccountId: entry?.lastAccountId ?? params.requesterAccountId,
+        origin,
       },
       queueSettings,
     );
@@ -617,14 +624,18 @@ export async function runSubagentAnnounceFlow(params: {
     }
 
     // Send to main agent - it will respond in its own voice
+    const directOrigin = normalizeDeliveryContext({
+      channel: params.requesterChannel,
+      accountId: params.requesterAccountId,
+    });
     await callGateway({
       method: "agent",
       params: {
         sessionKey: params.requesterSessionKey,
         message: triggerMessage,
         deliver: true,
-        channel: params.requesterChannel,
-        accountId: params.requesterAccountId,
+        channel: directOrigin?.channel,
+        accountId: directOrigin?.accountId,
         idempotencyKey: crypto.randomUUID(),
       },
       expectFinal: true,

src/agents/subagent-registry.persistence.test.ts

@@ -52,6 +52,7 @@ describe("subagent registry persistence", () => {
       runId: "run-1",
       childSessionKey: "agent:main:subagent:test",
       requesterSessionKey: "agent:main:main",
+      requesterAccountId: "acct-main",
       requesterDisplayKey: "main",
       task: "do the thing",
       cleanup: "keep",
@@ -61,6 +62,8 @@ describe("subagent registry persistence", () => {
     const raw = await fs.readFile(registryPath, "utf8");
     const parsed = JSON.parse(raw) as { runs?: Record<string, unknown> };
     expect(parsed.runs && Object.keys(parsed.runs)).toContain("run-1");
+    const run = parsed.runs?.["run-1"] as { requesterAccountId?: string } | undefined;
+    expect(run?.requesterAccountId).toBe("acct-main");
 
     // Simulate a process restart: module re-import should load persisted runs
     // and trigger the announce flow once the run resolves.
@@ -77,12 +80,14 @@ describe("subagent registry persistence", () => {
       childSessionKey: string;
       childRunId: string;
       requesterSessionKey: string;
+      requesterAccountId?: string;
       task: string;
       cleanup: string;
       label?: string;
     };
     const first = announceSpy.mock.calls[0]?.[0] as unknown as AnnounceParams;
     expect(first.childSessionKey).toBe("agent:main:subagent:test");
+    expect(first.requesterAccountId).toBe("acct-main");
   });
 
   it("skips cleanup when cleanupHandled/announceHandled was persisted", async () => {