Skip to content

Commit 5c0eb51

Browse files
fix(server): a missed fixed-time slot shows as failed on its scheduled task (pingdotgg#34815)
1 parent 26433ac commit 5c0eb51

3 files changed

Lines changed: 333 additions & 5 deletions

File tree

‎apps/server/src/scheduledTasks/ScheduledTaskService.schedule.test.ts‎

Lines changed: 164 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -392,3 +392,167 @@ it.effect(
392392
}).pipe(Effect.provide(ScheduledTaskService.layer.pipe(Layer.provide(layerDependencies))));
393393
}).pipe(Effect.provide(SqlitePersistence.layerMemory)),
394394
);
395+
396+
it.effect("a fixed-time slot missed while the server was off shows on the task", () =>
397+
Effect.gen(function* () {
398+
const at = (hour: number, minute = 0, day = 1) =>
399+
DateTime.makeZonedUnsafe(
400+
{ year: 2026, month: 7, day, hour, minute, second: 0, millisecond: 0 },
401+
{ timeZone: DateTime.zoneMakeLocal(), adjustForTimeZone: true },
402+
);
403+
yield* TestClock.setTime(DateTime.toEpochMillis(at(8)));
404+
const launches = yield* Ref.make(0);
405+
const layerDependencies = Layer.mergeAll(
406+
NodeCrypto.layer,
407+
Scheduler.layer,
408+
ManagedPolicy.layerTest(),
409+
Layer.mock(ThreadLaunchService.ThreadLaunchService)({
410+
launch: () =>
411+
Ref.update(launches, (count) => count + 1).pipe(
412+
Effect.as({ threadId: "thread-missed-slot", resumed: false } as never),
413+
),
414+
}),
415+
Layer.mock(ManagedProjectFolders.ManagedProjectFolders)({
416+
namedProjectsRoot: "/projects",
417+
isScratchProject: () => Effect.succeed(false),
418+
}),
419+
Layer.mock(ThreadManagementService.ThreadManagementService)({}),
420+
Layer.mock(SecretRequests.SecretRequests)({}),
421+
);
422+
const withServer = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
423+
effect.pipe(
424+
Effect.provide(ScheduledTaskService.layer.pipe(Layer.provide(layerDependencies))),
425+
);
426+
427+
const taskId = yield* withServer(
428+
Effect.gen(function* () {
429+
const service = yield* ScheduledTaskService.ScheduledTaskService;
430+
const { task } = yield* service.upsert(
431+
yield* decodeUpsertInput({
432+
title: "Morning bookkeeping",
433+
prompt: "Update yesterday's notes.",
434+
enabled: true,
435+
schedule: { type: "fixed_time", timeOfDay: "09:00" },
436+
projectId: "project-missed-slot",
437+
workspaceStrategy: { type: "root" },
438+
modelSelection: { instanceId: "codex", model: "gpt-5.4" },
439+
runtimeMode: "full-access",
440+
interactionMode: "default",
441+
}),
442+
);
443+
yield* service.runNow({ id: task.id });
444+
return task.id;
445+
}),
446+
);
447+
448+
// The server is off across the 09:00 slot and comes back at 09:30.
449+
yield* TestClock.setTime(DateTime.toEpochMillis(at(9, 30)));
450+
const [listed] = yield* withServer(
451+
Effect.gen(function* () {
452+
const service = yield* ScheduledTaskService.ScheduledTaskService;
453+
yield* TestClock.adjust("6 seconds");
454+
return (yield* service.list()).tasks;
455+
}),
456+
);
457+
458+
expect(listed?.id).toBe(taskId);
459+
expect(yield* Ref.get(launches)).toBe(1);
460+
expect(listed?.nextRunAt).toBe(DateTime.formatIso(DateTime.toUtc(at(9, 0, 2))));
461+
// The skipped slot must not read as the earlier manual run's clean success.
462+
expect({ status: listed?.lastRunStatus, error: listed?.lastRunError }).not.toEqual({
463+
status: "succeeded",
464+
error: null,
465+
});
466+
}).pipe(Effect.provide(SqlitePersistence.layerMemory)),
467+
);
468+
469+
it.effect(
470+
"a run made while the scheduler was busy is not overwritten by its stale missed slot",
471+
() =>
472+
Effect.gen(function* () {
473+
const at = (hour: number, minute = 0, day = 1) =>
474+
DateTime.makeZonedUnsafe(
475+
{ year: 2026, month: 7, day, hour, minute, second: 0, millisecond: 0 },
476+
{ timeZone: DateTime.zoneMakeLocal(), adjustForTimeZone: true },
477+
);
478+
yield* TestClock.setTime(DateTime.toEpochMillis(at(6)));
479+
const slowStarted = yield* Deferred.make<void>();
480+
const releaseSlow = yield* Deferred.make<void>();
481+
const lastProcessed = yield* Deferred.make<void>();
482+
const layerDependencies = Layer.mergeAll(
483+
NodeCrypto.layer,
484+
Scheduler.layer,
485+
ManagedPolicy.layerTest(),
486+
Layer.mock(ThreadLaunchService.ThreadLaunchService)({
487+
launch: (input) =>
488+
(input.title === "Slow"
489+
? Deferred.succeed(slowStarted, undefined).pipe(
490+
Effect.andThen(Deferred.await(releaseSlow)),
491+
)
492+
: input.title === "Last"
493+
? Deferred.succeed(lastProcessed, undefined)
494+
: Effect.void
495+
).pipe(Effect.as({ threadId: `thread-${input.title}`, resumed: false } as never)),
496+
}),
497+
Layer.mock(ManagedProjectFolders.ManagedProjectFolders)({
498+
namedProjectsRoot: "/projects",
499+
isScratchProject: () => Effect.succeed(false),
500+
}),
501+
Layer.mock(ThreadManagementService.ThreadManagementService)({}),
502+
Layer.mock(SecretRequests.SecretRequests)({}),
503+
);
504+
const withServer = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
505+
effect.pipe(
506+
Effect.provide(ScheduledTaskService.layer.pipe(Layer.provide(layerDependencies))),
507+
);
508+
const upsert = (
509+
title: string,
510+
schedule: { type: "interval"; everyMs: number } | { type: "fixed_time"; timeOfDay: string },
511+
) =>
512+
Effect.gen(function* () {
513+
const service = yield* ScheduledTaskService.ScheduledTaskService;
514+
const { task } = yield* service.upsert(
515+
yield* decodeUpsertInput({
516+
title,
517+
prompt: "Update the notes.",
518+
enabled: true,
519+
schedule,
520+
projectId: "project-stale-slot",
521+
workspaceStrategy: { type: "root" },
522+
modelSelection: { instanceId: "codex", model: "gpt-5.4" },
523+
runtimeMode: "full-access",
524+
interactionMode: "default",
525+
}),
526+
);
527+
return task.id;
528+
});
529+
530+
// Due at 07:00, 08:00 and 08:30; the server is off until 09:30.
531+
const morningId = yield* withServer(
532+
Effect.gen(function* () {
533+
yield* upsert("Slow", { type: "interval", everyMs: 60 * 60 * 1000 });
534+
const id = yield* upsert("Morning", { type: "fixed_time", timeOfDay: "08:00" });
535+
yield* upsert("Last", { type: "interval", everyMs: 150 * 60 * 1000 });
536+
return id;
537+
}),
538+
);
539+
yield* TestClock.setTime(DateTime.toEpochMillis(at(9, 30)));
540+
const morning = yield* withServer(
541+
Effect.gen(function* () {
542+
const service = yield* ScheduledTaskService.ScheduledTaskService;
543+
yield* TestClock.adjust("6 seconds");
544+
yield* Deferred.await(slowStarted);
545+
yield* service.runNow({ id: morningId });
546+
yield* Deferred.succeed(releaseSlow, undefined);
547+
yield* Deferred.await(lastProcessed);
548+
return (yield* service.list()).tasks.find((task) => task.id === morningId);
549+
}),
550+
);
551+
552+
expect({ status: morning?.lastRunStatus, error: morning?.lastRunError }).toEqual({
553+
status: "succeeded",
554+
error: null,
555+
});
556+
expect(morning?.nextRunAt).toBe(DateTime.formatIso(DateTime.toUtc(at(8, 0, 2))));
557+
}).pipe(Effect.provide(SqlitePersistence.layerMemory)),
558+
);

‎apps/server/src/scheduledTasks/ScheduledTaskService.test.ts‎

Lines changed: 89 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -17,6 +17,7 @@ import * as Effect from "effect/Effect";
1717
import * as Exit from "effect/Exit";
1818
import * as Layer from "effect/Layer";
1919
import * as Logger from "effect/Logger";
20+
import * as Option from "effect/Option";
2021
import * as SqlClient from "effect/sql/SqlClient";
2122

2223
import * as Fiber from "effect/Fiber";
@@ -418,6 +419,94 @@ it.effect("thread cleanup notifies subscribers and a finishing run cannot recrea
418419
}).pipe(Effect.provide(SqlitePersistence.layerMemory)),
419420
);
420421

422+
it.effect.each([
423+
{ status: "failed", error: "Weekly usage limit reached" },
424+
{ status: "interrupted", error: "The run was stopped." },
425+
{ status: "cancelled", error: "The run was cancelled." },
426+
] as const)("a run that ends $status after its message was accepted records it", (outcome) =>
427+
Effect.gen(function* () {
428+
const projectId = ProjectId.make("project:test");
429+
const ended = yield* Deferred.make<void>();
430+
const sent = yield* Ref.make("");
431+
const run = { id: "run:2", status: outcome.status, rootNodeId: "node:root" };
432+
const layer = ScheduledTaskService.layer.pipe(
433+
Layer.provide(
434+
Layer.mergeAll(
435+
ManagedPolicy.layerTest(),
436+
Layer.mock(ThreadLaunchService.ThreadLaunchService)({}),
437+
Layer.mock(ThreadManagementService.ThreadManagementService)({
438+
sendToThread: (input) => Ref.set(sent, input.messageId).pipe(Effect.as({} as never)),
439+
getThreadShell: () => Effect.succeed(threadShell(projectId)),
440+
getProjectThreadRecords: () =>
441+
Effect.map(
442+
Ref.get(sent),
443+
(userMessageId) =>
444+
({
445+
runs: [
446+
{ id: "run:1", status: "completed", userMessageId: "message:earlier" },
447+
{ ...run, userMessageId },
448+
],
449+
messages: [{ id: userMessageId, runId: "run:2" }],
450+
turnItems: [
451+
{
452+
type: "error",
453+
status: "failed",
454+
runId: "run:2",
455+
nodeId: "node:root",
456+
failure: { message: "Weekly usage limit reached" },
457+
},
458+
],
459+
}) as never,
460+
),
461+
waitForThread: (input) =>
462+
Deferred.await(ended).pipe(
463+
Effect.as({
464+
threadId: input.threadId,
465+
run: { ...run, id: input.runId, userMessageId: "" },
466+
timedOut: false,
467+
} as never),
468+
),
469+
}),
470+
Layer.mock(SecretRequests.SecretRequests)({}),
471+
Layer.mock(ManagedProjectFolders.ManagedProjectFolders)({
472+
namedProjectsRoot: "/projects",
473+
isScratchProject: () => Effect.succeed(false),
474+
}),
475+
NodeCrypto.layer,
476+
Scheduler.layer,
477+
),
478+
),
479+
);
480+
yield* Effect.gen(function* () {
481+
const service = yield* ScheduledTaskService.ScheduledTaskService;
482+
const { task } = yield* service.upsert({
483+
id: ScheduledTaskId.make("task:quota"),
484+
title: "Quota bookkeeping",
485+
prompt: "Update the notes",
486+
enabled: true,
487+
schedule: { type: "interval", everyMs: 60_000 },
488+
projectId,
489+
threadId: ThreadId.make("thread:quota"),
490+
workspaceStrategy: { type: "root" },
491+
modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" },
492+
runtimeMode: "full-access",
493+
interactionMode: "default",
494+
});
495+
yield* service.runNow({ id: task.id });
496+
const failed = yield* service.subscribeList().pipe(
497+
Stream.map(({ tasks }) => tasks.find((candidate) => candidate.id === task.id)),
498+
Stream.filter((current) => current?.lastRunStatus === "failed"),
499+
Stream.runHead,
500+
Effect.forkChild,
501+
);
502+
yield* Deferred.succeed(ended, undefined);
503+
const recorded = Option.getOrUndefined(yield* Fiber.join(failed));
504+
assert.equal(recorded?.lastRunError, outcome.error);
505+
assert.equal(recorded?.runCount, 1);
506+
}).pipe(Effect.provide(layer));
507+
}).pipe(Effect.provide(SqlitePersistence.layerMemory)),
508+
);
509+
421510
it.effect("a bound run follows its thread when promotion moves it mid-send", () =>
422511
Effect.gen(function* () {
423512
const scratch = ProjectId.make("project:scratch");

0 commit comments

Comments
 (0)