@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 1,228 lines 50.7 KB
Raw
1 import * as Scheduler from "../scheduling/Scheduler.ts";
2 import * as NodeUtil from "node:util";
3
4 import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
5 import { assert, it, vi } from "@effect/vitest";
6 import {
7 CommandId,
8 ProjectId,
9 ProviderInstanceId,
10 ScheduledTaskError,
11 ScheduledTaskId,
12 type ScheduledTaskUpsertInput,
13 SecretRef,
14 ThreadId,
15 } from "@t3tools/contracts";
16 import * as DateTime from "effect/DateTime";
17 import * as Effect from "effect/Effect";
18 import * as Exit from "effect/Exit";
19 import * as Layer from "effect/Layer";
20 import * as Logger from "effect/Logger";
21 import * as Option from "effect/Option";
22 import * as SqlClient from "effect/sql/SqlClient";
23
24 import * as Fiber from "effect/Fiber";
25 import * as Stream from "effect/Stream";
26 import * as Deferred from "effect/Deferred";
27 import * as Ref from "effect/Ref";
28 import * as Schema from "effect/Schema";
29 import * as TestClock from "effect/testing/TestClock";
30
31 import * as ThreadLaunchService from "../orchestration-v2/ThreadLaunchService.ts";
32 import * as ThreadManagementService from "../orchestration-v2/ThreadManagementService.ts";
33 import { OrchestratorDispatchError } from "../orchestration-v2/Orchestrator.ts";
34 import * as SecretRequests from "../secrets/SecretRequests.ts";
35 import * as ManagedProjectFolders from "../project/ManagedProjectFolders.ts";
36 import * as SqlitePersistence from "../persistence/Sqlite.ts";
37 import * as ScheduledTaskService from "./ScheduledTaskService.ts";
38 import * as ManagedPolicy from "../policy/ManagedPolicy.ts";
39
40 const isScheduledTaskError = Schema.is(ScheduledTaskError);
41
42 const threadShell = (
43 projectId: ProjectId,
44 state: { archivedAt?: string | null; deletedAt?: string | null } = {},
45 ) => ({ projectId, archivedAt: null, deletedAt: null, ...state }) as never;
46
47 const insertRow = (
48 sql: SqlClient.SqlClient,
49 row: {
50 id: string | null;
51 next: string | null;
52 enabled: number;
53 status: string;
54 scheduleJson?: string;
55 prompt?: string;
56 },
57 now: string,
58 ) =>
59 sql`INSERT INTO scheduled_tasks ${sql.insert({
60 task_id: row.id,
61 title: "task",
62 prompt: row.prompt ?? "Run task",
63 enabled: row.enabled,
64 schedule_json: row.scheduleJson ?? '{"type":"interval","everyMs":60000}',
65 project_id: "project:test",
66 thread_id: null,
67 workspace_strategy_json: '{"type":"root"}',
68 model_selection_json: '{"instanceId":"codex","model":"gpt-5"}',
69 runtime_mode: "full-access",
70 interaction_mode: "default",
71 created_by: "user",
72 creation_source: "web",
73 created_at: now,
74 updated_at: now,
75 next_run_at: row.next,
76 last_run_at: null,
77 last_run_status: row.status,
78 last_run_error: null,
79 run_count: 0,
80 })}`;
81
82 it.effect("loads only due tasks and skips corrupt due rows without decoding settled tasks", () =>
83 Effect.gen(function* () {
84 const sql = yield* SqlClient.SqlClient;
85 const now = "2026-09-09T12:00:00.000Z";
86 const secret = "PROMPT-SECRET-DO-NOT-LOG";
87 const credential = "CREDENTIAL-SECRET-DO-NOT-LOG";
88 for (const row of [
89 { id: "due-now", next: now, enabled: 1, status: "never" },
90 { id: "", next: now, enabled: 1, status: "never" },
91 { id: " ", next: now, enabled: 1, status: "never" },
92 { id: null, next: now, enabled: 1, status: "never" },
93 {
94 id: "due-earlier",
95 next: "2026-09-09T11:00:00.000Z",
96 enabled: 1,
97 status: "failed",
98 },
99 { id: "due-bad-date", next: "", enabled: 1, status: "never" },
100 {
101 id: "due-corrupt",
102 next: now,
103 enabled: 1,
104 status: "never",
105 scheduleJson: "broken",
106 },
107 {
108 id: "due-cred",
109 next: now,
110 enabled: 1,
111 status: "never",
112 scheduleJson: `{"type":"interval","everyMs":"${credential}"}`,
113 },
114 { id: "disabled", next: now, enabled: 0, status: "never", scheduleJson: "broken" },
115 {
116 id: "future",
117 next: "2026-09-09T12:00:00.001Z",
118 enabled: 1,
119 status: "never",
120 scheduleJson: "broken",
121 },
122 {
123 id: "unscheduled",
124 next: null,
125 enabled: 1,
126 status: "never",
127 scheduleJson: "broken",
128 },
129 { id: "running", next: now, enabled: 1, status: "running", scheduleJson: "broken" },
130 ]) {
131 yield* insertRow(sql, { ...row, prompt: secret }, now);
132 }
133 const warnings: unknown[] = [];
134 const tasks = yield* ScheduledTaskService.listDueTasks(DateTime.makeUnsafe(now)).pipe(
135 Effect.provide(
136 Logger.layer([
137 Logger.make(({ message }) => {
138 warnings.push(message);
139 }),
140 ]),
141 ),
142 );
143 assert.deepEqual(
144 tasks.map((task) => task.id),
145 ["due-earlier", "due-now"],
146 );
147 assert.equal(warnings.length, 6);
148 const annotations = warnings.map(
149 (warning) => (warning as ReadonlyArray<unknown>)[1] as Record<string, unknown>,
150 );
151 assert.deepEqual(
152 annotations.map((annotation) => annotation.taskId),
153 ["due-bad-date", null, "", " ", "due-corrupt", "due-cred"],
154 );
155 const causes = annotations.map((annotation) => annotation.cause);
156 assert.deepEqual(
157 causes.map((cause) => (isScheduledTaskError(cause) ? cause.taskId : undefined)),
158 [undefined, undefined, undefined, undefined, "due-corrupt", "due-cred"],
159 );
160 for (const cause of causes) {
161 if (cause !== undefined) assert.isTrue(isScheduledTaskError(cause));
162 }
163 const rendered = NodeUtil.inspect(annotations, { depth: null });
164 assert.isFalse(rendered.includes(secret));
165 assert.isFalse(rendered.includes(credential));
166 const running = yield* sql<{
167 last_run_status: string;
168 }>`SELECT last_run_status FROM scheduled_tasks WHERE task_id = 'running'`;
169 assert.equal(running[0]?.last_run_status, "running");
170 }).pipe(Effect.provide(SqlitePersistence.layerMemory)),
171 );
172
173 it.effect(
174 "releases interrupted runs on startup and still executes due tasks, skipping corrupt rows",
175 () =>
176 Effect.gen(function* () {
177 const sql = yield* SqlClient.SqlClient;
178 const now = "2026-09-09T12:00:00.000Z";
179 const hugeInterval = '{"type":"interval","everyMs":9000000000000000}';
180 for (const row of [
181 { id: "stuck-valid", next: now, status: "running" },
182 { id: "stuck-corrupt", next: now, status: "running", scheduleJson: "broken" },
183 { id: "stuck-huge", next: now, status: "running", scheduleJson: hugeInterval },
184 { id: null, next: now, status: "running" },
185 { id: "due-bad-date", next: "", status: "never" },
186 { id: "due-healthy", next: now, status: "never" },
187 { id: "due-huge", next: now, status: "never", scheduleJson: hugeInterval },
188 { id: "due-second", next: now, status: "never" },
189 { id: "due-third", next: now, status: "never" },
190 ]) {
191 yield* insertRow(sql, { ...row, enabled: 1 }, now);
192 }
193
194 yield* TestClock.setTime(Date.parse(now) + 1_000);
195 const dispatched = yield* Ref.make(0);
196 const lastDispatched = yield* Deferred.make<void>();
197 const releaseLast = yield* Deferred.make<void>();
198 yield* Effect.scoped(
199 Effect.gen(function* () {
200 yield* Layer.build(
201 Layer.provideMerge(
202 ScheduledTaskService.layer,
203 Layer.mergeAll(
204 ManagedPolicy.layerTest(),
205 Layer.mock(ThreadLaunchService.ThreadLaunchService)({
206 launch: () =>
207 Ref.updateAndGet(dispatched, (n) => n + 1).pipe(
208 Effect.andThen((n) =>
209 n === 4
210 ? Deferred.succeed(lastDispatched, undefined).pipe(
211 Effect.andThen(Deferred.await(releaseLast)),
212 )
213 : Effect.void,
214 ),
215 Effect.andThen(Effect.die(new Error("test launch failure"))),
216 ),
217 }),
218 Layer.mock(ManagedProjectFolders.ManagedProjectFolders)({
219 namedProjectsRoot: "/projects",
220 isScratchProject: () => Effect.succeed(false),
221 }),
222 Layer.mock(ThreadManagementService.ThreadManagementService)({}),
223 Layer.mock(SecretRequests.SecretRequests)({}),
224 NodeCrypto.layer,
225 Scheduler.layer,
226 ),
227 ),
228 );
229 // The poll delays before its first pass; advance the frozen clock once.
230 yield* TestClock.adjust("6 seconds");
231 yield* Deferred.await(lastDispatched);
232 const inflight = yield* sql<{
233 last_run_status: string;
234 }>`SELECT last_run_status FROM scheduled_tasks WHERE task_id = 'due-third'`;
235 assert.equal(inflight[0]?.last_run_status, "running");
236 yield* Deferred.succeed(releaseLast, undefined);
237 }),
238 );
239
240 const rows = yield* sql<{
241 task_id: string | null;
242 last_run_status: string;
243 last_run_error: string | null;
244 next_run_at: string | null;
245 run_count: number;
246 }>`SELECT task_id, last_run_status, last_run_error, next_run_at, run_count
247 FROM scheduled_tasks ORDER BY task_id`;
248 const byId = new Map(rows.map((row) => [row.task_id, row]));
249 assert.equal(rows.length, 9);
250 assert.equal(byId.get("stuck-valid")?.last_run_status, "failed");
251 assert.isNotNull(byId.get("stuck-valid")?.next_run_at);
252 assert.equal(byId.get("stuck-corrupt")?.last_run_status, "failed");
253 assert.equal(byId.get(null)?.last_run_status, "failed");
254 const stuckHuge = byId.get("stuck-huge");
255 assert.equal(stuckHuge?.last_run_status, "failed");
256 assert.isNull(stuckHuge?.next_run_at);
257 for (const id of ["stuck-valid", "stuck-corrupt", "stuck-huge", null]) {
258 const row = byId.get(id);
259 assert.equal(row?.last_run_error, "Run was interrupted by a server restart.");
260 assert.equal(row?.run_count, 1);
261 }
262 for (const id of ["due-healthy", "due-huge", "due-second"]) {
263 const row = byId.get(id);
264 assert.equal(row?.last_run_status, "failed");
265 assert.isTrue(row?.last_run_error?.includes("test launch failure") === true);
266 assert.equal(row?.run_count, 1);
267 }
268 assert.isNull(byId.get("due-huge")?.next_run_at);
269 assert.equal(byId.get("due-bad-date")?.last_run_status, "never");
270 assert.equal(byId.get("due-bad-date")?.run_count, 0);
271 }).pipe(Effect.provide(SqlitePersistence.layerMemory)),
272 );
273
274 it.effect(
275 "treats a next_run_at corrupted before the dispatch re-read as not due instead of defecting the poll",
276 () =>
277 Effect.gen(function* () {
278 const sql = yield* SqlClient.SqlClient;
279 const now = "2026-09-09T12:00:00.000Z";
280 for (const row of [
281 { id: "run-a", next: now, status: "never" },
282 { id: "run-b-victim", next: now, status: "never" },
283 { id: "run-c", next: now, status: "never" },
284 { id: "run-d", next: now, status: "never" },
285 ]) {
286 yield* insertRow(sql, { ...row, enabled: 1 }, now);
287 }
288 yield* TestClock.setTime(Date.parse(now) + 1_000);
289 const dispatched = yield* Ref.make(0);
290 const lastDispatched = yield* Deferred.make<void>();
291 const releaseLast = yield* Deferred.make<void>();
292 yield* Effect.scoped(
293 Effect.gen(function* () {
294 yield* Layer.build(
295 Layer.provideMerge(
296 ScheduledTaskService.layer,
297 Layer.mergeAll(
298 ManagedPolicy.layerTest(),
299 Layer.mock(ThreadLaunchService.ThreadLaunchService)({
300 launch: () =>
301 Ref.updateAndGet(dispatched, (n) => n + 1).pipe(
302 Effect.andThen((n) =>
303 n === 1
304 ? sql`UPDATE scheduled_tasks
305 SET next_run_at = ''
306 WHERE task_id = 'run-b-victim'`.pipe(Effect.asVoid, Effect.orDie)
307 : n === 3
308 ? Deferred.succeed(lastDispatched, undefined).pipe(
309 Effect.andThen(Deferred.await(releaseLast)),
310 )
311 : Effect.void,
312 ),
313 Effect.andThen(Effect.die(new Error("test launch failure"))),
314 ),
315 }),
316 Layer.mock(ManagedProjectFolders.ManagedProjectFolders)({
317 namedProjectsRoot: "/projects",
318 isScratchProject: () => Effect.succeed(false),
319 }),
320 Layer.mock(ThreadManagementService.ThreadManagementService)({}),
321 Layer.mock(SecretRequests.SecretRequests)({}),
322 NodeCrypto.layer,
323 Scheduler.layer,
324 ),
325 ),
326 );
327 yield* TestClock.adjust("6 seconds");
328 yield* Deferred.await(lastDispatched);
329 assert.equal(yield* Ref.get(dispatched), 3);
330 const rows = yield* sql<{
331 task_id: string;
332 last_run_status: string;
333 next_run_at: string | null;
334 run_count: number;
335 }>`SELECT task_id, last_run_status, next_run_at, run_count
336 FROM scheduled_tasks ORDER BY task_id`;
337 const byId = new Map(rows.map((row) => [row.task_id, row]));
338 const victim = byId.get("run-b-victim");
339 assert.equal(victim?.last_run_status, "never");
340 assert.equal(victim?.run_count, 0);
341 assert.equal(victim?.next_run_at, "");
342 for (const id of ["run-a", "run-c"]) {
343 const row = byId.get(id);
344 assert.equal(row?.last_run_status, "failed");
345 assert.equal(row?.run_count, 1);
346 }
347 yield* Deferred.succeed(releaseLast, undefined);
348 }),
349 );
350 }).pipe(Effect.provide(SqlitePersistence.layerMemory)),
351 );
352
353 it.effect("thread cleanup notifies subscribers and a finishing run cannot recreate the task", () =>
354 Effect.gen(function* () {
355 const started = yield* Deferred.make<void>();
356 const release = yield* Deferred.make<void>();
357 const subscribed = yield* Deferred.make<void>();
358 const running = yield* Deferred.make<void>();
359 const removed = yield* Deferred.make<void>();
360 const layer = ScheduledTaskService.layer.pipe(
361 Layer.provide(
362 Layer.mergeAll(
363 ManagedPolicy.layerTest(),
364 Layer.mock(ThreadLaunchService.ThreadLaunchService)({}),
365 Layer.mock(ThreadManagementService.ThreadManagementService)({
366 sendToThread: () =>
367 Deferred.succeed(started, undefined).pipe(
368 Effect.andThen(Deferred.await(release)),
369 Effect.andThen(Effect.die("test dispatch failure")),
370 ),
371 getThreadShell: () => Effect.succeed(threadShell(ProjectId.make("project:test"))),
372 }),
373 Layer.mock(SecretRequests.SecretRequests)({}),
374 Layer.mock(ManagedProjectFolders.ManagedProjectFolders)({
375 namedProjectsRoot: "/projects",
376 isScratchProject: () => Effect.succeed(false),
377 }),
378 NodeCrypto.layer,
379 Scheduler.layer,
380 ),
381 ),
382 );
383 yield* Effect.gen(function* () {
384 const service = yield* ScheduledTaskService.ScheduledTaskService;
385 const threadId = ThreadId.make("thread:deleted-during-run");
386 const { task } = yield* service.upsert({
387 id: ScheduledTaskId.make("task:deleted-during-run"),
388 title: "Check orchestration",
389 prompt: "Check progress",
390 enabled: true,
391 schedule: { type: "interval", everyMs: 60_000 },
392 projectId: ProjectId.make("project:test"),
393 threadId,
394 workspaceStrategy: { type: "root" },
395 modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" },
396 runtimeMode: "full-access",
397 interactionMode: "default",
398 });
399 yield* service.subscribeList().pipe(
400 Stream.runForEach(({ tasks }) => {
401 const current = tasks.find((candidate) => candidate.id === task.id);
402 if (current === undefined) return Deferred.succeed(removed, undefined);
403 return current.lastRunStatus === "running"
404 ? Deferred.succeed(running, undefined)
405 : Deferred.succeed(subscribed, undefined);
406 }),
407 Effect.forkChild,
408 );
409 yield* Deferred.await(subscribed);
410 const run = yield* service.runNow({ id: task.id }).pipe(Effect.forkChild);
411 yield* Deferred.await(started);
412 yield* Deferred.await(running);
413 const refused = yield* service.runNow({ id: task.id }).pipe(Effect.flip);
414 assert.equal(refused.message, "Schedule task is already running.");
415 yield* service.deleteForThread(threadId);
416 yield* Deferred.await(removed);
417 yield* Deferred.succeed(release, undefined);
418 yield* Fiber.join(run);
419 assert.lengthOf((yield* service.list()).tasks, 0);
420 }).pipe(Effect.provide(layer));
421 }).pipe(Effect.provide(SqlitePersistence.layerMemory)),
422 );
423
424 it.effect.each([
425 { status: "failed", error: "Weekly usage limit reached", heldWarning: false },
426 { status: "failed", error: "Weekly usage limit reached", heldWarning: true },
427 { status: "interrupted", error: "The run was stopped.", heldWarning: false },
428 { status: "cancelled", error: "The run was cancelled.", heldWarning: false },
429 ] as const)("a run that ends $status after its message was accepted records it", (outcome) =>
430 Effect.gen(function* () {
431 const projectId = ProjectId.make("project:test");
432 const ended = yield* Deferred.make<void>();
433 const sent = yield* Ref.make("");
434 const run = { id: "run:2", status: outcome.status, rootNodeId: "node:root" };
435 const layer = ScheduledTaskService.layer.pipe(
436 Layer.provide(
437 Layer.mergeAll(
438 ManagedPolicy.layerTest(),
439 Layer.mock(ThreadLaunchService.ThreadLaunchService)({}),
440 Layer.mock(ThreadManagementService.ThreadManagementService)({
441 sendToThread: (input) => Ref.set(sent, input.messageId).pipe(Effect.as({} as never)),
442 getThreadShell: () => Effect.succeed(threadShell(projectId)),
443 getProjectThreadRecords: () =>
444 Effect.map(
445 Ref.get(sent),
446 (userMessageId) =>
447 ({
448 runs: [
449 { id: "run:1", status: "completed", userMessageId: "message:earlier" },
450 { ...run, userMessageId },
451 ],
452 messages: [{ id: userMessageId, runId: "run:2" }],
453 turnItems: [
454 {
455 type: "error",
456 status: "failed",
457 runId: "run:2",
458 nodeId: "node:root",
459 failure: { message: "Weekly usage limit reached" },
460 },
461 ],
462 }) as never,
463 ),
464 waitForThread: (input) =>
465 Deferred.await(ended).pipe(
466 Effect.as({
467 threadId: input.threadId,
468 run: { ...run, id: input.runId, userMessageId: "" },
469 timedOut: false,
470 } as never),
471 ),
472 }),
473 Layer.mock(SecretRequests.SecretRequests)({}),
474 Layer.mock(ManagedProjectFolders.ManagedProjectFolders)({
475 namedProjectsRoot: "/projects",
476 isScratchProject: () => Effect.succeed(false),
477 }),
478 NodeCrypto.layer,
479 Scheduler.layer,
480 ),
481 ),
482 );
483 yield* Effect.gen(function* () {
484 const service = yield* ScheduledTaskService.ScheduledTaskService;
485 const { task } = yield* service.upsert({
486 id: ScheduledTaskId.make("task:quota"),
487 title: "Quota bookkeeping",
488 prompt: "Update the notes",
489 enabled: true,
490 schedule: { type: "interval", everyMs: 60_000 },
491 projectId,
492 threadId: ThreadId.make("thread:quota"),
493 workspaceStrategy: { type: "root" },
494 modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" },
495 runtimeMode: "full-access",
496 interactionMode: "default",
497 });
498 yield* service.runNow({ id: task.id });
499 if (outcome.heldWarning) {
500 const sql = yield* SqlClient.SqlClient;
501 yield* sql`UPDATE scheduled_tasks SET last_run_status = 'failed',
502 last_run_error = 'A previous occurrence is held in the thread queue. Resume or remove it to run this task again.'
503 WHERE task_id = ${task.id}`;
504 }
505 const failed = yield* service.subscribeList().pipe(
506 Stream.map(({ tasks }) => tasks.find((candidate) => candidate.id === task.id)),
507 Stream.filter((current) => current?.lastRunError === outcome.error),
508 Stream.runHead,
509 Effect.forkChild,
510 );
511 yield* Deferred.succeed(ended, undefined);
512 const recorded = Option.getOrUndefined(yield* Fiber.join(failed));
513 assert.equal(recorded?.lastRunError, outcome.error);
514 assert.equal(recorded?.runCount, 1);
515 }).pipe(Effect.provide(layer));
516 }).pipe(Effect.provide(SqlitePersistence.layerMemory)),
517 );
518
519 it.effect("a one-time task is removed once its turn completes", () =>
520 Effect.gen(function* () {
521 yield* TestClock.setTime(Date.parse("2026-11-01T07:00:00.000Z"));
522 const projectId = ProjectId.make("project:test");
523 const ended = yield* Deferred.make<void>();
524 const sent = yield* Ref.make("");
525 const run = { id: "run:1", status: "completed", rootNodeId: "node:root" };
526 const layer = ScheduledTaskService.layer.pipe(
527 Layer.provide(
528 Layer.mergeAll(
529 ManagedPolicy.layerTest(),
530 Layer.mock(ThreadLaunchService.ThreadLaunchService)({}),
531 Layer.mock(ThreadManagementService.ThreadManagementService)({
532 sendToThread: (input) => Ref.set(sent, input.messageId).pipe(Effect.as({} as never)),
533 getThreadShell: () => Effect.succeed(threadShell(projectId)),
534 getProjectThreadRecords: () =>
535 Effect.map(
536 Ref.get(sent),
537 (userMessageId) => ({ runs: [{ ...run, userMessageId }] }) as never,
538 ),
539 waitForThread: (input) =>
540 Deferred.await(ended).pipe(
541 Effect.as({ threadId: input.threadId, run, timedOut: false } as never),
542 ),
543 }),
544 Layer.mock(SecretRequests.SecretRequests)({}),
545 Layer.mock(ManagedProjectFolders.ManagedProjectFolders)({
546 namedProjectsRoot: "/projects",
547 isScratchProject: () => Effect.succeed(false),
548 }),
549 NodeCrypto.layer,
550 Scheduler.layer,
551 ),
552 ),
553 );
554 yield* Effect.gen(function* () {
555 const service = yield* ScheduledTaskService.ScheduledTaskService;
556 const { task } = yield* service.upsert({
557 id: ScheduledTaskId.make("task:once"),
558 title: "Release notes",
559 prompt: "Draft the release notes",
560 enabled: true,
561 schedule: { type: "once", runAt: "2026-11-01T07:01:00.000Z" },
562 projectId,
563 threadId: ThreadId.make("thread:once"),
564 workspaceStrategy: { type: "root" },
565 modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" },
566 runtimeMode: "full-access",
567 interactionMode: "default",
568 });
569 const dispatched = service.subscribeList().pipe(
570 Stream.map(({ tasks }) => tasks.find((candidate) => candidate.id === task.id)),
571 Stream.filter((current) => current?.lastRunStatus === "succeeded"),
572 Stream.runHead,
573 );
574 const removed = service.subscribeList().pipe(
575 Stream.filter(({ tasks }) => tasks.every((candidate) => candidate.id !== task.id)),
576 Stream.runHead,
577 );
578 const recorded = yield* Effect.forkChild(dispatched);
579 const gone = yield* Effect.forkChild(removed);
580 yield* TestClock.adjust("2 minutes");
581 // The dispatch alone keeps it: the turn can still fail.
582 assert.isNull(Option.getOrThrow(yield* Fiber.join(recorded))?.nextRunAt);
583 yield* Deferred.succeed(ended, undefined);
584 yield* Fiber.join(gone);
585 assert.lengthOf((yield* service.list()).tasks, 0);
586 }).pipe(Effect.provide(layer));
587 }).pipe(Effect.provide(SqlitePersistence.layerMemory)),
588 );
589
590 it.effect("a paused one-time task run by hand before its time is kept", () =>
591 Effect.gen(function* () {
592 yield* TestClock.setTime(Date.parse("2026-11-01T07:00:00.000Z"));
593 const projectId = ProjectId.make("project:test");
594 const ended = yield* Deferred.make<void>();
595 const outcomeRead = yield* Deferred.make<void>();
596 const sent = yield* Ref.make("");
597 const run = { id: "run:1", status: "completed", rootNodeId: "node:root" };
598 const layer = ScheduledTaskService.layer.pipe(
599 Layer.provide(
600 Layer.mergeAll(
601 ManagedPolicy.layerTest(),
602 Layer.mock(ThreadLaunchService.ThreadLaunchService)({}),
603 Layer.mock(ThreadManagementService.ThreadManagementService)({
604 sendToThread: (input) => Ref.set(sent, input.messageId).pipe(Effect.as({} as never)),
605 getThreadShell: () => Effect.succeed(threadShell(projectId)),
606 getProjectThreadRecords: () =>
607 Effect.map(
608 Ref.get(sent),
609 (userMessageId) => ({ runs: [{ ...run, userMessageId }] }) as never,
610 ),
611 waitForThread: (input) =>
612 Deferred.await(ended).pipe(
613 Effect.tap(() => Deferred.succeed(outcomeRead, undefined)),
614 Effect.as({ threadId: input.threadId, run, timedOut: false } as never),
615 ),
616 }),
617 Layer.mock(SecretRequests.SecretRequests)({}),
618 Layer.mock(ManagedProjectFolders.ManagedProjectFolders)({
619 namedProjectsRoot: "/projects",
620 isScratchProject: () => Effect.succeed(false),
621 }),
622 NodeCrypto.layer,
623 Scheduler.layer,
624 ),
625 ),
626 );
627 yield* Effect.gen(function* () {
628 const service = yield* ScheduledTaskService.ScheduledTaskService;
629 const { task } = yield* service.upsert({
630 id: ScheduledTaskId.make("task:paused-once"),
631 title: "Release notes",
632 prompt: "Draft the release notes",
633 enabled: true,
634 schedule: { type: "once", runAt: "2026-11-01T08:00:00.000Z" },
635 projectId,
636 threadId: ThreadId.make("thread:once"),
637 workspaceStrategy: { type: "root" },
638 modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" },
639 runtimeMode: "full-access",
640 interactionMode: "default",
641 });
642 yield* service.setEnabled({ id: task.id, enabled: false });
643 yield* service.runNow({ id: task.id });
644 yield* Deferred.succeed(ended, undefined);
645 yield* Deferred.await(outcomeRead);
646 yield* TestClock.adjust("1 second");
647 const [kept] = (yield* service.list()).tasks;
648 assert.equal(kept?.id, task.id);
649 assert.equal(kept?.runCount, 1);
650 const resumed = yield* service.setEnabled({ id: task.id, enabled: true });
651 assert.equal(resumed.task.nextRunAt, "2026-11-01T08:00:00.000Z");
652 }).pipe(Effect.provide(layer));
653 }).pipe(Effect.provide(SqlitePersistence.layerMemory)),
654 );
655
656 it.effect("a bound run follows its thread when promotion moves it mid-send", () =>
657 Effect.gen(function* () {
658 const scratch = ProjectId.make("project:scratch");
659 const promoted = ProjectId.make("project:promoted");
660 const sends = yield* Ref.make<Array<{ projectId: ProjectId; commandId: string }>>([]);
661 // Saving reads it first. Then the rebind lands, and the promotion commits between the shell
662 // read and the retry.
663 const shellProjects = yield* Ref.make([promoted, scratch, promoted]);
664 const layer = ScheduledTaskService.layer.pipe(
665 Layer.provide(
666 Layer.mergeAll(
667 ManagedPolicy.layerTest(),
668 Layer.mock(ThreadLaunchService.ThreadLaunchService)({}),
669 Layer.mock(ThreadManagementService.ThreadManagementService)({
670 sendToThread: (input) =>
671 Ref.updateAndGet(sends, (all) => [
672 ...all,
673 { projectId: input.projectId, commandId: input.commandId },
674 ]).pipe(
675 Effect.flatMap((all) =>
676 all.length < 3
677 ? Effect.fail(
678 new ThreadManagementService.ThreadManagementThreadNotFoundError({
679 projectId: input.projectId,
680 threadId: input.threadId,
681 }),
682 )
683 : Effect.succeed({} as never),
684 ),
685 ),
686 getThreadShell: () =>
687 Ref.modify(shellProjects, ([next, ...rest]) => [threadShell(next ?? promoted), rest]),
688 }),
689 Layer.mock(SecretRequests.SecretRequests)({}),
690 Layer.mock(ManagedProjectFolders.ManagedProjectFolders)({
691 namedProjectsRoot: "/projects",
692 isScratchProject: () => Effect.succeed(false),
693 }),
694 NodeCrypto.layer,
695 Scheduler.layer,
696 ),
697 ),
698 );
699 yield* Effect.gen(function* () {
700 const service = yield* ScheduledTaskService.ScheduledTaskService;
701 const threadId = ThreadId.make("thread:promoted-during-run");
702 const { task } = yield* service.upsert({
703 id: ScheduledTaskId.make("task:promoted-during-run"),
704 title: "Check in",
705 prompt: "Check progress",
706 enabled: true,
707 schedule: { type: "interval", everyMs: 60_000 },
708 projectId: promoted,
709 threadId,
710 workspaceStrategy: { type: "root" },
711 modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" },
712 runtimeMode: "full-access",
713 interactionMode: "default",
714 });
715
716 const result = yield* service.runNow({ id: task.id });
717
718 assert.equal(result.threadId, threadId);
719 const attempts = yield* Ref.get(sends);
720 assert.deepEqual(
721 attempts.map((attempt) => attempt.projectId),
722 [promoted, scratch, promoted],
723 );
724 assert.equal(new Set(attempts.map((attempt) => attempt.commandId)).size, 1);
725 }).pipe(Effect.provide(layer));
726 }).pipe(Effect.provide(SqlitePersistence.layerMemory)),
727 );
728
729 it.effect("a fresh-session task launches one thread, then starts each later run fresh in it", () =>
730 Effect.gen(function* () {
731 const launches = yield* Ref.make(0);
732 const sends = yield* Ref.make<Array<{ threadId: ThreadId; freshContext?: boolean }>>([]);
733 const launched = ThreadId.make("thread:fresh-session-task");
734 const layer = ScheduledTaskService.layer.pipe(
735 Layer.provide(
736 Layer.mergeAll(
737 ManagedPolicy.layerTest(),
738 Layer.mock(ThreadLaunchService.ThreadLaunchService)({
739 launch: () =>
740 Ref.update(launches, (n) => n + 1).pipe(
741 Effect.as({ threadId: launched, resumed: false } as never),
742 ),
743 }),
744 Layer.mock(ThreadManagementService.ThreadManagementService)({
745 getThreadShell: () =>
746 Effect.succeed({
747 deletedAt: null,
748 archivedAt: null,
749 projectId: ProjectId.make("project:test"),
750 } as never),
751 sendToThread: (input) =>
752 Ref.update(sends, (all) => [
753 ...all,
754 {
755 threadId: input.threadId,
756 ...(input.freshContext === undefined ? {} : { freshContext: input.freshContext }),
757 },
758 ]).pipe(Effect.as({} as never)),
759 }),
760 Layer.mock(SecretRequests.SecretRequests)({}),
761 Layer.mock(ManagedProjectFolders.ManagedProjectFolders)({
762 namedProjectsRoot: "/projects",
763 isScratchProject: () => Effect.succeed(false),
764 }),
765 NodeCrypto.layer,
766 Layer.succeed(Scheduler.Scheduler, { register: () => Effect.void }),
767 ),
768 ),
769 );
770 yield* Effect.gen(function* () {
771 const service = yield* ScheduledTaskService.ScheduledTaskService;
772 const input = {
773 id: ScheduledTaskId.make("task:fresh-session"),
774 title: "Triage",
775 prompt: "Triage new issues",
776 enabled: true,
777 schedule: { type: "interval", everyMs: 60_000 },
778 projectId: ProjectId.make("project:test"),
779 workspaceStrategy: { type: "root" },
780 modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" },
781 runtimeMode: "full-access",
782 interactionMode: "default",
783 } as const;
784 yield* service.upsert({ ...input, threadMode: "fresh_session" });
785
786 assert.equal((yield* service.runNow({ id: input.id })).threadId, launched);
787 // A form opened before the first run saves no thread; the binding stays.
788 const { task } = yield* service.upsert({
789 ...input,
790 threadId: null,
791 threadMode: "fresh_session",
792 });
793 assert.equal(task.threadId, launched);
794 assert.equal(task.threadMode, "fresh_session");
795 // A client that predates thread modes sends neither; both stay.
796 const legacy = yield* service.upsert({ ...input, threadId: null });
797 assert.equal(legacy.task.threadId, launched);
798 assert.equal(legacy.task.threadMode, "fresh_session");
799 yield* service.runNow({ id: input.id });
800
801 assert.equal(yield* Ref.get(launches), 1);
802 assert.deepEqual(yield* Ref.get(sends), [{ threadId: launched, freshContext: true }]);
803 // Its thread stays in the old project, so moving the task leaves it for a new one.
804 const moved = yield* service.upsert({
805 ...input,
806 projectId: ProjectId.make("project:moved"),
807 threadId: launched,
808 });
809 assert.equal(moved.task.threadId, null);
810 assert.equal(moved.task.threadMode, "fresh_session");
811 const unbound = yield* service.upsert({ ...input, threadMode: "new_thread" });
812 assert.equal(unbound.task.threadId, null);
813 // Clearing the thread keeps the mode, so the next run starts a thread for later runs.
814 yield* service.upsert({ ...input, threadId: launched, threadMode: "continue" });
815 const cleared = yield* service.upsert({
816 ...input,
817 threadId: null,
818 unbindThread: true,
819 threadMode: "continue",
820 });
821 assert.equal(cleared.task.threadId, null);
822 assert.equal(cleared.task.threadMode, "continue");
823 }).pipe(Effect.provide(layer));
824 }).pipe(Effect.provide(SqlitePersistence.layerMemory)),
825 );
826
827 it.effect("a refused dispatch records its refusal, and opaque causes stay generic", () =>
828 Effect.gen(function* () {
829 const refusal = "Thread thread:refused was stopped.";
830 const refused = (cause: unknown) =>
831 new OrchestratorDispatchError({
832 commandId: CommandId.make("command:refused"),
833 commandType: "message.dispatch",
834 cause,
835 });
836 const generic = refused(undefined).message;
837 const cases = [
838 [refusal, refusal],
839 [" ", generic],
840 [new Error("private-nested-secret"), generic],
841 ] as const;
842 const failure = yield* Ref.make<unknown>(undefined);
843 const layer = ScheduledTaskService.layer.pipe(
844 Layer.provide(
845 Layer.mergeAll(
846 ManagedPolicy.layerTest(),
847 Layer.mock(ThreadLaunchService.ThreadLaunchService)({}),
848 Layer.mock(ThreadManagementService.ThreadManagementService)({
849 getThreadShell: () => Effect.succeed(threadShell(ProjectId.make("project:test"))),
850 sendToThread: () =>
851 Ref.get(failure).pipe(Effect.flatMap((cause) => Effect.fail(refused(cause)))),
852 }),
853 Layer.mock(SecretRequests.SecretRequests)({}),
854 Layer.mock(ManagedProjectFolders.ManagedProjectFolders)({
855 namedProjectsRoot: "/projects",
856 isScratchProject: () => Effect.succeed(false),
857 }),
858 NodeCrypto.layer,
859 Layer.succeed(Scheduler.Scheduler, { register: () => Effect.void }),
860 ),
861 ),
862 );
863 yield* Effect.gen(function* () {
864 const service = yield* ScheduledTaskService.ScheduledTaskService;
865 const { task } = yield* service.upsert({
866 id: ScheduledTaskId.make("task:refused"),
867 title: "Refused dispatch",
868 prompt: "Check progress",
869 enabled: true,
870 schedule: { type: "interval", everyMs: 60_000 },
871 projectId: ProjectId.make("project:test"),
872 threadId: ThreadId.make("thread:refused"),
873 workspaceStrategy: { type: "root" },
874 modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" },
875 runtimeMode: "full-access",
876 interactionMode: "default",
877 });
878 for (const [cause, expected] of cases) {
879 yield* Ref.set(failure, cause);
880 const result = yield* service.runNow({ id: task.id });
881 assert.equal(result.task.lastRunStatus, "failed");
882 assert.equal(result.task.lastRunError, expected);
883 }
884 }).pipe(Effect.provide(layer));
885 }).pipe(Effect.provide(SqlitePersistence.layerMemory)),
886 );
887
888 it.effect("a first run whose thread was deleted before it bound removes the task", () =>
889 Effect.gen(function* () {
890 const layer = ScheduledTaskService.layer.pipe(
891 Layer.provide(
892 Layer.mergeAll(
893 ManagedPolicy.layerTest(),
894 Layer.mock(ThreadLaunchService.ThreadLaunchService)({
895 launch: () =>
896 Effect.succeed({
897 threadId: ThreadId.make("thread:deleted"),
898 resumed: false,
899 } as never),
900 }),
901 // Deleted before the binding landed, so its cleanup found no task to remove.
902 Layer.mock(ThreadManagementService.ThreadManagementService)({
903 getThreadShell: () =>
904 Effect.succeed({ deletedAt: DateTime.makeUnsafe("2026-11-03T00:00:00Z") } as never),
905 }),
906 Layer.mock(SecretRequests.SecretRequests)({}),
907 Layer.mock(ManagedProjectFolders.ManagedProjectFolders)({
908 namedProjectsRoot: "/projects",
909 isScratchProject: () => Effect.succeed(false),
910 }),
911 NodeCrypto.layer,
912 Layer.succeed(Scheduler.Scheduler, { register: () => Effect.void }),
913 ),
914 ),
915 );
916 yield* Effect.gen(function* () {
917 const service = yield* ScheduledTaskService.ScheduledTaskService;
918 const { task } = yield* service.upsert({
919 id: ScheduledTaskId.make("task:thread-deleted-mid-launch"),
920 title: "Triage",
921 prompt: "Triage new issues",
922 enabled: true,
923 schedule: { type: "interval", everyMs: 60_000 },
924 projectId: ProjectId.make("project:test"),
925 threadMode: "continue",
926 workspaceStrategy: { type: "root" },
927 modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" },
928 runtimeMode: "full-access",
929 interactionMode: "default",
930 });
931 yield* service.runNow({ id: task.id });
932 assert.deepEqual((yield* service.list()).tasks, []);
933 }).pipe(Effect.provide(layer));
934 }).pipe(Effect.provide(SqlitePersistence.layerMemory)),
935 );
936
937 it.effect.each(["recreated under the same id", "moved to another project"] as const)(
938 "a first run never binds its thread to a task %s",
939 (change) =>
940 Effect.gen(function* () {
941 const launching = yield* Deferred.make<void>();
942 const proceed = yield* Deferred.make<void>();
943 const layer = ScheduledTaskService.layer.pipe(
944 Layer.provide(
945 Layer.mergeAll(
946 ManagedPolicy.layerTest(),
947 Layer.mock(ThreadLaunchService.ThreadLaunchService)({
948 launch: () =>
949 Deferred.succeed(launching, undefined).pipe(
950 Effect.andThen(Deferred.await(proceed)),
951 Effect.as({
952 threadId: ThreadId.make("thread:old-generation"),
953 resumed: false,
954 } as never),
955 ),
956 }),
957 Layer.mock(ThreadManagementService.ThreadManagementService)({}),
958 Layer.mock(SecretRequests.SecretRequests)({}),
959 Layer.mock(ManagedProjectFolders.ManagedProjectFolders)({
960 namedProjectsRoot: "/projects",
961 isScratchProject: () => Effect.succeed(false),
962 }),
963 NodeCrypto.layer,
964 Layer.succeed(Scheduler.Scheduler, { register: () => Effect.void }),
965 ),
966 ),
967 );
968 yield* Effect.gen(function* () {
969 const service = yield* ScheduledTaskService.ScheduledTaskService;
970 const input = {
971 id: ScheduledTaskId.make("task:recreated-mid-launch"),
972 title: "Triage",
973 prompt: "Triage new issues",
974 enabled: true,
975 schedule: { type: "interval", everyMs: 60_000 },
976 projectId: ProjectId.make("project:test"),
977 threadMode: "fresh_session",
978 workspaceStrategy: { type: "root" },
979 modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" },
980 runtimeMode: "full-access",
981 interactionMode: "default",
982 } as const;
983 yield* service.upsert(input);
984 const run = yield* Effect.forkChild(service.runNow({ id: input.id }));
985 yield* Deferred.await(launching);
986 if (change === "recreated under the same id") {
987 yield* service.delete({ id: input.id });
988 yield* TestClock.adjust("1 second");
989 yield* service.upsert(input);
990 } else {
991 yield* service.upsert({ ...input, projectId: ProjectId.make("project:moved") });
992 }
993 yield* Deferred.succeed(proceed, undefined);
994 yield* Fiber.await(run);
995
996 const replacement = (yield* service.list()).tasks.find((task) => task.id === input.id);
997 assert.equal(replacement?.threadId, null);
998 }).pipe(Effect.provide(layer));
999 }).pipe(Effect.provide(SqlitePersistence.layerMemory)),
1000 );
1001
1002 it.effect("refuses saving an enabled task above the policy ceiling", () =>
1003 Effect.gen(function* () {
1004 const layer = ScheduledTaskService.layer.pipe(
1005 Layer.provide(
1006 Layer.mergeAll(
1007 ManagedPolicy.layerTest({
1008 schemaVersion: 1,
1009 organization: "Example Corp",
1010 limits: { maxRuntimeMode: "auto-accept-edits" },
1011 }),
1012 Layer.mock(ThreadLaunchService.ThreadLaunchService)({}),
1013 Layer.mock(ThreadManagementService.ThreadManagementService)({
1014 getThreadShell: () => Effect.succeed(threadShell(ProjectId.make("project:test"))),
1015 }),
1016 Layer.mock(SecretRequests.SecretRequests)({}),
1017 Layer.mock(ManagedProjectFolders.ManagedProjectFolders)({
1018 namedProjectsRoot: "/projects",
1019 isScratchProject: () => Effect.succeed(false),
1020 }),
1021 NodeCrypto.layer,
1022 Scheduler.layer,
1023 ),
1024 ),
1025 );
1026 yield* Effect.gen(function* () {
1027 const service = yield* ScheduledTaskService.ScheduledTaskService;
1028 const save = (enabled: boolean) =>
1029 service.upsert({
1030 id: ScheduledTaskId.make("task:above-ceiling"),
1031 title: "Nightly",
1032 prompt: "Check progress",
1033 enabled,
1034 schedule: { type: "interval", everyMs: 60_000 },
1035 projectId: ProjectId.make("project:test"),
1036 workspaceStrategy: { type: "root" },
1037 modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" },
1038 runtimeMode: "full-access",
1039 interactionMode: "default",
1040 });
1041 const refused = yield* save(true).pipe(Effect.flip);
1042 assert.equal(refused.message, "Example Corp limits threads to Auto-accept edits.");
1043 assert.lengthOf((yield* service.list()).tasks, 0);
1044 // A disabled task does not run, so it can still be saved.
1045 yield* save(false);
1046 assert.lengthOf((yield* service.list()).tasks, 1);
1047 // Nor can it be switched back on while its mode is above the ceiling.
1048 const reenabled = yield* service
1049 .setEnabled({ id: ScheduledTaskId.make("task:above-ceiling"), enabled: true })
1050 .pipe(Effect.flip);
1051 assert.equal(reenabled.message, "Example Corp limits threads to Auto-accept edits.");
1052 // A task bound to a thread runs in that thread's mode, so its own is not checked.
1053 const bound = {
1054 id: ScheduledTaskId.make("task:bound"),
1055 title: "Follow up",
1056 prompt: "Check progress",
1057 enabled: true,
1058 schedule: { type: "interval", everyMs: 60_000 },
1059 projectId: ProjectId.make("project:test"),
1060 workspaceStrategy: { type: "root" },
1061 modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" },
1062 runtimeMode: "full-access",
1063 interactionMode: "default",
1064 } as const;
1065 yield* service.upsert({ ...bound, threadId: ThreadId.make("thread:bound") });
1066 // Nor when an edit omits the thread it stays bound to.
1067 yield* service.upsert(bound);
1068 }).pipe(Effect.provide(layer));
1069 }).pipe(Effect.provide(SqlitePersistence.layerMemory)),
1070 );
1071
1072 it.effect("checks a task's destination thread only when the destination changes", () =>
1073 Effect.gen(function* () {
1074 const project = ProjectId.make("project:test");
1075 const otherProject = ProjectId.make("project:other");
1076 const destination = ThreadId.make("thread:destination");
1077 const archivedAt = "2026-11-05T00:00:00.000Z";
1078 const shells = yield* Ref.make<ReadonlyMap<ThreadId, never>>(
1079 new Map([
1080 [destination, threadShell(project)],
1081 [ThreadId.make("thread:archived"), threadShell(project, { archivedAt })],
1082 [ThreadId.make("thread:deleted"), threadShell(project, { deletedAt: archivedAt })],
1083 [ThreadId.make("thread:other-project"), threadShell(otherProject)],
1084 ]),
1085 );
1086 const consumed = yield* Ref.make(0);
1087 const layer = ScheduledTaskService.layer.pipe(
1088 Layer.provide(
1089 Layer.mergeAll(
1090 ManagedPolicy.layerTest(),
1091 Layer.mock(ThreadLaunchService.ThreadLaunchService)({}),
1092 Layer.mock(ThreadManagementService.ThreadManagementService)({
1093 getThreadShell: (threadId) =>
1094 Ref.get(shells).pipe(Effect.map((all) => all.get(threadId) ?? null)),
1095 }),
1096 Layer.mock(SecretRequests.SecretRequests)({
1097 consume: () => Ref.update(consumed, (count) => count + 1).pipe(Effect.as("secret")),
1098 }),
1099 Layer.mock(ManagedProjectFolders.ManagedProjectFolders)({
1100 namedProjectsRoot: "/projects",
1101 isScratchProject: () => Effect.succeed(false),
1102 }),
1103 NodeCrypto.layer,
1104 Scheduler.layer,
1105 ),
1106 ),
1107 );
1108 yield* Effect.gen(function* () {
1109 const service = yield* ScheduledTaskService.ScheduledTaskService;
1110 const id = ScheduledTaskId.make("task:destination");
1111 const save = (
1112 threadId: ThreadId,
1113 schedule: ScheduledTaskUpsertInput["schedule"] = { type: "interval", everyMs: 60_000 },
1114 ) =>
1115 service.upsert({
1116 id,
1117 title: "Follow up",
1118 prompt: "Check progress",
1119 enabled: true,
1120 schedule,
1121 projectId: project,
1122 threadId,
1123 workspaceStrategy: { type: "root" },
1124 modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" },
1125 runtimeMode: "full-access",
1126 interactionMode: "default",
1127 });
1128
1129 for (const [threadId, message] of [
1130 ["thread:missing", "That thread no longer exists."],
1131 ["thread:deleted", "That thread no longer exists."],
1132 ["thread:archived", "That thread is archived. Unarchive it or pick another destination."],
1133 ["thread:other-project", "That thread belongs to a different project."],
1134 ] as const) {
1135 const refused = yield* save(ThreadId.make(threadId)).pipe(Effect.flip);
1136 assert.equal(refused.message, message);
1137 }
1138 assert.lengthOf((yield* service.list()).tasks, 0);
1139
1140 // A rejected save must not burn a one-shot secret.
1141 yield* save(ThreadId.make("thread:missing"), {
1142 type: "webhook",
1143 signature: {
1144 header: "x-signature",
1145 encoding: "hex",
1146 prefix: "",
1147 secretRef: SecretRef.make("secret-ref:00000000000000000000000000000001"),
1148 },
1149 }).pipe(Effect.flip);
1150 assert.equal(yield* Ref.get(consumed), 0);
1151
1152 yield* save(destination);
1153 // A task whose thread was archived later stays editable.
1154 yield* Ref.update(shells, (all) =>
1155 new Map(all).set(destination, threadShell(project, { archivedAt })),
1156 );
1157 assert.equal((yield* save(destination)).task.threadId, destination);
1158 }).pipe(Effect.provide(layer));
1159 }).pipe(Effect.provide(SqlitePersistence.layerMemory)),
1160 );
1161
1162 it.effect("a run interrupted right after it reserves the task does not block the next run", () =>
1163 Effect.gen(function* () {
1164 const launches = yield* Ref.make(0);
1165 const layer = ScheduledTaskService.layer.pipe(
1166 Layer.provide(
1167 Layer.mergeAll(
1168 ManagedPolicy.layerTest(),
1169 Layer.mock(ThreadLaunchService.ThreadLaunchService)({
1170 launch: () =>
1171 Ref.update(launches, (n) => n + 1).pipe(
1172 Effect.as({ threadId: ThreadId.make("thread:launched"), resumed: false } as never),
1173 ),
1174 }),
1175 Layer.mock(ThreadManagementService.ThreadManagementService)({}),
1176 Layer.mock(SecretRequests.SecretRequests)({}),
1177 Layer.mock(ManagedProjectFolders.ManagedProjectFolders)({
1178 namedProjectsRoot: "/projects",
1179 isScratchProject: () => Effect.succeed(false),
1180 }),
1181 NodeCrypto.layer,
1182 Layer.succeed(Scheduler.Scheduler, { register: () => Effect.void }),
1183 ),
1184 ),
1185 );
1186 yield* Effect.gen(function* () {
1187 const service = yield* ScheduledTaskService.ScheduledTaskService;
1188 const { task } = yield* service.upsert({
1189 id: ScheduledTaskId.make("task:interrupted-reservation"),
1190 title: "Check in",
1191 prompt: "Check progress",
1192 enabled: true,
1193 schedule: { type: "interval", everyMs: 60_000 },
1194 projectId: ProjectId.make("project:test"),
1195 workspaceStrategy: { type: "root" },
1196 modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" },
1197 runtimeMode: "full-access",
1198 interactionMode: "default",
1199 });
1200
1201 // The reservation is the first Set.add of the task id; interrupt the run right there.
1202 const add = Set.prototype.add;
1203 let interrupted = false;
1204 const first = yield* Effect.gen(function* () {
1205 using _reserve = vi.spyOn(Set.prototype, "add").mockImplementation(function (
1206 this: Set<unknown>,
1207 value: unknown,
1208 ) {
1209 const result = add.call(this, value);
1210 if (value === task.id && !interrupted) {
1211 interrupted = true;
1212 Fiber.getCurrent()?.interruptUnsafe();
1213 }
1214 return result;
1215 });
1216 return yield* service
1217 .runNow({ id: task.id })
1218 .pipe(Effect.forkChild, Effect.flatMap(Fiber.await));
1219 });
1220 assert.isTrue(interrupted);
1221 assert.isTrue(Exit.hasInterrupts(first));
1222
1223 const second = yield* service.runNow({ id: task.id });
1224 assert.equal(second.threadId, ThreadId.make("thread:launched"));
1225 assert.equal(yield* Ref.get(launches), 1);
1226 }).pipe(Effect.provide(layer));
1227 }).pipe(Effect.provide(SqlitePersistence.layerMemory)),
1228 );