bonecode 1.0.0 → 1.1.0

package/src/engine/tool/tool/tool.ts

@@ -1,164 +1,164 @@
-import { Effect, Schema } from "effect"
-import type { JSONSchema7 } from "@ai-sdk/provider"
-import type { MessageV2 } from "../session/message-v2"
-import type { Permission } from "../permission"
-import type { SessionID, MessageID } from "../session/schema"
-import * as Truncate from "./truncate"
-import { Agent } from "@/agent/agent"
-
-interface Metadata {
-  [key: string]: any
-}
-
-// TODO: remove this hack
-export type DynamicDescription = (agent: Agent.Info) => Effect.Effect<string>
-
-export type Context<M extends Metadata = Metadata> = {
-  sessionID: SessionID
-  messageID: MessageID
-  agent: string
-  abort: AbortSignal
-  callID?: string
-  extra?: { [key: string]: unknown }
-  messages: MessageV2.WithParts[]
-  metadata(input: { title?: string; metadata?: M }): Effect.Effect<void>
-  ask(input: Omit<Permission.Request, "id" | "sessionID" | "tool">): Effect.Effect<void>
-}
-
-export interface ExecuteResult<M extends Metadata = Metadata> {
-  title: string
-  metadata: M
-  output: string
-  attachments?: Omit<MessageV2.FilePart, "id" | "sessionID" | "messageID">[]
-}
-
-export interface Def<
-  Parameters extends Schema.Decoder<unknown> = Schema.Decoder<unknown>,
-  M extends Metadata = Metadata,
-> {
-  id: string
-  description: string
-  parameters: Parameters
-  jsonSchema?: JSONSchema7
-  execute(args: Schema.Schema.Type<Parameters>, ctx: Context): Effect.Effect<ExecuteResult<M>>
-  formatValidationError?(error: unknown): string
-}
-export type DefWithoutID<
-  Parameters extends Schema.Decoder<unknown> = Schema.Decoder<unknown>,
-  M extends Metadata = Metadata,
-> = Omit<Def<Parameters, M>, "id">
-
-export interface Info<
-  Parameters extends Schema.Decoder<unknown> = Schema.Decoder<unknown>,
-  M extends Metadata = Metadata,
-> {
-  id: string
-  init: () => Effect.Effect<DefWithoutID<Parameters, M>>
-}
-
-type Init<Parameters extends Schema.Decoder<unknown>, M extends Metadata> =
-  | DefWithoutID<Parameters, M>
-  | (() => Effect.Effect<DefWithoutID<Parameters, M>>)
-
-export type InferParameters<T> =
-  T extends Info<infer P, any>
-    ? Schema.Schema.Type<P>
-    : T extends Effect.Effect<Info<infer P, any>, any, any>
-      ? Schema.Schema.Type<P>
-      : never
-export type InferMetadata<T> =
-  T extends Info<any, infer M> ? M : T extends Effect.Effect<Info<any, infer M>, any, any> ? M : never
-
-export type InferDef<T> =
-  T extends Info<infer P, infer M>
-    ? Def<P, M>
-    : T extends Effect.Effect<Info<infer P, infer M>, any, any>
-      ? Def<P, M>
-      : never
-
-function wrap<Parameters extends Schema.Decoder<unknown>, Result extends Metadata>(
-  id: string,
-  init: Init<Parameters, Result>,
-  truncate: Truncate.Interface,
-  agents: Agent.Interface,
-) {
-  return () =>
-    Effect.gen(function* () {
-      const toolInfo = typeof init === "function" ? { ...(yield* init()) } : { ...init }
-      // Compile the parser closure once per tool init; `decodeUnknownEffect`
-      // allocates a new closure per call, so hoisting avoids re-closing it for
-      // every LLM tool invocation.
-      const decode = Schema.decodeUnknownEffect(toolInfo.parameters)
-      const execute = toolInfo.execute
-      toolInfo.execute = (args, ctx) => {
-        const attrs = {
-          "tool.name": id,
-          "session.id": ctx.sessionID,
-          "message.id": ctx.messageID,
-          ...(ctx.callID ? { "tool.call_id": ctx.callID } : {}),
-        }
-        return Effect.gen(function* () {
-          const decoded = yield* decode(args).pipe(
-            Effect.mapError((error) =>
-              toolInfo.formatValidationError
-                ? new Error(toolInfo.formatValidationError(error), { cause: error })
-                : new Error(
-                    `The ${id} tool was called with invalid arguments: ${error}.\nPlease rewrite the input so it satisfies the expected schema.`,
-                    { cause: error },
-                  ),
-            ),
-          )
-          const result = yield* execute(decoded as Schema.Schema.Type<Parameters>, ctx)
-          if (result.metadata.truncated !== undefined) {
-            return result
-          }
-          const agent = yield* agents.get(ctx.agent)
-          const truncated = yield* truncate.output(result.output, {}, agent)
-          return {
-            ...result,
-            output: truncated.content,
-            metadata: {
-              ...result.metadata,
-              truncated: truncated.truncated,
-              ...(truncated.truncated && { outputPath: truncated.outputPath }),
-            },
-          }
-        }).pipe(Effect.orDie, Effect.withSpan("Tool.execute", { attributes: attrs }))
-      }
-      return toolInfo
-    })
-}
-
-export function define<
-  Parameters extends Schema.Decoder<unknown>,
-  Result extends Metadata,
-  R,
-  ID extends string = string,
->(
-  id: ID,
-  init: Effect.Effect<Init<Parameters, Result>, never, R>,
-): Effect.Effect<Info<Parameters, Result>, never, R | Truncate.Service | Agent.Service> & { id: ID } {
-  return Object.assign(
-    Effect.gen(function* () {
-      const resolved = yield* init
-      const truncate = yield* Truncate.Service
-      const agents = yield* Agent.Service
-      return { id, init: wrap(id, resolved, truncate, agents) }
-    }),
-    { id },
-  )
-}
-
-export function init<P extends Schema.Decoder<unknown>, M extends Metadata>(
-  info: Info<P, M>,
-): Effect.Effect<Def<P, M>> {
-  return Effect.gen(function* () {
-    const init = yield* info.init()
-    return {
-      ...init,
-      id: info.id,
-    }
-  })
-}
-
-export * as Tool from "./tool"
+import { Effect, Schema } from "effect"
+import type { JSONSchema7 } from "@ai-sdk/provider"
+import type { MessageV2 } from "../session/message-v2"
+import type { Permission } from "../permission"
+import type { SessionID, MessageID } from "../session/schema"
+import * as Truncate from "./truncate"
+import { Agent } from "@/agent/agent"
+
+interface Metadata {
+  [key: string]: any
+}
+
+// TODO: remove this hack
+export type DynamicDescription = (agent: Agent.Info) => Effect.Effect<string>
+
+export type Context<M extends Metadata = Metadata> = {
+  sessionID: SessionID
+  messageID: MessageID
+  agent: string
+  abort: AbortSignal
+  callID?: string
+  extra?: { [key: string]: unknown }
+  messages: MessageV2.WithParts[]
+  metadata(input: { title?: string; metadata?: M }): Effect.Effect<void>
+  ask(input: Omit<Permission.Request, "id" | "sessionID" | "tool">): Effect.Effect<void>
+}
+
+export interface ExecuteResult<M extends Metadata = Metadata> {
+  title: string
+  metadata: M
+  output: string
+  attachments?: Omit<MessageV2.FilePart, "id" | "sessionID" | "messageID">[]
+}
+
+export interface Def<
+  Parameters extends Schema.Decoder<unknown> = Schema.Decoder<unknown>,
+  M extends Metadata = Metadata,
+> {
+  id: string
+  description: string
+  parameters: Parameters
+  jsonSchema?: JSONSchema7
+  execute(args: Schema.Schema.Type<Parameters>, ctx: Context): Effect.Effect<ExecuteResult<M>>
+  formatValidationError?(error: unknown): string
+}
+export type DefWithoutID<
+  Parameters extends Schema.Decoder<unknown> = Schema.Decoder<unknown>,
+  M extends Metadata = Metadata,
+> = Omit<Def<Parameters, M>, "id">
+
+export interface Info<
+  Parameters extends Schema.Decoder<unknown> = Schema.Decoder<unknown>,
+  M extends Metadata = Metadata,
+> {
+  id: string
+  init: () => Effect.Effect<DefWithoutID<Parameters, M>>
+}
+
+type Init<Parameters extends Schema.Decoder<unknown>, M extends Metadata> =
+  | DefWithoutID<Parameters, M>
+  | (() => Effect.Effect<DefWithoutID<Parameters, M>>)
+
+export type InferParameters<T> =
+  T extends Info<infer P, any>
+    ? Schema.Schema.Type<P>
+    : T extends Effect.Effect<Info<infer P, any>, any, any>
+      ? Schema.Schema.Type<P>
+      : never
+export type InferMetadata<T> =
+  T extends Info<any, infer M> ? M : T extends Effect.Effect<Info<any, infer M>, any, any> ? M : never
+
+export type InferDef<T> =
+  T extends Info<infer P, infer M>
+    ? Def<P, M>
+    : T extends Effect.Effect<Info<infer P, infer M>, any, any>
+      ? Def<P, M>
+      : never
+
+function wrap<Parameters extends Schema.Decoder<unknown>, Result extends Metadata>(
+  id: string,
+  init: Init<Parameters, Result>,
+  truncate: Truncate.Interface,
+  agents: Agent.Interface,
+) {
+  return () =>
+    Effect.gen(function* () {
+      const toolInfo = typeof init === "function" ? { ...(yield* init()) } : { ...init }
+      // Compile the parser closure once per tool init; `decodeUnknownEffect`
+      // allocates a new closure per call, so hoisting avoids re-closing it for
+      // every LLM tool invocation.
+      const decode = Schema.decodeUnknownEffect(toolInfo.parameters)
+      const execute = toolInfo.execute
+      toolInfo.execute = (args, ctx) => {
+        const attrs = {
+          "tool.name": id,
+          "session.id": ctx.sessionID,
+          "message.id": ctx.messageID,
+          ...(ctx.callID ? { "tool.call_id": ctx.callID } : {}),
+        }
+        return Effect.gen(function* () {
+          const decoded = yield* decode(args).pipe(
+            Effect.mapError((error) =>
+              toolInfo.formatValidationError
+                ? new Error(toolInfo.formatValidationError(error), { cause: error })
+                : new Error(
+                    `The ${id} tool was called with invalid arguments: ${error}.\nPlease rewrite the input so it satisfies the expected schema.`,
+                    { cause: error },
+                  ),
+            ),
+          )
+          const result = yield* execute(decoded as Schema.Schema.Type<Parameters>, ctx)
+          if (result.metadata.truncated !== undefined) {
+            return result
+          }
+          const agent = yield* agents.get(ctx.agent)
+          const truncated = yield* truncate.output(result.output, {}, agent)
+          return {
+            ...result,
+            output: truncated.content,
+            metadata: {
+              ...result.metadata,
+              truncated: truncated.truncated,
+              ...(truncated.truncated && { outputPath: truncated.outputPath }),
+            },
+          }
+        }).pipe(Effect.orDie, Effect.withSpan("Tool.execute", { attributes: attrs }))
+      }
+      return toolInfo
+    })
+}
+
+export function define<
+  Parameters extends Schema.Decoder<unknown>,
+  Result extends Metadata,
+  R,
+  ID extends string = string,
+>(
+  id: ID,
+  init: Effect.Effect<Init<Parameters, Result>, never, R>,
+): Effect.Effect<Info<Parameters, Result>, never, R | Truncate.Service | Agent.Service> & { id: ID } {
+  return Object.assign(
+    Effect.gen(function* () {
+      const resolved = yield* init
+      const truncate = yield* Truncate.Service
+      const agents = yield* Agent.Service
+      return { id, init: wrap(id, resolved, truncate, agents) }
+    }),
+    { id },
+  )
+}
+
+export function init<P extends Schema.Decoder<unknown>, M extends Metadata>(
+  info: Info<P, M>,
+): Effect.Effect<Def<P, M>> {
+  return Effect.gen(function* () {
+    const init = yield* info.init()
+    return {
+      ...init,
+      id: info.id,
+    }
+  })
+}
+
+export * as Tool from "./tool"

package/src/engine/tool/tool/truncate.ts

@@ -1,160 +1,160 @@
-import { NodePath } from "@effect/platform-node"
-import { Cause, Duration, Effect, Layer, Option, Schedule, Context } from "effect"
-import path from "path"
-import type { Agent } from "../agent/agent"
-import { AppFileSystem } from "@opencode-ai/core/filesystem"
-import { evaluate } from "@/permission/evaluate"
-import { Config } from "@/config/config"
-import { Identifier } from "../id/id"
-import * as Log from "@opencode-ai/core/util/log"
-import { ToolID } from "./schema"
-import { TRUNCATION_DIR } from "./truncation-dir"
-
-const log = Log.create({ service: "truncation" })
-const RETENTION = Duration.days(7)
-
-export const MAX_LINES = 2000
-export const MAX_BYTES = 50 * 1024
-export const DIR = TRUNCATION_DIR
-export const GLOB = path.join(TRUNCATION_DIR, "*")
-
-export type Result = { content: string; truncated: false } | { content: string; truncated: true; outputPath: string }
-
-export interface Options {
-  maxLines?: number
-  maxBytes?: number
-  direction?: "head" | "tail"
-}
-
-function hasTaskTool(agent?: Agent.Info) {
-  if (!agent?.permission) return false
-  return evaluate("task", "*", agent.permission).action !== "deny"
-}
-
-export interface Interface {
-  readonly cleanup: () => Effect.Effect<void>
-  readonly write: (text: string) => Effect.Effect<string>
-  /**
-   * Returns output unchanged when it fits within the limits, otherwise writes the full text
-   * to the truncation directory and returns a preview plus a hint to inspect the saved file.
-   */
-  readonly output: (text: string, options?: Options, agent?: Agent.Info) => Effect.Effect<Result>
-  /**
-   * Resolved truncation limits: values from `tool_output` in opencode config, or MAX_LINES / MAX_BYTES if unset.
-   */
-  readonly limits: () => Effect.Effect<{ maxLines: number; maxBytes: number }>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/Truncate") {}
-
-export const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const fs = yield* AppFileSystem.Service
-
-    const cleanup = Effect.fn("Truncate.cleanup")(function* () {
-      const cutoff = Identifier.timestamp(
-        Identifier.create("tool", "ascending", Date.now() - Duration.toMillis(RETENTION)),
-      )
-      const entries = yield* fs.readDirectory(TRUNCATION_DIR).pipe(
-        Effect.map((all) => all.filter((name) => name.startsWith("tool_"))),
-        Effect.catch(() => Effect.succeed([])),
-      )
-      for (const entry of entries) {
-        if (Identifier.timestamp(entry) >= cutoff) continue
-        yield* fs.remove(path.join(TRUNCATION_DIR, entry)).pipe(Effect.catch(() => Effect.void))
-      }
-    })
-
-    const write = Effect.fn("Truncate.write")(function* (text: string) {
-      const file = path.join(TRUNCATION_DIR, ToolID.ascending())
-      yield* fs.ensureDir(TRUNCATION_DIR).pipe(Effect.orDie)
-      yield* fs.writeFileString(file, text).pipe(Effect.orDie)
-      return file
-    })
-
-    const limits = Effect.fn("Truncate.limits")(function* () {
-      const configSvc = yield* Effect.serviceOption(Config.Service)
-      if (Option.isNone(configSvc)) return { maxLines: MAX_LINES, maxBytes: MAX_BYTES }
-      const cfg = yield* configSvc.value.get().pipe(Effect.catch(() => Effect.succeed(undefined)))
-      return {
-        maxLines: cfg?.tool_output?.max_lines ?? MAX_LINES,
-        maxBytes: cfg?.tool_output?.max_bytes ?? MAX_BYTES,
-      }
-    })
-
-    const output = Effect.fn("Truncate.output")(function* (text: string, options: Options = {}, agent?: Agent.Info) {
-      const resolved = yield* limits()
-      const maxLines = options.maxLines ?? resolved.maxLines
-      const maxBytes = options.maxBytes ?? resolved.maxBytes
-      const direction = options.direction ?? "head"
-      const lines = text.split("\n")
-      const totalBytes = Buffer.byteLength(text, "utf-8")
-
-      if (lines.length <= maxLines && totalBytes <= maxBytes) {
-        return { content: text, truncated: false } as const
-      }
-
-      const out: string[] = []
-      let i = 0
-      let bytes = 0
-      let hitBytes = false
-
-      if (direction === "head") {
-        for (i = 0; i < lines.length && i < maxLines; i++) {
-          const size = Buffer.byteLength(lines[i], "utf-8") + (i > 0 ? 1 : 0)
-          if (bytes + size > maxBytes) {
-            hitBytes = true
-            break
-          }
-          out.push(lines[i])
-          bytes += size
-        }
-      } else {
-        for (i = lines.length - 1; i >= 0 && out.length < maxLines; i--) {
-          const size = Buffer.byteLength(lines[i], "utf-8") + (out.length > 0 ? 1 : 0)
-          if (bytes + size > maxBytes) {
-            hitBytes = true
-            break
-          }
-          out.unshift(lines[i])
-          bytes += size
-        }
-      }
-
-      const removed = hitBytes ? totalBytes - bytes : lines.length - out.length
-      const unit = hitBytes ? "bytes" : "lines"
-      const preview = out.join("\n")
-      const file = yield* write(text)
-
-      const hint = hasTaskTool(agent)
-        ? `The tool call succeeded but the output was truncated. Full output saved to: ${file}\nUse the Task tool to have explore agent process this file with Grep and Read (with offset/limit). Do NOT read the full file yourself - delegate to save context.`
-        : `The tool call succeeded but the output was truncated. Full output saved to: ${file}\nUse Grep to search the full content or Read with offset/limit to view specific sections.`
-
-      return {
-        content:
-          direction === "head"
-            ? `${preview}\n\n...${removed} ${unit} truncated...\n\n${hint}`
-            : `...${removed} ${unit} truncated...\n\n${hint}\n\n${preview}`,
-        truncated: true,
-        outputPath: file,
-      } as const
-    })
-
-    yield* cleanup().pipe(
-      Effect.catchCause((cause) => {
-        log.error("truncation cleanup failed", { cause: Cause.pretty(cause) })
-        return Effect.void
-      }),
-      Effect.repeat(Schedule.spaced(Duration.hours(1))),
-      Effect.delay(Duration.minutes(1)),
-      Effect.forkScoped,
-    )
-
-    return Service.of({ cleanup, write, output, limits })
-  }),
-)
-
-export const defaultLayer = layer.pipe(Layer.provide(AppFileSystem.defaultLayer), Layer.provide(NodePath.layer))
-
-export * as Truncate from "./truncate"
+import { NodePath } from "@effect/platform-node"
+import { Cause, Duration, Effect, Layer, Option, Schedule, Context } from "effect"
+import path from "path"
+import type { Agent } from "../agent/agent"
+import { AppFileSystem } from "@opencode-ai/core/filesystem"
+import { evaluate } from "@/permission/evaluate"
+import { Config } from "@/config/config"
+import { Identifier } from "../id/id"
+import * as Log from "@opencode-ai/core/util/log"
+import { ToolID } from "./schema"
+import { TRUNCATION_DIR } from "./truncation-dir"
+
+const log = Log.create({ service: "truncation" })
+const RETENTION = Duration.days(7)
+
+export const MAX_LINES = 2000
+export const MAX_BYTES = 50 * 1024
+export const DIR = TRUNCATION_DIR
+export const GLOB = path.join(TRUNCATION_DIR, "*")
+
+export type Result = { content: string; truncated: false } | { content: string; truncated: true; outputPath: string }
+
+export interface Options {
+  maxLines?: number
+  maxBytes?: number
+  direction?: "head" | "tail"
+}
+
+function hasTaskTool(agent?: Agent.Info) {
+  if (!agent?.permission) return false
+  return evaluate("task", "*", agent.permission).action !== "deny"
+}
+
+export interface Interface {
+  readonly cleanup: () => Effect.Effect<void>
+  readonly write: (text: string) => Effect.Effect<string>
+  /**
+   * Returns output unchanged when it fits within the limits, otherwise writes the full text
+   * to the truncation directory and returns a preview plus a hint to inspect the saved file.
+   */
+  readonly output: (text: string, options?: Options, agent?: Agent.Info) => Effect.Effect<Result>
+  /**
+   * Resolved truncation limits: values from `tool_output` in opencode config, or MAX_LINES / MAX_BYTES if unset.
+   */
+  readonly limits: () => Effect.Effect<{ maxLines: number; maxBytes: number }>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@opencode/Truncate") {}
+
+export const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const fs = yield* AppFileSystem.Service
+
+    const cleanup = Effect.fn("Truncate.cleanup")(function* () {
+      const cutoff = Identifier.timestamp(
+        Identifier.create("tool", "ascending", Date.now() - Duration.toMillis(RETENTION)),
+      )
+      const entries = yield* fs.readDirectory(TRUNCATION_DIR).pipe(
+        Effect.map((all) => all.filter((name) => name.startsWith("tool_"))),
+        Effect.catch(() => Effect.succeed([])),
+      )
+      for (const entry of entries) {
+        if (Identifier.timestamp(entry) >= cutoff) continue
+        yield* fs.remove(path.join(TRUNCATION_DIR, entry)).pipe(Effect.catch(() => Effect.void))
+      }
+    })
+
+    const write = Effect.fn("Truncate.write")(function* (text: string) {
+      const file = path.join(TRUNCATION_DIR, ToolID.ascending())
+      yield* fs.ensureDir(TRUNCATION_DIR).pipe(Effect.orDie)
+      yield* fs.writeFileString(file, text).pipe(Effect.orDie)
+      return file
+    })
+
+    const limits = Effect.fn("Truncate.limits")(function* () {
+      const configSvc = yield* Effect.serviceOption(Config.Service)
+      if (Option.isNone(configSvc)) return { maxLines: MAX_LINES, maxBytes: MAX_BYTES }
+      const cfg = yield* configSvc.value.get().pipe(Effect.catch(() => Effect.succeed(undefined)))
+      return {
+        maxLines: cfg?.tool_output?.max_lines ?? MAX_LINES,
+        maxBytes: cfg?.tool_output?.max_bytes ?? MAX_BYTES,
+      }
+    })
+
+    const output = Effect.fn("Truncate.output")(function* (text: string, options: Options = {}, agent?: Agent.Info) {
+      const resolved = yield* limits()
+      const maxLines = options.maxLines ?? resolved.maxLines
+      const maxBytes = options.maxBytes ?? resolved.maxBytes
+      const direction = options.direction ?? "head"
+      const lines = text.split("\n")
+      const totalBytes = Buffer.byteLength(text, "utf-8")
+
+      if (lines.length <= maxLines && totalBytes <= maxBytes) {
+        return { content: text, truncated: false } as const
+      }
+
+      const out: string[] = []
+      let i = 0
+      let bytes = 0
+      let hitBytes = false
+
+      if (direction === "head") {
+        for (i = 0; i < lines.length && i < maxLines; i++) {
+          const size = Buffer.byteLength(lines[i], "utf-8") + (i > 0 ? 1 : 0)
+          if (bytes + size > maxBytes) {
+            hitBytes = true
+            break
+          }
+          out.push(lines[i])
+          bytes += size
+        }
+      } else {
+        for (i = lines.length - 1; i >= 0 && out.length < maxLines; i--) {
+          const size = Buffer.byteLength(lines[i], "utf-8") + (out.length > 0 ? 1 : 0)
+          if (bytes + size > maxBytes) {
+            hitBytes = true
+            break
+          }
+          out.unshift(lines[i])
+          bytes += size
+        }
+      }
+
+      const removed = hitBytes ? totalBytes - bytes : lines.length - out.length
+      const unit = hitBytes ? "bytes" : "lines"
+      const preview = out.join("\n")
+      const file = yield* write(text)
+
+      const hint = hasTaskTool(agent)
+        ? `The tool call succeeded but the output was truncated. Full output saved to: ${file}\nUse the Task tool to have explore agent process this file with Grep and Read (with offset/limit). Do NOT read the full file yourself - delegate to save context.`
+        : `The tool call succeeded but the output was truncated. Full output saved to: ${file}\nUse Grep to search the full content or Read with offset/limit to view specific sections.`
+
+      return {
+        content:
+          direction === "head"
+            ? `${preview}\n\n...${removed} ${unit} truncated...\n\n${hint}`
+            : `...${removed} ${unit} truncated...\n\n${hint}\n\n${preview}`,
+        truncated: true,
+        outputPath: file,
+      } as const
+    })
+
+    yield* cleanup().pipe(
+      Effect.catchCause((cause) => {
+        log.error("truncation cleanup failed", { cause: Cause.pretty(cause) })
+        return Effect.void
+      }),
+      Effect.repeat(Schedule.spaced(Duration.hours(1))),
+      Effect.delay(Duration.minutes(1)),
+      Effect.forkScoped,
+    )
+
+    return Service.of({ cleanup, write, output, limits })
+  }),
+)
+
+export const defaultLayer = layer.pipe(Layer.provide(AppFileSystem.defaultLayer), Layer.provide(NodePath.layer))
+
+export * as Truncate from "./truncate"

package/src/engine/tool/tool/truncation-dir.ts

@@ -1,4 +1,4 @@
-import path from "path"
-import { Global } from "@opencode-ai/core/global"
-
-export const TRUNCATION_DIR = path.join(Global.Path.data, "tool-output")
+import path from "path"
+import { Global } from "@opencode-ai/core/global"
+
+export const TRUNCATION_DIR = path.join(Global.Path.data, "tool-output")