});

});

it("does not queue main-session awareness for implicit last-target delivery", async () => {

it("refuses keyless implicit last-target delivery inherited from the shared main bucket, queuing no awareness", async () => {

// #91613: a keyless implicit cron (sessionTarget "isolated", delivery.channel "last", no `to`)

// would inherit the SHARED agent-main bucket's lastTo. In a multi-conversation agent that room

// belongs to whichever conversation last wrote main — the wrong room — and the durable queue

// replays it after a restart. It is now refused at the delivery dispatch !ok gate (errorKind

// delivery-target) — the agent turn still runs, but delivery is refused, so nothing reaches the

// wrong room or the durable queue, and no main-session awareness event is queued. (This is the

// single-conversation behavior change called out for the maintainer: a keyless cron must now

// pin delivery.to / delivery.channel, or run from a session that carries its own context.)

await withTempCronHome(async (home) => {

const storePath = await writeDefaultAgentSessionStoreEntries({

"agent:main:main": {

},

});

expect(result.status).toBe("ok");

expect(result.delivered).toBe(true);

expect(result.status).toBe("error");

expect(result.delivered).toBeFalsy();

expect(peekSystemEvents("agent:main:main")).toStrictEqual([]);

});

});

expect(retireSessionMcpRuntime).not.toHaveBeenCalled();

});

it("cleans up the direct cron session when delivery target resolution is refused (deleteAfterRun)", async () => {

// A keyless implicit cron whose inherited shared-bucket target is refused

// (resolvedDelivery.ok=false, issue #91613 fail-closed path) must still

// retire its session/transcript when deleteAfterRun is enabled — otherwise

// the one-shot session leaks.

const params = makeBaseParams({ synthesizedText: "refused report" });

params.resolvedDelivery = {

ok: false,

channel: "telegram",

to: undefined,

accountId: undefined,

threadId: undefined,

mode: "implicit",

error: new Error("refusing inherited shared-bucket delivery target"),

};

params.agentSessionKey = "agent:main:cron:test-job";

(params.job as { deleteAfterRun?: boolean }).deleteAfterRun = true;

const state = await dispatchCronDelivery(params);

expect(deliverOutboundPayloads).not.toHaveBeenCalled();

expectResultFields(state.result, {

status: "error",

errorKind: "delivery-target",

});

expect(callGateway).toHaveBeenCalledWith({

method: "sessions.delete",

params: {

key: "agent:main:cron:test-job",

deleteTranscript: true,

emitLifecycleHooks: false,

},

timeoutMs: 10_000,

});

});

it("cleans up the direct cron session when refused delivery is best-effort (deleteAfterRun)", async () => {

// Same fail-closed refusal, best-effort variant: dispatch returns status:ok

// (warn-logs instead of failing the run) but the deleteAfterRun session must

// still be retired.

const params = makeBaseParams({

synthesizedText: "refused report",

deliveryBestEffort: true,

});

params.resolvedDelivery = {

ok: false,

channel: "telegram",

to: undefined,

accountId: undefined,

threadId: undefined,

mode: "implicit",

error: new Error("refusing inherited shared-bucket delivery target"),

};

params.agentSessionKey = "agent:main:cron:test-job";

(params.job as { deleteAfterRun?: boolean }).deleteAfterRun = true;

const state = await dispatchCronDelivery(params);

expect(deliverOutboundPayloads).not.toHaveBeenCalled();

expectResultFields(state.result, {

status: "ok",

});

expect(callGateway).toHaveBeenCalledWith({

method: "sessions.delete",

params: {

key: "agent:main:cron:test-job",

deleteTranscript: true,

emitLifecycleHooks: false,

},

timeoutMs: 10_000,

});

});

it("text delivery fires exactly once (no double-deliver)", async () => {

vi.mocked(deliverOutboundPayloads).mockResolvedValue([{ ok: true } as never]);

if (params.deliveryRequested && !params.skipHeartbeatDelivery && !sourceDeliverySatisfied) {

if (!params.resolvedDelivery.ok) {

// The target could not be resolved (e.g. a keyless implicit cron whose

// inherited shared-bucket target was refused). We never send here, so a

// deleteAfterRun cron must still retire its session/transcript before

// returning — otherwise the one-shot session leaks. Safe no-op for

// non-deleteAfterRun / non-cron sessions (see cleanupDirectCronSession).

await cleanupDirectCronSessionIfNeeded();

if (!params.deliveryBestEffort) {

return {

result: failDeliveryTarget(params.resolvedDelivery.error.message),