// Subagent announce delivery tests cover the last-mile routing used when child

// runs report progress or completion back to the requester session.

import fs from "node:fs/promises";

import os from "node:os";

import path from "node:path";

import { afterEach, describe, expect, it, vi } from "vitest";

import { OutboundDeliveryError } from "../infra/outbound/deliver-types.js";

import {

});

});

});

describe("deliverSubagentAnnouncement requester session backfill (issue #86034)", () => {

// Regression: image_generate launched from a non-direct-reply turn (heartbeat,

// cron, subagent spawn) supplies a completion origin missing `to`. The

// already-loaded requester session entry carries `lastTo`/`lastChannel`, so

// effectiveDirectOrigin must backfill from it before the deliverability gate,

// otherwise generated media is silently dropped.

it("backfills to/accountId from the requester session entry when completion origin is incomplete", async () => {

const agentId = `backfill-${Date.now()}-${Math.random().toString(16).slice(2)}`;

const sessionKey = `agent:${agentId}:telegram:5866004662`;

const storeTemplate = path.join(

os.tmpdir(),

`openclaw-86034-session-${agentId}-{agentId}.json`,

);

const storePath = storeTemplate.replaceAll("{agentId}", agentId);

await fs.writeFile(

storePath,

JSON.stringify(

{

[sessionKey]: {

sessionId: "telegram-session-1",

updatedAt: Date.now(),

channel: "telegram",

lastChannel: "telegram",

lastTo: "5866004662",

lastAccountId: "bot-1",

},

},

null,

2,

),

"utf-8",

);

try {

const dispatchGatewayMethodInProcess = createInProcessGatewayMock({

result: { payloads: [{ text: "requester voice completion" }] },

});

testing.setDepsForTest({

dispatchGatewayMethodInProcess,

getRequesterSessionActivity: () => ({

sessionId: "telegram-session-1",

isActive: false,

}),

getRuntimeConfig: () => ({ session: { store: storeTemplate } }) as never,

});

const result = await deliverSubagentAnnouncement({

requesterSessionKey: sessionKey,

targetRequesterSessionKey: sessionKey,

triggerMessage: "image done",

steerMessage: "image done",

// Origin carries channel but NOT `to` or `accountId` — simulates an

// image_generate task created off the direct-reply path.

requesterOrigin: { channel: "telegram" },

requesterSessionOrigin: { channel: "telegram" },

completionDirectOrigin: { channel: "telegram" },

directOrigin: { channel: "telegram" },

requesterIsSubagent: false,

expectsCompletionMessage: true,

bestEffortDeliver: true,

directIdempotencyKey: "announce-86034-backfill",

sourceTool: "image_generate",

});

expectRecordFields(result, {

delivered: true,

path: "direct",

});

// The deliverability decision must see the backfilled `to`.

expectInProcessAgentParams(dispatchGatewayMethodInProcess, {

deliver: true,

channel: "telegram",

accountId: "bot-1",

to: "5866004662",

});

} finally {

await fs.rm(storePath, { force: true });

}

});

// Cross-channel safety regression: a stale lastChannel that differs from

// the completion origin's channel must not leak its lastTo into the

// telegram delivery. mergeDeliveryContext.channelsConflict (delivery-context.shared.ts:233-260)

// is the structural guard; this test locks it.

it("does not import a cross-channel lastTo when the completion origin's channel differs from lastChannel (cross-channel guard regression)", async () => {

const agentId = `xchan-${Date.now()}-${Math.random().toString(16).slice(2)}`;

const sessionKey = `agent:${agentId}:telegram:5866004662`;

const storeTemplate = path.join(

os.tmpdir(),

`openclaw-86034-xchan-session-${agentId}-{agentId}.json`,

);

const storePath = storeTemplate.replaceAll("{agentId}", agentId);

await fs.writeFile(

storePath,

JSON.stringify(

{

[sessionKey]: {

sessionId: "telegram-session-xchan",

updatedAt: Date.now(),

channel: "telegram",

lastChannel: "signal",

lastTo: "signal-stale-target",

lastAccountId: "signal-bot-1",

},

},

null,

2,

),

"utf-8",

);

try {

const dispatchGatewayMethodInProcess = createInProcessGatewayMock({

result: { payloads: [{ text: "requester voice completion" }] },

});

testing.setDepsForTest({

dispatchGatewayMethodInProcess,

getRequesterSessionActivity: () => ({

sessionId: "telegram-session-xchan",

isActive: false,

}),

getRuntimeConfig: () => ({ session: { store: storeTemplate } }) as never,

});

const result = await deliverSubagentAnnouncement({

requesterSessionKey: sessionKey,

targetRequesterSessionKey: sessionKey,

triggerMessage: "image done",

steerMessage: "image done",

requesterOrigin: { channel: "telegram", accountId: "telegram-bot-1" },

requesterSessionOrigin: { channel: "telegram", accountId: "telegram-bot-1" },

completionDirectOrigin: { channel: "telegram", accountId: "telegram-bot-1" },

directOrigin: { channel: "telegram", accountId: "telegram-bot-1" },

requesterIsSubagent: false,

expectsCompletionMessage: true,

bestEffortDeliver: true,

directIdempotencyKey: "announce-86034-cross-channel",

sourceTool: "image_generate",

});

// Structural assertion: the stale signal `to` must not have leaked into

// any in-process gateway dispatch, regardless of whether the call ended

// up routed (path: "direct") or short-circuited (delivered: false /

// path: "none"). The guard is "no cross-channel `to` ever reaches the

// gateway", not a specific terminal path.

expect(dispatchGatewayMethodInProcess).not.toHaveBeenCalledWith(

"agent",

expect.objectContaining({ to: "signal-stale-target" }),

expect.anything(),

);

expect(dispatchGatewayMethodInProcess).not.toHaveBeenCalledWith(

"agent",

expect.objectContaining({ channel: "signal" }),

expect.anything(),

);

for (const call of asMock(dispatchGatewayMethodInProcess).mock.calls) {

const params = call[1] as Record<string, unknown> | undefined;

if (!params) {

continue;

}

expect(params.to).not.toBe("signal-stale-target");

expect(params.channel).not.toBe("signal");

}

// Result-shape assertion: if the dispatcher was invoked at all on the

// direct path, it must not have been with the stale signal target.

if (

(result as { path?: string }).path === "direct" &&

(result as { delivered?: boolean }).delivered === true

) {

const params = mockCallArg(dispatchGatewayMethodInProcess, 0, 1) as Record<string, unknown>;

expect(params.to).not.toBe("signal-stale-target");

expect(params.channel).not.toBe("signal");

}

} finally {

await fs.rm(storePath, { force: true });

}

});

});