1import { assert, it } from "@effect/vitest";
2import {
3 CheckpointId,
4 CheckpointScopeId,
5 CommandId,
6 NodeId,
7 ProviderSessionId,
8 ProviderThreadId,
9 ProviderTurnId,
10 RunAttemptId,
11 RunId,
12 RuntimeRequestId,
13 ThreadId,
14 VcsProcessExitError,
15} from "@t3tools/contracts";
16import * as Cause from "effect/Cause";
17import * as DateTime from "effect/DateTime";
18import * as Deferred from "effect/Deferred";
19import * as Effect from "effect/Effect";
20import * as Exit from "effect/Exit";
21import * as Layer from "effect/Layer";
22import * as Option from "effect/Option";
23import * as Ref from "effect/Ref";
24import * as Stream from "effect/Stream";
25
26import * as CheckpointRollbackService from "./CheckpointRollbackService.ts";
27import * as CheckpointService from "./CheckpointService.ts";
28import * as EffectOutbox from "./EffectOutbox.ts";
29import * as EffectWorker from "./EffectWorker.ts";
30import * as RunFinalizationService from "./RunFinalizationService.ts";
31import * as ProviderSessionManager from "./ProviderSessionManager.ts";
32import * as ProviderTurnControlService from "./ProviderTurnControlService.ts";
33import * as ProviderTurnStartService from "./ProviderTurnStartService.ts";
34import * as RuntimeRequestService from "./RuntimeRequestService.ts";
35import * as ThreadTitleRegenerationService from "./ThreadTitleRegenerationService.ts";
36import * as ThreadManagementService from "./ThreadManagementService.ts";
37import * as ServerSettings from "../serverSettings.ts";
38
39const threadId = ThreadId.make("thread:effect-worker-restart");
40const oldSessionId = ProviderSessionId.make("provider-session:effect-worker-restart:old");
41const providerThreadId = ProviderThreadId.make("provider-thread:effect-worker-restart");
42const providerTurnId = ProviderTurnId.make("provider-turn:effect-worker-restart");
43const attemptId = RunAttemptId.make("run-attempt:effect-worker-restart");
44const runId = RunId.make("run:effect-worker-restart");
45
46function restartEffect(
47 now: DateTime.Utc,
48 sessionTransition: NonNullable<
49 Extract<
50 EffectOutbox.OrchestrationEffectV2["request"],
51 { readonly type: "provider-turn.restart" }
52 >["sessionTransition"]
53 >,
54): EffectOutbox.OrchestrationEffectV2 {
55 const timestamp = DateTime.formatIso(now);
56 return {
57 id: `effect:restart:${sessionTransition.type}`,
58 commandId: CommandId.make(`command:restart:${sessionTransition.type}`),
59 threadId,
60 request: {
61 type: "provider-turn.restart",
62 providerSessionId: oldSessionId,
63 providerThreadId,
64 providerTurnId,
65 interruptedAttemptId: attemptId,
66 runId,
67 sessionTransition,
68 },
69 status: "running",
70 attemptCount: 1,
71 availableAt: timestamp,
72 leaseOwner: "test-worker",
73 createdAt: timestamp,
74 updatedAt: timestamp,
75 completedAt: null,
76 lastError: null,
77 };
78}
79
80function layerExecutorFor(input: {
81 readonly events: Ref.Ref<ReadonlyArray<string>>;
82 readonly failFirstStart?: Ref.Ref<boolean>;
83 readonly threads?: Partial<ThreadManagementService.ThreadManagementService["Service"]>;
84 readonly continueAfterRestart?: boolean;
85 readonly interrupt?: ProviderTurnControlService.ProviderTurnControlServiceV2Shape["interrupt"];
86 readonly rollback?: CheckpointRollbackService.CheckpointRollbackServiceV2Shape["execute"];
87 readonly respond?: RuntimeRequestService.RuntimeRequestServiceV2["Service"]["respond"];
88}) {
89 const record = (event: string) => Ref.update(input.events, (events) => [...events, event]);
90 const layerDependencies = Layer.mergeAll(
91 Layer.succeed(
92 ProviderTurnControlService.ProviderTurnControlServiceV2,
93 ProviderTurnControlService.ProviderTurnControlServiceV2.of({
94 interrupt: input.interrupt ?? (() => Effect.void),
95 steer: () => Effect.void,
96 applyModelSelection: () => Effect.void,
97 interruptAndAwaitTerminal: (request) =>
98 record(
99 request.replacementProviderSessionId === undefined
100 ? "interrupt"
101 : `interrupt:${request.replacementProviderSessionId}`,
102 ),
103 }),
104 ),
105 Layer.succeed(
106 ProviderSessionManager.ProviderSessionManagerV2,
107 ProviderSessionManager.ProviderSessionManagerV2.of({
108 shutdown: Effect.void,
109 open: () => Effect.die("unused open"),
110 get: () => Effect.succeedNone,
111 isLive: () => Effect.succeed(false),
112 close: () => Effect.void,
113 closeInstance: () => Effect.void,
114 release: () => record("release"),
115 detach: () => record("detach"),
116 otherWorkingThreads: () => Effect.succeed([]),
117 releaseUnlessBusy: () => Effect.succeed(true),
118 subscribePromptSuggestion: () => Stream.empty,
119 }),
120 ),
121 Layer.succeed(
122 ProviderTurnStartService.ProviderTurnStartServiceV2,
123 ProviderTurnStartService.ProviderTurnStartServiceV2.of({
124 start: () =>
125 Effect.gen(function* () {
126 yield* record("start");
127 if (
128 input.failFirstStart !== undefined &&
129 (yield* Ref.getAndSet(input.failFirstStart, false))
130 ) {
131 return yield* new ProviderTurnStartService.ProviderTurnStartError({
132 runId,
133 cause: "simulated first start failure",
134 });
135 }
136 }),
137 }),
138 ),
139 Layer.succeed(
140 RunFinalizationService.RunFinalizationService,
141 RunFinalizationService.RunFinalizationService.of({ finalize: () => Effect.void }),
142 ),
143 Layer.succeed(
144 CheckpointRollbackService.CheckpointRollbackServiceV2,
145 CheckpointRollbackService.CheckpointRollbackServiceV2.of({
146 execute: input.rollback ?? (() => Effect.void),
147 }),
148 ),
149 Layer.succeed(
150 RuntimeRequestService.RuntimeRequestServiceV2,
151 RuntimeRequestService.RuntimeRequestServiceV2.of({
152 respond: input.respond ?? (() => Effect.void),
153 }),
154 ),
155 Layer.succeed(
156 ThreadTitleRegenerationService.ThreadTitleRegenerationService,
157 ThreadTitleRegenerationService.ThreadTitleRegenerationService.of({
158 execute: () => Effect.void,
159 }),
160 ),
161 );
162 return EffectWorker.layerExecutor.pipe(
163 Layer.provide(
164 Layer.mergeAll(
165 layerDependencies,
166 Layer.mock(ThreadManagementService.ThreadManagementService)(input.threads ?? {}),
167 ServerSettings.layerTest(
168 input.continueAfterRestart === true ? { continueThreadsAfterServerUpdate: true } : {},
169 ),
170 ),
171 ),
172 );
173}
174
175it.effect.each([
176 {
177 name: "settles a stopped run when its adapter has already lost the native turn",
178 unresponsive: false,
179 dispatched: ["thread.background-work.settle"],
180 },
181 {
182 name: "leaves the run running and flags the Stop when the provider never confirms it",
183 unresponsive: true,
184 dispatched: ["thread.interrupt.unresponsive"],
185 },
186])("$name", ({ unresponsive, dispatched }) =>
187 Effect.gen(function* () {
188 const now = yield* DateTime.now;
189 const events = yield* Ref.make<ReadonlyArray<string>>([]);
190 const layer = layerExecutorFor({
191 events,
192 interrupt: () =>
193 new ProviderTurnControlService.ProviderTurnControlError({
194 threadId,
195 operation: "interrupt",
196 providerTurnId,
197 ...(unresponsive ? { unresponsive } : {}),
198 cause: unresponsive ? "Timed out." : "Provider turn is not active.",
199 }),
200 threads: {
201 dispatch: (command) =>
202 Ref.update(events, (current) => [...current, command.type]).pipe(
203 Effect.as({ sequence: 1, storedEvents: [] }),
204 ),
205 },
206 });
207 yield* Effect.gen(function* () {
208 const executor = yield* EffectWorker.OrchestrationEffectExecutorV2;
209 yield* executor.execute({
210 ...restartEffect(now, { type: "detach" }),
211 request: {
212 type: "provider-turn.interrupt",
213 providerSessionId: oldSessionId,
214 providerThreadId,
215 providerTurnId,
216 },
217 });
218 }).pipe(Effect.provide(layer));
219 assert.deepEqual(yield* Ref.get(events), dispatched);
220 }),
221);
222
223const lockedIndexMessage =
224 "Git's index is locked. Wait for other Git operations to finish, then try again.";
225const rollbackCheckpointId = CheckpointId.make("checkpoint:effect-worker-rollback");
226const rollbackScopeId = CheckpointScopeId.make("checkpoint-scope:effect-worker-rollback");
227const restoreFailure = (detail: string) =>
228 new CheckpointRollbackService.CheckpointRollbackExecutionError({
229 reason: "unexpected-failure",
230 threadId,
231 providerThreadId,
232 checkpointId: rollbackCheckpointId,
233 cause: new CheckpointService.CheckpointRestoreError({
234 scopeId: rollbackScopeId,
235 checkpointId: rollbackCheckpointId,
236 cause: new VcsProcessExitError({
237 operation: "GitVcsDriverCore.restoreCheckpoint",
238 command: "git",
239 cwd: "/private/repo",
240 exitCode: 128,
241 detail,
242 failureKind: "command-failed",
243 }),
244 }),
245 });
246
247it.effect.each([
248 {
249 name: "a held Git index lock",
250 failure: restoreFailure(lockedIndexMessage),
251 message: lockedIndexMessage,
252 },
253 {
254 name: "raw Git output",
255 failure: restoreFailure("error: could not clean /private/repo/secret.txt"),
256 message: CheckpointRollbackService.ROLLBACK_FAILED_MESSAGE,
257 },
258])("reports a rollback blocked by $name only after the last attempt", ({ failure, message }) =>
259 Effect.gen(function* () {
260 const now = yield* DateTime.now;
261 const failures = yield* Ref.make<ReadonlyArray<string>>([]);
262 const layer = layerExecutorFor({
263 events: yield* Ref.make<ReadonlyArray<string>>([]),
264 rollback: () => Effect.fail(failure),
265 threads: {
266 dispatch: (command) =>
267 Ref.update(failures, (current) =>
268 command.type === "checkpoint.rollback.fail" ? [...current, command.message] : current,
269 ).pipe(Effect.as({ sequence: 1, storedEvents: [] })),
270 },
271 });
272 yield* Effect.gen(function* () {
273 const executor = yield* EffectWorker.OrchestrationEffectExecutorV2;
274 const rollback: EffectOutbox.OrchestrationEffectV2 = {
275 ...restartEffect(now, { type: "detach" }),
276 request: {
277 type: "provider-thread.rollback",
278 providerThreadId,
279 checkpointId: rollbackCheckpointId,
280 scopeId: rollbackScopeId,
281 restoreFiles: true,
282 },
283 };
284 yield* Effect.flip(executor.execute(rollback, { willRetry: true }));
285 assert.deepEqual(yield* Ref.get(failures), []);
286 yield* Effect.flip(executor.execute(rollback, { willRetry: false }));
287 }).pipe(Effect.provide(layer));
288 assert.deepEqual(yield* Ref.get(failures), [message]);
289 }),
290);
291
292it.effect("does not report an answer whose last delivery attempt is interrupted", () =>
293 Effect.gen(function* () {
294 const now = yield* DateTime.now;
295 const reported = yield* Ref.make(0);
296 const layer = layerExecutorFor({
297 events: yield* Ref.make<ReadonlyArray<string>>([]),
298 respond: () => Effect.interrupt,
299 threads: {
300 dispatch: (command) =>
301 Ref.update(reported, (count) =>
302 command.type === "runtime-request.delivery.fail" ? count + 1 : count,
303 ).pipe(Effect.as({ sequence: 1, storedEvents: [] })),
304 },
305 });
306 const exit = yield* Effect.gen(function* () {
307 const executor = yield* EffectWorker.OrchestrationEffectExecutorV2;
308 return yield* Effect.exit(
309 executor.execute(
310 {
311 ...restartEffect(now, { type: "detach" }),
312 request: {
313 type: "runtime-request.respond",
314 providerSessionId: oldSessionId,
315 requestId: RuntimeRequestId.make("runtime-request:effect-worker-interrupted"),
316 answers: { next: "Ship it" },
317 },
318 },
319 { willRetry: false },
320 ),
321 );
322 }).pipe(Effect.provide(layer));
323 assert.isTrue(Exit.hasInterrupts(exit));
324 assert.equal(yield* Ref.get(reported), 0);
325 }),
326);
327
328it.effect("requeues a claim when a pre-execution worker check fails", () =>
329 Effect.gen(function* () {
330 const now = DateTime.formatIso(yield* DateTime.now);
331 const effectId = "effect:worker-pre-execution-failure";
332 const workerId = "worker-pre-execution-failure";
333 const claimedEffect: EffectOutbox.OrchestrationEffectV2 = {
334 id: effectId,
335 commandId: CommandId.make("command:worker-pre-execution-failure"),
336 threadId: ThreadId.make("thread:worker-pre-execution-failure"),
337 request: { type: "terminal.cleanup" },
338 status: "running",
339 attemptCount: 1,
340 availableAt: now,
341 leaseOwner: workerId,
342 createdAt: now,
343 updatedAt: now,
344 completedAt: null,
345 lastError: null,
346 };
347 const retries = yield* Ref.make<
348 ReadonlyArray<{
349 readonly effectId: string;
350 readonly workerId: string;
351 readonly error: string;
352 readonly delayMs: number;
353 }>
354 >([]);
355 const executionCount = yield* Ref.make(0);
356 const layerOutbox = Layer.mock(EffectOutbox.EffectOutboxV2)({
357 claimNext: () => Effect.succeedSome(claimedEffect),
358 get: () =>
359 Effect.fail(
360 new EffectOutbox.EffectOutboxError({
361 operation: "get",
362 effectId,
363 cause: "simulated cancellation-state read failure",
364 }),
365 ),
366 retry: (input) =>
367 Ref.update(retries, (existing) => [...existing, input]).pipe(Effect.as(true)),
368 });
369 const layerExecutor = Layer.succeed(
370 EffectWorker.OrchestrationEffectExecutorV2,
371 EffectWorker.OrchestrationEffectExecutorV2.of({
372 execute: () => Ref.update(executionCount, (count) => count + 1),
373 }),
374 );
375 const layerWorker = EffectWorker.layerWithOptions({ workerId }).pipe(
376 Layer.provide(Layer.merge(layerOutbox, layerExecutor)),
377 );
378
379 const exit = yield* EffectWorker.OrchestrationEffectWorkerV2.pipe(
380 Effect.flatMap((worker) => worker.runOnce()),
381 Effect.provide(layerWorker),
382 Effect.exit,
383 );
384
385 assert.isTrue(Exit.isFailure(exit));
386 if (Exit.isFailure(exit)) {
387 assert.include(Cause.pretty(exit.cause), "simulated cancellation-state read failure");
388 }
389 assert.equal(yield* Ref.get(executionCount), 0);
390 const retry = (yield* Ref.get(retries))[0];
391 assert.isDefined(retry);
392 assert.equal(retry.effectId, effectId);
393 assert.equal(retry.workerId, workerId);
394 assert.equal(retry.delayMs, 0);
395 assert.include(retry.error, "simulated cancellation-state read failure");
396 }),
397);
398
399it.effect("arms cancellation before the durable pre-execution check", () =>
400 Effect.gen(function* () {
401 const now = DateTime.formatIso(yield* DateTime.now);
402 const effectId = "effect:worker-cancellation-registration-race";
403 const workerId = "worker-cancellation-registration-race";
404 const claimedEffect: EffectOutbox.OrchestrationEffectV2 = {
405 id: effectId,
406 commandId: CommandId.make("command:worker-cancellation-registration-race"),
407 threadId: ThreadId.make("thread:worker-cancellation-registration-race"),
408 request: { type: "terminal.cleanup" },
409 status: "running",
410 attemptCount: 1,
411 availableAt: now,
412 leaseOwner: workerId,
413 createdAt: now,
414 updatedAt: now,
415 completedAt: null,
416 lastError: null,
417 };
418 const signal = yield* Deferred.make<void>();
419 let cancellationArmed = false;
420 const executionCount = yield* Ref.make(0);
421 const settlementCount = yield* Ref.make(0);
422 const layerOutbox = Layer.mock(EffectOutbox.EffectOutboxV2)({
423 claimNext: () => Effect.succeedSome(claimedEffect),
424 awaitCancellation: () => {
425 cancellationArmed = true;
426 return Deferred.await(signal);
427 },
428 get: () =>
429 Effect.gen(function* () {
430 if (cancellationArmed) {
431 yield* Deferred.succeed(signal, undefined);
432 }
433 return Option.some(claimedEffect);
434 }),
435 clearCancellation: () => Effect.void,
436 succeed: () => Ref.update(settlementCount, (count) => count + 1).pipe(Effect.as(true)),
437 });
438 const layerExecutor = Layer.succeed(
439 EffectWorker.OrchestrationEffectExecutorV2,
440 EffectWorker.OrchestrationEffectExecutorV2.of({
441 execute: () =>
442 Effect.yieldNow.pipe(Effect.andThen(Ref.update(executionCount, (count) => count + 1))),
443 }),
444 );
445 const layerWorker = EffectWorker.layerWithOptions({ workerId }).pipe(
446 Layer.provide(Layer.merge(layerOutbox, layerExecutor)),
447 );
448
449 const exit = yield* EffectWorker.OrchestrationEffectWorkerV2.pipe(
450 Effect.flatMap((worker) => worker.runOnce()),
451 Effect.provide(layerWorker),
452 Effect.exit,
453 );
454
455 if (Exit.isFailure(exit)) {
456 assert.fail(Cause.pretty(exit.cause));
457 }
458 assert.equal(yield* Ref.get(executionCount), 0);
459 assert.equal(yield* Ref.get(settlementCount), 0);
460 }),
461);
462
463it.effect("terminalizes a process-bound claim when success settlement fails", () =>
464 Effect.gen(function* () {
465 const now = DateTime.formatIso(yield* DateTime.now);
466 const effectId = "effect:worker-process-bound-settlement-failure";
467 const workerId = "worker-process-bound-settlement-failure";
468 const claimedEffect: EffectOutbox.OrchestrationEffectV2 = {
469 id: effectId,
470 commandId: CommandId.make("command:worker-process-bound-settlement-failure"),
471 threadId: ThreadId.make("thread:worker-process-bound-settlement-failure"),
472 request: {
473 type: "provider-turn.start",
474 runId: RunId.make("run:worker-process-bound-settlement-failure"),
475 },
476 status: "running",
477 attemptCount: 1,
478 availableAt: now,
479 leaseOwner: workerId,
480 createdAt: now,
481 updatedAt: now,
482 completedAt: null,
483 lastError: null,
484 };
485 const retries = yield* Ref.make(0);
486 const terminalErrors = yield* Ref.make<ReadonlyArray<string>>([]);
487 const executionCount = yield* Ref.make(0);
488 const layerOutbox = Layer.mock(EffectOutbox.EffectOutboxV2)({
489 claimNext: () => Effect.succeedSome(claimedEffect),
490 get: () => Effect.succeedSome(claimedEffect),
491 awaitCancellation: () => Effect.never,
492 clearCancellation: () => Effect.void,
493 succeed: () =>
494 Effect.fail(
495 new EffectOutbox.EffectOutboxError({
496 operation: "succeed",
497 effectId,
498 cause: "simulated success settlement failure",
499 }),
500 ),
501 retry: () => Ref.update(retries, (count) => count + 1).pipe(Effect.as(true)),
502 fail: ({ error }) =>
503 Ref.update(terminalErrors, (existing) => [...existing, error]).pipe(Effect.as(true)),
504 });
505 const layerExecutor = Layer.succeed(
506 EffectWorker.OrchestrationEffectExecutorV2,
507 EffectWorker.OrchestrationEffectExecutorV2.of({
508 execute: () => Ref.update(executionCount, (count) => count + 1),
509 }),
510 );
511 const layerWorker = EffectWorker.layerWithOptions({ workerId }).pipe(
512 Layer.provide(Layer.merge(layerOutbox, layerExecutor)),
513 );
514
515 const exit = yield* EffectWorker.OrchestrationEffectWorkerV2.pipe(
516 Effect.flatMap((worker) => worker.runOnce()),
517 Effect.provide(layerWorker),
518 Effect.exit,
519 );
520
521 assert.isTrue(Exit.isFailure(exit));
522 assert.equal(yield* Ref.get(executionCount), 1);
523 assert.equal(yield* Ref.get(retries), 0);
524 const terminalError = (yield* Ref.get(terminalErrors))[0];
525 assert.isDefined(terminalError);
526 assert.include(terminalError, "after execution started");
527 assert.include(terminalError, "simulated success settlement failure");
528 }),
529);
530
531it.effect("settles a delegated child once its restart continuation fails for good", () =>
532 Effect.gen(function* () {
533 const timestamp = DateTime.formatIso(yield* DateTime.now);
534 const events = yield* Ref.make<ReadonlyArray<string>>([]);
535 const recovered = yield* Ref.make<ReadonlyArray<ThreadId>>([]);
536 const layer = layerExecutorFor({
537 events,
538 continueAfterRestart: true,
539 threads: {
540 getThreadRecords: () => Effect.fail(new Error("provider instance removed") as never),
541 recoverDelegatedTask: (childThreadId) =>
542 Ref.update(recovered, (ids) => [...ids, childThreadId]),
543 },
544 });
545 const effect: EffectOutbox.OrchestrationEffectV2 = {
546 id: `effect:restart-continuation:${runId}`,
547 commandId: CommandId.make("command:restart-continuation-failure"),
548 threadId,
549 request: { type: "provider-runtime.continue", sourceRunId: runId },
550 status: "running",
551 attemptCount: 1,
552 availableAt: timestamp,
553 leaseOwner: "test-worker",
554 createdAt: timestamp,
555 updatedAt: timestamp,
556 completedAt: null,
557 lastError: null,
558 };
559 yield* Effect.gen(function* () {
560 const executor = yield* EffectWorker.OrchestrationEffectExecutorV2;
561 assert.isTrue(
562 Exit.isFailure(yield* Effect.exit(executor.execute(effect, { willRetry: true }))),
563 );
564 assert.deepEqual(yield* Ref.get(recovered), []);
565 assert.isTrue(
566 Exit.isFailure(yield* Effect.exit(executor.execute(effect, { willRetry: false }))),
567 );
568 assert.deepEqual(yield* Ref.get(recovered), [threadId]);
569 }).pipe(Effect.provide(layer));
570 }),
571);
572
573it.effect.each(["confirmed", "unconfirmed", "failed"] as const)(
574 "a native subagent stop only repairs %s provider evidence",
575 (outcome) =>
576 Effect.gen(function* () {
577 const now = yield* DateTime.now;
578 const events = yield* Ref.make<ReadonlyArray<string>>([]);
579 const layer = layerExecutorFor({
580 events,
581 interrupt: (input) => {
582 assert.equal(input.subagent?.nativeTaskId, "native-task");
583 return Ref.update(events, (current) => [...current, "stop-child"]).pipe(
584 Effect.andThen(
585 outcome === "failed"
586 ? new ProviderTurnControlService.ProviderTurnControlError({
587 threadId,
588 providerTurnId,
589 operation: "interrupt",
590 cause: "SDK stop failed",
591 })
592 : Effect.succeed(
593 outcome === "confirmed"
594 ? {
595 status: "cancelled" as const,
596 completedAt: now,
597 result: "Stopped by Claude",
598 }
599 : undefined,
600 ),
601 ),
602 );
603 },
604 threads: {
605 dispatch: (command) => {
606 assert.equal(command.type, "thread.background-work.settle");
607 if (command.type === "thread.background-work.settle") {
608 assert.equal(command.subagent?.id, "subagent");
609 assert.deepEqual(command.subagent?.outcome, {
610 status: "cancelled",
611 completedAt: now,
612 result: "Stopped by Claude",
613 });
614 }
615 return Ref.update(events, (current) => [...current, "settle-child"]).pipe(
616 Effect.as({ sequence: 1, storedEvents: [] }),
617 );
618 },
619 },
620 });
621 const execution = yield* Effect.gen(function* () {
622 const executor = yield* EffectWorker.OrchestrationEffectExecutorV2;
623 yield* executor.execute({
624 ...restartEffect(now, { type: "detach" }),
625 request: {
626 type: "provider-turn.interrupt",
627 providerSessionId: oldSessionId,
628 providerThreadId,
629 providerTurnId,
630 subagent: { id: NodeId.make("subagent"), nativeTaskId: "native-task" },
631 },
632 });
633 }).pipe(Effect.provide(layer), Effect.exit);
634 assert.equal(Exit.isFailure(execution), outcome === "failed");
635 assert.deepEqual(
636 yield* Ref.get(events),
637 outcome === "confirmed" ? ["stop-child", "settle-child"] : ["stop-child"],
638 );
639 }),
640);