openAgent

1import { afterEach, describe, expect } from "bun:test"
2import { SessionV1 } from "@opencode-ai/core/v1/session"
3import { Database } from "@opencode-ai/core/database/database"
4import { LayerNode } from "@opencode-ai/core/effect/layer-node"
5import { SessionProjector } from "@opencode-ai/core/session/projector"
6import { Deferred, Effect, Exit, Fiber, Layer } from "effect"
7import { Agent } from "../../src/agent/agent"
8import { BackgroundJob } from "@/background/job"
9import { EventV2Bridge } from "@/event-v2-bridge"
10import { Config } from "@/config/config"
11import { CrossSpawnSpawner } from "@opencode-ai/core/cross-spawn-spawner"
12import { Ripgrep } from "@opencode-ai/core/ripgrep"
13import { Session } from "@/session/session"
14import type { SessionPrompt } from "../../src/session/prompt"
15import { MessageID, PartID, SessionID } from "../../src/session/schema"
16import { SessionRunState } from "@/session/run-state"
17import { SessionStatus } from "@/session/status"
18 
19import { TaskTool, type TaskPromptOps } from "../../src/tool/task"
20import { Truncate } from "@/tool/truncate"
21import { ToolRegistry } from "@/tool/registry"
22import { RuntimeFlags } from "@/effect/runtime-flags"
23import { disposeAllInstances } from "../fixture/fixture"
24import { testEffect } from "../lib/effect"
25import { ProviderV2 } from "@opencode-ai/core/provider"
26import { ModelV2 } from "@opencode-ai/core/model"
27 
28afterEach(async () => {
29  await disposeAllInstances()
30})
31 
32const ref = {
33  providerID: ProviderV2.ID.make("test"),
34  modelID: ModelV2.ID.make("test-model"),
35}
36 
37const layer = (flags: Partial<RuntimeFlags.Info> = {}) =>
38  LayerNode.compile(
39    LayerNode.group([
40      Agent.node,
41      BackgroundJob.node,
42      EventV2Bridge.node,
43      Config.node,
44      CrossSpawnSpawner.node,
45      Session.node,
46      SessionProjector.node,
47      SessionRunState.node,
48      SessionStatus.node,
49      Truncate.node,
50      ToolRegistry.node,
51      Database.node,
52      RuntimeFlags.node,
53      Ripgrep.node,
54    ]),
55    [[RuntimeFlags.node, RuntimeFlags.layer(flags)]],
56  )
57 
58const it = testEffect(layer())
59const background = testEffect(layer({ experimentalBackgroundSubagents: true }))
60 
61function defer<T>() {
62  let resolve!: (value: T | PromiseLike<T>) => void
63  const promise = new Promise<T>((done) => {
64    resolve = done
65  })
66  return { promise, resolve }
67}
68 
69const seed = Effect.fn("TaskToolTest.seed")(function* (title = "Pinned") {
70  const session = yield* Session.Service
71  const chat = yield* session.create({ title })
72  const user = yield* session.updateMessage({
73    id: MessageID.ascending(),
74    role: "user",
75    sessionID: chat.id,
76    agent: "build",
77    model: ref,
78    time: { created: Date.now() },
79  })
80  const assistant: SessionV1.Assistant = {
81    id: MessageID.ascending(),
82    role: "assistant",
83    parentID: user.id,
84    sessionID: chat.id,
85    mode: "build",
86    agent: "build",
87    cost: 0,
88    path: { cwd: "/tmp", root: "/tmp" },
89    tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
90    modelID: ref.modelID,
91    providerID: ref.providerID,
92    variant: "xhigh",
93    time: { created: Date.now() },
94  }
95  yield* session.updateMessage(assistant)
96  return { chat, assistant }
97})
98 
99function stubOps(opts?: { onPrompt?: (input: SessionPrompt.PromptInput) => void; text?: string }): TaskPromptOps {
100  return {
101    cancel: () => Effect.void,
102    resolvePromptParts: (template) => Effect.succeed([{ type: "text" as const, text: template }]),
103    prompt: (input) =>
104      Effect.sync(() => {
105        opts?.onPrompt?.(input)
106        return reply(input, opts?.text ?? "done")
107      }),
108  }
109}
110 
111function reply(input: SessionPrompt.PromptInput, text: string): SessionV1.WithParts {
112  const id = MessageID.ascending()
113  return {
114    info: {
115      id,
116      role: "assistant",
117      parentID: input.messageID ?? MessageID.ascending(),
118      sessionID: input.sessionID,
119      mode: input.agent ?? "general",
120      agent: input.agent ?? "general",
121      cost: 0,
122      path: { cwd: "/tmp", root: "/tmp" },
123      tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
124      modelID: input.model?.modelID ?? ref.modelID,
125      providerID: input.model?.providerID ?? ref.providerID,
126      time: { created: Date.now() },
127      finish: "stop",
128    },
129    parts: [
130      {
131        id: PartID.ascending(),
132        messageID: id,
133        sessionID: input.sessionID,
134        type: "text",
135        text,
136      },
137    ],
138  }
139}
140 
141describe("tool.task", () => {
142  it.instance(
143    "description sorts subagents by name and is stable across calls",
144    () =>
145      Effect.gen(function* () {
146        const agent = yield* Agent.Service
147        const build = yield* agent.get("build")
148        const registry = yield* ToolRegistry.Service
149        const get = Effect.fnUntraced(function* () {
150          const tools = yield* registry.tools({ ...ref, agent: build })
151          return tools.find((tool) => tool.id === TaskTool.id)?.description ?? ""
152        })
153        const first = yield* get()
154        const second = yield* get()
155 
156        expect(first).toBe(second)
157 
158        const alpha = first.indexOf("- alpha: Alpha agent")
159        const explore = first.indexOf("- explore:")
160        const general = first.indexOf("- general:")
161        const zebra = first.indexOf("- zebra: Zebra agent")
162 
163        expect(alpha).toBeGreaterThan(-1)
164        expect(explore).toBeGreaterThan(alpha)
165        expect(general).toBeGreaterThan(explore)
166        expect(zebra).toBeGreaterThan(general)
167      }),
168    {
169      config: {
170        agent: {
171          zebra: {
172            description: "Zebra agent",
173            mode: "subagent",
174          },
175          alpha: {
176            description: "Alpha agent",
177            mode: "subagent",
178          },
179        },
180      },
181    },
182  )
183 
184  it.instance(
185    "description hides denied subagents for the caller",
186    () =>
187      Effect.gen(function* () {
188        const agent = yield* Agent.Service
189        const build = yield* agent.get("build")
190        const registry = yield* ToolRegistry.Service
191        const description =
192          (yield* registry.tools({ ...ref, agent: build })).find((tool) => tool.id === TaskTool.id)?.description ?? ""
193 
194        expect(description).toContain("- alpha: Alpha agent")
195        expect(description).not.toContain("- zebra: Zebra agent")
196      }),
197    {
198      config: {
199        permission: {
200          task: {
201            "*": "allow",
202            zebra: "deny",
203          },
204        },
205        agent: {
206          zebra: {
207            description: "Zebra agent",
208            mode: "subagent",
209          },
210          alpha: {
211            description: "Alpha agent",
212            mode: "subagent",
213          },
214        },
215      },
216    },
217  )
218 
219  it.instance("execute resumes an existing task session from task_id", () =>
220    Effect.gen(function* () {
221      const sessions = yield* Session.Service
222      const { chat, assistant } = yield* seed()
223      const child = yield* sessions.create({ parentID: chat.id, title: "Existing child" })
224      const tool = yield* TaskTool
225      const def = yield* tool.init()
226      let seen: SessionPrompt.PromptInput | undefined
227      const promptOps = stubOps({ text: "resumed", onPrompt: (input) => (seen = input) })
228 
229      const result = yield* def.execute(
230        {
231          description: "inspect bug",
232          prompt: "look into the cache key path",
233          subagent_type: "general",
234          task_id: child.id,
235        },
236        {
237          sessionID: chat.id,
238          messageID: assistant.id,
239          agent: "build",
240          abort: new AbortController().signal,
241          extra: { promptOps },
242          messages: [],
243          metadata: () => Effect.void,
244          ask: () => Effect.void,
245        },
246      )
247 
248      const kids = yield* sessions.children(chat.id)
249      expect(kids).toHaveLength(1)
250      expect(kids[0]?.id).toBe(child.id)
251      expect(result.metadata.sessionId).toBe(child.id)
252      expect(result.output).toContain(`<task id="${child.id}" state="completed">`)
253      expect(seen?.sessionID).toBe(child.id)
254      expect(seen?.variant).toBe("xhigh")
255    }),
256  )
257 
258  it.instance("execute asks by default and skips checks when bypassed", () =>
259    Effect.gen(function* () {
260      const { chat, assistant } = yield* seed()
261      const tool = yield* TaskTool
262      const def = yield* tool.init()
263      const calls: unknown[] = []
264      const promptOps = stubOps()
265 
266      const exec = (extra?: Record<string, any>) =>
267        def.execute(
268          {
269            description: "inspect bug",
270            prompt: "look into the cache key path",
271            subagent_type: "general",
272          },
273          {
274            sessionID: chat.id,
275            messageID: assistant.id,
276            agent: "build",
277            abort: new AbortController().signal,
278            extra: { promptOps, ...extra },
279            messages: [],
280            metadata: () => Effect.void,
281            ask: (input) =>
282              Effect.sync(() => {
283                calls.push(input)
284              }),
285          },
286        )
287 
288      yield* exec()
289      yield* exec({ bypassAgentCheck: true })
290 
291      expect(calls).toHaveLength(1)
292      expect(calls[0]).toEqual({
293        permission: "task",
294        patterns: ["general"],
295        always: ["*"],
296        metadata: {
297          description: "inspect bug",
298          subagent_type: "general",
299        },
300      })
301    }),
302  )
303 
304  it.instance("execute cancels child session when abort signal fires", () =>
305    Effect.gen(function* () {
306      const { chat, assistant } = yield* seed()
307      const tool = yield* TaskTool
308      const def = yield* tool.init()
309      const ready = defer<SessionPrompt.PromptInput>()
310      const cancelled = defer<SessionID>()
311      const abort = new AbortController()
312      const promptOps: TaskPromptOps = {
313        cancel: (sessionID) =>
314          Effect.sync(() => {
315            cancelled.resolve(sessionID)
316          }),
317        resolvePromptParts: (template) => Effect.succeed([{ type: "text" as const, text: template }]),
318        prompt: (input) =>
319          Effect.promise(() => {
320            ready.resolve(input)
321            return cancelled.promise
322          }).pipe(Effect.as(reply(input, "cancelled"))),
323      }
324 
325      const fiber = yield* def
326        .execute(
327          {
328            description: "inspect bug",
329            prompt: "look into the cache key path",
330            subagent_type: "general",
331          },
332          {
333            sessionID: chat.id,
334            messageID: assistant.id,
335            agent: "build",
336            abort: abort.signal,
337            extra: { promptOps },
338            messages: [],
339            metadata: () => Effect.void,
340            ask: () => Effect.void,
341          },
342        )
343        .pipe(Effect.forkChild)
344 
345      const input = yield* Effect.promise(() => ready.promise)
346      abort.abort()
347      expect(yield* Effect.promise(() => cancelled.promise)).toBe(input.sessionID)
348 
349      const exit = yield* Fiber.await(fiber)
350      expect(Exit.isSuccess(exit)).toBe(true)
351    }),
352  )
353 
354  it.instance("execute creates a child when task_id does not exist", () =>
355    Effect.gen(function* () {
356      const sessions = yield* Session.Service
357      const { chat, assistant } = yield* seed()
358      const tool = yield* TaskTool
359      const def = yield* tool.init()
360      let seen: SessionPrompt.PromptInput | undefined
361      const promptOps = stubOps({ text: "created", onPrompt: (input) => (seen = input) })
362 
363      const result = yield* def.execute(
364        {
365          description: "inspect bug",
366          prompt: "look into the cache key path",
367          subagent_type: "general",
368          task_id: "ses_missing",
369        },
370        {
371          sessionID: chat.id,
372          messageID: assistant.id,
373          agent: "build",
374          abort: new AbortController().signal,
375          extra: { promptOps },
376          messages: [],
377          metadata: () => Effect.void,
378          ask: () => Effect.void,
379        },
380      )
381 
382      const kids = yield* sessions.children(chat.id)
383      expect(kids).toHaveLength(1)
384      expect(kids[0]?.id).toBe(result.metadata.sessionId)
385      expect(result.metadata.sessionId).not.toBe("ses_missing")
386      expect(result.output).toContain(`<task id="${result.metadata.sessionId}" state="completed">`)
387      expect(seen?.sessionID).toBe(result.metadata.sessionId)
388    }),
389  )
390 
391  it.instance("prevents subagents from launching subagents by default", () =>
392    Effect.gen(function* () {
393      const sessions = yield* Session.Service
394      const { chat, assistant } = yield* seed()
395      const child = yield* sessions.create({ parentID: chat.id, title: "child" })
396      const nestedAssistant = yield* sessions.updateMessage({
397        ...assistant,
398        id: MessageID.ascending(),
399        parentID: MessageID.ascending(),
400        sessionID: child.id,
401      })
402      const tool = yield* TaskTool
403      const def = yield* tool.init()
404      let asked = false
405 
406      const exit = yield* def
407        .execute(
408          {
409            description: "inspect bug",
410            prompt: "look into the cache key path",
411            subagent_type: "general",
412          },
413          {
414            sessionID: child.id,
415            messageID: nestedAssistant.id,
416            agent: "general",
417            abort: new AbortController().signal,
418            extra: { promptOps: stubOps() },
419            messages: [],
420            metadata: () => Effect.void,
421            ask: () => Effect.sync(() => (asked = true)),
422          },
423        )
424        .pipe(Effect.exit)
425 
426      expect(Exit.isFailure(exit)).toBe(true)
427      expect(asked).toBe(false)
428      expect(yield* sessions.children(child.id)).toHaveLength(0)
429    }),
430  )
431 
432  it.instance(
433    "allows nested subagents up to the configured depth",
434    () =>
435      Effect.gen(function* () {
436        const sessions = yield* Session.Service
437        const { chat, assistant } = yield* seed()
438        const child = yield* sessions.create({ parentID: chat.id, title: "child" })
439        const nestedAssistant = yield* sessions.updateMessage({
440          ...assistant,
441          id: MessageID.ascending(),
442          parentID: MessageID.ascending(),
443          sessionID: child.id,
444        })
445        const tool = yield* TaskTool
446        const def = yield* tool.init()
447 
448        const result = yield* def.execute(
449          {
450            description: "inspect bug",
451            prompt: "look into the cache key path",
452            subagent_type: "general",
453          },
454          {
455            sessionID: child.id,
456            messageID: nestedAssistant.id,
457            agent: "general",
458            abort: new AbortController().signal,
459            extra: { promptOps: stubOps() },
460            messages: [],
461            metadata: () => Effect.void,
462            ask: () => Effect.void,
463          },
464        )
465 
466        expect((yield* sessions.get(result.metadata.sessionId)).parentID).toBe(child.id)
467      }),
468    { config: { subagent_depth: 2 } },
469  )
470 
471  it.instance(
472    "execute shapes child permissions for task, todowrite, and primary tools",
473    () =>
474      Effect.gen(function* () {
475        const sessions = yield* Session.Service
476        const { chat, assistant } = yield* seed()
477        const tool = yield* TaskTool
478        const def = yield* tool.init()
479        let seen: SessionPrompt.PromptInput | undefined
480        const promptOps = stubOps({ onPrompt: (input) => (seen = input) })
481 
482        const result = yield* def.execute(
483          {
484            description: "inspect bug",
485            prompt: "look into the cache key path",
486            subagent_type: "reviewer",
487          },
488          {
489            sessionID: chat.id,
490            messageID: assistant.id,
491            agent: "build",
492            abort: new AbortController().signal,
493            extra: { promptOps },
494            messages: [],
495            metadata: () => Effect.void,
496            ask: () => Effect.void,
497          },
498        )
499 
500        const child = yield* sessions.get(result.metadata.sessionId)
501        expect(child.parentID).toBe(chat.id)
502        expect(child.agent).toBe("reviewer")
503        expect(child.permission).toEqual([
504          {
505            permission: "todowrite",
506            pattern: "*",
507            action: "deny",
508          },
509          {
510            permission: "bash",
511            pattern: "*",
512            action: "deny",
513          },
514          {
515            permission: "read",
516            pattern: "*",
517            action: "deny",
518          },
519        ])
520        expect(seen?.tools).toBeUndefined()
521      }),
522    {
523      config: {
524        agent: {
525          reviewer: {
526            mode: "subagent",
527            permission: {
528              task: "allow",
529            },
530          },
531        },
532        experimental: {
533          primary_tools: ["bash", "read"],
534        },
535      },
536    },
537  )
538 
539  it.instance("rejects background execution when the experiment is disabled", () =>
540    Effect.gen(function* () {
541      const { chat, assistant } = yield* seed()
542      const tool = yield* TaskTool
543      const def = yield* tool.init()
544 
545      const exit = yield* def
546        .execute(
547          {
548            description: "inspect bug",
549            prompt: "look into the cache key path",
550            subagent_type: "general",
551            background: true,
552          },
553          {
554            sessionID: chat.id,
555            messageID: assistant.id,
556            agent: "build",
557            abort: new AbortController().signal,
558            extra: { promptOps: stubOps() },
559            messages: [],
560            metadata: () => Effect.void,
561            ask: () => Effect.void,
562          },
563        )
564        .pipe(Effect.exit)
565 
566      expect(Exit.isFailure(exit)).toBe(true)
567    }),
568  )
569 
570  it.instance("promotes a running foreground task without restarting it", () =>
571    Effect.gen(function* () {
572      const jobs = yield* BackgroundJob.Service
573      const { chat, assistant } = yield* seed()
574      const tool = yield* TaskTool
575      const def = yield* tool.init()
576      const ready = yield* Deferred.make<void>()
577      const done = yield* Deferred.make<void>()
578      const injected = yield* Deferred.make<SessionPrompt.PromptInput>()
579      let runs = 0
580      const promptOps: TaskPromptOps = {
581        cancel: () => Effect.void,
582        resolvePromptParts: (template) => Effect.succeed([{ type: "text" as const, text: template }]),
583        prompt: (input) => {
584          if (input.sessionID === chat.id) {
585            return Deferred.succeed(injected, input).pipe(Effect.as(reply(input, "injected")))
586          }
587          return Effect.gen(function* () {
588            runs += 1
589            yield* Deferred.succeed(ready, undefined)
590            yield* Deferred.await(done)
591            return reply(input, "background done")
592          })
593        },
594      }
595 
596      const fiber = yield* def
597        .execute(
598          {
599            description: "inspect bug",
600            prompt: "look into the cache key path",
601            subagent_type: "general",
602          },
603          {
604            sessionID: chat.id,
605            messageID: assistant.id,
606            agent: "build",
607            abort: new AbortController().signal,
608            extra: { promptOps },
609            messages: [],
610            metadata: () => Effect.void,
611            ask: () => Effect.void,
612          },
613        )
614        .pipe(Effect.forkChild)
615 
616      yield* Deferred.await(ready)
617      const job = (yield* jobs.list())[0]
618      expect(job).toBeDefined()
619      if (!job) throw new Error("task job not found")
620      expect(job.metadata?.parentSessionId).toBe(chat.id)
621      yield* jobs.promote(job.id)
622 
623      const result = yield* Fiber.join(fiber)
624      expect(result.metadata.background).toBe(true)
625      expect(result.output).toContain(`state="running"`)
626      expect((yield* jobs.get(result.metadata.sessionId))?.status).toBe("running")
627      expect(runs).toBe(1)
628 
629      yield* Deferred.succeed(done, undefined)
630      expect((yield* jobs.wait({ id: result.metadata.sessionId })).info?.output).toBe("background done")
631      expect((yield* Deferred.await(injected)).parts[0]?.type).toBe("text")
632      expect(runs).toBe(1)
633    }),
634  )
635 
636  background.instance("execute launches background tasks without waiting for completion", () =>
637    Effect.gen(function* () {
638      const jobs = yield* BackgroundJob.Service
639      const { chat, assistant } = yield* seed()
640      const tool = yield* TaskTool
641      const def = yield* tool.init()
642 
643      const result = yield* def.execute(
644        {
645          description: "inspect bug",
646          prompt: "look into the cache key path",
647          subagent_type: "general",
648          background: true,
649        },
650        {
651          sessionID: chat.id,
652          messageID: assistant.id,
653          agent: "build",
654          abort: new AbortController().signal,
655          extra: {
656            promptOps: {
657              ...stubOps(),
658              prompt: () => Effect.never,
659            } satisfies TaskPromptOps,
660          },
661          messages: [],
662          metadata: () => Effect.void,
663          ask: () => Effect.void,
664        },
665      )
666 
667      const job = yield* jobs.get(result.metadata.sessionId)
668      expect(result.metadata.background).toBe(true)
669      expect(result.output).toContain(`state="running"`)
670      expect(job?.status).toBe("running")
671    }),
672  )
673 
674  background.instance("background task completion waits for running updates", () =>
675    Effect.gen(function* () {
676      const jobs = yield* BackgroundJob.Service
677      const { chat, assistant } = yield* seed()
678      const tool = yield* TaskTool
679      const def = yield* tool.init()
680      const first = defer<void>()
681      const second = defer<void>()
682      const updated = defer<SessionPrompt.PromptInput>()
683      const injected = defer<SessionPrompt.PromptInput>()
684      let prompts = 0
685      const promptOps: TaskPromptOps = {
686        ...stubOps(),
687        prompt: (input) => {
688          if (input.sessionID === chat.id) {
689            injected.resolve(input)
690            return Effect.succeed(reply(input, "done"))
691          }
692          prompts++
693          if (prompts === 1) return Effect.promise(() => first.promise).pipe(Effect.as(reply(input, "first done")))
694          updated.resolve(input)
695          return Effect.promise(() => second.promise).pipe(Effect.as(reply(input, "second done")))
696        },
697      }
698      const context = {
699        sessionID: chat.id,
700        messageID: assistant.id,
701        agent: "build",
702        abort: new AbortController().signal,
703        extra: { promptOps },
704        messages: [],
705        metadata: () => Effect.void,
706        ask: () => Effect.void,
707      }
708 
709      const started = yield* def.execute(
710        {
711          description: "inspect bug",
712          prompt: "look into the cache key path",
713          subagent_type: "general",
714          background: true,
715        },
716        context,
717      )
718      const result = yield* def.execute(
719        {
720          description: "add investigation scope",
721          prompt: "also inspect cancellation",
722          subagent_type: "general",
723          task_id: started.metadata.sessionId,
724        },
725        context,
726      )
727 
728      expect(result.metadata.sessionId).toBe(started.metadata.sessionId)
729      expect(result.metadata.background).toBe(true)
730      expect(result.output).toContain("Background task updated")
731      first.resolve()
732      expect((yield* jobs.get(started.metadata.sessionId))?.status).toBe("running")
733      expect((yield* Effect.promise(() => updated.promise)).parts).toEqual([
734        { type: "text", text: "also inspect cancellation" },
735      ])
736 
737      second.resolve()
738      const waited = yield* jobs.wait({ id: started.metadata.sessionId, timeout: 1_000 })
739      expect(waited.info?.status).toBe("completed")
740      expect(waited.info?.output).toBe("second done")
741      const notification = yield* Effect.promise(() => injected.promise)
742      expect(notification.variant).toBe("xhigh")
743      expect(notification.parts[0]?.type).toBe("text")
744      if (notification.parts[0]?.type === "text") expect(notification.parts[0].text).toContain("second done")
745    }),
746  )
747 
748  background.instance("background tasks complete through the background job service", () =>
749    Effect.gen(function* () {
750      const jobs = yield* BackgroundJob.Service
751      const { chat, assistant } = yield* seed()
752      const tool = yield* TaskTool
753      const def = yield* tool.init()
754 
755      const result = yield* def.execute(
756        {
757          description: "inspect bug",
758          prompt: "look into the cache key path",
759          subagent_type: "general",
760          background: true,
761        },
762        {
763          sessionID: chat.id,
764          messageID: assistant.id,
765          agent: "build",
766          abort: new AbortController().signal,
767          extra: { promptOps: stubOps({ text: "background done" }) },
768          messages: [],
769          metadata: () => Effect.void,
770          ask: () => Effect.void,
771        },
772      )
773 
774      const waited = yield* jobs.wait({ id: result.metadata.sessionId, timeout: 1_000 })
775      expect(waited.timedOut).toBe(false)
776      expect(waited.info?.status).toBe("completed")
777      expect(waited.info?.output).toBe("background done")
778    }),
779  )
780 
781  background.instance("background task completion does not wait for the parent async prompt", () =>
782    Effect.gen(function* () {
783      const jobs = yield* BackgroundJob.Service
784      const { chat, assistant } = yield* seed()
785      const tool = yield* TaskTool
786      const def = yield* tool.init()
787 
788      const result = yield* def.execute(
789        {
790          description: "inspect bug",
791          prompt: "look into the cache key path",
792          subagent_type: "general",
793          background: true,
794        },
795        {
796          sessionID: chat.id,
797          messageID: assistant.id,
798          agent: "build",
799          abort: new AbortController().signal,
800          extra: {
801            promptOps: {
802              ...stubOps({ text: "background done" }),
803              prompt: (input) =>
804                input.sessionID === chat.id ? Effect.never : Effect.succeed(reply(input, "background done")),
805            } satisfies TaskPromptOps,
806          },
807          messages: [],
808          metadata: () => Effect.void,
809          ask: () => Effect.void,
810        },
811      )
812 
813      const waited = yield* jobs.wait({ id: result.metadata.sessionId, timeout: 1_000 })
814      expect(waited.timedOut).toBe(false)
815      expect(waited.info?.status).toBe("completed")
816    }),
817  )
818 
819  background.instance("removing the parent session cancels running background tasks", () =>
820    Effect.gen(function* () {
821      const jobs = yield* BackgroundJob.Service
822      const sessions = yield* Session.Service
823      const { chat, assistant } = yield* seed()
824      const tool = yield* TaskTool
825      const def = yield* tool.init()
826 
827      const result = yield* def.execute(
828        {
829          description: "inspect bug",
830          prompt: "look into the cache key path",
831          subagent_type: "general",
832          background: true,
833        },
834        {
835          sessionID: chat.id,
836          messageID: assistant.id,
837          agent: "build",
838          abort: new AbortController().signal,
839          extra: {
840            promptOps: {
841              ...stubOps(),
842              prompt: () => Effect.never,
843            } satisfies TaskPromptOps,
844          },
845          messages: [],
846          metadata: () => Effect.void,
847          ask: () => Effect.void,
848        },
849      )
850 
851      yield* sessions.remove(chat.id)
852      const waited = yield* jobs.wait({ id: result.metadata.sessionId, timeout: 1_000 })
853      expect(waited.timedOut).toBe(false)
854      expect(waited.info?.status).toBe("cancelled")
855    }),
856  )
857 
858  background.instance("removing the child task session cancels its running background task", () =>
859    Effect.gen(function* () {
860      const jobs = yield* BackgroundJob.Service
861      const sessions = yield* Session.Service
862      const { chat, assistant } = yield* seed()
863      const tool = yield* TaskTool
864      const def = yield* tool.init()
865 
866      const result = yield* def.execute(
867        {
868          description: "inspect bug",
869          prompt: "look into the cache key path",
870          subagent_type: "general",
871          background: true,
872        },
873        {
874          sessionID: chat.id,
875          messageID: assistant.id,
876          agent: "build",
877          abort: new AbortController().signal,
878          extra: {
879            promptOps: {
880              ...stubOps(),
881              prompt: () => Effect.never,
882            } satisfies TaskPromptOps,
883          },
884          messages: [],
885          metadata: () => Effect.void,
886          ask: () => Effect.void,
887        },
888      )
889 
890      yield* sessions.remove(result.metadata.sessionId)
891      const waited = yield* jobs.wait({ id: result.metadata.sessionId, timeout: 1_000 })
892      expect(waited.timedOut).toBe(false)
893      expect(waited.info?.status).toBe("cancelled")
894    }),
895  )
896 
897  background.instance("cancelling the parent run cancels running background tasks", () =>
898    Effect.gen(function* () {
899      const jobs = yield* BackgroundJob.Service
900      const runState = yield* SessionRunState.Service
901      const { chat, assistant } = yield* seed()
902      const tool = yield* TaskTool
903      const def = yield* tool.init()
904 
905      const result = yield* def.execute(
906        {
907          description: "inspect bug",
908          prompt: "look into the cache key path",
909          subagent_type: "general",
910          background: true,
911        },
912        {
913          sessionID: chat.id,
914          messageID: assistant.id,
915          agent: "build",
916          abort: new AbortController().signal,
917          extra: {
918            promptOps: {
919              ...stubOps(),
920              prompt: () => Effect.never,
921            } satisfies TaskPromptOps,
922          },
923          messages: [],
924          metadata: () => Effect.void,
925          ask: () => Effect.void,
926        },
927      )
928 
929      yield* runState.cancel(chat.id)
930      const waited = yield* jobs.wait({ id: result.metadata.sessionId, timeout: 1_000 })
931      expect(waited.timedOut).toBe(false)
932      expect(waited.info?.status).toBe("cancelled")
933    }),
934  )
935 
936  it.instance("cancelling a child run cancels its own pre-runner task job", () =>
937    Effect.gen(function* () {
938      const jobs = yield* BackgroundJob.Service
939      const runState = yield* SessionRunState.Service
940      const sessions = yield* Session.Service
941      const { chat } = yield* seed()
942      const child = yield* sessions.create({ parentID: chat.id, title: "child" })
943 
944      yield* jobs.start({
945        id: child.id,
946        type: "task",
947        metadata: { parentSessionId: chat.id, sessionId: child.id },
948        run: Effect.never,
949      })
950 
951      yield* runState.cancel(child.id)
952 
953      expect((yield* jobs.get(child.id))?.status).toBe("cancelled")
954    }),
955  )
956 
957  it.instance("cancelling a parent run recursively cancels descendant background tasks", () =>
958    Effect.gen(function* () {
959      const jobs = yield* BackgroundJob.Service
960      const runState = yield* SessionRunState.Service
961      const sessions = yield* Session.Service
962      const { chat } = yield* seed()
963      const child = yield* sessions.create({ parentID: chat.id, title: "child" })
964      const grandchild = yield* sessions.create({ parentID: child.id, title: "grandchild" })
965 
966      yield* jobs.start({
967        id: child.id,
968        type: "task",
969        metadata: { parentSessionId: chat.id, sessionId: child.id },
970        run: Effect.never,
971      })
972      yield* jobs.start({
973        id: grandchild.id,
974        type: "task",
975        metadata: { parentSessionId: child.id, sessionId: grandchild.id },
976        run: Effect.never,
977      })
978 
979      yield* runState.cancel(chat.id)
980 
981      expect((yield* jobs.get(child.id))?.status).toBe("cancelled")
982      expect((yield* jobs.get(grandchild.id))?.status).toBe("cancelled")
983    }),
984  )
985})
986