woozlit 2.3.0 → 2.3.1

package/test/tool/registry-invocation-style.test.ts

@@ -1,121 +0,0 @@
-import { afterEach, describe, expect } from "bun:test"
-import { Effect, Layer } from "effect"
-import { ToolRegistry } from "../../src/tool"
-import { Agent } from "../../src/agent/agent"
-import { ProviderID, ModelID } from "../../src/provider/schema"
-import * as CrossSpawnSpawner from "../../src/effect/cross-spawn-spawner"
-import { testEffect } from "../lib/effect"
-import { provideTmpdirInstance } from "../fixture/fixture"
-import { Instance } from "../../src/project/instance"
-
-const it = testEffect(
-  Layer.mergeAll(ToolRegistry.defaultLayer, Agent.defaultLayer, CrossSpawnSpawner.defaultLayer),
-)
-
-afterEach(async () => {
-  await Instance.disposeAll()
-})
-
-describe("ToolRegistry.tools: invocation style resolution", () => {
-  it.live("default config keeps task in JSON mode", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const reg = yield* ToolRegistry.Service
-        const agents = yield* Agent.Service
-        const general = yield* agents.get("general")
-        if (!general) throw new Error("no general agent")
-        const tools = yield* reg.tools({
-          providerID: ProviderID.opencode,
-          modelID: ModelID.make("opencode/claude-sonnet-4-6"),
-          agent: general,
-        })
-        const task = tools.find((t) => t.id === "task")
-        expect(task).toBeDefined()
-        // JSON mode → parameters is an object wrapping an `operation` discriminated
-        // union (discriminator "action"). Confirm `operation` is present and `script`
-        // (the shell-mode shape) is not.
-        const schema = task!.parameters as any
-        expect(schema.shape?.operation ?? schema._def?.shape?.operation).toBeDefined()
-        expect(schema.shape?.script ?? schema._def?.shape?.script).toBeUndefined()
-      }),
-    ),
-  )
-
-  it.live(
-    "invocationStyleByTool.task='shell' replaces parameters with { script } once shell field exists",
-    () =>
-      provideTmpdirInstance(
-        () =>
-          Effect.gen(function* () {
-            const reg = yield* ToolRegistry.Service
-            const agents = yield* Agent.Service
-            const general = yield* agents.get("general")
-            if (!general) throw new Error("no general agent")
-            const tools = yield* reg.tools({
-              providerID: ProviderID.opencode,
-              modelID: ModelID.make("opencode/claude-sonnet-4-6"),
-              agent: general,
-            })
-            const task = tools.find((t) => t.id === "task")
-            expect(task).toBeDefined()
-            // Task has shell field (Task 13 added it). Shell mode is active: parameters has `script`.
-            const schema = task!.parameters as any
-            expect(schema.shape?.script ?? schema._def?.shape?.script).toBeDefined()
-            expect(schema.shape?.action ?? schema._def?.shape?.action).toBeUndefined()
-          }),
-        { config: { tool: { invocation_style_by_tool: { task: "shell" } } } },
-      ),
-  )
-
-  it.live("invocationStyleByTool.read='shell' falls back to JSON (read has no shell field)", () =>
-    provideTmpdirInstance(
-      () =>
-        Effect.gen(function* () {
-          const reg = yield* ToolRegistry.Service
-          const agents = yield* Agent.Service
-          const general = yield* agents.get("general")
-          if (!general) throw new Error("no general agent")
-          const tools = yield* reg.tools({
-            providerID: ProviderID.opencode,
-            modelID: ModelID.make("opencode/claude-sonnet-4-6"),
-            agent: general,
-          })
-          const read = tools.find((t) => t.id === "read")
-          expect(read).toBeDefined()
-          const schema = read!.parameters as any
-          // Original `read` parameters has filePath; shell wrap would expose `script`
-          expect(schema.shape?.filePath ?? schema._def?.shape?.filePath).toBeDefined()
-          expect(schema.shape?.script ?? schema._def?.shape?.script).toBeUndefined()
-        }),
-      { config: { tool: { invocation_style_by_tool: { read: "shell" } } } },
-    ),
-  )
-})
-
-describe("ToolRegistry.tools: shell mode end-to-end on task", () => {
-  it.live("task shell-mode resolves to shellInputSchema parameters and shell description", () =>
-    provideTmpdirInstance(
-      () =>
-        Effect.gen(function* () {
-          const reg = yield* ToolRegistry.Service
-          const agents = yield* Agent.Service
-          const general = yield* agents.get("general")
-          if (!general) throw new Error("no general agent")
-          const tools = yield* reg.tools({
-            providerID: ProviderID.opencode,
-            modelID: ModelID.make("opencode/claude-sonnet-4-6"),
-            agent: general,
-          })
-          const task = tools.find((t) => t.id === "task")!
-          // Sanity: parameters is shellInputSchema (just `script`)
-          const parsed = task.parameters.parse({ script: "task list" })
-          expect(parsed).toEqual({ script: "task list" })
-          // Description starts with the task.shell.txt header
-          expect(task.description).toContain("Persistent work-item tool (shell form)")
-          // Description is NOT the JSON-mode task.txt
-          expect(task.description).not.toContain('"action": "create"')
-        }),
-      { config: { tool: { invocation_style_by_tool: { task: "shell" } } } },
-    ),
-  )
-})

package/test/tool/registry.test.ts

@@ -1,164 +0,0 @@
-import { afterEach, describe, expect } from "bun:test"
-import path from "path"
-import fs from "fs/promises"
-import { Effect, Layer } from "effect"
-import { Instance } from "../../src/project/instance"
-import * as CrossSpawnSpawner from "../../src/effect/cross-spawn-spawner"
-import { ToolRegistry } from "../../src/tool"
-import { provideTmpdirInstance } from "../fixture/fixture"
-import { testEffect } from "../lib/effect"
-
-const node = CrossSpawnSpawner.defaultLayer
-
-const it = testEffect(Layer.mergeAll(ToolRegistry.defaultLayer, node))
-
-afterEach(async () => {
-  await Instance.disposeAll()
-})
-
-describe("tool.registry", () => {
-  it.live("loads tools from .WOOZLIT_CODE/tool (singular)", () =>
-    provideTmpdirInstance((dir) =>
-      Effect.gen(function* () {
-        const opencode = path.join(dir, ".WOOZLIT_CODE")
-        const tool = path.join(opencode, "tool")
-        yield* Effect.promise(() => fs.mkdir(tool, { recursive: true }))
-        yield* Effect.promise(() =>
-          Bun.write(
-            path.join(tool, "hello.ts"),
-            [
-              "export default {",
-              "  description: 'hello tool',",
-              "  args: {},",
-              "  execute: async () => {",
-              "    return 'hello world'",
-              "  },",
-              "}",
-              "",
-            ].join("\n"),
-          ),
-        )
-        const registry = yield* ToolRegistry.Service
-        const ids = yield* registry.ids()
-        expect(ids).toContain("hello")
-      }),
-    ),
-  )
-
-  it.live("loads tools from .WOOZLIT_CODE/tools (plural)", () =>
-    provideTmpdirInstance((dir) =>
-      Effect.gen(function* () {
-        const opencode = path.join(dir, ".WOOZLIT_CODE")
-        const tools = path.join(opencode, "tools")
-        yield* Effect.promise(() => fs.mkdir(tools, { recursive: true }))
-        yield* Effect.promise(() =>
-          Bun.write(
-            path.join(tools, "hello.ts"),
-            [
-              "export default {",
-              "  description: 'hello tool',",
-              "  args: {},",
-              "  execute: async () => {",
-              "    return 'hello world'",
-              "  },",
-              "}",
-              "",
-            ].join("\n"),
-          ),
-        )
-        const registry = yield* ToolRegistry.Service
-        const ids = yield* registry.ids()
-        expect(ids).toContain("hello")
-      }),
-    ),
-  )
-
-  it.live("loads tools with external dependencies without crashing", () =>
-    provideTmpdirInstance((dir) =>
-      Effect.gen(function* () {
-        const opencode = path.join(dir, ".WOOZLIT_CODE")
-        const tools = path.join(opencode, "tools")
-        yield* Effect.promise(() => fs.mkdir(tools, { recursive: true }))
-        yield* Effect.promise(() =>
-          Bun.write(
-            path.join(opencode, "package.json"),
-            JSON.stringify({
-              name: "custom-tools",
-              dependencies: {
-                "@woozlit/plugin": "^0.0.0",
-                cowsay: "^1.6.0",
-              },
-            }),
-          ),
-        )
-        yield* Effect.promise(() =>
-          Bun.write(
-            path.join(opencode, "package-lock.json"),
-            JSON.stringify({
-              name: "custom-tools",
-              lockfileVersion: 3,
-              packages: {
-                "": {
-                  dependencies: {
-                    "@woozlit/plugin": "^0.0.0",
-                    cowsay: "^1.6.0",
-                  },
-                },
-              },
-            }),
-          ),
-        )
-
-        const cowsay = path.join(opencode, "node_modules", "cowsay")
-        yield* Effect.promise(() => fs.mkdir(cowsay, { recursive: true }))
-        yield* Effect.promise(() =>
-          Bun.write(
-            path.join(cowsay, "package.json"),
-            JSON.stringify({
-              name: "cowsay",
-              type: "module",
-              exports: "./index.js",
-            }),
-          ),
-        )
-        yield* Effect.promise(() =>
-          Bun.write(
-            path.join(cowsay, "index.js"),
-            ["export function say({ text }) {", "  return `moo ${text}`", "}", ""].join("\n"),
-          ),
-        )
-        yield* Effect.promise(() =>
-          Bun.write(
-            path.join(tools, "cowsay.ts"),
-            [
-              "import { say } from 'cowsay'",
-              "export default {",
-              "  description: 'tool that imports cowsay at top level',",
-              "  args: { text: { type: 'string' } },",
-              "  execute: async ({ text }: { text: string }) => {",
-              "    return say({ text })",
-              "  },",
-              "}",
-              "",
-            ].join("\n"),
-          ),
-        )
-        const registry = yield* ToolRegistry.Service
-        const ids = yield* registry.ids()
-        expect(ids).toContain("cowsay")
-      }),
-    ),
-  )
-
-  it.live("todowrite tool is not registered; task is", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const registry = yield* ToolRegistry.Service
-        const ids = yield* registry.ids()
-        expect(ids).not.toContain("todowrite")
-        expect(ids).not.toContain("todo")
-        expect(ids).toContain("task")
-      }),
-    ),
-  )
-})

package/test/tool/shell-tokenize.test.ts

@@ -1,273 +0,0 @@
-import { describe, test, expect } from "bun:test"
-import { Effect } from "effect"
-import { tokenize, type Argv, type ParseError } from "../../src/tool/shell-tokenize"
-
-async function tokenizeOk(script: string): Promise<Argv[]> {
-  const exit = await Effect.runPromise(Effect.exit(tokenize(script)))
-  if (exit._tag === "Failure") throw new Error(`expected success: ${JSON.stringify(exit.cause)}`)
-  return exit.value
-}
-
-async function tokenizeErr(script: string): Promise<ParseError> {
-  const exit = await Effect.runPromise(Effect.exit(tokenize(script)))
-  if (exit._tag !== "Failure") throw new Error("expected failure, got success")
-  const cause: any = exit.cause
-  const fail = cause.reasons?.find?.((r: any) => r._tag === "Fail")
-  if (!fail) throw new Error(`no Fail reason in cause: ${JSON.stringify(cause)}`)
-  return fail.error as ParseError
-}
-
-describe("shell-tokenize: basic", () => {
-  test("verb plus positional, no quoting", async () => {
-    const out = await tokenizeOk("task create T1")
-    expect(out).toEqual([{ line: 1, tokens: ["task", "create", "T1"] }])
-  })
-
-  test("blank input produces no commands", async () => {
-    const out = await tokenizeOk("")
-    expect(out).toEqual([])
-  })
-})
-
-describe("shell-tokenize: quoting", () => {
-  test("double-quoted string preserves spaces", async () => {
-    const out = await tokenizeOk('task create "hello world"')
-    expect(out).toEqual([{ line: 1, tokens: ["task", "create", "hello world"] }])
-  })
-
-  test("double-quoted string preserves literal newlines", async () => {
-    const out = await tokenizeOk('task revise T1 "line1\nline2"')
-    expect(out).toEqual([{ line: 1, tokens: ["task", "revise", "T1", "line1\nline2"] }])
-  })
-
-  test("single-quoted string preserves verbatim", async () => {
-    const out = await tokenizeOk(`task echo 'a"b c'`)
-    expect(out).toEqual([{ line: 1, tokens: ["task", "echo", `a"b c`] }])
-  })
-})
-
-describe("shell-tokenize: multi-command", () => {
-  test("two commands separated by newline", async () => {
-    const out = await tokenizeOk('task create "a"\ntask create "b"')
-    expect(out).toEqual([
-      { line: 1, tokens: ["task", "create", "a"] },
-      { line: 2, tokens: ["task", "create", "b"] },
-    ])
-  })
-
-  test("blank lines are skipped, line numbers preserved", async () => {
-    const out = await tokenizeOk('\n\ntask list\n\ntask get T1\n')
-    expect(out).toEqual([
-      { line: 3, tokens: ["task", "list"] },
-      { line: 5, tokens: ["task", "get", "T1"] },
-    ])
-  })
-
-  test("command containing quoted multi-line still spans lines correctly", async () => {
-    const out = await tokenizeOk('task list\ntask revise T1 "line1\nline2"\ntask get T1')
-    expect(out).toEqual([
-      { line: 1, tokens: ["task", "list"] },
-      { line: 2, tokens: ["task", "revise", "T1", "line1\nline2"] },
-      { line: 4, tokens: ["task", "get", "T1"] },
-    ])
-  })
-
-  test("backslash-newline continuation joins to one command, line is the start", async () => {
-    // task create T1 followed by line continuation, second physical line continues the same command
-    const out = await tokenizeOk('task create \\\nT1\ntask list')
-    // Two commands: line 1 (spans physical lines 1-2 via continuation), line 3 (task list)
-    expect(out).toEqual([
-      { line: 1, tokens: ["task", "create", "T1"] },
-      { line: 3, tokens: ["task", "list"] },
-    ])
-  })
-})
-
-describe("shell-tokenize: variables", () => {
-  test("$varname inside double quotes is preserved literally", async () => {
-    const out = await tokenizeOk('task echo "use $myvar here"')
-    expect(out).toEqual([{ line: 1, tokens: ["task", "echo", "use $myvar here"] }])
-  })
-
-  test("${name} brace form normalized to $name", async () => {
-    const out = await tokenizeOk('task echo "code ${name}"')
-    expect(out).toEqual([{ line: 1, tokens: ["task", "echo", "code $name"] }])
-  })
-
-  test("$ alone (no name following) is preserved", async () => {
-    const out = await tokenizeOk('task echo "amount $5"')
-    expect(out).toEqual([{ line: 1, tokens: ["task", "echo", "amount $5"] }])
-  })
-
-  test("escaped \\$ produces literal $", async () => {
-    const out = await tokenizeOk('task echo "literal \\$ here"')
-    expect(out).toEqual([{ line: 1, tokens: ["task", "echo", "literal $ here"] }])
-  })
-
-  test("single quotes preserve $ verbatim", async () => {
-    const out = await tokenizeOk("task echo '$varname stays'")
-    expect(out).toEqual([{ line: 1, tokens: ["task", "echo", "$varname stays"] }])
-  })
-})
-
-describe("shell-tokenize: errors", () => {
-  test("pipe operator rejected", async () => {
-    const err = await tokenizeErr("task list | head -1")
-    expect(err.kind).toBe("unsupported-operator")
-    expect(err.detail).toContain("|")
-  })
-
-  test("redirect operator rejected", async () => {
-    const err = await tokenizeErr("task list > out.txt")
-    expect(err.kind).toBe("unsupported-operator")
-    expect(err.detail).toContain(">")
-  })
-
-  test("semicolon rejected as separator (only newlines separate commands)", async () => {
-    const err = await tokenizeErr('task create "a"; task create "b"')
-    expect(err.kind).toBe("unsupported-operator")
-    expect(err.detail).toContain(";")
-  })
-
-  test("unclosed double quote", async () => {
-    const err = await tokenizeErr('task create "unterminated')
-    expect(err.kind).toBe("unclosed-quote")
-    expect(err.line).toBe(1)
-  })
-
-  test("herestring (<<<) rejected", async () => {
-    const err = await tokenizeErr("task list <<< foo")
-    expect(err.kind).toBe("unsupported-operator")
-    expect(err.detail).toContain("<<<")
-  })
-
-  test("subshell open paren rejected", async () => {
-    const err = await tokenizeErr("(task list)")
-    expect(err.kind).toBe("unsupported-operator")
-    expect(err.detail).toContain("(")
-  })
-
-  test("glob pattern rejected", async () => {
-    const err = await tokenizeErr("task create *.ts")
-    expect(err.kind).toBe("unsupported-operator")
-    expect(err.detail).toContain("*.ts")
-  })
-})
-
-describe("shell-tokenize: POSIX # comment handling", () => {
-  test("after-command comment dropped", async () => {
-    const out = await tokenizeOk("task list # debug")
-    expect(out).toEqual([{ line: 1, tokens: ["task", "list"] }])
-  })
-
-  test("whole-line comment dropped", async () => {
-    const out = await tokenizeOk("# title\ntask list")
-    expect(out).toEqual([{ line: 2, tokens: ["task", "list"] }])
-  })
-
-  test("mid-token # is literal", async () => {
-    const out = await tokenizeOk("task create issue#123 fix")
-    expect(out).toEqual([{ line: 1, tokens: ["task", "create", "issue#123", "fix"] }])
-  })
-
-  test("# inside double quotes is literal", async () => {
-    const out = await tokenizeOk('task create "value with # hash"')
-    expect(out).toEqual([{ line: 1, tokens: ["task", "create", "value with # hash"] }])
-  })
-
-  test("# inside single quotes is literal", async () => {
-    const out = await tokenizeOk("task create 'value with # hash'")
-    expect(out).toEqual([{ line: 1, tokens: ["task", "create", "value with # hash"] }])
-  })
-
-  test("markdown headings in double-quoted body are preserved", async () => {
-    const out = await tokenizeOk('actor run general "review" "# Heading\n## Sub\nbody"')
-    expect(out[0].tokens.at(-1)).toBe("# Heading\n## Sub\nbody")
-  })
-
-  test("markdown headings in heredoc body are preserved", async () => {
-    const script = [
-      "task revise T1 body <<EOF",
-      "# Heading",
-      "## Sub",
-      "body line",
-      "EOF",
-    ].join("\n")
-    const out = await tokenizeOk(script)
-    expect(out[0].tokens.at(-1)).toBe("# Heading\n## Sub\nbody line")
-  })
-
-  test("escaped \\# is literal #", async () => {
-    const out = await tokenizeOk("task list \\# escaped")
-    expect(out).toEqual([{ line: 1, tokens: ["task", "list", "#", "escaped"] }])
-  })
-})
-
-describe("shell-tokenize: heredoc", () => {
-  test("simple heredoc body becomes last token verbatim", async () => {
-    const script = ["task revise T1 <<EOF", "line 1", "line 2", "EOF"].join("\n")
-    const out = await tokenizeOk(script)
-    expect(out).toEqual([{ line: 1, tokens: ["task", "revise", "T1", "line 1\nline 2"] }])
-  })
-
-  test("heredoc body preserves quotes, escapes, dollars verbatim", async () => {
-    const script = [
-      `task revise T1 <<EOF`,
-      `He said "hello" and 'hi'`,
-      `Path: C:\\Users`,
-      `Var: $foo, escape: \\n`,
-      `EOF`,
-    ].join("\n")
-    const out = await tokenizeOk(script)
-    const last = out[0].tokens.at(-1)
-    expect(last).toBe(`He said "hello" and 'hi'\nPath: C:\\Users\nVar: $foo, escape: \\n`)
-  })
-
-  test("multiple heredocs in same script", async () => {
-    const script = [
-      `task create "first" <<A`,
-      `body A`,
-      `A`,
-      `task create "second" <<B`,
-      `body B line 1`,
-      `body B line 2`,
-      `B`,
-    ].join("\n")
-    const out = await tokenizeOk(script)
-    expect(out).toEqual([
-      { line: 1, tokens: ["task", "create", "first", "body A"] },
-      { line: 4, tokens: ["task", "create", "second", "body B line 1\nbody B line 2"] },
-    ])
-  })
-
-  test("unclosed heredoc reports error with line where it opened", async () => {
-    const script = ["task revise T1 <<EOF", "body line 1", "body line 2"].join("\n")
-    const err = await tokenizeErr(script)
-    expect(err.kind).toBe("unclosed-heredoc")
-    expect(err.line).toBe(1)
-    expect(err.detail).toContain("EOF")
-  })
-
-  test("<<MARKER inside double-quoted string is literal, not heredoc", async () => {
-    const out = await tokenizeOk(`task echo "<<EOF should be literal"`)
-    expect(out).toEqual([{ line: 1, tokens: ["task", "echo", "<<EOF should be literal"] }])
-  })
-
-  test("body line that equals marker after trim closes heredoc (not body content)", async () => {
-    const script = ["task revise T1 <<DONE", "  some body  ", "DONE"].join("\n")
-    const out = await tokenizeOk(script)
-    expect(out[0].tokens.at(-1)).toBe("  some body  ")
-  })
-
-  test("non-whitespace after <<MARKER on the same line is unsupported", async () => {
-    const script = ["task echo <<EOF extra", "body", "EOF"].join("\n")
-    const err = await tokenizeErr(script)
-    expect(err.kind).toBe("unsupported-operator")
-  })
-
-  test("heredoc body is empty if marker is on the very next line", async () => {
-    const script = ["task revise T1 <<EOF", "EOF"].join("\n")
-    const out = await tokenizeOk(script)
-    expect(out[0].tokens.at(-1)).toBe("")
-  })
-})

package/test/tool/shell-wrap-missing-script.test.ts

@@ -1,128 +0,0 @@
-import { describe, test, expect } from "bun:test"
-import { Effect } from "effect"
-import { shellWrap } from "../../src/tool/shell-wrap"
-import * as Tool from "../../src/tool/tool"
-
-// Minimal shell-style tool def: its shell.parse would crash on undefined input
-// (mirrors the real tokenize(script.trim()) path), so the guard must short-circuit
-// BEFORE parse is ever called.
-function fakeShellDef(): Tool.Def {
-  return {
-    id: "actor",
-    description: "fake",
-    parameters: {} as never,
-    execute: () => Effect.succeed({ title: "ok", output: "ran", metadata: {} }),
-    shell: {
-      description: "fake shell desc",
-      parse: (script: string) => Effect.sync(() => {
-        if (typeof script !== "string") throw new TypeError("undefined is not an object (evaluating 'script.trim')")
-        return [{ operation: "run" }] as never
-      }),
-    },
-  }
-}
-
-const ctx = {
-  sessionID: "ses_x" as never,
-  messageID: "msg_x" as never,
-  agent: "build",
-  abort: new AbortController().signal,
-  messages: [],
-  metadata: () => Effect.void,
-  ask: () => Effect.void,
-} as unknown as Tool.Context
-
-describe("shellWrap: missing/invalid script guard", () => {
-  test("undefined script → structured teaching error, no crash", async () => {
-    const wrapped = shellWrap(fakeShellDef())
-    const result = await Effect.runPromise(wrapped.execute({ script: undefined } as never, ctx))
-    expect(result.output.toLowerCase()).toContain("script")
-    expect(result.metadata).toMatchObject({ commands: 0, success: 0 })
-    expect(result.output).not.toContain("script.trim")
-    expect(result.output).toContain("actor")
-  })
-
-  test("non-string script → same structured error", async () => {
-    const wrapped = shellWrap(fakeShellDef())
-    const result = await Effect.runPromise(wrapped.execute({ script: { description: "x" } } as never, ctx))
-    expect(result.output.toLowerCase()).toContain("script")
-    expect(result.metadata).toMatchObject({ commands: 0, success: 0 })
-  })
-
-  test("empty/whitespace script → structured error", async () => {
-    const wrapped = shellWrap(fakeShellDef())
-    const result = await Effect.runPromise(wrapped.execute({ script: "   " } as never, ctx))
-    expect(result.output.toLowerCase()).toContain("script")
-    expect(result.metadata).toMatchObject({ commands: 0, success: 0 })
-  })
-
-  test("valid script still works (guard doesn't over-reject)", async () => {
-    const wrapped = shellWrap(fakeShellDef())
-    const result = await Effect.runPromise(wrapped.execute({ script: "actor run explore \"d\" \"p\"" } as never, ctx))
-    expect(result.metadata).toMatchObject({ commands: 1, success: 1 })
-  })
-})
-
-describe("shellWrap: recover routing", () => {
-  function recordingDef(recover?: (a: unknown) => unknown) {
-    const received: unknown[] = []
-    const def = {
-      id: "actor",
-      description: "fake",
-      parameters: {} as never,
-      execute: (args: unknown) =>
-        Effect.sync(() => {
-          received.push(args)
-          return { title: "ok", output: "actor_id: explore-1", metadata: { actorId: "explore-1" } }
-        }),
-      shell: {
-        description: "fake shell desc",
-        parse: (_s: string) => Effect.succeed([] as never),
-        ...(recover ? { recover } : {}),
-      },
-    } as unknown as Tool.Def
-    return { def, received }
-  }
-
-  test("recover returns op → routed to execute, success is silent (no format hint)", async () => {
-    const recovered = { operation: { action: "run", subagent_type: "explore", description: "d", prompt: "p" } }
-    const { def, received } = recordingDef(() => recovered)
-    const wrapped = shellWrap(def)
-    const result = await Effect.runPromise(wrapped.execute({ description: "d", prompt: "p", subagent_type: "explore" } as never, ctx))
-    expect(received).toEqual([recovered])
-    expect(result.metadata).toMatchObject({ commands: 1, success: 1 })
-    expect(result.output).toContain("actor_id: explore-1")
-    expect(result.output.toLowerCase()).not.toContain("takes a single")
-    expect(result.output.toLowerCase()).not.toContain("operation")
-  })
-
-  test("recover undefined + jsonish args → JSON teaching", async () => {
-    const { def } = recordingDef(() => undefined)
-    const wrapped = shellWrap(def)
-    const result = await Effect.runPromise(wrapped.execute({ description: "d", prompt: "p", subagent_type: "explore" } as never, ctx))
-    expect(result.metadata).toMatchObject({ commands: 0, success: 0 })
-    expect(result.output.toLowerCase()).toContain("operation")
-  })
-
-  test("recover undefined + had empty script key → shell teaching", async () => {
-    const { def } = recordingDef(() => undefined)
-    const wrapped = shellWrap(def)
-    const result = await Effect.runPromise(wrapped.execute({ script: "   " } as never, ctx))
-    expect(result.metadata).toMatchObject({ commands: 0, success: 0 })
-    expect(result.output.toLowerCase()).toContain("script")
-    expect(result.output.toLowerCase()).not.toContain("operation")
-  })
-
-  test("recover returns op but execute fails → JSON teaching", async () => {
-    const recovered = { operation: { action: "run" } }
-    const def = {
-      id: "actor", description: "fake", parameters: {} as never,
-      execute: () => Effect.fail(new Error("validation: missing prompt")),
-      shell: { description: "d", parse: (_s: string) => Effect.succeed([] as never), recover: () => recovered },
-    } as unknown as Tool.Def
-    const wrapped = shellWrap(def)
-    const result = await Effect.runPromise(wrapped.execute({ description: "d" } as never, ctx))
-    expect(result.metadata).toMatchObject({ commands: 0, success: 0 })
-    expect(result.output.toLowerCase()).toContain("operation")
-  })
-})