chore: rm models snapshot (#20929)

.github/workflows/test.yml

@@ -15,6 +15,7 @@ concurrency:
 
 permissions:
   contents: read
+  checks: write
 
 jobs:
   unit:
@@ -45,14 +46,39 @@ jobs:
           git config --global user.email "bot@opencode.ai"
           git config --global user.name "opencode"
 
+      - name: Cache Turbo
+        uses: actions/cache@v4
+        with:
+          path: node_modules/.cache/turbo
+          key: turbo-${{ runner.os }}-${{ hashFiles('turbo.json', '**/package.json') }}-${{ github.sha }}
+          restore-keys: |
+            turbo-${{ runner.os }}-${{ hashFiles('turbo.json', '**/package.json') }}-
+            turbo-${{ runner.os }}-
+
       - name: Run unit tests
-        run: bun turbo test
+        run: bun turbo test:ci
         env:
-          # Bun 1.3.11 intermittently crashes on Windows during test teardown
-          # inside the native @parcel/watcher binding. Unit CI does not rely on
-          # the live watcher backend there, so disable it for that platform.
           OPENCODE_EXPERIMENTAL_DISABLE_FILEWATCHER: ${{ runner.os == 'Windows' && 'true' || 'false' }}
 
+      - name: Publish unit reports
+        if: always()
+        uses: mikepenz/action-junit-report@v6
+        with:
+          report_paths: packages/*/.artifacts/unit/junit.xml
+          check_name: "unit results (${{ matrix.settings.name }})"
+          detailed_summary: true
+          include_time_in_summary: true
+          fail_on_failure: false
+
+      - name: Upload unit artifacts
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: unit-${{ matrix.settings.name }}-${{ github.run_attempt }}
+          if-no-files-found: ignore
+          retention-days: 7
+          path: packages/*/.artifacts/unit/junit.xml
+
   e2e:
     name: e2e (${{ matrix.settings.name }})
     strategy:

packages/app/package.json

@@ -15,6 +15,7 @@
     "build": "vite build",
     "serve": "vite preview",
     "test": "bun run test:unit",
+    "test:ci": "bun test --preload ./happydom.ts ./src --reporter=junit --reporter-outfile=.artifacts/unit/junit.xml",
     "test:unit": "bun test --preload ./happydom.ts ./src",
     "test:unit:watch": "bun test --watch --preload ./happydom.ts ./src",
     "test:e2e": "playwright test",

packages/opencode/package.json

@@ -9,6 +9,7 @@
     "prepare": "effect-language-service patch || true",
     "typecheck": "tsgo --noEmit",
     "test": "bun test --timeout 30000",
+    "test:ci": "bun test --timeout 30000 --reporter=junit --reporter-outfile=.artifacts/unit/junit.xml",
     "build": "bun run script/build.ts",
     "upgrade-opentui": "bun run script/upgrade-opentui.ts",
     "dev": "bun run --conditions=browser ./src/index.ts",

packages/opencode/src/tool/read.ts

@@ -1,5 +1,4 @@
 import z from "zod"
-import { Effect } from "effect"
 import { createReadStream } from "fs"
 import * as fs from "fs/promises"
 import * as path from "path"
@@ -19,227 +18,222 @@ const MAX_LINE_SUFFIX = `... (line truncated to ${MAX_LINE_LENGTH} chars)`
 const MAX_BYTES = 50 * 1024
 const MAX_BYTES_LABEL = `${MAX_BYTES / 1024} KB`
 
-const parameters = z.object({
-  filePath: z.string().describe("The absolute path to the file or directory to read"),
-  offset: z.coerce.number().describe("The line number to start reading from (1-indexed)").optional(),
-  limit: z.coerce.number().describe("The maximum number of lines to read (defaults to 2000)").optional(),
-})
+export const ReadTool = Tool.define("read", {
+  description: DESCRIPTION,
+  parameters: z.object({
+    filePath: z.string().describe("The absolute path to the file or directory to read"),
+    offset: z.coerce.number().describe("The line number to start reading from (1-indexed)").optional(),
+    limit: z.coerce.number().describe("The maximum number of lines to read (defaults to 2000)").optional(),
+  }),
+  async execute(params, ctx) {
+    if (params.offset !== undefined && params.offset < 1) {
+      throw new Error("offset must be greater than or equal to 1")
+    }
+    let filepath = params.filePath
+    if (!path.isAbsolute(filepath)) {
+      filepath = path.resolve(Instance.directory, filepath)
+    }
+    if (process.platform === "win32") {
+      filepath = Filesystem.normalizePath(filepath)
+    }
+    const title = path.relative(Instance.worktree, filepath)
 
-export const ReadTool = Tool.defineEffect(
-  "read",
-  Effect.succeed({
-    description: DESCRIPTION,
-    parameters,
-    async execute(params: z.infer<typeof parameters>, ctx) {
-      if (params.offset !== undefined && params.offset < 1) {
-        throw new Error("offset must be greater than or equal to 1")
-      }
-      let filepath = params.filePath
-      if (!path.isAbsolute(filepath)) {
-        filepath = path.resolve(Instance.directory, filepath)
-      }
-      if (process.platform === "win32") {
-        filepath = Filesystem.normalizePath(filepath)
-      }
-      const title = path.relative(Instance.worktree, filepath)
+    const stat = Filesystem.stat(filepath)
 
-      const stat = Filesystem.stat(filepath)
+    await assertExternalDirectory(ctx, filepath, {
+      bypass: Boolean(ctx.extra?.["bypassCwdCheck"]),
+      kind: stat?.isDirectory() ? "directory" : "file",
+    })
 
-      await assertExternalDirectory(ctx, filepath, {
-        bypass: Boolean(ctx.extra?.["bypassCwdCheck"]),
-        kind: stat?.isDirectory() ? "directory" : "file",
-      })
+    await ctx.ask({
+      permission: "read",
+      patterns: [filepath],
+      always: ["*"],
+      metadata: {},
+    })
 
-      await ctx.ask({
-        permission: "read",
-        patterns: [filepath],
-        always: ["*"],
-        metadata: {},
-      })
+    if (!stat) {
+      const dir = path.dirname(filepath)
+      const base = path.basename(filepath)
 
-      if (!stat) {
-        const dir = path.dirname(filepath)
-        const base = path.basename(filepath)
-
-        const suggestions = await fs
-          .readdir(dir)
-          .then((entries) =>
-            entries
-              .filter(
-                (entry) =>
-                  entry.toLowerCase().includes(base.toLowerCase()) || base.toLowerCase().includes(entry.toLowerCase()),
-              )
-              .map((entry) => path.join(dir, entry))
-              .slice(0, 3),
-          )
-          .catch(() => [])
-
-        if (suggestions.length > 0) {
-          throw new Error(`File not found: ${filepath}\n\nDid you mean one of these?\n${suggestions.join("\n")}`)
-        }
-
-        throw new Error(`File not found: ${filepath}`)
-      }
-
-      if (stat.isDirectory()) {
-        const dirents = await fs.readdir(filepath, { withFileTypes: true })
-        const entries = await Promise.all(
-          dirents.map(async (dirent) => {
-            if (dirent.isDirectory()) return dirent.name + "/"
-            if (dirent.isSymbolicLink()) {
-              const target = await fs.stat(path.join(filepath, dirent.name)).catch(() => undefined)
-              if (target?.isDirectory()) return dirent.name + "/"
-            }
-            return dirent.name
-          }),
+      const suggestions = await fs
+        .readdir(dir)
+        .then((entries) =>
+          entries
+            .filter(
+              (entry) =>
+                entry.toLowerCase().includes(base.toLowerCase()) || base.toLowerCase().includes(entry.toLowerCase()),
+            )
+            .map((entry) => path.join(dir, entry))
+            .slice(0, 3),
         )
-        entries.sort((a, b) => a.localeCompare(b))
+        .catch(() => [])
 
-        const limit = params.limit ?? DEFAULT_READ_LIMIT
-        const offset = params.offset ?? 1
-        const start = offset - 1
-        const sliced = entries.slice(start, start + limit)
-        const truncated = start + sliced.length < entries.length
-
-        const output = [
-          `<path>${filepath}</path>`,
-          `<type>directory</type>`,
-          `<entries>`,
-          sliced.join("\n"),
-          truncated
-            ? `\n(Showing ${sliced.length} of ${entries.length} entries. Use 'offset' parameter to read beyond entry ${offset + sliced.length})`
-            : `\n(${entries.length} entries)`,
-          `</entries>`,
-        ].join("\n")
-
-        return {
-          title,
-          output,
-          metadata: {
-            preview: sliced.slice(0, 20).join("\n"),
-            truncated,
-            loaded: [] as string[],
-          },
-        }
+      if (suggestions.length > 0) {
+        throw new Error(`File not found: ${filepath}\n\nDid you mean one of these?\n${suggestions.join("\n")}`)
       }
 
-      const instructions = await Instruction.resolve(ctx.messages, filepath, ctx.messageID)
+      throw new Error(`File not found: ${filepath}`)
+    }
 
-      // Exclude SVG (XML-based) and vnd.fastbidsheet (.fbs extension, commonly FlatBuffers schema files)
-      const mime = Filesystem.mimeType(filepath)
-      const isImage = mime.startsWith("image/") && mime !== "image/svg+xml" && mime !== "image/vnd.fastbidsheet"
-      const isPdf = mime === "application/pdf"
-      if (isImage || isPdf) {
-        const msg = `${isImage ? "Image" : "PDF"} read successfully`
-        return {
-          title,
-          output: msg,
-          metadata: {
-            preview: msg,
-            truncated: false,
-            loaded: instructions.map((i) => i.filepath),
-          },
-          attachments: [
-            {
-              type: "file",
-              mime,
-              url: `data:${mime};base64,${Buffer.from(await Filesystem.readBytes(filepath)).toString("base64")}`,
-            },
-          ],
-        }
-      }
-
-      const isBinary = await isBinaryFile(filepath, Number(stat.size))
-      if (isBinary) throw new Error(`Cannot read binary file: ${filepath}`)
-
-      const stream = createReadStream(filepath, { encoding: "utf8" })
-      const rl = createInterface({
-        input: stream,
-        // Note: we use the crlfDelay option to recognize all instances of CR LF
-        // ('\r\n') in file as a single line break.
-        crlfDelay: Infinity,
-      })
+    if (stat.isDirectory()) {
+      const dirents = await fs.readdir(filepath, { withFileTypes: true })
+      const entries = await Promise.all(
+        dirents.map(async (dirent) => {
+          if (dirent.isDirectory()) return dirent.name + "/"
+          if (dirent.isSymbolicLink()) {
+            const target = await fs.stat(path.join(filepath, dirent.name)).catch(() => undefined)
+            if (target?.isDirectory()) return dirent.name + "/"
+          }
+          return dirent.name
+        }),
+      )
+      entries.sort((a, b) => a.localeCompare(b))
 
       const limit = params.limit ?? DEFAULT_READ_LIMIT
       const offset = params.offset ?? 1
       const start = offset - 1
-      const raw: string[] = []
-      let bytes = 0
-      let lines = 0
-      let truncatedByBytes = false
-      let hasMoreLines = false
-      try {
-        for await (const text of rl) {
-          lines += 1
-          if (lines <= start) continue
+      const sliced = entries.slice(start, start + limit)
+      const truncated = start + sliced.length < entries.length
 
-          if (raw.length >= limit) {
-            hasMoreLines = true
-            continue
-          }
-
-          const line = text.length > MAX_LINE_LENGTH ? text.substring(0, MAX_LINE_LENGTH) + MAX_LINE_SUFFIX : text
-          const size = Buffer.byteLength(line, "utf-8") + (raw.length > 0 ? 1 : 0)
-          if (bytes + size > MAX_BYTES) {
-            truncatedByBytes = true
-            hasMoreLines = true
-            break
-          }
-
-          raw.push(line)
-          bytes += size
-        }
-      } finally {
-        rl.close()
-        stream.destroy()
-      }
-
-      if (lines < offset && !(lines === 0 && offset === 1)) {
-        throw new Error(`Offset ${offset} is out of range for this file (${lines} lines)`)
-      }
-
-      const content = raw.map((line, index) => {
-        return `${index + offset}: ${line}`
-      })
-      const preview = raw.slice(0, 20).join("\n")
-
-      let output = [`<path>${filepath}</path>`, `<type>file</type>`, "<content>"].join("\n")
-      output += content.join("\n")
-
-      const totalLines = lines
-      const lastReadLine = offset + raw.length - 1
-      const nextOffset = lastReadLine + 1
-      const truncated = hasMoreLines || truncatedByBytes
-
-      if (truncatedByBytes) {
-        output += `\n\n(Output capped at ${MAX_BYTES_LABEL}. Showing lines ${offset}-${lastReadLine}. Use offset=${nextOffset} to continue.)`
-      } else if (hasMoreLines) {
-        output += `\n\n(Showing lines ${offset}-${lastReadLine} of ${totalLines}. Use offset=${nextOffset} to continue.)`
-      } else {
-        output += `\n\n(End of file - total ${totalLines} lines)`
-      }
-      output += "\n</content>"
-
-      // just warms the lsp client
-      await LSP.touchFile(filepath, false)
-      await FileTime.read(ctx.sessionID, filepath)
-
-      if (instructions.length > 0) {
-        output += `\n\n<system-reminder>\n${instructions.map((i) => i.content).join("\n\n")}\n</system-reminder>`
-      }
+      const output = [
+        `<path>${filepath}</path>`,
+        `<type>directory</type>`,
+        `<entries>`,
+        sliced.join("\n"),
+        truncated
+          ? `\n(Showing ${sliced.length} of ${entries.length} entries. Use 'offset' parameter to read beyond entry ${offset + sliced.length})`
+          : `\n(${entries.length} entries)`,
+        `</entries>`,
+      ].join("\n")
 
       return {
         title,
         output,
         metadata: {
-          preview,
+          preview: sliced.slice(0, 20).join("\n"),
           truncated,
-          loaded: instructions.map((i) => i.filepath),
+          loaded: [] as string[],
         },
       }
-    },
-  }),
-)
+    }
+
+    const instructions = await Instruction.resolve(ctx.messages, filepath, ctx.messageID)
+
+    // Exclude SVG (XML-based) and vnd.fastbidsheet (.fbs extension, commonly FlatBuffers schema files)
+    const mime = Filesystem.mimeType(filepath)
+    const isImage = mime.startsWith("image/") && mime !== "image/svg+xml" && mime !== "image/vnd.fastbidsheet"
+    const isPdf = mime === "application/pdf"
+    if (isImage || isPdf) {
+      const msg = `${isImage ? "Image" : "PDF"} read successfully`
+      return {
+        title,
+        output: msg,
+        metadata: {
+          preview: msg,
+          truncated: false,
+          loaded: instructions.map((i) => i.filepath),
+        },
+        attachments: [
+          {
+            type: "file",
+            mime,
+            url: `data:${mime};base64,${Buffer.from(await Filesystem.readBytes(filepath)).toString("base64")}`,
+          },
+        ],
+      }
+    }
+
+    const isBinary = await isBinaryFile(filepath, Number(stat.size))
+    if (isBinary) throw new Error(`Cannot read binary file: ${filepath}`)
+
+    const stream = createReadStream(filepath, { encoding: "utf8" })
+    const rl = createInterface({
+      input: stream,
+      // Note: we use the crlfDelay option to recognize all instances of CR LF
+      // ('\r\n') in file as a single line break.
+      crlfDelay: Infinity,
+    })
+
+    const limit = params.limit ?? DEFAULT_READ_LIMIT
+    const offset = params.offset ?? 1
+    const start = offset - 1
+    const raw: string[] = []
+    let bytes = 0
+    let lines = 0
+    let truncatedByBytes = false
+    let hasMoreLines = false
+    try {
+      for await (const text of rl) {
+        lines += 1
+        if (lines <= start) continue
+
+        if (raw.length >= limit) {
+          hasMoreLines = true
+          continue
+        }
+
+        const line = text.length > MAX_LINE_LENGTH ? text.substring(0, MAX_LINE_LENGTH) + MAX_LINE_SUFFIX : text
+        const size = Buffer.byteLength(line, "utf-8") + (raw.length > 0 ? 1 : 0)
+        if (bytes + size > MAX_BYTES) {
+          truncatedByBytes = true
+          hasMoreLines = true
+          break
+        }
+
+        raw.push(line)
+        bytes += size
+      }
+    } finally {
+      rl.close()
+      stream.destroy()
+    }
+
+    if (lines < offset && !(lines === 0 && offset === 1)) {
+      throw new Error(`Offset ${offset} is out of range for this file (${lines} lines)`)
+    }
+
+    const content = raw.map((line, index) => {
+      return `${index + offset}: ${line}`
+    })
+    const preview = raw.slice(0, 20).join("\n")
+
+    let output = [`<path>${filepath}</path>`, `<type>file</type>`, "<content>"].join("\n")
+    output += content.join("\n")
+
+    const totalLines = lines
+    const lastReadLine = offset + raw.length - 1
+    const nextOffset = lastReadLine + 1
+    const truncated = hasMoreLines || truncatedByBytes
+
+    if (truncatedByBytes) {
+      output += `\n\n(Output capped at ${MAX_BYTES_LABEL}. Showing lines ${offset}-${lastReadLine}. Use offset=${nextOffset} to continue.)`
+    } else if (hasMoreLines) {
+      output += `\n\n(Showing lines ${offset}-${lastReadLine} of ${totalLines}. Use offset=${nextOffset} to continue.)`
+    } else {
+      output += `\n\n(End of file - total ${totalLines} lines)`
+    }
+    output += "\n</content>"
+
+    // just warms the lsp client
+    LSP.touchFile(filepath, false)
+    await FileTime.read(ctx.sessionID, filepath)
+
+    if (instructions.length > 0) {
+      output += `\n\n<system-reminder>\n${instructions.map((i) => i.content).join("\n\n")}\n</system-reminder>`
+    }
+
+    return {
+      title,
+      output,
+      metadata: {
+        preview,
+        truncated,
+        loaded: instructions.map((i) => i.filepath),
+      },
+    }
+  },
+})
 
 async function isBinaryFile(filepath: string, fileSize: number): Promise<boolean> {
   const ext = path.extname(filepath).toLowerCase()

packages/opencode/src/tool/registry.ts

@@ -33,7 +33,6 @@ import { Effect, Layer, ServiceMap } from "effect"
 import { InstanceState } from "@/effect/instance-state"
 import { makeRuntime } from "@/effect/run-service"
 import { Env } from "../env"
-import { Agent as AgentSvc } from "../agent/agent"
 import { Question } from "../question"
 import { Todo } from "../session/todo"
 
@@ -58,176 +57,173 @@ export namespace ToolRegistry {
 
   export class Service extends ServiceMap.Service<Service, Interface>()("@opencode/ToolRegistry") {}
 
-  export const layer: Layer.Layer<
-    Service,
-    never,
-    Config.Service | Plugin.Service | Question.Service | Todo.Service | AgentSvc.Service
-  > = Layer.effect(
-    Service,
-    Effect.gen(function* () {
-      const config = yield* Config.Service
-      const plugin = yield* Plugin.Service
+  export const layer: Layer.Layer<Service, never, Config.Service | Plugin.Service | Question.Service | Todo.Service> =
+    Layer.effect(
+      Service,
+      Effect.gen(function* () {
+        const config = yield* Config.Service
+        const plugin = yield* Plugin.Service
 
-      const build = <T extends Tool.Info>(tool: T | Effect.Effect<T, never, any>) =>
-        Effect.isEffect(tool) ? tool : Effect.succeed(tool)
+        const build = <T extends Tool.Info>(tool: T | Effect.Effect<T, never, any>) =>
+          Effect.isEffect(tool) ? tool : Effect.succeed(tool)
 
-      const state = yield* InstanceState.make<State>(
-        Effect.fn("ToolRegistry.state")(function* (ctx) {
-          const custom: Tool.Info[] = []
+        const state = yield* InstanceState.make<State>(
+          Effect.fn("ToolRegistry.state")(function* (ctx) {
+            const custom: Tool.Info[] = []
 
-          function fromPlugin(id: string, def: ToolDefinition): Tool.Info {
-            return {
-              id,
-              init: async (initCtx) => ({
-                parameters: z.object(def.args),
-                description: def.description,
-                execute: async (args, toolCtx) => {
-                  const pluginCtx = {
-                    ...toolCtx,
-                    directory: ctx.directory,
-                    worktree: ctx.worktree,
-                  } as unknown as PluginToolContext
-                  const result = await def.execute(args as any, pluginCtx)
-                  const out = await Truncate.output(result, {}, initCtx?.agent)
-                  return {
-                    title: "",
-                    output: out.truncated ? out.content : result,
-                    metadata: { truncated: out.truncated, outputPath: out.truncated ? out.outputPath : undefined },
-                  }
-                },
-              }),
+            function fromPlugin(id: string, def: ToolDefinition): Tool.Info {
+              return {
+                id,
+                init: async (initCtx) => ({
+                  parameters: z.object(def.args),
+                  description: def.description,
+                  execute: async (args, toolCtx) => {
+                    const pluginCtx = {
+                      ...toolCtx,
+                      directory: ctx.directory,
+                      worktree: ctx.worktree,
+                    } as unknown as PluginToolContext
+                    const result = await def.execute(args as any, pluginCtx)
+                    const out = await Truncate.output(result, {}, initCtx?.agent)
+                    return {
+                      title: "",
+                      output: out.truncated ? out.content : result,
+                      metadata: { truncated: out.truncated, outputPath: out.truncated ? out.outputPath : undefined },
+                    }
+                  },
+                }),
+              }
             }
-          }
 
-          const dirs = yield* config.directories()
-          const matches = dirs.flatMap((dir) =>
-            Glob.scanSync("{tool,tools}/*.{js,ts}", { cwd: dir, absolute: true, dot: true, symlink: true }),
-          )
-          if (matches.length) yield* config.waitForDependencies()
-          for (const match of matches) {
-            const namespace = path.basename(match, path.extname(match))
-            const mod = yield* Effect.promise(
-              () => import(process.platform === "win32" ? match : pathToFileURL(match).href),
+            const dirs = yield* config.directories()
+            const matches = dirs.flatMap((dir) =>
+              Glob.scanSync("{tool,tools}/*.{js,ts}", { cwd: dir, absolute: true, dot: true, symlink: true }),
             )
-            for (const [id, def] of Object.entries<ToolDefinition>(mod)) {
-              custom.push(fromPlugin(id === "default" ? namespace : `${namespace}_${id}`, def))
+            if (matches.length) yield* config.waitForDependencies()
+            for (const match of matches) {
+              const namespace = path.basename(match, path.extname(match))
+              const mod = yield* Effect.promise(
+                () => import(process.platform === "win32" ? match : pathToFileURL(match).href),
+              )
+              for (const [id, def] of Object.entries<ToolDefinition>(mod)) {
+                custom.push(fromPlugin(id === "default" ? namespace : `${namespace}_${id}`, def))
+              }
             }
-          }
 
-          const plugins = yield* plugin.list()
-          for (const p of plugins) {
-            for (const [id, def] of Object.entries(p.tool ?? {})) {
-              custom.push(fromPlugin(id, def))
+            const plugins = yield* plugin.list()
+            for (const p of plugins) {
+              for (const [id, def] of Object.entries(p.tool ?? {})) {
+                custom.push(fromPlugin(id, def))
+              }
             }
-          }
 
-          return { custom }
-        }),
-      )
-
-      const invalid = yield* build(InvalidTool)
-      const ask = yield* build(QuestionTool)
-      const bash = yield* build(BashTool)
-      const read = yield* build(ReadTool)
-      const glob = yield* build(GlobTool)
-      const grep = yield* build(GrepTool)
-      const edit = yield* build(EditTool)
-      const write = yield* build(WriteTool)
-      const task = yield* build(TaskTool)
-      const fetch = yield* build(WebFetchTool)
-      const todo = yield* build(TodoWriteTool)
-      const search = yield* build(WebSearchTool)
-      const code = yield* build(CodeSearchTool)
-      const skill = yield* build(SkillTool)
-      const patch = yield* build(ApplyPatchTool)
-      const lsp = yield* build(LspTool)
-      const batch = yield* build(BatchTool)
-      const plan = yield* build(PlanExitTool)
-
-      const all = Effect.fn("ToolRegistry.all")(function* (custom: Tool.Info[]) {
-        const cfg = yield* config.get()
-        const question = ["app", "cli", "desktop"].includes(Flag.OPENCODE_CLIENT) || Flag.OPENCODE_ENABLE_QUESTION_TOOL
-
-        return [
-          invalid,
-          ...(question ? [ask] : []),
-          bash,
-          read,
-          glob,
-          grep,
-          edit,
-          write,
-          task,
-          fetch,
-          todo,
-          search,
-          code,
-          skill,
-          patch,
-          ...(Flag.OPENCODE_EXPERIMENTAL_LSP_TOOL ? [lsp] : []),
-          ...(cfg.experimental?.batch_tool === true ? [batch] : []),
-          ...(Flag.OPENCODE_EXPERIMENTAL_PLAN_MODE && Flag.OPENCODE_CLIENT === "cli" ? [plan] : []),
-          ...custom,
-        ]
-      })
-
-      const ids = Effect.fn("ToolRegistry.ids")(function* () {
-        const s = yield* InstanceState.get(state)
-        const tools = yield* all(s.custom)
-        return tools.map((t) => t.id)
-      })
-
-      const tools = Effect.fn("ToolRegistry.tools")(function* (
-        model: { providerID: ProviderID; modelID: ModelID },
-        agent?: Agent.Info,
-      ) {
-        const s = yield* InstanceState.get(state)
-        const allTools = yield* all(s.custom)
-        const filtered = allTools.filter((tool) => {
-          if (tool.id === "codesearch" || tool.id === "websearch") {
-            return model.providerID === ProviderID.opencode || Flag.OPENCODE_ENABLE_EXA
-          }
-
-          const usePatch =
-            !!Env.get("OPENCODE_E2E_LLM_URL") ||
-            (model.modelID.includes("gpt-") && !model.modelID.includes("oss") && !model.modelID.includes("gpt-4"))
-          if (tool.id === "apply_patch") return usePatch
-          if (tool.id === "edit" || tool.id === "write") return !usePatch
-
-          return true
-        })
-        return yield* Effect.forEach(
-          filtered,
-          Effect.fnUntraced(function* (tool: Tool.Info) {
-            using _ = log.time(tool.id)
-            const next = yield* Effect.promise(() => tool.init({ agent }))
-            const output = {
-              description: next.description,
-              parameters: next.parameters,
-            }
-            yield* plugin.trigger("tool.definition", { toolID: tool.id }, output)
-            return {
-              id: tool.id,
-              description: output.description,
-              parameters: output.parameters,
-              execute: next.execute,
-              formatValidationError: next.formatValidationError,
-            }
+            return { custom }
           }),
-          { concurrency: "unbounded" },
         )
-      })
 
-      return Service.of({ ids, named: { task, read }, tools })
-    }),
-  )
+        const invalid = yield* build(InvalidTool)
+        const ask = yield* build(QuestionTool)
+        const bash = yield* build(BashTool)
+        const read = yield* build(ReadTool)
+        const glob = yield* build(GlobTool)
+        const grep = yield* build(GrepTool)
+        const edit = yield* build(EditTool)
+        const write = yield* build(WriteTool)
+        const task = yield* build(TaskTool)
+        const fetch = yield* build(WebFetchTool)
+        const todo = yield* build(TodoWriteTool)
+        const search = yield* build(WebSearchTool)
+        const code = yield* build(CodeSearchTool)
+        const skill = yield* build(SkillTool)
+        const patch = yield* build(ApplyPatchTool)
+        const lsp = yield* build(LspTool)
+        const batch = yield* build(BatchTool)
+        const plan = yield* build(PlanExitTool)
+
+        const all = Effect.fn("ToolRegistry.all")(function* (custom: Tool.Info[]) {
+          const cfg = yield* config.get()
+          const question =
+            ["app", "cli", "desktop"].includes(Flag.OPENCODE_CLIENT) || Flag.OPENCODE_ENABLE_QUESTION_TOOL
+
+          return [
+            invalid,
+            ...(question ? [ask] : []),
+            bash,
+            read,
+            glob,
+            grep,
+            edit,
+            write,
+            task,
+            fetch,
+            todo,
+            search,
+            code,
+            skill,
+            patch,
+            ...(Flag.OPENCODE_EXPERIMENTAL_LSP_TOOL ? [lsp] : []),
+            ...(cfg.experimental?.batch_tool === true ? [batch] : []),
+            ...(Flag.OPENCODE_EXPERIMENTAL_PLAN_MODE && Flag.OPENCODE_CLIENT === "cli" ? [plan] : []),
+            ...custom,
+          ]
+        })
+
+        const ids = Effect.fn("ToolRegistry.ids")(function* () {
+          const s = yield* InstanceState.get(state)
+          const tools = yield* all(s.custom)
+          return tools.map((t) => t.id)
+        })
+
+        const tools = Effect.fn("ToolRegistry.tools")(function* (
+          model: { providerID: ProviderID; modelID: ModelID },
+          agent?: Agent.Info,
+        ) {
+          const s = yield* InstanceState.get(state)
+          const allTools = yield* all(s.custom)
+          const filtered = allTools.filter((tool) => {
+            if (tool.id === "codesearch" || tool.id === "websearch") {
+              return model.providerID === ProviderID.opencode || Flag.OPENCODE_ENABLE_EXA
+            }
+
+            const usePatch =
+              !!Env.get("OPENCODE_E2E_LLM_URL") ||
+              (model.modelID.includes("gpt-") && !model.modelID.includes("oss") && !model.modelID.includes("gpt-4"))
+            if (tool.id === "apply_patch") return usePatch
+            if (tool.id === "edit" || tool.id === "write") return !usePatch
+
+            return true
+          })
+          return yield* Effect.forEach(
+            filtered,
+            Effect.fnUntraced(function* (tool: Tool.Info) {
+              using _ = log.time(tool.id)
+              const next = yield* Effect.promise(() => tool.init({ agent }))
+              const output = {
+                description: next.description,
+                parameters: next.parameters,
+              }
+              yield* plugin.trigger("tool.definition", { toolID: tool.id }, output)
+              return {
+                id: tool.id,
+                description: output.description,
+                parameters: output.parameters,
+                execute: next.execute,
+                formatValidationError: next.formatValidationError,
+              }
+            }),
+            { concurrency: "unbounded" },
+          )
+        })
+
+        return Service.of({ ids, named: { task, read }, tools })
+      }),
+    )
 
   export const defaultLayer = Layer.unwrap(
     Effect.sync(() =>
       layer.pipe(
         Layer.provide(Config.defaultLayer),
         Layer.provide(Plugin.defaultLayer),
-        Layer.provide(AgentSvc.defaultLayer),
         Layer.provide(Question.defaultLayer),
         Layer.provide(Todo.defaultLayer),
       ),

packages/opencode/src/tool/task.ts

@@ -1,7 +1,6 @@
 import { Tool } from "./tool"
 import DESCRIPTION from "./task.txt"
 import z from "zod"
-import { Effect } from "effect"
 import { Session } from "../session"
 import { SessionID, MessageID } from "../session/schema"
 import { MessageV2 } from "../session/message-v2"
@@ -26,156 +25,142 @@ const parameters = z.object({
   command: z.string().describe("The command that triggered this task").optional(),
 })
 
-export const TaskTool = Tool.defineEffect(
-  "task",
-  Effect.gen(function* () {
-    const agent = yield* Agent.Service
-    const config = yield* Config.Service
+export const TaskTool = Tool.define("task", async (ctx) => {
+  const agents = await Agent.list().then((x) => x.filter((a) => a.mode !== "primary"))
 
-    return async (ctx) => {
-      const agents = await agent.list().pipe(
-        Effect.map((x) => x.filter((a) => a.mode !== "primary")),
-        Effect.runPromise,
-      )
+  // Filter agents by permissions if agent provided
+  const caller = ctx?.agent
+  const accessibleAgents = caller
+    ? agents.filter((a) => Permission.evaluate("task", a.name, caller.permission).action !== "deny")
+    : agents
+  const list = accessibleAgents.toSorted((a, b) => a.name.localeCompare(b.name))
 
-      const caller = ctx?.agent
-      const accessibleAgents = caller
-        ? agents.filter((a) => Permission.evaluate("task", a.name, caller.permission).action !== "deny")
-        : agents
-      const list = accessibleAgents.toSorted((a, b) => a.name.localeCompare(b.name))
+  const description = DESCRIPTION.replace(
+    "{agents}",
+    list
+      .map((a) => `- ${a.name}: ${a.description ?? "This subagent should only be called manually by the user."}`)
+      .join("\n"),
+  )
+  return {
+    description,
+    parameters,
+    async execute(params: z.infer<typeof parameters>, ctx) {
+      const config = await Config.get()
 
-      const description = DESCRIPTION.replace(
-        "{agents}",
-        list
-          .map((a) => `- ${a.name}: ${a.description ?? "This subagent should only be called manually by the user."}`)
-          .join("\n"),
-      )
+      // Skip permission check when user explicitly invoked via @ or command subtask
+      if (!ctx.extra?.bypassAgentCheck) {
+        await ctx.ask({
+          permission: "task",
+          patterns: [params.subagent_type],
+          always: ["*"],
+          metadata: {
+            description: params.description,
+            subagent_type: params.subagent_type,
+          },
+        })
+      }
+
+      const agent = await Agent.get(params.subagent_type)
+      if (!agent) throw new Error(`Unknown agent type: ${params.subagent_type} is not a valid agent type`)
+
+      const hasTaskPermission = agent.permission.some((rule) => rule.permission === "task")
+      const hasTodoWritePermission = agent.permission.some((rule) => rule.permission === "todowrite")
+
+      const session = await iife(async () => {
+        if (params.task_id) {
+          const found = await Session.get(SessionID.make(params.task_id)).catch(() => {})
+          if (found) return found
+        }
+
+        return await Session.create({
+          parentID: ctx.sessionID,
+          title: params.description + ` (@${agent.name} subagent)`,
+          permission: [
+            ...(hasTodoWritePermission
+              ? []
+              : [
+                  {
+                    permission: "todowrite" as const,
+                    pattern: "*" as const,
+                    action: "deny" as const,
+                  },
+                ]),
+            ...(hasTaskPermission
+              ? []
+              : [
+                  {
+                    permission: "task" as const,
+                    pattern: "*" as const,
+                    action: "deny" as const,
+                  },
+                ]),
+            ...(config.experimental?.primary_tools?.map((t) => ({
+              pattern: "*",
+              action: "allow" as const,
+              permission: t,
+            })) ?? []),
+          ],
+        })
+      })
+      const msg = await MessageV2.get({ sessionID: ctx.sessionID, messageID: ctx.messageID })
+      if (msg.info.role !== "assistant") throw new Error("Not an assistant message")
+
+      const model = agent.model ?? {
+        modelID: msg.info.modelID,
+        providerID: msg.info.providerID,
+      }
+
+      ctx.metadata({
+        title: params.description,
+        metadata: {
+          sessionId: session.id,
+          model,
+        },
+      })
+
+      const messageID = MessageID.ascending()
+
+      function cancel() {
+        SessionPrompt.cancel(session.id)
+      }
+      ctx.abort.addEventListener("abort", cancel)
+      using _ = defer(() => ctx.abort.removeEventListener("abort", cancel))
+      const promptParts = await SessionPrompt.resolvePromptParts(params.prompt)
+
+      const result = await SessionPrompt.prompt({
+        messageID,
+        sessionID: session.id,
+        model: {
+          modelID: model.modelID,
+          providerID: model.providerID,
+        },
+        agent: agent.name,
+        tools: {
+          ...(hasTodoWritePermission ? {} : { todowrite: false }),
+          ...(hasTaskPermission ? {} : { task: false }),
+          ...Object.fromEntries((config.experimental?.primary_tools ?? []).map((t) => [t, false])),
+        },
+        parts: promptParts,
+      })
+
+      const text = result.parts.findLast((x) => x.type === "text")?.text ?? ""
+
+      const output = [
+        `task_id: ${session.id} (for resuming to continue this task if needed)`,
+        "",
+        "<task_result>",
+        text,
+        "</task_result>",
+      ].join("\n")
 
       return {
-        description,
-        parameters,
-        async execute(params: z.infer<typeof parameters>, ctx) {
-          const cfg = await config.get().pipe(Effect.runPromise)
-
-          // Skip permission check when user explicitly invoked via @ or command subtask
-          if (!ctx.extra?.bypassAgentCheck) {
-            await ctx.ask({
-              permission: "task",
-              patterns: [params.subagent_type],
-              always: ["*"],
-              metadata: {
-                description: params.description,
-                subagent_type: params.subagent_type,
-              },
-            })
-          }
-
-          const next = await agent
-            .get(params.subagent_type)
-            .pipe(Effect.runPromise)
-            .catch(() => undefined)
-          if (!next) throw new Error(`Unknown agent type: ${params.subagent_type} is not a valid agent type`)
-
-          const hasTaskPermission = next.permission.some((rule) => rule.permission === "task")
-          const hasTodoWritePermission = next.permission.some((rule) => rule.permission === "todowrite")
-
-          const session = await iife(async () => {
-            if (params.task_id) {
-              const found = await Session.get(SessionID.make(params.task_id)).catch(() => {})
-              if (found) return found
-            }
-
-            return await Session.create({
-              parentID: ctx.sessionID,
-              title: params.description + ` (@${next.name} subagent)`,
-              permission: [
-                ...(hasTodoWritePermission
-                  ? []
-                  : [
-                      {
-                        permission: "todowrite" as const,
-                        pattern: "*" as const,
-                        action: "deny" as const,
-                      },
-                    ]),
-                ...(hasTaskPermission
-                  ? []
-                  : [
-                      {
-                        permission: "task" as const,
-                        pattern: "*" as const,
-                        action: "deny" as const,
-                      },
-                    ]),
-                ...(cfg.experimental?.primary_tools?.map((t) => ({
-                  pattern: "*",
-                  action: "allow" as const,
-                  permission: t,
-                })) ?? []),
-              ],
-            })
-          })
-          const msg = await MessageV2.get({ sessionID: ctx.sessionID, messageID: ctx.messageID })
-          if (msg.info.role !== "assistant") throw new Error("Not an assistant message")
-
-          const model = next.model ?? {
-            modelID: msg.info.modelID,
-            providerID: msg.info.providerID,
-          }
-
-          ctx.metadata({
-            title: params.description,
-            metadata: {
-              sessionId: session.id,
-              model,
-            },
-          })
-
-          const messageID = MessageID.ascending()
-
-          function cancel() {
-            SessionPrompt.cancel(session.id)
-          }
-          ctx.abort.addEventListener("abort", cancel)
-          using _ = defer(() => ctx.abort.removeEventListener("abort", cancel))
-          const promptParts = await SessionPrompt.resolvePromptParts(params.prompt)
-
-          const result = await SessionPrompt.prompt({
-            messageID,
-            sessionID: session.id,
-            model: {
-              modelID: model.modelID,
-              providerID: model.providerID,
-            },
-            agent: next.name,
-            tools: {
-              ...(hasTodoWritePermission ? {} : { todowrite: false }),
-              ...(hasTaskPermission ? {} : { task: false }),
-              ...Object.fromEntries((cfg.experimental?.primary_tools ?? []).map((t) => [t, false])),
-            },
-            parts: promptParts,
-          })
-
-          const text = result.parts.findLast((x) => x.type === "text")?.text ?? ""
-
-          const output = [
-            `task_id: ${session.id} (for resuming to continue this task if needed)`,
-            "",
-            "<task_result>",
-            text,
-            "</task_result>",
-          ].join("\n")
-
-          return {
-            title: params.description,
-            metadata: {
-              sessionId: session.id,
-              model,
-            },
-            output,
-          }
+        title: params.description,
+        metadata: {
+          sessionId: session.id,
+          model,
         },
+        output,
       }
-    }
-  }),
-)
+    },
+  }
+})

packages/opencode/test/session/prompt-effect.test.ts

@@ -29,6 +29,7 @@ import { MessageID, PartID, SessionID } from "../../src/session/schema"
 import { SessionStatus } from "../../src/session/status"
 import { Shell } from "../../src/shell/shell"
 import { Snapshot } from "../../src/snapshot"
+import { TaskTool } from "../../src/tool/task"
 import { ToolRegistry } from "../../src/tool/registry"
 import { Truncate } from "../../src/tool/truncate"
 import { Log } from "../../src/util/log"
@@ -630,9 +631,7 @@ it.live(
         Effect.gen(function* () {
           const ready = defer<void>()
           const aborted = defer<void>()
-          const registry = yield* ToolRegistry.Service
-          const init = registry.named.task.init
-          registry.named.task.init = async () => ({
+          const init = spyOn(TaskTool, "init").mockImplementation(async () => ({
             description: "task",
             parameters: z.object({
               description: z.string(),
@@ -654,8 +653,8 @@ it.live(
                 output: "",
               }
             },
-          })
-          yield* Effect.addFinalizer(() => Effect.sync(() => void (registry.named.task.init = init)))
+          }))
+          yield* Effect.addFinalizer(() => Effect.sync(() => init.mockRestore()))
 
           const { prompt, chat } = yield* boot()
           const msg = yield* user(chat.id, "hello")

packages/opencode/test/tool/read.test.ts

@@ -1,9 +1,7 @@
 import { afterEach, describe, expect, test } from "bun:test"
-import { Effect } from "effect"
 import path from "path"
+import { ReadTool } from "../../src/tool/read"
 import { Instance } from "../../src/project/instance"
-import { ReadTool as ReadToolFx } from "../../src/tool/read"
-import { Tool } from "../../src/tool/tool"
 import { Filesystem } from "../../src/util/filesystem"
 import { tmpdir } from "../fixture/fixture"
 import { Permission } from "../../src/permission"
@@ -27,18 +25,6 @@ const ctx = {
   ask: async () => {},
 }
 
-const ReadTool = {
-  init: async () => ({
-    execute: (args: Tool.InferParameters<typeof ReadToolFx>, ctx: Tool.Context) =>
-      Effect.runPromise(
-        ReadToolFx.pipe(
-          Effect.flatMap((tool) => Effect.promise(() => tool.init())),
-          Effect.flatMap((tool) => Effect.promise(() => tool.execute(args, ctx))),
-        ),
-      ),
-  }),
-}
-
 const full = (p: string) => (process.platform === "win32" ? Filesystem.normalizePath(p) : p)
 const glob = (p: string) =>
   process.platform === "win32" ? Filesystem.normalizePathPattern(p) : p.replaceAll("\\", "/")

packages/opencode/test/tool/task.test.ts

@@ -1,56 +1,49 @@
-import { afterEach, describe, expect } from "bun:test"
-import { Effect, Layer } from "effect"
+import { afterEach, describe, expect, test } from "bun:test"
 import { Agent } from "../../src/agent/agent"
-import { Config } from "../../src/config/config"
-import * as CrossSpawnSpawner from "../../src/effect/cross-spawn-spawner"
 import { Instance } from "../../src/project/instance"
 import { TaskTool } from "../../src/tool/task"
-import { provideTmpdirInstance } from "../fixture/fixture"
-import { testEffect } from "../lib/effect"
+import { tmpdir } from "../fixture/fixture"
 
 afterEach(async () => {
   await Instance.disposeAll()
 })
 
-const it = testEffect(Layer.mergeAll(Agent.defaultLayer, Config.defaultLayer, CrossSpawnSpawner.defaultLayer))
-
 describe("tool.task", () => {
-  it.live("description sorts subagents by name and is stable across calls", () =>
-    provideTmpdirInstance(
-      () =>
-        Effect.gen(function* () {
-          const agent = yield* Agent.Service
-          const build = yield* agent.get("build")
-          const tool = yield* TaskTool
-          const first = yield* Effect.promise(() => tool.init({ agent: build }))
-          const second = yield* Effect.promise(() => tool.init({ agent: build }))
-
-          expect(first.description).toBe(second.description)
-
-          const alpha = first.description.indexOf("- alpha: Alpha agent")
-          const explore = first.description.indexOf("- explore:")
-          const general = first.description.indexOf("- general:")
-          const zebra = first.description.indexOf("- zebra: Zebra agent")
-
-          expect(alpha).toBeGreaterThan(-1)
-          expect(explore).toBeGreaterThan(alpha)
-          expect(general).toBeGreaterThan(explore)
-          expect(zebra).toBeGreaterThan(general)
-        }),
-      {
-        config: {
-          agent: {
-            zebra: {
-              description: "Zebra agent",
-              mode: "subagent",
-            },
-            alpha: {
-              description: "Alpha agent",
-              mode: "subagent",
-            },
+  test("description sorts subagents by name and is stable across calls", async () => {
+    await using tmp = await tmpdir({
+      config: {
+        agent: {
+          zebra: {
+            description: "Zebra agent",
+            mode: "subagent",
+          },
+          alpha: {
+            description: "Alpha agent",
+            mode: "subagent",
           },
         },
       },
-    ),
-  )
+    })
+
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const build = await Agent.get("build")
+        const first = await TaskTool.init({ agent: build })
+        const second = await TaskTool.init({ agent: build })
+
+        expect(first.description).toBe(second.description)
+
+        const alpha = first.description.indexOf("- alpha: Alpha agent")
+        const explore = first.description.indexOf("- explore:")
+        const general = first.description.indexOf("- general:")
+        const zebra = first.description.indexOf("- zebra: Zebra agent")
+
+        expect(alpha).toBeGreaterThan(-1)
+        expect(explore).toBeGreaterThan(alpha)
+        expect(general).toBeGreaterThan(explore)
+        expect(zebra).toBeGreaterThan(general)
+      },
+    })
+  })
 })

turbo.json

@@ -13,9 +13,19 @@
       "outputs": [],
       "passThroughEnv": ["*"]
     },
+    "opencode#test:ci": {
+      "dependsOn": ["^build"],
+      "outputs": [".artifacts/unit/junit.xml"],
+      "passThroughEnv": ["*"]
+    },
     "@opencode-ai/app#test": {
       "dependsOn": ["^build"],
       "outputs": []
+    },
+    "@opencode-ai/app#test:ci": {
+      "dependsOn": ["^build"],
+      "outputs": [".artifacts/unit/junit.xml"],
+      "passThroughEnv": ["*"]
     }
   }
 }