}

function plainErrorCalls(runtime: ReturnType<typeof makeRuntime>): string[] {

return runtime.error.mock.calls.map((call) => String(call[0]).replace(/\u001b\[[0-9;]*m/g, ""));

const ansiPattern = new RegExp(String.raw`\u001b\[[0-9;]*m`, "g");

return runtime.error.mock.calls.map((call) => String(call[0]).replace(ansiPattern, ""));

}

async function withCapturedStdout(run: () => Promise<void>): Promise<string> {

status: "error",

});

expect(readCronRunLogEntriesSync(logPath, { jobId: "job-1" })).toEqual([

expect.objectContaining({

jobId: "job-1",

status: "ok",

runAtMs: 900,

durationMs: 100,

}),

]);

const jobEntries = readCronRunLogEntriesSync(logPath, { jobId: "job-1" });

expect(jobEntries).toHaveLength(1);

expect(jobEntries[0]?.jobId).toBe("job-1");

expect(jobEntries[0]?.status).toBe("ok");

expect(jobEntries[0]?.runAtMs).toBe(900);

expect(jobEntries[0]?.durationMs).toBe(100);

expect(readCronRunLogEntriesSync(path.join(dir, "runs", "missing.jsonl"))).toStrictEqual([]);

});

});

});

const entries = await readCronRunLogEntries(logPath, { limit: 10, jobId: "job-1" });

expect(entries[0]?.diagnostics).toMatchObject({

summary: "exec stderr tail",

entries: [{ source: "exec", severity: "error", message: "exec stderr tail", exitCode: 2 }],

});

expect(entries[0]?.diagnostics?.summary).toBe("exec stderr tail");

expect(entries[0]?.diagnostics?.entries).toHaveLength(1);

expect(entries[0]?.diagnostics?.entries[0]?.source).toBe("exec");

expect(entries[0]?.diagnostics?.entries[0]?.severity).toBe("error");

expect(entries[0]?.diagnostics?.entries[0]?.message).toBe("exec stderr tail");

expect(entries[0]?.diagnostics?.entries[0]?.exitCode).toBe(2);

expect(

(

await readCronRunLogEntriesPage(logPath, {

const updated = jobs.find((j) => j.id === job.id);

// Job must have actually executed.

expect(enqueueSystemEvent).toHaveBeenCalledWith(

"cron-tick",

expect.objectContaining({ agentId: undefined }),

);

const enqueueCall = enqueueSystemEvent.mock.calls[0];

expect(enqueueCall?.[0]).toBe("cron-tick");

expect(enqueueCall?.[1]?.agentId).toBeUndefined();

expect(updated?.state.lastStatus).toBe("ok");

// nextRunAtMs must advance to a future minute boundary after execution.

expect(updated?.state.nextRunAtMs).toBeGreaterThan(firstDueAt);

const jobs = await cron.list({ includeDisabled: true });

const updated = jobs.find((j) => j.id === job.id);

expect(enqueueSystemEvent).toHaveBeenCalledWith(

"tick-5",

expect.objectContaining({ agentId: undefined }),

);

const enqueueCall = enqueueSystemEvent.mock.calls[0];

expect(enqueueCall?.[0]).toBe("tick-5");

expect(enqueueCall?.[1]?.agentId).toBeUndefined();

expect(updated?.state.lastStatus).toBe("ok");

cron.stop();

const result = await cron.run("missing-enabled-due", "due");

expect(result).toEqual({ ok: true, ran: true });

expect(enqueueSystemEvent).toHaveBeenCalledWith(

"missing-enabled-due",

expect.objectContaining({ agentId: undefined }),

);

const enqueueCall = enqueueSystemEvent.mock.calls[0];

expect(enqueueCall?.[0]).toBe("missing-enabled-due");

expect(enqueueCall?.[1]?.agentId).toBeUndefined();

cron.stop();

});

let persisted = await loadCronStore(store.storePath);

let storedJob = persisted.jobs.find((job) => job.id === disabledJob.id);

expect(storedJob?.enabled).toBe(false);

expect(storedJob?.schedule).toEqual(

expect.objectContaining({ kind: "cron", expr: "0 * * * *", tz: "UTC" }),

);

expect(storedJob?.schedule.kind).toBe("cron");

if (storedJob?.schedule.kind !== "cron") {

throw new Error("expected stored cron schedule");

}

expect(storedJob.schedule.expr).toBe("0 * * * *");

expect(storedJob.schedule.tz).toBe("UTC");

await writeCronStoreSnapshot(store.storePath, [

{

it("allows isolated session job for non-default agents", () => {

const state = createMockState(now, { defaultAgentId: "main" });

expect(

createJob(state, {

name: "isolated-job",

enabled: true,

schedule: { kind: "every", everyMs: 60_000 },

sessionTarget: "isolated",

wakeMode: "now",

payload: { kind: "agentTurn", message: "do it" },

agentId: "custom-agent",

}),

).toMatchObject({

agentId: "custom-agent",

const job = createJob(state, {

name: "isolated-job",

enabled: true,

schedule: { kind: "every", everyMs: 60_000 },

sessionTarget: "isolated",

wakeMode: "now",

payload: { kind: "agentTurn", message: "do it" },

agentId: "custom-agent",

});

expect(job.agentId).toBe("custom-agent");

expect(job.sessionTarget).toBe("isolated");

});

it("rejects custom session targets with path separators", () => {

await runSingleTick(cron);

expect(runHeartbeatOnce).toHaveBeenCalled();

expect(requestHeartbeat).toHaveBeenCalledWith(

expect.objectContaining({

source: "cron",

intent: "immediate",

reason: "cron:test-main-delivery-busy",

heartbeat: { target: "last" },

}),

);

const heartbeatRequest = requestHeartbeat.mock.calls[0]?.[0];

expect(heartbeatRequest?.source).toBe("cron");

expect(heartbeatRequest?.intent).toBe("immediate");

expect(heartbeatRequest?.reason).toBe("cron:test-main-delivery-busy");

expect(heartbeatRequest?.heartbeat).toEqual({ target: "last" });

});

it("should preserve heartbeat.target=last for wakeMode=next-heartbeat main jobs", async () => {

await runSingleTick(cron);

expect(requestHeartbeat).toHaveBeenCalled();

expect(requestHeartbeat).toHaveBeenCalledWith(

expect.objectContaining({

source: "cron",

intent: "event",

reason: "cron:test-next-heartbeat",

heartbeat: { target: "last" },

}),

);

const heartbeatRequest = requestHeartbeat.mock.calls[0]?.[0];

expect(heartbeatRequest?.source).toBe("cron");

expect(heartbeatRequest?.intent).toBe("event");

expect(heartbeatRequest?.reason).toBe("cron:test-next-heartbeat");

expect(heartbeatRequest?.heartbeat).toEqual({ target: "last" });

expect(runHeartbeatOnce).not.toHaveBeenCalled();

});

});

},

});

expect(capturedEvent).toMatchObject({

delivered: true,

deliveryStatus: "delivered",

});

expect(capturedEvent?.delivered).toBe(true);

expect(capturedEvent?.deliveryStatus).toBe("delivered");

});

});