opencode-overclock 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Thomas Caron
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,120 @@
+# opencode-overclock
+
+Power-ups for [opencode](https://opencode.ai). Background tasks, scheduling, sandboxed bash, tool hooks, usage telemetry, checkpoints. Each = module, toggleable. Module dies when opencode ships native equal/better.
+
+## Install
+
+```sh
+opencode plugin opencode-overclock       # this project
+opencode plugin -g opencode-overclock    # global
+```
+
+Requires opencode >= 1.18.9.
+
+One package, two surfaces: the **server** plugin (tools + hooks) and the **TUI** plugin (notifications + slash commands). They register in _separate_ config files, so use the command above rather than editing config by hand — it writes both:
+
+```jsonc
+// opencode.json  -> server surface
+{ "plugin": ["opencode-overclock"] }
+// tui.json       -> TUI surface  (omit this and notifications/slash commands silently never load)
+{ "plugin": ["opencode-overclock"] }
+```
+
+Local dev: copy or symlink into `.opencode/plugins/` — see [Dev](#dev). Note that a plugin _path_ only works there; `plugin` array entries resolve by npm name from the registry, and an unpublished name fails silently.
+
+## Config
+
+`.opencode/overclock.json` (optional, missing = defaults):
+
+```json
+{
+  "features": {
+    "tasks": true,
+    "sched": true,
+    "sandbox": { "net": false },
+    "guard": {
+      "hooks": [{ "name": "typecheck", "tools": ["edit", "write"], "run": "bun run typecheck" }]
+    }
+  }
+}
+```
+
+`true`/`false` toggle. Object = on + options. Defaults: all on except sandbox; guard inert without `hooks`.
+
+## Features
+
+| Module        | Tools                                                      | Does                                                                                                         |
+| ------------- | ---------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------ |
+| `tasks`       | `task_run` `task_status` `task_output` `task_kill`         | background shell cmds; exit -> result posted back into session; stall watchdog nudges on interactive prompts |
+| `sched`       | `schedule_create` `schedule_list` `schedule_delete`        | cron exprs or intervals ("5m"); interval + current session = loop; restart-safe                              |
+| `sandbox`     | `bash_unsandboxed` (escape hatch)                          | bwrap-wrap every bash call: `/` ro, project + `/tmp` rw, net configurable. Opt-in                            |
+| `guard`       | —                                                          | user hooks: after matching tool calls, run configured cmds (debounced), failures fed back to model           |
+| `usage`       | `usage_report`                                             | per-day + per-session cost/token telemetry off `message.updated` events                                      |
+| `checkpoints` | `checkpoint_list` `checkpoint_revert` `checkpoint_restore` | session revert/unrevert over opencode's shadow-git snapshots; revert gated by permission ask                 |
+
+TUI plugin (`src/tui.ts`, separate surface): OS notifications on idle/permission/question/error via `attention.notify`, slash commands for tasks/usage/schedules off the `.opencode/overclock/` state mirrors.
+
+## Layout
+
+```
+src/
+  index.ts          entry: config -> init modules -> merge hooks
+  tui.ts            TUI plugin (notifications + slash commands), separate export
+  types.ts          FeatureModule contract
+  config.ts         config loader
+  merge.ts          hook composition (many modules, same hook -> sequential)
+  lib/              state dir + json, session inject + toast
+  features/         one file per module + registry
+test/               bun test
+```
+
+## Add feature
+
+1. `src/features/<name>.ts`, export `FeatureModule`
+2. Register in `src/features/index.ts`
+
+## Docs
+
+- [docs/opencode-plugin-surface.md](docs/opencode-plugin-surface.md) — opencode plugin/hook/event surface map + upstream drift watchlist (research)
+
+## Dev
+
+```sh
+bun install
+bun test          # unit
+bun run check     # typecheck + format check
+bun run format
+bun run verify    # packaging: tarball contents, server+tui targets, manifest metadata
+```
+
+### Release
+
+```sh
+bun run check && bun test && bun run verify
+npm publish
+bun run verify:published    # runtime load, by name, from the registry
+```
+
+`verify` cannot exercise the runtime load path — opencode resolves `plugin` entries by npm
+name from the registry, and a miss is silent. `verify:published` is the only check that
+proves an installed-from-npm session actually gets the tools; run it after every publish.
+
+### Live loop
+
+`.opencode/plugins/dev.ts` re-exports `src/index.ts`, `dev-tui.ts` re-exports `src/tui.ts` -> opencode session in this repo runs both surfaces from source.
+
+1. `opencode` here. Plugin live.
+2. Edit `src/`. No hot reload -> restart opencode.
+3. State inspect: `.opencode/overclock/` (gitignored).
+
+### Headless e2e
+
+```sh
+timeout 90 opencode run -m anthropic/claude-sonnet-5 "Use task_run to run 'echo hi' ..." < /dev/null
+```
+
+Gotchas:
+
+- `< /dev/null` required. Open stdin -> hang.
+- Dev build hang on exit AFTER work done -> wrap in `timeout`, judge by artifacts (`.opencode/overclock/`, log tails), not exit code.
+- Plugin stderr: `opencode run --print-logs` or `~/.local/share/opencode/log/`. Grep `[overclock]`.

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "opencode-overclock",
+  "version": "0.1.0",
+  "description": "Power-ups for opencode: background tasks, scheduling, sandboxed bash, tool hooks, usage telemetry, checkpoints. Modular, toggleable.",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tomtom103/opencode-overclock.git"
+  },
+  "homepage": "https://github.com/tomtom103/opencode-overclock#readme",
+  "bugs": "https://github.com/tomtom103/opencode-overclock/issues",
+  "main": "src/index.ts",
+  "exports": {
+    ".": "./src/index.ts",
+    "./server": "./src/index.ts",
+    "./tui": "./src/tui.ts"
+  },
+  "files": [
+    "src"
+  ],
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "opencode-tui-plugin",
+    "agent",
+    "cli"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "format": "prettier --write .",
+    "check": "tsc --noEmit && prettier --check .",
+    "verify": "scripts/verify-pack.sh",
+    "verify:published": "scripts/verify-pack.sh --published",
+    "prepublishOnly": "tsc --noEmit && bun test"
+  },
+  "engines": {
+    "opencode": ">=1.18.9"
+  },
+  "dependencies": {
+    "@opencode-ai/plugin": "1.18.9",
+    "croner": "^10.0.1"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "prettier": "^3.9.6",
+    "typescript": "^5.7.0"
+  }
+}

package/src/config.ts

@@ -0,0 +1,19 @@
+import type { OverclockConfig } from "./types.ts"
+
+const CONFIG_PATHS = [".opencode/overclock.json", "overclock.json"]
+
+/** Load plugin config from project dir. Missing file -> {} (all defaults). */
+export async function loadConfig(directory: string): Promise<OverclockConfig> {
+  for (const rel of CONFIG_PATHS) {
+    const file = Bun.file(`${directory}/${rel}`)
+    if (await file.exists()) {
+      try {
+        return (await file.json()) as OverclockConfig
+      } catch (e) {
+        console.warn(`[overclock] bad config ${rel}: ${e}`)
+        return {}
+      }
+    }
+  }
+  return {}
+}

package/src/features/checkpoints.ts

@@ -0,0 +1,127 @@
+import { tool, type PluginInput } from "@opencode-ai/plugin"
+import type { FeatureModule } from "../types.ts"
+
+const z = tool.schema
+
+type Client = PluginInput["client"]
+
+interface MessagePart {
+  type: string
+  text?: string
+}
+
+interface MessageEntry {
+  info: {
+    id: string
+    role: string
+    time?: { created?: number }
+  }
+  parts: MessagePart[]
+}
+
+const collapse = (s: string) => s.replace(/\s+/g, " ").trim()
+
+/** Exported for tests: revert/unrevert/list core, decoupled from plugin ctx. */
+export interface Checkpoints {
+  list(sessionID: string): Promise<string>
+  revert(sessionID: string, messageID: string): Promise<string>
+  restore(sessionID: string): Promise<string>
+}
+
+export function createCheckpoints(client: Client): Checkpoints {
+  async function list(sessionID: string): Promise<string> {
+    try {
+      const res = await client.session.messages({ path: { id: sessionID } })
+      const msgs = ((res.data ?? []) as MessageEntry[]).filter((m) => m.info.role === "user")
+      if (!msgs.length) return "no checkpoints"
+      return msgs
+        .map((m) => {
+          const time = m.info.time?.created
+            ? new Date(m.info.time.created).toISOString()
+            : "unknown time"
+          const text = m.parts.find((p) => p.type === "text" && typeof p.text === "string")?.text ?? ""
+          const preview = collapse(text).slice(0, 60)
+          return `${m.info.id} ${time} ${preview}`
+        })
+        .join("\n")
+    } catch (e) {
+      console.warn(`[overclock] checkpoints: list failed (session ${sessionID}): ${e}`)
+      return `error listing checkpoints: ${e}`
+    }
+  }
+
+  async function revert(sessionID: string, messageID: string): Promise<string> {
+    try {
+      await client.session.revert({ path: { id: sessionID }, body: { messageID } })
+      return `reverted session ${sessionID} to before message ${messageID}`
+    } catch (e) {
+      console.warn(
+        `[overclock] checkpoints: revert failed (session ${sessionID}, message ${messageID}): ${e}`,
+      )
+      return `error reverting checkpoint: ${e}`
+    }
+  }
+
+  async function restore(sessionID: string): Promise<string> {
+    try {
+      await client.session.unrevert({ path: { id: sessionID } })
+      return `restored session ${sessionID} to latest (undo revert)`
+    } catch (e) {
+      console.warn(`[overclock] checkpoints: restore failed (session ${sessionID}): ${e}`)
+      return `error restoring checkpoint: ${e}`
+    }
+  }
+
+  return { list, revert, restore }
+}
+
+/**
+ * Shadow-git revert tools (map doc: "Checkpoints — none gap"). Wraps native
+ * session.revert/unrevert around each user message as a revert point.
+ */
+export const checkpoints: FeatureModule = {
+  name: "checkpoints",
+  defaultEnabled: true,
+  requires: ["session.revert", "session.unrevert", "session.messages"],
+  async init(ctx) {
+    const core = createCheckpoints(ctx.client)
+
+    return {
+      tool: {
+        checkpoint_list: tool({
+          description:
+            "List user messages of a session as revert points: messageID, time, first 60 chars. Most recent last.",
+          args: { sessionID: z.string().optional().describe("default: current session") },
+          async execute(args, tctx) {
+            return core.list(args.sessionID ?? tctx.sessionID)
+          },
+        }),
+        checkpoint_revert: tool({
+          description:
+            "Revert session files + conversation back to before the given message (shadow-git, reversible via checkpoint_restore). Requires user permission.",
+          args: {
+            messageID: z.string(),
+            sessionID: z.string().optional().describe("default: current session"),
+          },
+          async execute(args, tctx) {
+            const sessionID = args.sessionID ?? tctx.sessionID
+            await tctx.ask({
+              permission: "checkpoint_revert",
+              patterns: [args.messageID],
+              always: [],
+              metadata: { sessionID, messageID: args.messageID },
+            })
+            return core.revert(sessionID, args.messageID)
+          },
+        }),
+        checkpoint_restore: tool({
+          description: "Undo the most recent checkpoint_revert for a session.",
+          args: { sessionID: z.string().optional().describe("default: current session") },
+          async execute(args, tctx) {
+            return core.restore(args.sessionID ?? tctx.sessionID)
+          },
+        }),
+      },
+    }
+  },
+}

package/src/features/guard.ts

@@ -0,0 +1,227 @@
+import type { FeatureModule } from "../types.ts"
+import { inject, toast } from "../lib/inject.ts"
+
+export interface GuardHook {
+  name: string
+  tools: string[]
+  pathFilter?: string
+  run: string
+  mode: "inject" | "append"
+  debounceMs: number
+  timeoutMs: number
+  onSuccess: "silent" | "notify"
+}
+
+/** options.hooks -> validated GuardHook[]. Invalid entries -> console.warn, skipped, never throw. */
+export function parseHooks(raw: unknown): GuardHook[] {
+  if (!Array.isArray(raw)) return []
+  const hooks: GuardHook[] = []
+  for (const entry of raw) {
+    const e = (entry ?? {}) as Record<string, unknown>
+    const validTools =
+      Array.isArray(e.tools) && e.tools.length > 0 && e.tools.every((t) => typeof t === "string")
+    if (typeof e.name !== "string" || !e.name || !validTools || typeof e.run !== "string" || !e.run) {
+      console.warn(`[overclock] guard: skipping invalid hook config: ${JSON.stringify(entry)}`)
+      continue
+    }
+    hooks.push({
+      name: e.name,
+      tools: e.tools as string[],
+      pathFilter: typeof e.pathFilter === "string" ? e.pathFilter : undefined,
+      run: e.run,
+      mode: e.mode === "append" ? "append" : "inject",
+      debounceMs: typeof e.debounceMs === "number" ? e.debounceMs : 2000,
+      timeoutMs: typeof e.timeoutMs === "number" ? e.timeoutMs : 60000,
+      onSuccess: e.onSuccess === "notify" ? "notify" : "silent",
+    })
+  }
+  return hooks
+}
+
+/** tools: exact match. pathFilter set + no filePath -> no match. */
+export function matchHook(hook: GuardHook, toolName: string, filePath: string | undefined): boolean {
+  if (!hook.tools.includes(toolName)) return false
+  if (!hook.pathFilter) return true
+  if (typeof filePath !== "string") return false
+  return new Bun.Glob(hook.pathFilter).match(filePath)
+}
+
+/** `[guard "<name>" failed (exit <code>)]` + last 40 lines of combined stdout+stderr. */
+export function failurePayload(name: string, code: number | null, combined: string): string {
+  const tail = combined.split("\n").slice(-40).join("\n")
+  return `\n\n[guard "${name}" failed (exit ${code})]\n${tail}`
+}
+
+function buildEnv(toolName: string, filePath: string | undefined): Record<string, string | undefined> {
+  return {
+    ...process.env,
+    GUARD_TOOL: toolName,
+    ...(filePath !== undefined ? { GUARD_FILE: filePath } : {}),
+  }
+}
+
+async function runCommand(
+  hook: GuardHook,
+  cwd: string,
+  env: Record<string, string | undefined>,
+  register?: (proc: Bun.Subprocess) => void,
+): Promise<{ code: number | null; combined: string }> {
+  const proc = Bun.spawn(["bash", "-c", hook.run], { cwd, env, stdout: "pipe", stderr: "pipe" })
+  register?.(proc)
+  const killTimer = setTimeout(() => proc.kill("SIGTERM"), hook.timeoutMs)
+  const [out, err, code] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+    proc.exited,
+  ])
+  clearTimeout(killTimer)
+  return { code, combined: out + err }
+}
+
+interface HookState {
+  timer?: ReturnType<typeof setTimeout>
+  running: boolean
+  lastSessionID?: string
+  lastToolName: string
+  lastFilePath?: string
+  procs: Set<Bun.Subprocess>
+}
+
+export interface GuardRunnerDeps {
+  cwd: string
+  onInject: (sessionID: string, payload: string) => Promise<void>
+  onNotify: (hookName: string) => Promise<void>
+}
+
+export interface GuardRunner {
+  /** append mode: run synchronously, return failure payload (undefined on success). */
+  runAppend(hook: GuardHook, toolName: string, filePath: string | undefined): Promise<string | undefined>
+  /** inject mode: (re)arm the trailing debounce for this hook. */
+  triggerInject(hook: GuardHook, sessionID: string, toolName: string, filePath: string | undefined): void
+  dispose(): void
+}
+
+/** Exported for tests: debounce/run core decoupled from plugin ctx. */
+export function createGuardRunner(deps: GuardRunnerDeps): GuardRunner {
+  const states = new Map<string, HookState>()
+
+  function state(name: string): HookState {
+    let s = states.get(name)
+    if (!s) {
+      s = { running: false, lastToolName: "", procs: new Set() }
+      states.set(name, s)
+    }
+    return s
+  }
+
+  async function runAppend(
+    hook: GuardHook,
+    toolName: string,
+    filePath: string | undefined,
+  ): Promise<string | undefined> {
+    const s = state(hook.name)
+    const result = await runCommand(hook, deps.cwd, buildEnv(toolName, filePath), (p) => s.procs.add(p))
+    s.procs.clear()
+    if (result.code !== 0) return failurePayload(hook.name, result.code, result.combined)
+    if (hook.onSuccess === "notify") await deps.onNotify(hook.name)
+    return undefined
+  }
+
+  async function fire(hook: GuardHook): Promise<void> {
+    const s = state(hook.name)
+    if (s.running) {
+      // still mid-run: skip this launch, re-arm the trailing debounce
+      s.timer = setTimeout(() => void fire(hook), hook.debounceMs)
+      return
+    }
+    s.running = true
+    const sessionID = s.lastSessionID
+    const toolName = s.lastToolName
+    const filePath = s.lastFilePath
+    try {
+      const result = await runCommand(hook, deps.cwd, buildEnv(toolName, filePath), (p) =>
+        s.procs.add(p),
+      )
+      if (result.code !== 0) {
+        if (sessionID)
+          await deps.onInject(sessionID, failurePayload(hook.name, result.code, result.combined))
+      } else if (hook.onSuccess === "notify") {
+        await deps.onNotify(hook.name)
+      }
+    } finally {
+      s.running = false
+      s.procs.clear()
+    }
+  }
+
+  function triggerInject(
+    hook: GuardHook,
+    sessionID: string,
+    toolName: string,
+    filePath: string | undefined,
+  ): void {
+    const s = state(hook.name)
+    s.lastSessionID = sessionID
+    s.lastToolName = toolName
+    s.lastFilePath = filePath
+    if (s.timer) clearTimeout(s.timer)
+    s.timer = setTimeout(() => void fire(hook), hook.debounceMs)
+  }
+
+  function dispose(): void {
+    for (const s of states.values()) {
+      if (s.timer) clearTimeout(s.timer)
+      for (const p of s.procs) p.kill("SIGTERM")
+    }
+  }
+
+  return { runAppend, triggerInject, dispose }
+}
+
+/**
+ * User-configurable post-tool hooks. Run commands after matching tool calls. No config -> inert.
+ * "append": run synchronously, failure appended to tool output in place.
+ * "inject" (default): debounced per hook name, failure injected as a user turn.
+ */
+export const guard: FeatureModule = {
+  name: "guard",
+  defaultEnabled: true,
+  requires: ["session.promptAsync", "session.messages"],
+  async init(ctx, options) {
+    if (options.hooks !== undefined && !Array.isArray(options.hooks)) {
+      console.warn(`[overclock] guard: options.hooks must be an array, got ${typeof options.hooks}`)
+    }
+    const hooks = parseHooks(options.hooks)
+    if (hooks.length === 0) return {}
+
+    const runner = createGuardRunner({
+      cwd: ctx.directory,
+      onInject: async (sessionID, payload) => {
+        await inject(ctx.client, sessionID, payload)
+      },
+      onNotify: async (hookName) => {
+        await toast(ctx.client, `guard "${hookName}" passed`, "success")
+      },
+    })
+
+    return {
+      dispose: async () => {
+        runner.dispose()
+      },
+      "tool.execute.after": async (input, output) => {
+        const args = input.args as Record<string, unknown> | undefined
+        const filePath = typeof args?.filePath === "string" ? args.filePath : undefined
+
+        for (const hook of hooks) {
+          if (!matchHook(hook, input.tool, filePath)) continue
+          if (hook.mode === "append") {
+            const payload = await runner.runAppend(hook, input.tool, filePath)
+            if (payload && typeof output.output === "string") output.output += payload
+          } else {
+            runner.triggerInject(hook, input.sessionID, input.tool, filePath)
+          }
+        }
+      },
+    }
+  },
+}

package/src/features/index.ts

@@ -0,0 +1,10 @@
+import type { FeatureModule } from "../types.ts"
+import { tasks } from "./tasks.ts"
+import { sched } from "./sched.ts"
+import { sandbox } from "./sandbox.ts"
+import { guard } from "./guard.ts"
+import { usage } from "./usage.ts"
+import { checkpoints } from "./checkpoints.ts"
+
+/** Registry, ordered. Order = hook composition order. */
+export const features: FeatureModule[] = [tasks, sched, sandbox, guard, usage, checkpoints]

package/src/features/sandbox.ts

@@ -0,0 +1,102 @@
+import { tool } from "@opencode-ai/plugin"
+import type { FeatureModule } from "../types.ts"
+import { shellQuote } from "../lib/state.ts"
+
+const z = tool.schema
+
+export interface SandboxPolicy {
+  project: string
+  net: boolean
+}
+
+/** Pure: wrap shell cmd in bwrap. / ro, project + /tmp rw, net per policy. */
+export function wrapCommand(cmd: string, policy: SandboxPolicy): string {
+  const args = [
+    "bwrap",
+    "--ro-bind / /",
+    "--dev /dev",
+    "--proc /proc",
+    `--bind ${shellQuote(policy.project)} ${shellQuote(policy.project)}`,
+    "--bind /tmp /tmp",
+    "--die-with-parent",
+  ]
+  if (!policy.net) args.push("--unshare-net")
+  args.push("bash -c", shellQuote(cmd))
+  return args.join(" ")
+}
+
+/** Functional probe: bwrap present AND userns allowed (WSL2/distros vary). */
+export function probeBwrap(): boolean {
+  try {
+    const res = Bun.spawnSync([
+      "bwrap",
+      "--ro-bind",
+      "/",
+      "/",
+      "--dev",
+      "/dev",
+      "--proc",
+      "/proc",
+      "true",
+    ])
+    return res.exitCode === 0
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Sandboxed bash via bubblewrap. Rewrites every bash tool call.
+ * Off by default. No bwrap -> warn once, passthrough.
+ */
+export const sandbox: FeatureModule = {
+  name: "sandbox",
+  defaultEnabled: false,
+  async init(ctx, options) {
+    const policy: SandboxPolicy = {
+      project: ctx.directory,
+      net: options.net !== false,
+    }
+    const available = probeBwrap()
+    if (!available) console.warn("[overclock] sandbox: bwrap unavailable/blocked -> passthrough")
+
+    return {
+      "tool.execute.before": async (input, output) => {
+        if (!available || input.tool !== "bash") return
+        const cmd = (output.args as { command?: string }).command
+        if (typeof cmd !== "string") return
+        output.args.command = wrapCommand(cmd, policy)
+      },
+      tool: {
+        bash_unsandboxed: tool({
+          description:
+            "Run a shell command OUTSIDE the sandbox (full FS write access). Requires user permission. Use only when the sandbox blocks a legitimate operation.",
+          args: {
+            command: z.string(),
+            cwd: z.string().optional(),
+          },
+          async execute(args, tctx) {
+            await tctx.ask({
+              permission: "bash_unsandboxed",
+              patterns: [args.command],
+              always: [],
+              metadata: { command: args.command },
+            })
+            const proc = Bun.spawn(["bash", "-c", args.command], {
+              cwd: args.cwd ?? tctx.directory,
+              stdout: "pipe",
+              stderr: "pipe",
+            })
+            const [out, err, code] = await Promise.all([
+              new Response(proc.stdout).text(),
+              new Response(proc.stderr).text(),
+              proc.exited,
+            ])
+            const text = (out + (err ? `\nstderr:\n${err}` : "")).slice(0, 30_000)
+            return `exit ${code}\n${text}`
+          },
+        }),
+      },
+    }
+  },
+}