);

});

it("does not pin a session target from another account", () => {

subagentAnnounceDeliveryMocks.loadRequesterSessionEntry.mockReturnValue({

entry: {

lastChannel: "telegram",

lastTo: "peer-b",

lastAccountId: "bot-b",

},

});

const lifecycle = createMediaGenerationTaskLifecycle({

toolName: "image_generate",

taskKind: "image_generation",

label: "Image generation",

queuedProgressSummary: "Queued image generation",

generatedLabel: "image",

failureProgressSummary: "Image generation failed",

eventSource: "image_generation",

announceType: "image generation task",

completionLabel: "image",

});

const handle = lifecycle.createTaskRun({

sessionKey: "agent:main:telegram:shared",

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

prompt: "proof image",

});

expect(handle?.requesterOrigin).toEqual({

channel: "telegram",

to: undefined,

accountId: "bot-a",

});

});

it("returns the completion wake delivery result", async () => {

subagentAnnounceDeliveryMocks.deliverSubagentAnnouncement.mockResolvedValueOnce({

delivered: true,

/** Optional callback invoked when async media generation starts. */

export type MediaGenerateAsyncStartCallback = (message: string) => Promise<void> | void;

function resolvePinnedMediaRequesterOrigin(params: {

requesterOrigin?: DeliveryContext;

sessionOrigin?: DeliveryContext;

}): DeliveryContext | undefined {

const requesterOrigin = normalizeDeliveryContext(params.requesterOrigin);

const sessionOrigin = normalizeDeliveryContext(params.sessionOrigin);

const accountsConflict =

requesterOrigin?.channel === sessionOrigin?.channel &&

requesterOrigin?.accountId &&

sessionOrigin?.accountId &&

requesterOrigin.accountId !== sessionOrigin.accountId;

return accountsConflict ? requesterOrigin : mergeDeliveryContext(requesterOrigin, sessionOrigin);

}

/** Returns whether a media generation request should detach for a session. */

export function shouldDetachMediaGenerationTask(sessionKey: string | undefined): boolean {

const normalizedSessionKey = sessionKey?.trim();

try {

// Pin the complete requester route when detached work starts. Completion-time

// session state can move to another peer while generation is still running.

const requesterOrigin = mergeDeliveryContext(

normalizeDeliveryContext(params.requesterOrigin),

deliveryContextFromSession(loadRequesterSessionEntry(sessionKey).entry),

);

const requesterOrigin = resolvePinnedMediaRequesterOrigin({

requesterOrigin: params.requesterOrigin,

sessionOrigin: deliveryContextFromSession(loadRequesterSessionEntry(sessionKey).entry),

});

const task = createRunningTaskRun({

runtime: "cli",

taskKind: params.taskKind,