- Plugins: share package entrypoint resolution between install and discovery, reject mismatched `runtimeExtensions`, and cache bundled runtime-dependency manifest reads during scans. Thanks @codex.

- WhatsApp/Web: keep quiet but healthy linked-device sessions connected by basing the watchdog on WhatsApp Web transport activity, while retaining a longer app-silence cap so frame activity cannot mask a stuck session forever. Fixes #70678; carries forward the focused #71466 approach and keeps #63939 as related configurable-timeout follow-up. Thanks @vincentkoc and @oromeis.

- Discord/gateway: count failed health-monitor restart attempts toward cooldown and hourly caps, and evict stale account lifecycle state during channel reloads so repeated Discord gateway recovery cannot loop on old status. Fixes #38596. (#40413) Thanks @jellyAI-dev and @vashquez.

- Cron/context engine: run isolated cron jobs under run-scoped context-engine session keys so prior runs of the same job are not inherited unless the job is explicitly session-bound. (#72292) Thanks @jalehman.

## 2026.4.26

workspaceDir?: string;

sessionFile?: string;

};

expect(call?.sessionKey).toBe("agent:ops:cron:job-ops");

expect(call?.sessionKey).toMatch(/^agent:ops:cron:job-ops:run:/);

expect(call?.workspaceDir).toBe(opsWorkspace);

expect(call?.sessionFile).toContain(path.join("agents", "ops"));

});

runStartedAt?: number;

sessionTarget?: string;

deliveryBestEffort?: boolean;

runSessionKey?: string;

}): Parameters<typeof dispatchCronDelivery>[0] {

const resolvedDelivery = makeResolvedDelivery();

const runStartedAt = overrides.runStartedAt ?? Date.now();

} as never,

agentId: "main",

agentSessionKey: "agent:main",

runSessionKey: overrides.runSessionKey ?? "agent:main",

sessionId: "test-session-id",

runStartedAt,

runEndedAt: runStartedAt,

);

});

it("uses the run-scoped session key for isolated cron descendant fallback delivery", async () => {

const runStartedAt = 1_000;

const agentSessionKey = "agent:main:cron:daily-monitor";

const runSessionKey = "agent:main:cron:daily-monitor:run:test-session-id";

vi.mocked(countActiveDescendantRuns).mockReturnValue(0);

vi.mocked(isLikelyInterimCronMessage).mockReturnValue(true);

vi.mocked(readDescendantSubagentFallbackReply).mockImplementation(async (params) =>

params.sessionKey === runSessionKey

? "Run-scoped child result, everything finished successfully."

: undefined,

);

const params = makeBaseParams({

synthesizedText: "on it",

runStartedAt,

runSessionKey,

});

params.agentSessionKey = agentSessionKey;

const state = await dispatchCronDelivery(params);

expect(countActiveDescendantRuns).toHaveBeenCalledWith(runSessionKey);

expect(countActiveDescendantRuns).not.toHaveBeenCalledWith(agentSessionKey);

expect(readDescendantSubagentFallbackReply).toHaveBeenCalledWith({

sessionKey: runSessionKey,

runStartedAt,

});

expect(state.deliveryAttempted).toBe(true);

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

expect(deliverOutboundPayloads).toHaveBeenCalledWith(

expect.objectContaining({

payloads: [{ text: "Run-scoped child result, everything finished successfully." }],

}),

);

});

it("normal text delivery sends exactly once and sets deliveryAttempted=true", async () => {

vi.mocked(countActiveDescendantRuns).mockReturnValue(0);

vi.mocked(isLikelyInterimCronMessage).mockReturnValue(false);

job: CronJob;

agentId: string;

agentSessionKey: string;

runSessionKey: string;

sessionId: string;

runStartedAt: number;

runEndedAt: number;

const initialSynthesizedText = synthesizedText.trim();

const expectedSubagentFollowup = expectsSubagentFollowup(initialSynthesizedText);

const subagentRegistryRuntime = await loadDeliverySubagentRegistryRuntime();

const subagentFollowupSessionKey = params.runSessionKey;

let activeSubagentRuns = subagentRegistryRuntime.countActiveDescendantRuns(

params.agentSessionKey,

subagentFollowupSessionKey,

);

const shouldCheckCompletedDescendants =

activeSubagentRuns === 0 && isLikelyInterimCronMessage(initialSynthesizedText);

// descendant's output instead of the interim cron text.

const completedDescendantReply = shouldCheckCompletedDescendants

? await subagentFollowupRuntime?.readDescendantSubagentFallbackReply({

sessionKey: params.agentSessionKey,

sessionKey: subagentFollowupSessionKey,

runStartedAt: params.runStartedAt,

})

: undefined;

const hadDescendants = activeSubagentRuns > 0 || Boolean(completedDescendantReply);

if (activeSubagentRuns > 0 || expectedSubagentFollowup) {

let finalReply = await subagentFollowupRuntime?.waitForDescendantSubagentSummary({

sessionKey: params.agentSessionKey,

sessionKey: subagentFollowupSessionKey,

initialReply: initialSynthesizedText,

timeoutMs: params.timeoutMs,

observedActiveDescendants: activeSubagentRuns > 0 || expectedSubagentFollowup,

});

activeSubagentRuns = subagentRegistryRuntime.countActiveDescendantRuns(

params.agentSessionKey,

subagentFollowupSessionKey,

);

if (!finalReply && activeSubagentRuns === 0) {

finalReply = await subagentFollowupRuntime?.readDescendantSubagentFallbackReply({

sessionKey: params.agentSessionKey,

sessionKey: subagentFollowupSessionKey,

runStartedAt: params.runStartedAt,

});

}

agentId: string;

agentDir: string;

agentSessionKey: string;

runSessionKey: string;

workspaceDir: string;

lane?: string;

resolvedVerboseLevel: VerboseLevel;

: await getCliSessionId(params.cronSession.sessionEntry, providerOverride);

const result = await runCliAgent({

sessionId: params.cronSession.sessionEntry.sessionId,

sessionKey: params.agentSessionKey,

sessionKey: params.runSessionKey,

agentId: params.agentId,

trigger: "cron",

jobId: params.job.id,

});

const result = await runEmbeddedPiAgent({

sessionId: params.cronSession.sessionEntry.sessionId,

sessionKey: params.agentSessionKey,

sessionKey: params.runSessionKey,

agentId: params.agentId,

trigger: "cron",

jobId: params.job.id,

agentId: string;

agentDir: string;

agentSessionKey: string;

runSessionKey: string;

workspaceDir: string;

lane?: string;

resolvedDelivery: {

normalizeVerboseLevel(params.agentVerboseDefault) ??

"off";

registerAgentRunContext(params.cronSession.sessionEntry.sessionId, {

sessionKey: params.agentSessionKey,

sessionKey: params.runSessionKey,

verboseLevel: resolvedVerboseLevel,

});

const executor = createCronPromptExecutor({

agentId: params.agentId,

agentDir: params.agentDir,

agentSessionKey: params.agentSessionKey,

runSessionKey: params.runSessionKey,

workspaceDir: params.workspaceDir,

lane: params.lane,

resolvedVerboseLevel,

if (shouldRetryInterimAck) {

const { countActiveDescendantRuns, listDescendantRunsForRequester } =

await loadCronSubagentRegistryRuntime();

hasFreshDescendants = listDescendantRunsForRequester(params.agentSessionKey).some((entry) => {

hasFreshDescendants = listDescendantRunsForRequester(params.runSessionKey).some((entry) => {

const descendantStartedAt =

typeof entry.startedAt === "number" ? entry.startedAt : entry.createdAt;

return typeof descendantStartedAt === "number" && descendantStartedAt >= runStartedAt;

});

hasActiveDescendants = countActiveDescendantRuns(params.agentSessionKey) > 0;

hasActiveDescendants = countActiveDescendantRuns(params.runSessionKey) > 0;

}

if (shouldRetryInterimAck && !hasFreshDescendants && !hasActiveDescendants) {

}

describe("createPersistCronSessionEntry", () => {

it("persists a distinct run-session snapshot for isolated cron runs", async () => {

it("persists isolated cron state only under the stable cron session key", async () => {

const cronSession = makeCronSession(

makeSessionEntry({

status: "running",

const store: Record<string, SessionEntry> = {};

update(store);

expect(store["agent:main:cron:job"]).toBe(cronSession.sessionEntry);

expect(store["agent:main:cron:job:run:run-session-id"]).not.toBe(cronSession.sessionEntry);

expect(store["agent:main:cron:job:run:run-session-id"]).toEqual(cronSession.sessionEntry);

expect(store["agent:main:cron:job:run:run-session-id"]).toBeUndefined();

},

);

const persist = createPersistCronSessionEntry({

isFastTestEnv: false,

cronSession,

agentSessionKey: "agent:main:cron:job",

runSessionKey: "agent:main:cron:job:run:run-session-id",

updateSessionStore,

});

await persist();

expect(cronSession.store["agent:main:cron:job"]).toBe(cronSession.sessionEntry);

expect(cronSession.store["agent:main:cron:job:run:run-session-id"]).not.toBe(

cronSession.sessionEntry,

);

cronSession.sessionEntry.status = "done";

cronSession.sessionEntry.skillsSnapshot!.skills[0].name = "changed";

expect(cronSession.store["agent:main:cron:job:run:run-session-id"]?.status).toBe("running");

expect(

cronSession.store["agent:main:cron:job:run:run-session-id"]?.skillsSnapshot?.skills[0]?.name,

).toBe("memory");

expect(cronSession.store["agent:main:cron:job:run:run-session-id"]).toBeUndefined();

});

it("uses the shared session entry when the run key is the agent session key", async () => {

it("persists explicit session-bound cron state under the requested session key", async () => {

const cronSession = makeCronSession();

const updateSessionStore = vi.fn(

async (_storePath, update: (store: Record<string, SessionEntry>) => void) => {

isFastTestEnv: false,

cronSession,

agentSessionKey: "agent:main:session",

runSessionKey: "agent:main:session",

updateSessionStore,

});

export type PersistCronSessionEntry = () => Promise<void>;

function cloneSessionEntry(entry: MutableCronSessionEntry): MutableCronSessionEntry {

return globalThis.structuredClone(entry);

}

export function createPersistCronSessionEntry(params: {

isFastTestEnv: boolean;

cronSession: MutableCronSession;

agentSessionKey: string;

runSessionKey: string;

updateSessionStore: UpdateSessionStore;

}): PersistCronSessionEntry {

return async () => {

if (params.isFastTestEnv) {

return;

}

const runSessionEntry = cloneSessionEntry(params.cronSession.sessionEntry);

params.cronSession.store[params.agentSessionKey] = params.cronSession.sessionEntry;

if (params.runSessionKey !== params.agentSessionKey) {

params.cronSession.store[params.runSessionKey] = runSessionEntry;

}

await params.updateSessionStore(params.cronSession.storePath, (store) => {

store[params.agentSessionKey] = params.cronSession.sessionEntry;

if (params.runSessionKey !== params.agentSessionKey) {

store[params.runSessionKey] = runSessionEntry;

}

});

};

}

mockRunCronFallbackPassthrough();

await runTurnAndExpectOk(1, 1);

expect(listDescendantRunsForRequesterMock).toHaveBeenCalledWith(

"agent:default:cron:test:run:test-session-id",

);

expect(countActiveDescendantRunsMock).toHaveBeenCalledWith(

"agent:default:cron:test:run:test-session-id",

);

});

});

agentId: "default",

agentDir: "/tmp/agent-dir",

agentSessionKey: "cron:message-tool-policy",

runSessionKey: "cron:message-tool-policy:run:test-session-id",

workspaceDir: "/tmp/workspace",

resolvedVerboseLevel: "off",

thinkLevel: undefined,