feat(tui): speed up footer crossfade

feat(tui): simplify footer transition to crossfade
feat(tui): replace footer typewriter with cross-dissolve
2026-07-29 22:51:51 -04:00 · 2026-07-29 19:27:51 -04:00 · 2026-07-29 19:25:42 -04:00 · 2026-07-29 19:21:02 -04:00 · 2026-07-29 17:10:09 -04:00
23 changed files with 273 additions and 1049 deletions
@@ -5,7 +5,6 @@ import { Context, Effect, Layer, Schema } from "effect"
 import { dirname } from "path"
 import { KeyedMutex } from "./effect/keyed-mutex"
 import { FSUtil } from "@opencode-ai/util/fs-util"
-import { Bom } from "@opencode-ai/util/bom"

 export interface Target {
  readonly canonical: string
@@ -109,13 +108,13 @@ const layer = Layer.effect(
    const writeTextPreservingBom = Effect.fn("FileMutation.writeTextPreservingBom")((input: TextWriteInput) =>
      withTargetLock(input.target)(
        Effect.gen(function* () {
-          const next = Bom.split(input.content)
+          const next = splitBom(input.content)
          const current = yield* fs
            .readFile(input.target.canonical)
            .pipe(Effect.catchReason("PlatformError", "NotFound", () => Effect.succeed(undefined)))
          yield* fs.writeWithDirs(
            input.target.canonical,
-            Bom.join(next.text, Boolean(current && Bom.has(current)) || next.bom),
+            joinBom(next.text, Boolean(current && hasUtf8Bom(current)) || next.bom),
          )
          return writeResult(input.target, current !== undefined)
        }),
@@ -173,6 +172,20 @@ const layer = Layer.effect(
  }),
 )

+function splitBom(text: string) {
+  const stripped = text.replace(/^\uFEFF+/, "")
+  return { bom: stripped.length !== text.length, text: stripped }
+}
+
+function joinBom(text: string, bom: boolean) {
+  const stripped = splitBom(text).text
+  return bom ? `\uFEFF${stripped}` : stripped
+}
+
+function hasUtf8Bom(content: Uint8Array) {
+  return content[0] === 0xef && content[1] === 0xbb && content[2] === 0xbf
+}
+
 function sameBytes(left: Uint8Array, right: Uint8Array) {
  if (left.length !== right.length) return false
  return left.every((byte, index) => byte === right[index])
@@ -1,157 +0,0 @@
-export * as Formatter from "./formatter"
-
-import { Context, Effect, Layer, Schema } from "effect"
-import { ChildProcess } from "effect/unstable/process"
-import path from "path"
-import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
-import { FSUtil } from "@opencode-ai/util/fs-util"
-import { Npm } from "@opencode-ai/util/npm"
-import { AppProcess } from "@opencode-ai/util/process"
-import { Config } from "./config"
-import { Location } from "./location"
-import { make, type Info } from "./formatter/builtins"
-
-export const Status = Schema.Struct({
-  name: Schema.String,
-  extensions: Schema.Array(Schema.String),
-  enabled: Schema.Boolean,
-}).annotate({ identifier: "FormatterStatus" })
-export type Status = typeof Status.Type
-
-export interface Interface {
-  readonly init: () => Effect.Effect<void>
-  readonly status: () => Effect.Effect<Status[]>
-  readonly file: (filepath: string) => Effect.Effect<boolean>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/v2/Formatter") {}
-
-const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const config = yield* Config.Service
-    const fs = yield* FSUtil.Service
-    const location = yield* Location.Service
-    const npm = yield* Npm.Service
-    const processes = yield* AppProcess.Service
-    const commands = new Map<string, string[] | false>()
-    let formatters: Info[] = []
-
-    const load = yield* Effect.cached(
-      Effect.gen(function* () {
-        const configured = Config.latest(yield* config.entries(), "formatter")
-        if (!configured) {
-          yield* Effect.logInfo("all formatters are disabled")
-          return
-        }
-
-        const builtIns = make({
-          directory: location.directory,
-          worktree: location.project.directory,
-          fs,
-          npm,
-          processes,
-        })
-        formatters = builtIns
-        if (configured === true) return
-        if (configured.ruff?.disabled || configured.uv?.disabled) {
-          formatters = formatters.filter((formatter) => formatter.name !== "ruff" && formatter.name !== "uv")
-        }
-
-        for (const [name, entry] of Object.entries(configured)) {
-          const index = formatters.findIndex((formatter) => formatter.name === name)
-          if (entry.disabled) {
-            if (index !== -1) formatters.splice(index, 1)
-            continue
-          }
-
-          const builtIn = builtIns.find((formatter) => formatter.name === name)
-          const formatter: Info = {
-            name,
-            extensions: entry.extensions ?? builtIn?.extensions ?? [],
-            environment: { ...builtIn?.environment, ...entry.environment },
-            enabled:
-              builtIn && !entry.command ? builtIn.enabled : Effect.succeed(entry.command ? [...entry.command] : false),
-          }
-          if (index === -1) formatters.push(formatter)
-          else formatters[index] = formatter
-        }
-      }).pipe(Effect.withSpan("Formatter.load")),
-    )
-
-    const command = Effect.fnUntraced(function* (formatter: Info) {
-      const cached = commands.get(formatter.name)
-      if (cached !== undefined) return cached
-      const result = yield* formatter.enabled
-      if (result !== false) commands.set(formatter.name, result)
-      return result
-    })
-
-    const init = Effect.fn("Formatter.init")(function* () {
-      yield* load
-    })
-
-    const status = Effect.fn("Formatter.status")(function* () {
-      yield* load
-      return yield* Effect.forEach(formatters, (formatter) =>
-        command(formatter).pipe(
-          Effect.map((enabled) => ({
-            name: formatter.name,
-            extensions: [...formatter.extensions],
-            enabled: enabled !== false,
-          })),
-        ),
-      )
-    })
-
-    const file = Effect.fn("Formatter.file")(function* (filepath: string) {
-      yield* load
-      const matching = formatters.filter((formatter) =>
-        formatter.extensions.includes(path.extname(filepath)),
-      )
-
-      for (const formatter of matching) {
-        const enabled = yield* command(formatter)
-        if (enabled === false) continue
-        const cmd = enabled.map((argument) => argument.replace("$FILE", filepath))
-        yield* Effect.logInfo("formatting file", { file: filepath, command: cmd })
-        const result = yield* processes
-          .run(
-            ChildProcess.make(cmd[0], cmd.slice(1), {
-              cwd: location.directory,
-              env: formatter.environment,
-              extendEnv: true,
-              stdin: "ignore",
-              stdout: "ignore",
-              stderr: "ignore",
-            }),
-          )
-          .pipe(
-            Effect.catch((error) =>
-              Effect.logError("failed to format file", {
-                file: filepath,
-                command: cmd,
-                error: error.message,
-              }).pipe(Effect.as(undefined)),
-            ),
-          )
-        if (!result) continue
-        if (result.exitCode === 0) return true
-        yield* Effect.logError("formatter exited unsuccessfully", {
-          file: filepath,
-          command: cmd,
-          exitCode: result.exitCode,
-        })
-      }
-      return false
-    })
-
-    return Service.of({ init, status, file })
-  }),
-)
-
-export const node = makeLocationNode({
-  service: Service,
-  layer,
-  deps: [Config.node, FSUtil.node, Location.node, Npm.node, AppProcess.node],
-})
@@ -1,315 +0,0 @@
-import { Effect } from "effect"
-import { ChildProcess } from "effect/unstable/process"
-import { FSUtil } from "@opencode-ai/util/fs-util"
-import { Npm } from "@opencode-ai/util/npm"
-import { AppProcess } from "@opencode-ai/util/process"
-import { which } from "../util/which"
-
-export interface Info {
-  readonly name: string
-  readonly environment?: Record<string, string>
-  readonly extensions: readonly string[]
-  readonly enabled: Effect.Effect<string[] | false>
-}
-
-export function make(input: {
-  readonly directory: string
-  readonly worktree: string
-  readonly fs: FSUtil.Interface
-  readonly npm: Npm.Interface
-  readonly processes: AppProcess.Interface
-  readonly experimentalOxfmt?: boolean
-}) {
-  const disabled = false as const
-  const findUp = (target: string) => input.fs.findUp(target, input.directory, input.worktree)
-  const readText = (file: string) => input.fs.readFileString(file).pipe(Effect.orElseSucceed(() => ""))
-  const commandOutput = (command: string[]) =>
-    input.processes
-      .run(
-        ChildProcess.make(command[0], command.slice(1), {
-          cwd: input.directory,
-          extendEnv: true,
-          stdin: "ignore",
-        }),
-      )
-      .pipe(Effect.option)
-
-  const gofmt: Info = {
-    name: "gofmt",
-    extensions: [".go"],
-    enabled: Effect.sync(() => {
-      const match = which("gofmt")
-      return match ? [match, "-w", "$FILE"] : disabled
-    }),
-  }
-
-  const mix: Info = {
-    name: "mix",
-    extensions: [".ex", ".exs", ".eex", ".heex", ".leex", ".neex", ".sface"],
-    enabled: Effect.sync(() => {
-      const match = which("mix")
-      return match ? [match, "format", "$FILE"] : disabled
-    }),
-  }
-
-  const prettier: Info = {
-    name: "prettier",
-    environment: { BUN_BE_BUN: "1" },
-    extensions: [
-      ".js",
-      ".jsx",
-      ".mjs",
-      ".cjs",
-      ".ts",
-      ".tsx",
-      ".mts",
-      ".cts",
-      ".html",
-      ".htm",
-      ".css",
-      ".scss",
-      ".sass",
-      ".less",
-      ".vue",
-      ".svelte",
-      ".json",
-      ".jsonc",
-      ".yaml",
-      ".yml",
-      ".toml",
-      ".xml",
-      ".md",
-      ".mdx",
-      ".graphql",
-      ".gql",
-    ],
-    enabled: Effect.gen(function* () {
-      for (const file of yield* findUp("package.json")) {
-        if (!hasDependency(yield* input.fs.readJson(file), "prettier")) continue
-        const bin = yield* input.npm.which("prettier")
-        if (bin) return [bin, "--write", "$FILE"]
-      }
-      return disabled
-    }).pipe(Effect.orElseSucceed(() => disabled)),
-  }
-
-  const oxfmt: Info = {
-    name: "oxfmt",
-    environment: { BUN_BE_BUN: "1" },
-    extensions: [".js", ".jsx", ".mjs", ".cjs", ".ts", ".tsx", ".mts", ".cts"],
-    enabled: Effect.gen(function* () {
-      for (const file of yield* findUp("package.json")) {
-        if (!hasDependency(yield* input.fs.readJson(file), "oxfmt")) continue
-        const bin = yield* input.npm.which("oxfmt")
-        if (bin) return [bin, "$FILE"]
-      }
-      return disabled
-    }).pipe(Effect.orElseSucceed(() => disabled)),
-  }
-
-  const biome: Info = {
-    name: "biome",
-    environment: { BUN_BE_BUN: "1" },
-    extensions: [
-      ".js",
-      ".jsx",
-      ".mjs",
-      ".cjs",
-      ".ts",
-      ".tsx",
-      ".mts",
-      ".cts",
-      ".html",
-      ".htm",
-      ".css",
-      ".scss",
-      ".sass",
-      ".less",
-      ".vue",
-      ".svelte",
-      ".json",
-      ".jsonc",
-      ".yaml",
-      ".yml",
-      ".toml",
-      ".xml",
-      ".md",
-      ".mdx",
-      ".graphql",
-      ".gql",
-    ],
-    enabled: Effect.gen(function* () {
-      const found = yield* Effect.forEach(["biome.json", "biome.jsonc"], findUp, { concurrency: "unbounded" })
-      if (!found.some((items) => items.length > 0)) return disabled
-      const bin = yield* input.npm.which("@biomejs/biome")
-      return bin ? [bin, "format", "--write", "$FILE"] : disabled
-    }).pipe(Effect.orElseSucceed(() => disabled)),
-  }
-
-  const zig: Info = {
-    name: "zig",
-    extensions: [".zig", ".zon"],
-    enabled: Effect.sync(() => {
-      const match = which("zig")
-      return match ? [match, "fmt", "$FILE"] : disabled
-    }),
-  }
-
-  const clang: Info = {
-    name: "clang-format",
-    extensions: [".c", ".cc", ".cpp", ".cxx", ".c++", ".h", ".hh", ".hpp", ".hxx", ".h++", ".ino", ".C", ".H"],
-    enabled: Effect.gen(function* () {
-      if (!(yield* findUp(".clang-format")).length) return disabled
-      const match = which("clang-format")
-      return match ? [match, "-i", "$FILE"] : disabled
-    }).pipe(Effect.orElseSucceed(() => disabled)),
-  }
-
-  const ktlint: Info = {
-    name: "ktlint",
-    extensions: [".kt", ".kts"],
-    enabled: Effect.sync(() => {
-      const match = which("ktlint")
-      return match ? [match, "-F", "$FILE"] : disabled
-    }),
-  }
-
-  const ruff: Info = {
-    name: "ruff",
-    extensions: [".py", ".pyi"],
-    enabled: Effect.gen(function* () {
-      if (!which("ruff")) return disabled
-      for (const config of ["pyproject.toml", "ruff.toml", ".ruff.toml"]) {
-        const found = yield* findUp(config)
-        if (!found.length) continue
-        if (config !== "pyproject.toml" || (yield* readText(found[0])).includes("[tool.ruff]")) {
-          return ["ruff", "format", "$FILE"]
-        }
-      }
-      for (const dependency of ["requirements.txt", "pyproject.toml", "Pipfile"]) {
-        const found = yield* findUp(dependency)
-        if (found.length && (yield* readText(found[0])).includes("ruff")) return ["ruff", "format", "$FILE"]
-      }
-      return disabled
-    }).pipe(Effect.orElseSucceed(() => disabled)),
-  }
-
-  const air: Info = {
-    name: "air",
-    extensions: [".R"],
-    enabled: Effect.gen(function* () {
-      const bin = which("air")
-      if (!bin) return disabled
-      const output = yield* commandOutput([bin, "--help"])
-      if (output._tag === "None" || output.value.exitCode !== 0) return disabled
-      const first = output.value.stdout.toString("utf8").split("\n")[0]
-      return first.includes("R language") && first.includes("formatter") ? [bin, "format", "$FILE"] : disabled
-    }),
-  }
-
-  const uv: Info = {
-    name: "uv",
-    extensions: [".py", ".pyi"],
-    enabled: Effect.gen(function* () {
-      const bin = which("uv")
-      if (!bin) return disabled
-      const output = yield* commandOutput([bin, "format", "--help"])
-      return output._tag === "Some" && output.value.exitCode === 0
-        ? [bin, "format", "--", "$FILE"]
-        : disabled
-    }),
-  }
-
-  const rubocop = executable("rubocop", [".rb", ".rake", ".gemspec", ".ru"], ["--autocorrect", "$FILE"])
-  const standardrb = executable("standardrb", [".rb", ".rake", ".gemspec", ".ru"], ["--fix", "$FILE"])
-  const htmlbeautifier = executable("htmlbeautifier", [".erb", ".html.erb"], ["$FILE"])
-  const dart = executable("dart", [".dart"], ["format", "$FILE"])
-
-  const ocamlformat: Info = {
-    name: "ocamlformat",
-    extensions: [".ml", ".mli"],
-    enabled: Effect.gen(function* () {
-      if (!(yield* findUp(".ocamlformat")).length) return disabled
-      const match = which("ocamlformat")
-      return match ? [match, "-i", "$FILE"] : disabled
-    }).pipe(Effect.orElseSucceed(() => disabled)),
-  }
-
-  const terraform = executable("terraform", [".tf", ".tfvars"], ["fmt", "$FILE"])
-  const latexindent = executable("latexindent", [".tex"], ["-w", "-s", "$FILE"])
-  const gleam = executable("gleam", [".gleam"], ["format", "$FILE"])
-  const shfmt = executable("shfmt", [".sh", ".bash"], ["-w", "$FILE"])
-  const nixfmt = executable("nixfmt", [".nix"], ["$FILE"])
-  const rustfmt = executable("rustfmt", [".rs"], ["$FILE"])
-
-  const pint: Info = {
-    name: "pint",
-    extensions: [".php"],
-    enabled: Effect.gen(function* () {
-      for (const file of yield* findUp("composer.json")) {
-        const json = yield* input.fs.readJson(file)
-        if (hasRecordKey(json, "require", "laravel/pint") || hasRecordKey(json, "require-dev", "laravel/pint")) {
-          return ["./vendor/bin/pint", "$FILE"]
-        }
-      }
-      return disabled
-    }).pipe(Effect.orElseSucceed(() => disabled)),
-  }
-
-  const ormolu = executable("ormolu", [".hs"], ["-i", "$FILE"])
-  const cljfmt = executable("cljfmt", [".clj", ".cljs", ".cljc", ".edn"], ["fix", "--quiet", "$FILE"])
-  const dfmt = executable("dfmt", [".d"], ["-i", "$FILE"])
-
-  return [
-    gofmt,
-    mix,
-    oxfmt,
-    prettier,
-    biome,
-    zig,
-    clang,
-    ktlint,
-    ruff,
-    air,
-    uv,
-    rubocop,
-    standardrb,
-    htmlbeautifier,
-    dart,
-    ocamlformat,
-    terraform,
-    latexindent,
-    gleam,
-    shfmt,
-    nixfmt,
-    rustfmt,
-    pint,
-    ormolu,
-    cljfmt,
-    dfmt,
-  ] satisfies Info[]
-}
-
-function executable(name: string, extensions: readonly string[], args: string[]): Info {
-  return {
-    name,
-    extensions,
-    enabled: Effect.sync(() => {
-      const match = which(name)
-      return match ? [match, ...args] : false
-    }),
-  }
-}
-
-function hasDependency(input: unknown, dependency: string) {
-  return hasRecordKey(input, "dependencies", dependency) || hasRecordKey(input, "devDependencies", dependency)
-}
-
-function hasRecordKey(input: unknown, field: string, key: string) {
-  if (!isRecord(input)) return false
-  return isRecord(input[field]) && key in input[field]
-}
-
-function isRecord(input: unknown): input is Record<string, unknown> {
-  return Boolean(input && typeof input === "object" && !Array.isArray(input))
-}
@@ -8,7 +8,6 @@ import { LayerNode } from "@opencode-ai/util/effect/layer-node"
 import { Node } from "@opencode-ai/util/effect/app-node"
 import { Bus } from "./bus"
 import { FileMutation } from "./file-mutation"
-import { Formatter } from "./formatter"
 import { FileSystem } from "./filesystem"
 import { FileSystemSearch } from "./filesystem/search"
 import { Generate } from "./generate"
@@ -74,7 +73,6 @@ const locationServiceNodes = [
  InstructionDiscovery.node,
  LocationMutation.node,
  FileMutation.node,
-  Formatter.node,
  MCP.node,
  Permission.node,
  Tool.node,
@@ -16,7 +16,6 @@ import { ConfigSkillPlugin } from "../config/plugin/skill"
 import { ConfigWebSearchPlugin } from "../config/plugin/websearch"
 import { Bus } from "../bus"
 import { FileMutation } from "../file-mutation"
-import { Formatter } from "../formatter"
 import { Form } from "../form"
 import { FileSystem } from "../filesystem"
 import { FSUtil } from "@opencode-ai/util/fs-util"
@@ -69,7 +68,6 @@ const services = Effect.fn("PluginInternal.services")(function* () {
  const config = yield* Config.Service
  const bus = yield* Bus.Service
  const mutation = yield* FileMutation.Service
-  const formatter = yield* Formatter.Service
  const filesystem = yield* FileSystem.Service
  const fs = yield* FSUtil.Service
  const global = yield* Global.Service
@@ -100,7 +98,6 @@ const services = Effect.fn("PluginInternal.services")(function* () {
    Context.make(Config.Service, config),
    Context.make(Bus.Service, bus),
    Context.make(FileMutation.Service, mutation),
-    Context.make(Formatter.Service, formatter),
    Context.make(FileSystem.Service, filesystem),
    Context.make(FSUtil.Service, fs),
    Context.make(Global.Service, global),
@@ -14,7 +14,6 @@ import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import { httpClient } from "@opencode-ai/util/effect/app-node-platform"
 import { Bus } from "../bus"
 import { FileMutation } from "../file-mutation"
-import { Formatter } from "../formatter"
 import { FileSystem } from "../filesystem"
 import { Watcher } from "../filesystem/watcher"
 import { Form } from "../form"
@@ -319,7 +318,6 @@ export const node = makeLocationNode({
    Config.node,
    Bus.node,
    FileMutation.node,
-    Formatter.node,
    FileSystem.node,
    FSUtil.node,
    Global.node,
@@ -9,11 +9,9 @@ export * as EditTool from "./edit"
 import type { Context as PluginContext } from "@opencode-ai/plugin/effect/plugin"
 import { ToolFailure } from "@opencode-ai/ai"
 import { FileDiff } from "@opencode-ai/schema/file-diff"
-import { Bom } from "@opencode-ai/util/bom"
 import { createTwoFilesPatch, diffLines } from "diff"
 import { Effect, Schema } from "effect"
 import { FileMutation } from "../../file-mutation"
-import { Formatter } from "../../formatter"
 import { FSUtil } from "@opencode-ai/util/fs-util"
 import { LocationMutation } from "../../location-mutation"
 import { Permission } from "../../permission"
@@ -101,6 +99,7 @@ const findLineOccurrences = (content: string, search: string) => {
 }

 /** Deferred edit behavior and UX integrations remain visible at the model-facing seam. */
+// TODO: Add formatter integration after formatter runtime exists.
 // TODO: Publish watcher/file-edit events after watcher integration exists.
 // TODO: Add snapshots / undo after design exists.
 // TODO: Add LSP notification and diagnostics after LSP runtime exists.
@@ -110,7 +109,6 @@ export const Plugin = {
  effect: Effect.fn("EditTool.Plugin")(function* (ctx: PluginContext) {
    const mutation = yield* LocationMutation.Service
    const files = yield* FileMutation.Service
-    const formatter = yield* Formatter.Service
    const fs = yield* FSUtil.Service
    const permission = yield* Permission.Service

@@ -153,6 +151,14 @@ export const Plugin = {
                    })
                  }

+                  yield* permission.assert({
+                    action: "edit",
+                    resources: [target.resource],
+                    save: ["*"],
+                    sessionID: context.sessionID,
+                    agent: context.agent,
+                    source: permissionSource,
+                  })
                  const info = yield* fs.stat(target.canonical).pipe(
                    Effect.catchReason("PlatformError", "NotFound", () =>
                      Effect.fail(new ToolFailure({ message: `File not found: ${input.path}` })),
@@ -161,8 +167,9 @@ export const Plugin = {
                  if (info.type === "Directory") {
                    return yield* new ToolFailure({ message: `Path is a directory, not a file: ${input.path}` })
                  }
-                  const original = yield* Bom.readFile(fs, target.canonical)
-                  const source = original.text
+                  const bytes = yield* fs.readFile(target.canonical)
+                  const bom = bytes[0] === 0xef && bytes[1] === 0xbb && bytes[2] === 0xbf
+                  const source = new TextDecoder().decode(bom ? bytes.slice(3) : bytes)
                  const ending = source.includes(crlf) ? crlf : "\n"
                  const oldString = input.oldString.replaceAll(crlf, "\n").replaceAll("\n", ending)
                  const newString = input.newString.replaceAll(crlf, "\n").replaceAll("\n", ending)
@@ -176,26 +183,6 @@ export const Plugin = {
                      : findLineOccurrences(source, oldString)
                  const matches = exact.length > 0 ? exact : unicode.length > 0 ? unicode : trailing
                  const replacements = matches.length
-                  const replaced = (input.replaceAll === true ? matches : matches.slice(0, 1))
-                    .toReversed()
-                    .reduce(
-                      (content, match) =>
-                        `${content.slice(0, match.start)}${newString}${content.slice(match.end)}`,
-                      source,
-                    )
-                  const preview =
-                    replacements > 0 && (replacements === 1 || input.replaceAll === true)
-                      ? fileDiff(target.resource, source, replaced)
-                      : undefined
-                  yield* permission.assert({
-                    action: "edit",
-                    resources: [target.resource],
-                    save: ["*"],
-                    metadata: preview ? { files: [preview] } : undefined,
-                    sessionID: context.sessionID,
-                    agent: context.agent,
-                    source: permissionSource,
-                  })
                  if (replacements === 0) {
                    return yield* new ToolFailure({
                      message: `Could not find oldString in ${input.path}. It must match exactly, including whitespace and indentation.`,
@@ -206,17 +193,35 @@ export const Plugin = {
                      message: `Found ${replacements} matches for oldString, but expected exactly one. Add more surrounding context to make oldString unique, or set replaceAll to true to replace every occurrence.`,
                    })
                  }
+
+                  const replaced = (input.replaceAll === true ? matches : matches.slice(0, 1))
+                    .toReversed()
+                    .reduce(
+                      (content, match) =>
+                        `${content.slice(0, match.start)}${newString}${content.slice(match.end)}`,
+                      source,
+                    )
+                  const counts = diffLines(source, replaced).reduce(
+                    (result, item) => ({
+                      additions: result.additions + (item.added ? (item.count ?? 0) : 0),
+                      deletions: result.deletions + (item.removed ? (item.count ?? 0) : 0),
+                    }),
+                    { additions: 0, deletions: 0 },
+                  )
                  const replacementBom = replaced.startsWith("\uFEFF")
                  const result = yield* files.write({
                    target,
-                    content: Bom.join(replaced, original.bom || replacementBom),
+                    content: `${bom || replacementBom ? "\uFEFF" : ""}${replacementBom ? replaced.slice(1) : replaced}`,
                  })
-                  const bom = original.bom || replacementBom
-                  const formatted = (yield* formatter.file(target.canonical))
-                    ? yield* Bom.syncFile(fs, target.canonical, bom)
-                    : (yield* Bom.readFile(fs, target.canonical)).text
                  return {
-                    files: [fileDiff(result.resource, source, formatted)],
+                    files: [
+                      {
+                        file: result.resource,
+                        patch: createTwoFilesPatch(result.resource, result.resource, source, replaced),
+                        status: "modified" as const,
+                        ...counts,
+                      },
+                    ],
                    replacements,
                  } satisfies Output
                }).pipe(
@@ -238,19 +243,3 @@ export const Plugin = {
      .pipe(Effect.orDie)
  }),
 }
-
-function fileDiff(file: string, before: string, after: string): typeof FileDiff.Info.Type {
-  const counts = diffLines(before, after).reduce(
-    (result, item) => ({
-      additions: result.additions + (item.added ? (item.count ?? 0) : 0),
-      deletions: result.deletions + (item.removed ? (item.count ?? 0) : 0),
-    }),
-    { additions: 0, deletions: 0 },
-  )
-  return {
-    file,
-    patch: createTwoFilesPatch(file, file, before, after),
-    status: "modified",
-    ...counts,
-  }
-}
@@ -7,9 +7,7 @@ import { createTwoFilesPatch, diffLines } from "diff"
 import { Effect, Schema } from "effect"
 import { PlatformError } from "effect/PlatformError"
 import path from "path"
-import { Bom } from "@opencode-ai/util/bom"
 import { FSUtil } from "@opencode-ai/util/fs-util"
-import { Formatter } from "../../formatter"
 import { Location } from "../../location"
 import { Patch } from "@opencode-ai/util/patch"
 import { Permission } from "../../permission"
@@ -70,7 +68,6 @@ export const Plugin = {
  id: "opencode.tool.patch",
  effect: Effect.fn("PatchTool.Plugin")(function* (ctx: PluginContext) {
    const fs = yield* FSUtil.Service
-    const formatter = yield* Formatter.Service
    const location = yield* Location.Service
    const permission = yield* Permission.Service

@@ -132,16 +129,15 @@ export const Plugin = {
                          ...hunk,
                          target,
                          before: "",
-                          after: Bom.split(
-                            hunk.contents.endsWith("\n") || hunk.contents === ""
-                              ? hunk.contents
-                              : `${hunk.contents}\n`,
-                          ).text,
+                          after: (hunk.contents.endsWith("\n") || hunk.contents === ""
+                            ? hunk.contents
+                            : `${hunk.contents}\n`
+                          ).replace(/^\uFEFF/, ""),
                        })
                        return
                      }
                      if (hunk.type === "delete") {
-                        const content = yield* Bom.readFile(fs, target.canonical).pipe(
+                        const content = yield* fs.readFile(target.canonical).pipe(
                          Effect.mapError(
                            (error) =>
                              new ToolFailure({
@@ -149,7 +145,8 @@ export const Plugin = {
                              }),
                          ),
                        )
-                        prepared.push({ ...hunk, target, before: content.text, after: "" })
+                        const original = new TextDecoder("utf-8", { ignoreBOM: true }).decode(content)
+                        prepared.push({ ...hunk, target, before: original.replace(/^\uFEFF/, ""), after: "" })
                        return
                      }
                      const previous = updates.get(target.canonical)
@@ -169,17 +166,18 @@ export const Plugin = {
                              message: `patch verification failed: Failed to read file to update ${target.canonical}: path is a directory`,
                            })
                          }
-                          const content = yield* Bom.readFile(fs, target.canonical).pipe(
-                            Effect.mapError(
-                              (error) =>
-                                new ToolFailure({
-                                  message: `patch verification failed: Failed to read file to update ${target.canonical}: ${errorMessage(error)}`,
-                                }),
+                          return new TextDecoder("utf-8", { ignoreBOM: true }).decode(
+                            yield* fs.readFile(target.canonical).pipe(
+                              Effect.mapError(
+                                (error) =>
+                                  new ToolFailure({
+                                    message: `patch verification failed: Failed to read file to update ${target.canonical}: ${errorMessage(error)}`,
+                                  }),
+                              ),
                            ),
                          )
-                          return Bom.join(content.text, content.bom)
                        }))
-                      const before = Bom.split(original).text
+                      const before = original.replace(/^\uFEFF/, "")
                      const update = yield* Effect.try({
                        try: () => Patch.derive(hunk.path, hunk.chunks, original),
                        catch: (error) =>
@@ -219,7 +217,7 @@ export const Plugin = {
                    )
                  }

-                  const patchFiles = prepared.map((change) => patchFile(change))
+                  const patchFiles = prepared.map(patchFile)
                  yield* permission.assert({
                    action: "edit",
                    resources: [...new Set(targets.map((target) => target.resource))],
@@ -297,31 +295,7 @@ export const Plugin = {
                      }),
                    { discard: true },
                  )
-                  const formatted = new Map<string, string>()
-                  yield* Effect.forEach(
-                    [...new Set(applied.filter((item) => item.type !== "delete").map((item) => item.target))],
-                    (target) =>
-                      Effect.gen(function* () {
-                        const current = yield* Bom.readFile(fs, target).pipe(
-                          Effect.mapError((error) => fail(`Failed to read ${target}`, error)),
-                        )
-                        formatted.set(
-                          target,
-                          (yield* formatter.file(target))
-                            ? yield* Bom.syncFile(fs, target, current.bom).pipe(
-                                Effect.mapError((error) => fail(`Failed to sync ${target}`, error)),
-                              )
-                            : current.text,
-                        )
-                      }),
-                    { discard: true },
-                  )
-                  const files = yield* Effect.forEach(prepared, (change) => {
-                    if (change.type === "delete") return Effect.succeed(patchFile(change))
-                    const target = change.type === "update" && change.moveTarget ? change.moveTarget : change.target
-                    return Effect.succeed(patchFile(change, formatted.get(target.canonical)))
-                  })
-                  return { applied, files }
+                  return { applied, files: patchFiles }
                }).pipe(
                  Effect.map((output) => ({
                    output,
@@ -363,15 +337,15 @@ function errorMessage(error: unknown) {
  return error instanceof Error ? error.message : String(error)
 }

-function patchFile(change: Prepared, after = change.after): typeof FileDiff.Info.Type {
+function patchFile(change: Prepared): typeof FileDiff.Info.Type {
  const target = (change.type === "update" ? change.moveTarget : undefined)?.resource ?? change.target.resource
  const patch = trimDiff(
-    createTwoFilesPatch(change.target.canonical, change.target.canonical, change.before, after),
+    createTwoFilesPatch(change.target.canonical, change.target.canonical, change.before, change.after),
  )
  const counts =
    change.type === "delete"
      ? { additions: 0, deletions: change.before.split("\n").length }
-      : diffLines(change.before, after).reduce(
+      : diffLines(change.before, change.after).reduce(
          (result, item) => ({
            additions: result.additions + (item.added ? (item.count ?? 0) : 0),
            deletions: result.deletions + (item.removed ? (item.count ?? 0) : 0),
@@ -13,19 +13,15 @@ export const name = "subagent"

 const NO_TEXT = "Subagent completed without a text response."
 const backgroundStarted = (sessionID: SessionSchema.ID) =>
-  [
-    `The subagent is working in the background (id: ${sessionID}). You will be notified automatically when it finishes.`,
-    "DO NOT sleep, poll for progress, ask the subagent for status, or duplicate this subagent's work; avoid working with the same files or topics it is using.",
-    "Work on non-overlapping tasks, or briefly tell the user what you launched and end your response.",
-  ].join("\n")
+  `The subagent is working in the background (id: ${sessionID}). You will be notified automatically when it finishes. DO NOT sleep, poll, or proactively check on its progress.`

 export const Input = Schema.Struct({
-  agent: Schema.String.annotate({ description: "The type of specialized agent to use for this task" }),
-  description: Schema.String.annotate({ description: "A short 3-5 word label for the task, displayed to the user" }),
+  agent: Schema.String.annotate({ description: "The configured agent to run as the subagent" }),
+  description: Schema.String.annotate({ description: "A short description of the subagent's task" }),
  prompt: Schema.String.annotate({ description: "The task for the subagent to perform" }),
  background: Schema.optionalKey(Schema.Boolean).annotate({
    description:
-      "Run the subagent in the background and return immediately. You will be notified when it completes. DO NOT sleep, poll, or proactively check on its progress.",
+      "Run the subagent in the background and return immediately. You will be notified when it completes. DO NOT poll its progress.",
  }),
 })

@@ -35,8 +31,7 @@ export const Output = Schema.Struct({
  output: Schema.String,
 })
 export const description = [
-  "Spawns an agent in a child session to work on the specified task.",
-  "Include all relevant context and instructions in the prompt because the child starts with fresh context.",
+  "Spawn a subagent: a child session running a configured agent with fresh context.",
  "Foreground (default) runs the subagent to completion and returns its final response.",
  "Background mode (background=true) launches it asynchronously and returns immediately; you are notified when it finishes.",
  "Use background only for independent work that can run while you continue elsewhere.",
@@ -8,13 +8,8 @@ export * as WriteTool from "./write"

 import type { Context as PluginContext } from "@opencode-ai/plugin/effect/plugin"
 import { ToolFailure } from "@opencode-ai/ai"
-import { FileDiff } from "@opencode-ai/schema/file-diff"
 import { Effect, Schema } from "effect"
-import { createTwoFilesPatch, diffLines } from "diff"
-import { Bom } from "@opencode-ai/util/bom"
-import { FSUtil } from "@opencode-ai/util/fs-util"
 import { FileMutation } from "../../file-mutation"
-import { Formatter } from "../../formatter"
 import { LocationMutation } from "../../location-mutation"
 import { Permission } from "../../permission"

@@ -23,7 +18,8 @@ export const name = "write"
 // TODO: Revisit whether model-facing mutation schemas should prefer absolute `filePath` naming for trained-in compatibility after evaluating model behavior.
 export const Input = Schema.Struct({
  path: Schema.String.annotate({
-    description: "Path to the file to write to",
+    description:
+      "File path to write. Relative paths resolve within the active Location. Absolute paths inside that Location are accepted; external absolute paths require external_directory approval.",
  }),
  content: Schema.String.annotate({ description: "Content to write to the file" }),
 })
@@ -40,6 +36,7 @@ export const toModelOutput = (output: Output) =>
  `${output.existed ? "Wrote" : "Created"} file successfully: ${output.resource}`

 /** Deferred write UX integrations remain visible at the model-facing seam. */
+// TODO: Add formatter integration after formatter runtime exists.
 // TODO: Publish watcher/file-edit events after watcher integration exists.
 // TODO: Add snapshots / undo after design exists.
 // TODO: Add LSP notification and diagnostics after LSP runtime exists.
@@ -49,8 +46,6 @@ export const Plugin = {
  effect: Effect.fn("WriteTool.Plugin")(function* (ctx: PluginContext) {
    const mutation = yield* LocationMutation.Service
    const files = yield* FileMutation.Service
-    const formatter = yield* Formatter.Service
-    const fs = yield* FSUtil.Service
    const permission = yield* Permission.Service

    yield* ctx.tool
@@ -60,7 +55,7 @@ export const Plugin = {
              name,
              options: { codemode: false, permission: "edit" },
              description:
-                "Writes a file to the local filesystem, overwriting if one exists.\n\nMissing parent directories are created automatically.\n\nUse this tool to create new files or overwrite existing files. For partial changes, use the edit tool instead.",
+                "Write content to one file. Relative paths resolve within the active Location. Absolute paths inside the Location are accepted. Explicit external absolute paths require external_directory approval before edit approval.",
              input: Input,
              output: Output,
              execute: (input, context) =>
@@ -79,36 +74,15 @@ export const Plugin = {
                      agent: context.agent,
                      source,
                    })
-                  const current = yield* Bom.readFile(fs, target.canonical).pipe(
-                    Effect.catchReason("PlatformError", "NotFound", () => Effect.succeed(undefined)),
-                  )
-                  const next = Bom.split(input.content)
-                  const counts = diffLines(current?.text ?? "", next.text).reduce(
-                    (result, item) => ({
-                      additions: result.additions + (item.added ? (item.count ?? 0) : 0),
-                      deletions: result.deletions + (item.removed ? (item.count ?? 0) : 0),
-                    }),
-                    { additions: 0, deletions: 0 },
-                  )
-                  const preview: typeof FileDiff.Info.Type = {
-                    file: target.resource,
-                    patch: createTwoFilesPatch(target.resource, target.resource, current?.text ?? "", next.text),
-                    status: current ? "modified" : "added",
-                    ...counts,
-                  }
                  yield* permission.assert({
                    action: "edit",
                    resources: [target.resource],
                    save: ["*"],
-                    metadata: { files: [preview] },
                    sessionID: context.sessionID,
                    agent: context.agent,
                    source,
                  })
-                  const result = yield* files.writeTextPreservingBom({ target, content: input.content })
-                  const bom = (yield* Bom.readFile(fs, target.canonical)).bom
-                  if (yield* formatter.file(target.canonical)) yield* Bom.syncFile(fs, target.canonical, bom)
-                  return result
+                  return yield* files.writeTextPreservingBom({ target, content: input.content })
                }).pipe(
                  Effect.map((output) => ({ output, content: toModelOutput(output) })),
                  Effect.mapError((error) => new ToolFailure({ message: `Unable to write ${input.path}`, error })),
@@ -1,199 +0,0 @@
-import fs from "fs/promises"
-import path from "path"
-import { describe, expect } from "bun:test"
-import { Effect, Layer, Schema, Stream } from "effect"
-import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
-import { AbsolutePath } from "@opencode-ai/core/schema"
-import { Npm } from "@opencode-ai/util/npm"
-import { Config } from "../src/config"
-import { Formatter } from "../src/formatter"
-import { Location } from "../src/location"
-import { location } from "./fixture/location"
-import { tmpdir } from "./fixture/tmpdir"
-import { testEffect } from "./lib/effect"
-
-const it = testEffect(Layer.empty)
-type ConfigInput = typeof Config.Info.Encoded
-
-function formatterLayer(directory: string, configured?: ConfigInput["formatter"]) {
-  const entries =
-    configured === undefined
-      ? []
-      : [
-          new Config.Document({
-            type: "document",
-            info: Schema.decodeUnknownSync(Config.Info)({ formatter: configured }),
-          }),
-        ]
-  return AppNodeBuilder.build(Formatter.node, [
-    [
-      Config.node,
-      Layer.succeed(
-        Config.Service,
-        Config.Service.of({
-          entries: () => Effect.succeed(entries),
-          changes: () => Stream.empty,
-        }),
-      ),
-    ],
-    [
-      Location.node,
-      Layer.succeed(
-        Location.Service,
-        Location.Service.of(location({ directory: AbsolutePath.make(directory) })),
-      ),
-    ],
-    [Npm.node, Layer.mock(Npm.Service, { which: () => Effect.succeed(undefined) })],
-  ])
-}
-
-function withTemp<A, E, R>(body: (directory: string) => Effect.Effect<A, E, R>) {
-  return Effect.acquireUseRelease(
-    Effect.promise(() => tmpdir()),
-    (tmp) => body(tmp.path),
-    (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-  )
-}
-
-describe("Formatter", () => {
-  it.live("status() returns empty list when no formatters are configured", () =>
-    withTemp((directory) =>
-      Formatter.Service.use((formatter) => formatter.status()).pipe(Effect.provide(formatterLayer(directory))),
-    ),
-  )
-
-  it.live("status() returns built-in formatters when formatter is true", () =>
-    withTemp((directory) =>
-      Formatter.Service.use((formatter) =>
-        Effect.gen(function* () {
-          const statuses = yield* formatter.status()
-          const gofmt = statuses.find((item) => item.name === "gofmt")
-          expect(gofmt).toBeDefined()
-          expect(gofmt?.extensions).toContain(".go")
-        }),
-      ).pipe(Effect.provide(formatterLayer(directory, true))),
-    ),
-  )
-
-  it.live("status() keeps built-in formatters when config object is provided", () =>
-    withTemp((directory) =>
-      Formatter.Service.use((formatter) =>
-        Effect.gen(function* () {
-          const statuses = yield* formatter.status()
-          expect(statuses.find((item) => item.name === "gofmt")?.extensions).toContain(".go")
-          expect(statuses.find((item) => item.name === "mix")).toBeDefined()
-        }),
-      ).pipe(Effect.provide(formatterLayer(directory, { gofmt: {} }))),
-    ),
-  )
-
-  it.live("status() excludes formatters marked as disabled in config", () =>
-    withTemp((directory) =>
-      Formatter.Service.use((formatter) =>
-        Effect.gen(function* () {
-          const statuses = yield* formatter.status()
-          expect(statuses.find((item) => item.name === "gofmt")).toBeUndefined()
-          expect(statuses.find((item) => item.name === "mix")).toBeDefined()
-        }),
-      ).pipe(Effect.provide(formatterLayer(directory, { gofmt: { disabled: true } }))),
-    ),
-  )
-
-  it.live("service initializes without error", () =>
-    withTemp((directory) =>
-      Formatter.Service.use((formatter) => formatter.init()).pipe(Effect.provide(formatterLayer(directory))),
-    ),
-  )
-
-  it.live("file() returns false when no formatter runs", () =>
-    withTemp((directory) =>
-      Effect.gen(function* () {
-        const file = path.join(directory, "test.txt")
-        yield* Effect.promise(() => fs.writeFile(file, "x"))
-        expect(yield* Formatter.Service.use((formatter) => formatter.file(file))).toBe(false)
-      }).pipe(Effect.provide(formatterLayer(directory, false))),
-    ),
-  )
-
-  it.live("status() initializes formatter state per directory", () =>
-    Effect.acquireUseRelease(
-      Effect.promise(() => Promise.all([tmpdir(), tmpdir()])),
-      ([off, on]) =>
-        Effect.gen(function* () {
-          const disabled = yield* Formatter.Service.use((formatter) => formatter.status()).pipe(
-            Effect.provide(formatterLayer(off.path, false)),
-          )
-          const enabled = yield* Formatter.Service.use((formatter) => formatter.status()).pipe(
-            Effect.provide(formatterLayer(on.path, true)),
-          )
-          expect(disabled).toEqual([])
-          expect(enabled.find((item) => item.name === "gofmt")).toBeDefined()
-        }),
-      (directories) =>
-        Effect.promise(() => Promise.all(directories.map((tmp) => tmp[Symbol.asyncDispose]())).then(() => undefined)),
-    ),
-  )
-
-  it.live("stops after the first matching formatter succeeds", () =>
-    withTemp((directory) =>
-      Effect.gen(function* () {
-        const file = path.join(directory, "test.seq")
-        yield* Effect.promise(() => fs.writeFile(file, "x"))
-        expect(yield* Formatter.Service.use((formatter) => formatter.file(file))).toBe(true)
-        expect(yield* Effect.promise(() => fs.readFile(file, "utf8"))).toBe("xA")
-      }).pipe(
-        Effect.provide(
-          formatterLayer(directory, {
-            first: {
-              command: [
-                process.execPath,
-                "-e",
-                "const fs = require('fs'); const file = process.argv.at(-1); fs.appendFileSync(file, 'A')",
-                "$FILE",
-              ],
-              extensions: [".seq"],
-            },
-            second: {
-              command: [
-                process.execPath,
-                "-e",
-                "const fs = require('fs'); const file = process.argv.at(-1); fs.appendFileSync(file, 'B')",
-                "$FILE",
-              ],
-              extensions: [".seq"],
-            },
-          }),
-        ),
-      ),
-    ),
-  )
-
-  it.live("tries the next matching formatter when the first fails", () =>
-    withTemp((directory) =>
-      Effect.gen(function* () {
-        const file = path.join(directory, "test.fallback")
-        yield* Effect.promise(() => fs.writeFile(file, "x"))
-        expect(yield* Formatter.Service.use((formatter) => formatter.file(file))).toBe(true)
-        expect(yield* Effect.promise(() => fs.readFile(file, "utf8"))).toBe("xB")
-      }).pipe(
-        Effect.provide(
-          formatterLayer(directory, {
-            first: {
-              command: [process.execPath, "-e", "process.exit(1)", "$FILE"],
-              extensions: [".fallback"],
-            },
-            second: {
-              command: [
-                process.execPath,
-                "-e",
-                "const fs = require('fs'); const file = process.argv.at(-1); fs.appendFileSync(file, 'B')",
-                "$FILE",
-              ],
-              extensions: [".fallback"],
-            },
-          }),
-        ),
-      ),
-    ),
-  )
-})
@@ -5,7 +5,6 @@ import { Effect, Layer } from "effect"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
 import { FileMutation } from "@opencode-ai/core/file-mutation"
-import { Formatter } from "@opencode-ai/core/formatter"
 import { FSUtil } from "@opencode-ai/util/fs-util"
 import { Location } from "@opencode-ai/core/location"
 import { LocationMutation } from "@opencode-ai/core/location-mutation"
@@ -23,7 +22,7 @@ import { toolIdentity, executeTool, registerToolPlugin, toolDefinitions } from "
 const editToolNode = makeLocationNode({
  name: "test/edit-tool-plugin",
  layer: Layer.effectDiscard(registerToolPlugin(EditTool.Plugin)),
-  deps: [Tool.node, LocationMutation.node, FileMutation.node, Formatter.node, FSUtil.node, Permission.node],
+  deps: [Tool.node, LocationMutation.node, FileMutation.node, FSUtil.node, Permission.node],
 })

 const sessionID = Session.ID.make("ses_edit_tool_test")
@@ -32,7 +31,6 @@ const writes: string[] = []
 let reads = 0
 let denyAction: string | undefined
 let afterRead = (_target: string, _content: Uint8Array): Effect.Effect<void> => Effect.void
-let formatFile = (_target: string): Effect.Effect<boolean> => Effect.succeed(false)

 const permission = Layer.succeed(
  Permission.Service,
@@ -59,17 +57,12 @@ const permission = Layer.succeed(
  }),
 )

-const formatter = Layer.mock(Formatter.Service, {
-  file: (target) => formatFile(target),
-})
-
 const reset = () => {
  assertions.length = 0
  writes.length = 0
  reads = 0
  denyAction = undefined
  afterRead = () => Effect.void
-  formatFile = () => Effect.succeed(false)
 }

 const filesystem = Layer.effect(
@@ -116,7 +109,6 @@ const withTool = <A, E, R>(directory: string, body: (registry: Tool.Interface) =
        [
          [FSUtil.node, filesystem],
          [Location.node, activeLocation],
-          [Formatter.node, formatter],
          [Permission.node, permission],
        ],
      ),
@@ -179,17 +171,6 @@ describe("EditTool", () => {
                })
                expect(yield* Effect.promise(() => fs.readFile(target, "utf8"))).toBe("after\nrest\n")
                expect(assertions).toMatchObject([{ sessionID, action: "edit", resources: ["hello.txt"], save: ["*"] }])
-                expect(assertions[0]?.metadata).toMatchObject({
-                  files: [
-                    {
-                      file: "hello.txt",
-                      status: "modified",
-                      additions: 1,
-                      deletions: 1,
-                      patch: expect.stringContaining("-before\n+after"),
-                    },
-                  ],
-                })
                expect(writes).toEqual([yield* Effect.promise(() => fs.realpath(target))])
              }),
            ),
@@ -200,39 +181,6 @@ describe("EditTool", () => {
    ),
  )

-  it.live("returns the diff for final formatted content", () =>
-    Effect.acquireUseRelease(
-      Effect.promise(() => tmpdir()),
-      (tmp) => {
-        reset()
-        const target = path.join(tmp.path, "formatted.txt")
-        formatFile = (file) =>
-          Effect.promise(async () => {
-            await fs.writeFile(file, (await fs.readFile(file, "utf8")).replace("after", "AFTER"))
-            return true
-          })
-        return Effect.promise(() => fs.writeFile(target, "before\n")).pipe(
-          Effect.andThen(
-            withTool(tmp.path, (registry) =>
-              Effect.gen(function* () {
-                const settled = yield* executeTool(
-                  registry,
-                  call({ path: "formatted.txt", oldString: "before", newString: "after" }),
-                )
-                expect(settled.status).toBe("completed")
-                if (settled.status !== "completed") return
-                expect(settled.output.files[0]?.patch).toContain("-before\n+AFTER")
-                expect(settled.metadata?.files?.[0]?.patch).toContain("-before\n+AFTER")
-                expect(yield* Effect.promise(() => fs.readFile(target, "utf8"))).toBe("AFTER\n")
-              }),
-            ),
-          ),
-        )
-      },
-      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-    ),
-  )
-
  it.live("accepts an absolute file path inside the active Location", () =>
    Effect.acquireUseRelease(
      Effect.promise(() => tmpdir()),
@@ -354,7 +302,7 @@ describe("EditTool", () => {
            error: { type: "permission.rejected", message: "Permission denied: edit" },
          })
          expect(assertions.map((input) => input.action)).toEqual(["external_directory", "edit"])
-          expect(reads).toBe(1)
+          expect(reads).toBe(0)
          expect(writes).toEqual([])
          expect(yield* Effect.promise(() => fs.readFile(external, "utf8"))).toBe("before")
        }),
@@ -365,7 +313,7 @@ describe("EditTool", () => {
    ),
  )

-  it.live("denied edit does not disclose whether oldString matches", () =>
+  it.live("denied edit reads no target content and does not disclose whether oldString matches", () =>
    Effect.acquireUseRelease(
      Effect.promise(() => tmpdir()),
      (tmp) => {
@@ -391,7 +339,7 @@ describe("EditTool", () => {
                })
                expect(missing).toEqual(matching)
                expect(assertions.map((input) => input.action)).toEqual(["edit", "edit"])
-                expect(reads).toBe(2)
+                expect(reads).toBe(0)
                expect(writes).toEqual([])
              }),
            ),
@@ -626,11 +574,6 @@ describe("EditTool", () => {
      (tmp) => {
        reset()
        const target = path.join(tmp.path, "windows.txt")
-        formatFile = (file) =>
-          Effect.promise(async () => {
-            await fs.writeFile(file, (await fs.readFile(file, "utf8")).replace(/^\uFEFF/, ""))
-            return true
-          })
        return Effect.promise(() => fs.writeFile(target, "\uFEFFbefore\r\nrest\r\n")).pipe(
          Effect.andThen(
            withTool(tmp.path, (registry) =>
@@ -6,7 +6,6 @@ import { systemError } from "effect/PlatformError"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
 import { FSUtil } from "@opencode-ai/util/fs-util"
-import { Formatter } from "@opencode-ai/core/formatter"
 import { Location } from "@opencode-ai/core/location"
 import { Permission } from "@opencode-ai/core/permission"
 import { AbsolutePath } from "@opencode-ai/core/schema"
@@ -22,7 +21,7 @@ import { toolIdentity, executeTool, registerToolPlugin, toolDefinitions } from "
 const patchToolNode = makeLocationNode({
  name: "test/patch-tool-plugin",
  layer: Layer.effectDiscard(registerToolPlugin(PatchTool.Plugin)),
-  deps: [Tool.node, Formatter.node, FSUtil.node, Location.node, Permission.node],
+  deps: [Tool.node, FSUtil.node, Location.node, Permission.node],
 })

 const sessionID = Session.ID.make("ses_patch_tool_test")
@@ -34,7 +33,6 @@ let failWriteTarget: string | undefined
 let readsBeforeEditApproval = 0
 let editApproved = false
 let afterEditApproval = (): Effect.Effect<void> => Effect.void
-let formatFile = (_target: string): Effect.Effect<boolean> => Effect.succeed(false)

 const permission = Layer.succeed(
  Permission.Service,
@@ -65,10 +63,6 @@ const permission = Layer.succeed(
  }),
 )

-const formatter = Layer.mock(Formatter.Service, {
-  file: (target) => formatFile(target),
-})
-
 const reset = () => {
  assertions.length = 0
  denyAction = undefined
@@ -78,7 +72,6 @@ const reset = () => {
  readsBeforeEditApproval = 0
  editApproved = false
  afterEditApproval = () => Effect.void
-  formatFile = () => Effect.succeed(false)
 }

 const filesystem = Layer.effect(
@@ -142,7 +135,6 @@ const withTool = <A, E, R>(
      AppNodeBuilder.build(LayerNode.group([Tool.node, patchToolNode]), [
        [FSUtil.node, filesystem],
        [Location.node, activeLocation],
-        [Formatter.node, formatter],
        [Permission.node, permission],
      ]),
    ),
@@ -262,28 +254,6 @@ describe("PatchTool", () => {
    ),
  )

-  it.live("returns file diffs for final formatted content", () =>
-    withTempTool((directory, registry) => {
-      const target = path.join(directory, "formatted.txt")
-      formatFile = (file) =>
-        Effect.promise(async () => {
-          await fs.writeFile(file, (await fs.readFile(file, "utf8")).replace("created", "FORMATTED"))
-          return true
-        })
-      return Effect.gen(function* () {
-        const settled = yield* executeTool(
-          registry,
-          call("*** Begin Patch\n*** Add File: formatted.txt\n+created\n*** End Patch"),
-        )
-        expect(settled.status).toBe("completed")
-        if (settled.status !== "completed") return
-        expect(settled.output.files[0]?.patch).toContain("+FORMATTED")
-        expect(settled.metadata?.files?.[0]?.patch).toContain("+FORMATTED")
-        expect(yield* Effect.promise(() => fs.readFile(target, "utf8"))).toBe("FORMATTED\n")
-      })
-    }),
-  )
-
  it.live("moves and updates a file", () =>
    Effect.acquireUseRelease(
      Effect.promise(() => tmpdir()),
@@ -582,11 +552,6 @@ describe("PatchTool", () => {
        const bom = "\uFEFF"
        const target = path.join(directory, "example.cs")
        yield* Effect.promise(() => fs.writeFile(target, `${bom}using System;\n\nclass Test {}\n`))
-        formatFile = (file) =>
-          Effect.promise(async () => {
-            await fs.writeFile(file, (await fs.readFile(file, "utf8")).replace(/^\uFEFF/, ""))
-            return true
-          })
        const settled = yield* executeTool(
          registry,
          call("*** Begin Patch\n*** Update File: example.cs\n@@\n class Test {}\n+class Next {}\n*** End Patch"),
@@ -3,7 +3,6 @@ import path from "path"
 import { describe, expect } from "bun:test"
 import { Effect, Layer } from "effect"
 import { FileMutation } from "@opencode-ai/core/file-mutation"
-import { Formatter } from "@opencode-ai/core/formatter"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
 import { FSUtil } from "@opencode-ai/util/fs-util"
@@ -23,13 +22,12 @@ import { toolIdentity, executeTool, registerToolPlugin, toolDefinitions } from "
 const writeToolNode = makeLocationNode({
  name: "test/write-tool-plugin",
  layer: Layer.effectDiscard(registerToolPlugin(WriteTool.Plugin)),
-  deps: [Tool.node, LocationMutation.node, FileMutation.node, Formatter.node, FSUtil.node, Permission.node],
+  deps: [Tool.node, LocationMutation.node, FileMutation.node, Permission.node],
 })

 const sessionID = Session.ID.make("ses_write_tool_test")
 const assertions: Permission.AssertInput[] = []
 const writes: string[] = []
-let formatFile = (_target: string): Effect.Effect<boolean> => Effect.succeed(false)
 let denyAction: string | undefined

 const permission = Layer.succeed(
@@ -57,14 +55,9 @@ const permission = Layer.succeed(
  }),
 )

-const formatter = Layer.mock(Formatter.Service, {
-  file: (target) => formatFile(target),
-})
-
 const reset = () => {
  assertions.length = 0
  writes.length = 0
-  formatFile = () => Effect.succeed(false)
  denyAction = undefined
 }

@@ -100,7 +93,6 @@ const withTool = <A, E, R>(directory: string, body: (registry: Tool.Interface) =
        [
          [FSUtil.node, filesystem],
          [Location.node, activeLocation],
-          [Formatter.node, formatter],
          [Permission.node, permission],
        ],
      ),
@@ -140,17 +132,6 @@ describe("WriteTool", () => {
              "created",
            )
            expect(assertions).toMatchObject([{ sessionID, action: "edit", resources: ["src/new.txt"], save: ["*"] }])
-            expect(assertions[0]?.metadata).toMatchObject({
-              files: [
-                {
-                  file: "src/new.txt",
-                  status: "added",
-                  additions: 1,
-                  deletions: 0,
-                  patch: expect.stringContaining("+created"),
-                },
-              ],
-            })
            expect(writes).toEqual([path.join(yield* Effect.promise(() => fs.realpath(tmp.path)), "src", "new.txt")])
          }),
        )
@@ -159,30 +140,6 @@ describe("WriteTool", () => {
    ),
  )

-  it.live("formats the committed file", () =>
-    Effect.acquireUseRelease(
-      Effect.promise(() => tmpdir()),
-      (tmp) => {
-        reset()
-        const target = path.join(tmp.path, "formatted.txt")
-        formatFile = (file) =>
-          Effect.promise(async () => {
-            await fs.writeFile(file, (await fs.readFile(file, "utf8")).toUpperCase())
-            return true
-          })
-        return withTool(tmp.path, (registry) =>
-          Effect.gen(function* () {
-            expect(yield* executeTool(registry, call({ path: "formatted.txt", content: "format me" }))).toMatchObject({
-              status: "completed",
-            })
-            expect(yield* Effect.promise(() => fs.readFile(target, "utf8"))).toBe("FORMAT ME")
-          }),
-        )
-      },
-      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-    ),
-  )
-
  it.live("overwrites a relative existing file and reports that it wrote the file", () =>
    Effect.acquireUseRelease(
      Effect.promise(() => tmpdir()),
@@ -198,17 +155,6 @@ describe("WriteTool", () => {
              if (settled.status !== "completed") return
              expect(settled.content).toEqual([{ type: "text", text: "Wrote file successfully: existing.txt" }])
              expect(settled.output).toMatchObject({ resource: "existing.txt", existed: true })
-              expect(assertions[0]?.metadata).toMatchObject({
-                files: [
-                  {
-                    file: "existing.txt",
-                    status: "modified",
-                    additions: 1,
-                    deletions: 1,
-                    patch: expect.stringMatching(/-before[\s\S]*\+after/),
-                  },
-                ],
-              })
              expect(yield* Effect.promise(() => fs.readFile(path.join(tmp.path, "existing.txt"), "utf8"))).toBe(
                "after",
              )
@@ -228,11 +174,6 @@ describe("WriteTool", () => {
        reset()
        const preserved = path.join(tmp.path, "preserved.txt")
        const deduplicated = path.join(tmp.path, "deduplicated.txt")
-        formatFile = (target) =>
-          Effect.promise(async () => {
-            await fs.writeFile(target, `\uFEFF\uFEFF\uFEFF${(await fs.readFile(target, "utf8")).replace(/^\uFEFF+/, "")}`)
-            return true
-          })
        return Effect.promise(() =>
          Promise.all([fs.writeFile(preserved, "\uFEFFbefore"), fs.writeFile(deduplicated, "\uFEFFbefore")]),
        ).pipe(
@@ -66,6 +66,7 @@ import { DialogThemeList } from "./component/dialog-theme-list"
 import { DialogHelp } from "./ui/dialog-help"
 import { DialogAgent } from "./component/dialog-agent"
 import { DialogSessionList } from "./component/dialog-session-list"
+import { DialogProject } from "./component/dialog-project"
 import { SessionTabs } from "./component/session-tabs"
 import { ThemeErrorToast } from "./component/theme-error-toast"
 import { ThemeProvider, useTheme, useThemes } from "./context/theme"
@@ -648,6 +649,15 @@ function App(props: { pair?: DialogPairCredentials }) {
          dialog.clear()
        },
      },
+      {
+        name: "project.switch",
+        title: "Switch project",
+        category: "Session",
+        slash: { name: "projects", aliases: ["project"] },
+        run: () => {
+          dialog.replace(() => <DialogProject />)
+        },
+      },
      ...Array.from({ length: 9 }, (_, i) => ({
        name: `session.quick_switch.${i + 1}`,
        title: `Switch to session in quick slot ${i + 1}`,
@@ -0,0 +1,66 @@
+import path from "path"
+import { createMemo, createResource } from "solid-js"
+import { DialogSelect } from "../ui/dialog-select"
+import { useDialog } from "../ui/dialog"
+import { useClient } from "../context/client"
+import { useData } from "../context/data"
+import { useRoute } from "../context/route"
+import { useToast } from "../ui/toast"
+import { abbreviateHome } from "../runtime"
+import { useTuiPaths } from "../context/runtime"
+import { errorMessage } from "../util/error"
+
+export function DialogProject() {
+  const dialog = useDialog()
+  const client = useClient()
+  const data = useData()
+  const route = useRoute()
+  const toast = useToast()
+  const paths = useTuiPaths()
+
+  const [projects] = createResource(() => client.api.project.list())
+  const current = createMemo(() => data.location.info()?.project.directory ?? data.location.default().directory)
+
+  const options = createMemo(() => {
+    const list = [...(projects() ?? [])]
+    list.sort((a, b) => {
+      if (a.worktree === current()) return -1
+      if (b.worktree === current()) return 1
+      return (b.time.initialized ?? 0) - (a.time.initialized ?? 0)
+    })
+    return list
+      .filter((project) => project.worktree !== "/")
+      .filter((project, index, all) => all.findIndex((other) => other.worktree === project.worktree) === index)
+      .map((project) => ({
+        title: project.name ?? path.basename(project.worktree),
+        description: abbreviateHome(project.worktree, paths.home),
+        value: project.worktree,
+        category: project.worktree === current() ? "Current" : "Projects",
+      }))
+  })
+
+  return (
+    <DialogSelect
+      title="Switch project"
+      placeholder="Search projects…"
+      options={options()}
+      current={current()}
+      emptyView={
+        <box paddingLeft={4} paddingRight={4} paddingTop={1}>
+          <text>{projects.loading ? "Loading projects…" : "No projects found"}</text>
+        </box>
+      }
+      onSelect={(option) => {
+        dialog.clear()
+        if (option.value === current()) return
+        // Navigating while already home would remount the footer mid-animation.
+        if (route.data.type !== "home") route.navigate({ type: "home" })
+        void data.location
+          .setDefault(option.value)
+          .catch((error) =>
+            toast.show({ variant: "error", title: "Failed to switch project", message: errorMessage(error) }),
+          )
+      }}
+    />
+  )
+}
@@ -1082,6 +1082,12 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
        default() {
          return defaultLocation()
        },
+        // Repoints the whole TUI at another project directory, like a shell `cd`.
+        // The follow-up default sync lets the server canonicalize the directory.
+        async setDefault(directory: string) {
+          setDefaultLocation({ directory })
+          await result.location.sync()
+        },
        async sync(ref?: LocationRef) {
          const current = ref ?? defaultLocation()
          await sync.run(`location:${locationKey(current)}`, async () => {
@@ -1,8 +1,8 @@
 import { Plugin } from "@opencode-ai/plugin/tui"
 import { createMemo, Match, Show, Switch } from "solid-js"
 import { useTerminalDimensions } from "@opentui/solid"
-import { FilePath } from "../../ui/file-path"
 import { stringWidth } from "../../util/string-width"
+import { FadeFilePath } from "../../ui/fade-file-path"

 function Directory(props: { context: Plugin.Context; maxWidth: number }) {
  const directory = createMemo(() =>
@@ -10,9 +10,12 @@ function Directory(props: { context: Plugin.Context; maxWidth: number }) {
  )

  return (
-    <Show when={directory()}>
-      {(value) => <FilePath value={value()} maxWidth={props.maxWidth} fg={props.context.theme.text.subdued} />}
-    </Show>
+    <FadeFilePath
+      value={directory()}
+      maxWidth={props.maxWidth}
+      fg={props.context.theme.text.subdued}
+      bg={props.context.theme.background.default}
+    />
  )
 }

@@ -1,15 +1,18 @@
 import { Plugin } from "@opencode-ai/plugin/tui"
-import { createMemo, Show } from "solid-js"
-import { FilePath } from "../../ui/file-path"
+import { createMemo } from "solid-js"
+import { FadeFilePath } from "../../ui/fade-file-path"

 function View(props: { context: Plugin.Context }) {
  const directory = createMemo(() =>
    props.context.location ? props.context.ui.format.path(props.context.location.directory) : undefined,
  )
  return (
-    <Show when={directory()}>
-      {(value) => <FilePath value={value()} maxWidth={38} fg={props.context.theme.text.subdued} />}
-    </Show>
+    <FadeFilePath
+      value={directory()}
+      maxWidth={38}
+      fg={props.context.theme.text.subdued}
+      bg={props.context.theme.background.default}
+    />
  )
 }

@@ -0,0 +1,79 @@
+import { RGBA } from "@opentui/core"
+import { createEffect, createMemo, on, onCleanup, Show } from "solid-js"
+import { createStore } from "solid-js/store"
+import { useConfig } from "../config"
+import { FilePath } from "./file-path"
+
+const DURATION = 300
+
+// FilePath that crossfades when its value changes: the old path fades to the
+// background, the text swaps at the midpoint, and the new path fades back in.
+// The initial value renders immediately; only subsequent changes animate.
+export function FadeFilePath(props: {
+  value: string | undefined
+  maxWidth: number
+  fg: RGBA
+  bg: RGBA
+  basenameFg?: RGBA
+}) {
+  const config = useConfig().data
+  const [store, setStore] = createStore({
+    text: props.value,
+    previous: undefined as string | undefined,
+    progress: 1,
+  })
+
+  createEffect(
+    on(
+      () => props.value,
+      (text) => {
+        // The source can flicker to undefined while a new location syncs;
+        // retain the last path so the change animates as one transition.
+        if (text === undefined || text === store.text) return
+        if (store.text === undefined || !(config.animations ?? true)) {
+          setStore({ text, previous: undefined, progress: 1 })
+          return
+        }
+        setStore({ text, previous: store.text, progress: 0 })
+        const started = performance.now()
+        const timer = setInterval(() => {
+          const progress = Math.min(1, (performance.now() - started) / DURATION)
+          setStore("progress", progress)
+          if (progress >= 1) {
+            clearInterval(timer)
+            setStore("previous", undefined)
+          }
+        }, 33)
+        onCleanup(() => clearInterval(timer))
+      },
+      { defer: true },
+    ),
+  )
+
+  const display = createMemo(() => (store.previous !== undefined && store.progress < 0.5 ? store.previous : store.text))
+  const fg = createMemo(() => {
+    if (store.previous === undefined) return props.fg
+    const t = store.progress < 0.5 ? 1 - store.progress * 2 : store.progress * 2 - 1
+    return mix(props.bg, props.fg, t)
+  })
+
+  return (
+    <Show when={display() !== undefined}>
+      <FilePath
+        value={display() ?? ""}
+        maxWidth={props.maxWidth}
+        fg={fg()}
+        basenameFg={store.previous === undefined ? props.basenameFg : undefined}
+      />
+    </Show>
+  )
+}
+
+function mix(from: RGBA, to: RGBA, t: number) {
+  return RGBA.fromValues(
+    from.r + (to.r - from.r) * t,
+    from.g + (to.g - from.g) * t,
+    from.b + (to.b - from.b) * t,
+    from.a + (to.a - from.a) * t,
+  )
+}
@@ -1398,29 +1398,6 @@ test("restores queued compaction from durable pending input", async () => {
      { type: "compaction-queued", inputID: "message-compaction-later" },
    ])

-    emitEvent(events, {
-      id: "evt_step_started",
-      created: 2,
-      type: "session.step.started",
-      durable: durable(sessionID, 3),
-      data: {
-        sessionID,
-        assistantMessageID: "message-assistant",
-        agent: "build",
-        model: { id: "model", providerID: "provider" },
-      },
-    })
-    emitEvent(events, {
-      id: "evt_text_started",
-      created: 2,
-      type: "session.text.started",
-      durable: durable(sessionID, 4),
-      data: {
-        sessionID,
-        assistantMessageID: "message-assistant",
-        ordinal: 0,
-      },
-    })
    emitEvent(events, {
      id: "evt_text_ended",
      created: 2,
@@ -1440,7 +1417,7 @@ test("restores queued compaction from durable pending input", async () => {
      id: "evt_compaction_started",
      created: 2,
      type: "session.compaction.started",
-      durable: durable(sessionID, 6),
+      durable: durable(sessionID, 4),
      data: {
        sessionID,
        reason: "manual",
@@ -1455,7 +1432,7 @@ test("restores queued compaction from durable pending input", async () => {
      id: "evt_compaction_ended",
      created: 3,
      type: "session.compaction.ended",
-      durable: durable(sessionID, 7),
+      durable: durable(sessionID, 5),
      data: { sessionID, reason: "manual", text: "Summary", recent: "" },
    })
    expect(data.session.pending.list(sessionID).map((item) => item.id)).toEqual(["message-compaction-later"])
@@ -1,38 +0,0 @@
-export * as Bom from "./bom.js"
-
-import { Effect } from "effect"
-import { FSUtil } from "./fs-util.js"
-
-const code = 0xfeff
-const value = String.fromCharCode(code)
-
-export function split(text: string) {
-  const stripped = text.replace(/^\uFEFF+/, "")
-  return { bom: stripped.length !== text.length, text: stripped }
-}
-
-export function join(text: string, bom: boolean) {
-  const stripped = split(text).text
-  return bom ? value + stripped : stripped
-}
-
-export function has(content: Uint8Array) {
-  return content[0] === 0xef && content[1] === 0xbb && content[2] === 0xbf
-}
-
-export const readFile = Effect.fn("Bom.readFile")(function* (fs: FSUtil.Interface, filepath: string) {
-  return split(decode(yield* fs.readFile(filepath)))
-})
-
-export const syncFile = Effect.fn("Bom.syncFile")(function* (fs: FSUtil.Interface, filepath: string, bom: boolean) {
-  const decoded = decode(yield* fs.readFile(filepath))
-  const current = split(decoded)
-  const canonical = join(current.text, bom)
-  if (decoded === canonical) return current.text
-  yield* fs.writeWithDirs(filepath, canonical)
-  return current.text
-})
-
-function decode(content: Uint8Array) {
-  return new TextDecoder("utf-8", { ignoreBOM: true }).decode(content)
-}
@@ -1,7 +1,6 @@
 export * as Patch from "./patch.js"

 import { Result, Schema } from "effect"
-import { Bom } from "./bom.js"

 export class BoundaryError extends Schema.TaggedErrorClass<BoundaryError>()("Patch.BoundaryError", {
  boundary: Schema.Literals(["first", "last"]),
@@ -126,19 +125,20 @@ export function parse(patchText: string): Result.Result<ReadonlyArray<Hunk>, Par
 }

 export function derive(path: string, chunks: ReadonlyArray<UpdateFileChunk>, original: string): FileUpdate {
-  const source = Bom.split(original)
+  const source = splitBom(original)
  const lines = source.text.split("\n")
  if (lines.at(-1) === "") lines.pop()
  const replacements = computeReplacements(lines, path, chunks)
  const updated = [...lines]
  for (const [start, remove, insert] of replacements.toReversed()) updated.splice(start, remove, ...insert)
  if (updated.at(-1) !== "") updated.push("")
-  const next = Bom.split(updated.join("\n"))
+  const next = splitBom(updated.join("\n"))
  return { content: next.text, bom: source.bom || next.bom }
 }

 export function joinBom(text: string, bom: boolean) {
-  return Bom.join(text, bom)
+  const stripped = splitBom(text).text
+  return bom ? `\uFEFF${stripped}` : stripped
 }

 function parseAdd(
@@ -379,4 +379,6 @@ const normalize = (value: string) =>
    .replace(/[“”„‟]/g, '"')
    .replace(/[‐‑‒–—―−]/g, "-")
    .replace(/[\u00A0\u2002-\u200A\u202F\u205F\u3000]/g, " ")
+const splitBom = (text: string) =>
+  text.startsWith("\uFEFF") ? { bom: true, text: text.slice(1) } : { bom: false, text }
 const stripHeredoc = (input: string) => input.match(/^(?:cat\s+)?<<(['"]?)(\w+)\1\s*\n([\s\S]*?)\n\2\s*$/)?.[3] ?? input
Author	SHA1	Message	Date
Kit Langton	e8fc72539a	feat(tui): speed up footer crossfade	2026-07-29 19:27:51 -04:00
Kit Langton	7f44669937	feat(tui): simplify footer transition to crossfade	2026-07-29 19:25:42 -04:00
Kit Langton	d0eb91c69d	feat(tui): replace footer typewriter with cross-dissolve	2026-07-29 19:21:02 -04:00
Kit Langton	b75187ff59	feat(tui): project picker with footer typewriter flash	2026-07-29 17:10:09 -04:00