@devries-cameron20 / t3code Mirror · read-only
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 04:45 UTC

main
ts 603 lines 25.3 KB
Raw
1 import * as Scheduler from "../scheduling/Scheduler.ts";
2 import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
3 import { expect, it } from "@effect/vitest";
4 import {
5 type OrchestrationV2ConversationMessage,
6 type OrchestrationV2Run,
7 MessageId,
8 RunId,
9 ScheduledTaskUpsertInput,
10 } from "@t3tools/contracts";
11 import * as DateTime from "effect/DateTime";
12 import * as Deferred from "effect/Deferred";
13 import * as Effect from "effect/Effect";
14 import * as Layer from "effect/Layer";
15 import * as Ref from "effect/Ref";
16 import * as Schema from "effect/Schema";
17 import * as SqlClient from "effect/sql/SqlClient";
18 import * as TestClock from "effect/testing/TestClock";
19
20 import * as ThreadLaunchService from "../orchestration-v2/ThreadLaunchService.ts";
21 import * as ThreadManagementService from "../orchestration-v2/ThreadManagementService.ts";
22 import * as SecretRequests from "../secrets/SecretRequests.ts";
23 import * as ManagedProjectFolders from "../project/ManagedProjectFolders.ts";
24 import * as SqlitePersistence from "../persistence/Sqlite.ts";
25 import * as ScheduledTaskService from "./ScheduledTaskService.ts";
26 import * as ManagedPolicy from "../policy/ManagedPolicy.ts";
27
28 const decodeUpsertInput = Schema.decodeUnknownEffect(ScheduledTaskUpsertInput);
29
30 it.effect("rejects a stale form save after deletion while preserving explicit-id creates", () =>
31 Effect.gen(function* () {
32 const layerDependencies = Layer.mergeAll(
33 NodeCrypto.layer,
34 Scheduler.layer,
35 ManagedPolicy.layerTest(),
36 Layer.mock(ThreadLaunchService.ThreadLaunchService)({}),
37 Layer.mock(ManagedProjectFolders.ManagedProjectFolders)({
38 namedProjectsRoot: "/projects",
39 isScratchProject: () => Effect.succeed(false),
40 }),
41 Layer.mock(ThreadManagementService.ThreadManagementService)({}),
42 Layer.mock(SecretRequests.SecretRequests)({}),
43 );
44 yield* Effect.gen(function* () {
45 const service = yield* ScheduledTaskService.ScheduledTaskService;
46 const input = yield* decodeUpsertInput({
47 id: "scheduled-task:edit-after-delete",
48 title: "Review",
49 prompt: "Review the open pull requests.",
50 enabled: true,
51 schedule: { type: "interval", everyMs: 60_000 },
52 projectId: "project-stale-schedule",
53 workspaceStrategy: { type: "root" },
54 modelSelection: { instanceId: "codex", model: "gpt-5.4" },
55 runtimeMode: "full-access",
56 interactionMode: "default",
57 });
58 const created = yield* service.upsert(input);
59 const edit = yield* decodeUpsertInput({ ...input, requireExisting: true, title: "Edited" });
60 expect((yield* service.upsert(edit)).task.title).toBe("Edited");
61 yield* service.delete({ id: created.task.id });
62
63 const failure = yield* service.upsert(edit).pipe(Effect.flip);
64 expect(failure.message).toBe("Schedule task not found.");
65 expect((yield* service.list()).tasks).toEqual([]);
66
67 expect((yield* service.upsert(input)).task.id).toBe(created.task.id);
68 }).pipe(Effect.provide(ScheduledTaskService.layer.pipe(Layer.provide(layerDependencies))));
69 }).pipe(Effect.provide(SqlitePersistence.layerMemory)),
70 );
71
72 it.effect("preserves a due run when a save only pads the scheduled hour", () =>
73 Effect.gen(function* () {
74 const dueAt = DateTime.makeZonedUnsafe(
75 { year: 2026, month: 7, day: 1, hour: 9, minute: 0, second: 0, millisecond: 0 },
76 { timeZone: DateTime.zoneMakeLocal(), adjustForTimeZone: true },
77 );
78 yield* TestClock.setTime(DateTime.toEpochMillis(dueAt) - 1_000);
79
80 const layerDependencies = Layer.mergeAll(
81 NodeCrypto.layer,
82 Scheduler.layer,
83 ManagedPolicy.layerTest(),
84 Layer.mock(ThreadLaunchService.ThreadLaunchService)({}),
85 Layer.mock(ManagedProjectFolders.ManagedProjectFolders)({
86 namedProjectsRoot: "/projects",
87 isScratchProject: () => Effect.succeed(false),
88 }),
89 Layer.mock(ThreadManagementService.ThreadManagementService)({}),
90 Layer.mock(SecretRequests.SecretRequests)({}),
91 );
92 yield* Effect.gen(function* () {
93 const service = yield* ScheduledTaskService.ScheduledTaskService;
94 const input = yield* decodeUpsertInput({
95 commandId: "schedule-time-format",
96 title: "Morning review",
97 prompt: "Review the open pull requests.",
98 enabled: true,
99 schedule: { type: "fixed_time", timeOfDay: "9:00" },
100 projectId: "project-schedule-time-format",
101 workspaceStrategy: { type: "root" },
102 modelSelection: { instanceId: "codex", model: "gpt-5.4" },
103 runtimeMode: "full-access",
104 interactionMode: "default",
105 creationSource: "mcp",
106 });
107 const created = yield* service.upsert(input);
108 const expectedDueAt = DateTime.formatIso(DateTime.toUtc(dueAt));
109 expect(created.task.nextRunAt).toBe(expectedDueAt);
110
111 yield* TestClock.setTime(DateTime.toEpochMillis(dueAt) + 1_000);
112 const update = yield* decodeUpsertInput({
113 ...input,
114 id: created.task.id,
115 schedule: { type: "fixed_time", timeOfDay: "09:00" },
116 });
117 const updated = yield* service.upsert(update);
118 expect(updated.task.nextRunAt).toBe(expectedDueAt);
119 expect((yield* service.list()).tasks[0]?.nextRunAt).toBe(expectedDueAt);
120
121 const rescheduled = yield* service.upsert({
122 ...update,
123 schedule: { type: "fixed_time", timeOfDay: "09:30" },
124 });
125 expect(rescheduled.task.nextRunAt).toBe(
126 DateTime.formatIso(DateTime.toUtc(DateTime.add(dueAt, { minutes: 30 }))),
127 );
128 }).pipe(Effect.provide(ScheduledTaskService.layer.pipe(Layer.provide(layerDependencies))));
129 }).pipe(Effect.provide(SqlitePersistence.layerMemory)),
130 );
131
132 it.effect("keeps the task list order when a toggle or edit rewrites updated_at", () =>
133 Effect.gen(function* () {
134 yield* TestClock.setTime(Date.parse("2026-07-01T09:00:00.000Z"));
135 const layerDependencies = Layer.mergeAll(
136 NodeCrypto.layer,
137 Scheduler.layer,
138 ManagedPolicy.layerTest(),
139 Layer.mock(ThreadLaunchService.ThreadLaunchService)({}),
140 Layer.mock(ManagedProjectFolders.ManagedProjectFolders)({
141 namedProjectsRoot: "/projects",
142 isScratchProject: () => Effect.succeed(false),
143 }),
144 Layer.mock(ThreadManagementService.ThreadManagementService)({}),
145 Layer.mock(SecretRequests.SecretRequests)({}),
146 );
147 yield* Effect.gen(function* () {
148 const service = yield* ScheduledTaskService.ScheduledTaskService;
149 const input = (id: string) => ({
150 id,
151 title: id,
152 prompt: "Review the open pull requests.",
153 enabled: true,
154 schedule: { type: "interval", everyMs: 60_000 },
155 projectId: "project-stable-order",
156 workspaceStrategy: { type: "root" },
157 modelSelection: { instanceId: "codex", model: "gpt-5.4" },
158 runtimeMode: "full-access",
159 interactionMode: "default",
160 });
161 const listedIds = service
162 .list()
163 .pipe(Effect.map(({ tasks }) => tasks.map((task) => String(task.id))));
164
165 const older = yield* service.upsert(yield* decodeUpsertInput(input("scheduled-task:older")));
166 yield* TestClock.adjust("1 second");
167 yield* service.upsert(yield* decodeUpsertInput(input("scheduled-task:newer")));
168 const order = ["scheduled-task:newer", "scheduled-task:older"];
169 expect(yield* listedIds).toEqual(order);
170
171 yield* TestClock.adjust("1 second");
172 const toggled = yield* service.setEnabled({ id: older.task.id, enabled: false });
173 expect(toggled.task.updatedAt > older.task.updatedAt).toBe(true);
174 expect(yield* listedIds).toEqual(order);
175
176 yield* TestClock.adjust("1 second");
177 const edit = { ...input(older.task.id), requireExisting: true, title: "Edited" };
178 yield* service.upsert(yield* decodeUpsertInput({ ...edit, enabled: false }));
179 expect(yield* listedIds).toEqual(order);
180 }).pipe(Effect.provide(ScheduledTaskService.layer.pipe(Layer.provide(layerDependencies))));
181 }).pipe(Effect.provide(SqlitePersistence.layerMemory)),
182 );
183
184 it.effect("keeps one queued occurrence of a recurring task while its bound thread is busy", () =>
185 Effect.gen(function* () {
186 yield* TestClock.setTime(Date.parse("2026-07-01T09:00:00.000Z"));
187 // The bound thread's own run never finishes, so every scheduled send lands
188 // in its queue and stays there.
189 const activeRun = {
190 id: RunId.make("run:busy"),
191 status: "running",
192 userMessageId: MessageId.make("message:busy"),
193 } as OrchestrationV2Run;
194 const thread = yield* Ref.make<{
195 readonly runs: ReadonlyArray<OrchestrationV2Run>;
196 readonly messages: ReadonlyArray<OrchestrationV2ConversationMessage>;
197 }>({ runs: [activeRun], messages: [] });
198 const runDueWork = yield* Ref.make<Effect.Effect<void>>(Effect.void);
199 const sql = yield* SqlClient.SqlClient;
200 const outcomeDuringLookup = yield* Ref.make(false);
201 const layerDependencies = Layer.mergeAll(
202 NodeCrypto.layer,
203 ManagedPolicy.layerTest(),
204 // Capture the poll pass so the test drives each due interval directly.
205 Layer.mock(Scheduler.Scheduler)({
206 register: (name, work) =>
207 name !== "scheduled-tasks"
208 ? Effect.void
209 : Effect.context<Effect.Services<typeof work>>().pipe(
210 Effect.flatMap((context) =>
211 Ref.set(runDueWork, work.pipe(Effect.provideContext(context), Effect.ignore)),
212 ),
213 ),
214 }),
215 Layer.mock(ThreadLaunchService.ThreadLaunchService)({}),
216 Layer.mock(ManagedProjectFolders.ManagedProjectFolders)({
217 namedProjectsRoot: "/projects",
218 isScratchProject: () => Effect.succeed(false),
219 }),
220 Layer.mock(ThreadManagementService.ThreadManagementService)({
221 sendToThread: (input) =>
222 Ref.modify(thread, (current) => {
223 const run = {
224 id: RunId.make(`run:${input.messageId}`),
225 status: "queued",
226 userMessageId: input.messageId,
227 } as OrchestrationV2Run;
228 const message = {
229 id: input.messageId,
230 threadId: input.threadId,
231 runId: run.id,
232 role: "user",
233 text: input.text,
234 ...(input.scheduledTaskId === undefined
235 ? {}
236 : { scheduledTaskId: input.scheduledTaskId }),
237 } as OrchestrationV2ConversationMessage;
238 return [
239 {
240 delivery: "queued",
241 run,
242 message,
243 } as ThreadManagementService.ThreadManagementSendResult,
244 { runs: [...current.runs, run], messages: [...current.messages, message] },
245 ];
246 }),
247 getThreadRecords: (_id, fields) =>
248 Effect.gen(function* () {
249 if (
250 fields.some((field) => field === "messages") &&
251 (yield* Ref.get(outcomeDuringLookup))
252 ) {
253 yield* Ref.set(outcomeDuringLookup, false);
254 yield* sql`UPDATE scheduled_tasks SET last_run_status = 'failed',
255 last_run_error = 'Provider failed' WHERE task_id = 'scheduled-task:busy-thread'`;
256 }
257 return (yield* Ref.get(thread)) as never;
258 }).pipe(Effect.orDie),
259 getThreadShell: () =>
260 Effect.succeed({
261 projectId: "project-busy-thread",
262 deletedAt: null,
263 archivedAt: null,
264 } as never),
265 }),
266 Layer.mock(SecretRequests.SecretRequests)({}),
267 );
268 yield* Effect.gen(function* () {
269 const service = yield* ScheduledTaskService.ScheduledTaskService;
270 const { task } = yield* service.upsert(
271 yield* decodeUpsertInput({
272 id: "scheduled-task:busy-thread",
273 title: "Check progress",
274 prompt: "Check progress",
275 enabled: true,
276 schedule: { type: "interval", everyMs: 60_000 },
277 projectId: "project-busy-thread",
278 threadId: "thread:busy",
279 workspaceStrategy: { type: "root" },
280 modelSelection: { instanceId: "codex", model: "gpt-5.4" },
281 runtimeMode: "full-access",
282 interactionMode: "default",
283 }),
284 );
285
286 for (let interval = 0; interval < 3; interval++) {
287 yield* TestClock.adjust("61 seconds");
288 yield* Effect.flatten(Ref.get(runDueWork));
289 }
290
291 const queuedOccurrencesOf = (taskId: typeof task.id) =>
292 Ref.get(thread).pipe(
293 Effect.map(
294 ({ runs, messages }) =>
295 runs
296 .filter((run) => run.status === "queued")
297 .map((run) => messages.find((message) => message.id === run.userMessageId))
298 .filter((message) => message?.scheduledTaskId === taskId).length,
299 ),
300 );
301 const queuedOccurrences = queuedOccurrencesOf(task.id);
302 expect(yield* queuedOccurrences).toBe(1);
303 // Skipped intervals still move the schedule forward.
304 const [listed] = (yield* service.list()).tasks;
305 expect(Date.parse(listed?.nextRunAt ?? "")).toBeGreaterThan(
306 Date.parse("2026-07-01T09:03:03.000Z"),
307 );
308
309 yield* Ref.update(thread, (current) => ({
310 ...current,
311 runs: current.runs.map((run) =>
312 run.status === "queued" ? { ...run, queueHeld: true } : run,
313 ),
314 }));
315 yield* TestClock.adjust("61 seconds");
316 yield* Effect.flatten(Ref.get(runDueWork));
317 const [blocked] = (yield* service.list()).tasks;
318 expect(blocked?.lastRunStatus).toBe("failed");
319 expect(blocked?.lastRunError).toBe(
320 "A previous occurrence is held in the thread queue. Resume or remove it to run this task again.",
321 );
322 expect(yield* queuedOccurrences).toBe(1);
323
324 // The prior run can finish while the poll is looking up its held occurrence.
325 yield* sql`UPDATE scheduled_tasks SET last_run_status = 'succeeded', last_run_error = NULL
326 WHERE task_id = ${task.id}`;
327 yield* Ref.set(outcomeDuringLookup, true);
328 yield* TestClock.adjust("61 seconds");
329 yield* Effect.flatten(Ref.get(runDueWork));
330 const [raced] = (yield* service.list()).tasks;
331 expect(raced?.lastRunStatus).toBe("failed");
332 expect(raced?.lastRunError).toBe("Provider failed");
333 expect(Date.parse(raced?.nextRunAt ?? "")).toBeGreaterThan(
334 Date.parse(blocked?.nextRunAt ?? ""),
335 );
336
337 // Run now is an explicit request, so it still queues behind the held one.
338 yield* service.runNow({ id: task.id });
339 expect(yield* queuedOccurrences).toBe(2);
340
341 // Once the queued copies start, the next interval sends again.
342 yield* Ref.update(thread, (current) => ({
343 ...current,
344 runs: current.runs.map((run) =>
345 run.status === "queued" ? ({ ...run, status: "running" } as OrchestrationV2Run) : run,
346 ),
347 }));
348 yield* TestClock.adjust("61 seconds");
349 yield* Effect.flatten(Ref.get(runDueWork));
350 expect(yield* queuedOccurrences).toBe(1);
351 const [resumed] = (yield* service.list()).tasks;
352 expect(resumed?.lastRunStatus).toBe("succeeded");
353 expect(resumed?.lastRunError).toBeNull();
354
355 // A one-time task's only scheduled occurrence still sends behind a queued Run now.
356 const { task: once } = yield* service.upsert(
357 yield* decodeUpsertInput({
358 id: "scheduled-task:busy-thread-once",
359 title: "Check once",
360 prompt: "Check once",
361 enabled: true,
362 schedule: { type: "once", runAt: "2026-07-01T09:07:00.000Z" },
363 projectId: "project-busy-thread",
364 threadId: "thread:busy",
365 workspaceStrategy: { type: "root" },
366 modelSelection: { instanceId: "codex", model: "gpt-5.4" },
367 runtimeMode: "full-access",
368 interactionMode: "default",
369 }),
370 );
371 yield* service.runNow({ id: once.id });
372 yield* TestClock.adjust("61 seconds");
373 yield* Effect.flatten(Ref.get(runDueWork));
374 expect(yield* queuedOccurrencesOf(once.id)).toBe(2);
375 }).pipe(Effect.provide(ScheduledTaskService.layer.pipe(Layer.provide(layerDependencies))));
376 }).pipe(Effect.provide(SqlitePersistence.layerMemory)),
377 );
378
379 it.effect(
380 "idle polls still wake for tasks saved later, recorded due times, and beside far-future tasks",
381 () =>
382 Effect.gen(function* () {
383 yield* TestClock.setTime(Date.parse("2026-07-01T09:00:00.000Z"));
384 const launched = yield* Deferred.make<string>();
385 const layerDependencies = Layer.mergeAll(
386 NodeCrypto.layer,
387 Scheduler.layer,
388 ManagedPolicy.layerTest(),
389 Layer.mock(ThreadLaunchService.ThreadLaunchService)({
390 launch: (input) =>
391 Deferred.succeed(launched, input.title).pipe(
392 Effect.as({ threadId: "thread-idle-poll", resumed: false } as never),
393 ),
394 }),
395 Layer.mock(ManagedProjectFolders.ManagedProjectFolders)({
396 namedProjectsRoot: "/projects",
397 isScratchProject: () => Effect.succeed(false),
398 }),
399 Layer.mock(ThreadManagementService.ThreadManagementService)({}),
400 Layer.mock(SecretRequests.SecretRequests)({}),
401 );
402 yield* Effect.gen(function* () {
403 const service = yield* ScheduledTaskService.ScheduledTaskService;
404 // The first poll finds no tasks and remembers that nothing is due.
405 yield* TestClock.adjust("6 seconds");
406 // Its year-10000+ next run sorts first as text; it must not hide the task below.
407 yield* service.upsert(
408 yield* decodeUpsertInput({
409 title: "Far future",
410 prompt: "Review the open pull requests.",
411 enabled: true,
412 schedule: { type: "interval", everyMs: 3e14 },
413 projectId: "project-idle-poll",
414 workspaceStrategy: { type: "root" },
415 modelSelection: { instanceId: "codex", model: "gpt-5.4" },
416 runtimeMode: "full-access",
417 interactionMode: "default",
418 }),
419 );
420 const created = yield* service.upsert(
421 yield* decodeUpsertInput({
422 title: "Idle poll",
423 prompt: "Review the open pull requests.",
424 enabled: true,
425 schedule: { type: "interval", everyMs: 60_000 },
426 projectId: "project-idle-poll",
427 workspaceStrategy: { type: "root" },
428 modelSelection: { instanceId: "codex", model: "gpt-5.4" },
429 runtimeMode: "full-access",
430 interactionMode: "default",
431 }),
432 );
433 // This poll records the new task's due time; the later ones must still fire it.
434 yield* TestClock.adjust("6 seconds");
435 yield* TestClock.adjust("60 seconds");
436 expect(yield* Deferred.await(launched)).toBe(created.task.title);
437 }).pipe(Effect.provide(ScheduledTaskService.layer.pipe(Layer.provide(layerDependencies))));
438 }).pipe(Effect.provide(SqlitePersistence.layerMemory)),
439 );
440
441 it.effect("a fixed-time slot missed while the server was off shows on the task", () =>
442 Effect.gen(function* () {
443 const at = (hour: number, minute = 0, day = 1) =>
444 DateTime.makeZonedUnsafe(
445 { year: 2026, month: 7, day, hour, minute, second: 0, millisecond: 0 },
446 { timeZone: DateTime.zoneMakeLocal(), adjustForTimeZone: true },
447 );
448 yield* TestClock.setTime(DateTime.toEpochMillis(at(8)));
449 const launches = yield* Ref.make(0);
450 const layerDependencies = Layer.mergeAll(
451 NodeCrypto.layer,
452 Scheduler.layer,
453 ManagedPolicy.layerTest(),
454 Layer.mock(ThreadLaunchService.ThreadLaunchService)({
455 launch: () =>
456 Ref.update(launches, (count) => count + 1).pipe(
457 Effect.as({ threadId: "thread-missed-slot", resumed: false } as never),
458 ),
459 }),
460 Layer.mock(ManagedProjectFolders.ManagedProjectFolders)({
461 namedProjectsRoot: "/projects",
462 isScratchProject: () => Effect.succeed(false),
463 }),
464 Layer.mock(ThreadManagementService.ThreadManagementService)({}),
465 Layer.mock(SecretRequests.SecretRequests)({}),
466 );
467 const withServer = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
468 effect.pipe(
469 Effect.provide(ScheduledTaskService.layer.pipe(Layer.provide(layerDependencies))),
470 );
471
472 const taskId = yield* withServer(
473 Effect.gen(function* () {
474 const service = yield* ScheduledTaskService.ScheduledTaskService;
475 const { task } = yield* service.upsert(
476 yield* decodeUpsertInput({
477 title: "Morning bookkeeping",
478 prompt: "Update yesterday's notes.",
479 enabled: true,
480 schedule: { type: "fixed_time", timeOfDay: "09:00" },
481 projectId: "project-missed-slot",
482 workspaceStrategy: { type: "root" },
483 modelSelection: { instanceId: "codex", model: "gpt-5.4" },
484 runtimeMode: "full-access",
485 interactionMode: "default",
486 }),
487 );
488 yield* service.runNow({ id: task.id });
489 return task.id;
490 }),
491 );
492
493 // The server is off across the 09:00 slot and comes back at 09:30.
494 yield* TestClock.setTime(DateTime.toEpochMillis(at(9, 30)));
495 const [listed] = yield* withServer(
496 Effect.gen(function* () {
497 const service = yield* ScheduledTaskService.ScheduledTaskService;
498 yield* TestClock.adjust("6 seconds");
499 return (yield* service.list()).tasks;
500 }),
501 );
502
503 expect(listed?.id).toBe(taskId);
504 expect(yield* Ref.get(launches)).toBe(1);
505 expect(listed?.nextRunAt).toBe(DateTime.formatIso(DateTime.toUtc(at(9, 0, 2))));
506 // The skipped slot must not read as the earlier manual run's clean success.
507 expect({ status: listed?.lastRunStatus, error: listed?.lastRunError }).not.toEqual({
508 status: "succeeded",
509 error: null,
510 });
511 }).pipe(Effect.provide(SqlitePersistence.layerMemory)),
512 );
513
514 it.effect(
515 "a run made while the scheduler was busy is not overwritten by its stale missed slot",
516 () =>
517 Effect.gen(function* () {
518 const at = (hour: number, minute = 0, day = 1) =>
519 DateTime.makeZonedUnsafe(
520 { year: 2026, month: 7, day, hour, minute, second: 0, millisecond: 0 },
521 { timeZone: DateTime.zoneMakeLocal(), adjustForTimeZone: true },
522 );
523 yield* TestClock.setTime(DateTime.toEpochMillis(at(6)));
524 const slowStarted = yield* Deferred.make<void>();
525 const releaseSlow = yield* Deferred.make<void>();
526 const lastProcessed = yield* Deferred.make<void>();
527 const layerDependencies = Layer.mergeAll(
528 NodeCrypto.layer,
529 Scheduler.layer,
530 ManagedPolicy.layerTest(),
531 Layer.mock(ThreadLaunchService.ThreadLaunchService)({
532 launch: (input) =>
533 (input.title === "Slow"
534 ? Deferred.succeed(slowStarted, undefined).pipe(
535 Effect.andThen(Deferred.await(releaseSlow)),
536 )
537 : input.title === "Last"
538 ? Deferred.succeed(lastProcessed, undefined)
539 : Effect.void
540 ).pipe(Effect.as({ threadId: `thread-${input.title}`, resumed: false } as never)),
541 }),
542 Layer.mock(ManagedProjectFolders.ManagedProjectFolders)({
543 namedProjectsRoot: "/projects",
544 isScratchProject: () => Effect.succeed(false),
545 }),
546 Layer.mock(ThreadManagementService.ThreadManagementService)({}),
547 Layer.mock(SecretRequests.SecretRequests)({}),
548 );
549 const withServer = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
550 effect.pipe(
551 Effect.provide(ScheduledTaskService.layer.pipe(Layer.provide(layerDependencies))),
552 );
553 const upsert = (
554 title: string,
555 schedule: { type: "interval"; everyMs: number } | { type: "fixed_time"; timeOfDay: string },
556 ) =>
557 Effect.gen(function* () {
558 const service = yield* ScheduledTaskService.ScheduledTaskService;
559 const { task } = yield* service.upsert(
560 yield* decodeUpsertInput({
561 title,
562 prompt: "Update the notes.",
563 enabled: true,
564 schedule,
565 projectId: "project-stale-slot",
566 workspaceStrategy: { type: "root" },
567 modelSelection: { instanceId: "codex", model: "gpt-5.4" },
568 runtimeMode: "full-access",
569 interactionMode: "default",
570 }),
571 );
572 return task.id;
573 });
574
575 // Due at 07:00, 08:00 and 08:30; the server is off until 09:30.
576 const morningId = yield* withServer(
577 Effect.gen(function* () {
578 yield* upsert("Slow", { type: "interval", everyMs: 60 * 60 * 1000 });
579 const id = yield* upsert("Morning", { type: "fixed_time", timeOfDay: "08:00" });
580 yield* upsert("Last", { type: "interval", everyMs: 150 * 60 * 1000 });
581 return id;
582 }),
583 );
584 yield* TestClock.setTime(DateTime.toEpochMillis(at(9, 30)));
585 const morning = yield* withServer(
586 Effect.gen(function* () {
587 const service = yield* ScheduledTaskService.ScheduledTaskService;
588 yield* TestClock.adjust("6 seconds");
589 yield* Deferred.await(slowStarted);
590 yield* service.runNow({ id: morningId });
591 yield* Deferred.succeed(releaseSlow, undefined);
592 yield* Deferred.await(lastProcessed);
593 return (yield* service.list()).tasks.find((task) => task.id === morningId);
594 }),
595 );
596
597 expect({ status: morning?.lastRunStatus, error: morning?.lastRunError }).toEqual({
598 status: "succeeded",
599 error: null,
600 });
601 expect(morning?.nextRunAt).toBe(DateTime.formatIso(DateTime.toUtc(at(8, 0, 2))));
602 }).pipe(Effect.provide(SqlitePersistence.layerMemory)),
603 );