fix(tui): watch newly created plugin directory

Co-authored-by: Kit Langton <kit.langton@gmail.com>

bun.lock

@@ -88,7 +88,6 @@
         "@tanstack/solid-query": "5.91.4",
         "@tanstack/solid-virtual": "catalog:",
         "@thisbeyond/solid-dnd": "0.7.5",
-        "diff": "catalog:",
         "effect": "catalog:",
         "fuzzysort": "catalog:",
         "ghostty-web": "github:anomalyco/ghostty-web#83c0a07b8628b748aed073b232cb4b52a6ca11c1",
@@ -384,7 +383,6 @@
         "@opencode-ai/ai": "workspace:*",
         "@opencode-ai/codemode": "workspace:*",
         "@opencode-ai/effect-drizzle-sqlite": "workspace:*",
-        "@opencode-ai/effect-sqlite-node": "workspace:*",
         "@opencode-ai/plugin": "workspace:*",
         "@opencode-ai/schema": "workspace:*",
         "@opencode-ai/util": "workspace:*",
@@ -405,7 +403,6 @@
         "ignore": "7.0.5",
         "immer": "11.1.4",
         "jsonc-parser": "3.3.1",
-        "semver": "^7.6.3",
         "tree-sitter-bash": "0.25.0",
         "tree-sitter-powershell": "0.25.10",
         "turndown": "7.2.0",
@@ -427,7 +424,6 @@
         "@tsconfig/bun": "catalog:",
         "@types/bun": "catalog:",
         "@types/node": "catalog:",
-        "@types/semver": "catalog:",
         "@types/turndown": "5.0.5",
         "@types/which": "3.0.4",
         "drizzle-kit": "catalog:",

packages/cli/src/commands/commands.ts

@@ -133,7 +133,6 @@ export const Commands = Spec.make(typeof OPENCODE_CLI_NAME === "string" ? OPENCO
       description: "Manage plugins",
       commands: [Spec.make("list", { description: "List active plugins" })],
     }),
-    Spec.make("migrate", { description: "Migrate v1 data to v2" }),
     Spec.make("mini", {
       description: "Start the minimal interactive interface",
       params: {

packages/cli/src/commands/handlers/migrate.ts

@@ -1,5 +0,0 @@
-import { Effect } from "effect"
-import { Commands } from "../commands"
-import { Runtime } from "../../framework/runtime"
-
-export default Runtime.handler(Commands.commands.migrate, (_input) => Effect.log("No migrations to run."))

packages/cli/src/config/migrate.ts

@@ -116,13 +116,6 @@ export function migrateV1(legacy: TuiConfigV1.Info | undefined, kv: Record<strin
               : { grouping: kv.exploration_grouping ? ("auto" as const) : ("none" as const) }),
           },
         }),
-    ...(kv.dismissed_getting_started === undefined
-      ? {}
-      : {
-          hints: {
-            onboarding: !kv.dismissed_getting_started,
-          },
-        }),
     ...(kv.animations_enabled === undefined ? {} : { animations: kv.animations_enabled }),
     ...(legacy?.mouse === undefined ? {} : { mouse: legacy.mouse }),
   }

packages/cli/src/index.ts

@@ -35,7 +35,6 @@ const Handlers = Runtime.handlers(Commands, {
   plugin: {
     list: () => import("./commands/handlers/plugin/list"),
   },
-  migrate: () => import("./commands/handlers/migrate"),
   mini: () => import("./commands/handlers/mini"),
   run: () => import("./commands/handlers/run"),
   pair: () => import("./commands/handlers/pair"),

packages/cli/src/run/run.ts

@@ -235,10 +235,6 @@ async function renderToolError(part: SessionMessageAssistantTool, directory: str
   UI.println(UI.Style.TEXT_NORMAL + "✗", UI.Style.TEXT_NORMAL + `${info.title} failed`)
 }
 
-function warning(message: string) {
-  UI.println(UI.Style.TEXT_WARNING_BOLD + "!", UI.Style.TEXT_NORMAL, message)
-}
-
 function errorMessage(error: unknown) {
   if (error instanceof Error) return error.message
   if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string")

packages/cli/test/config.test.ts

@@ -74,12 +74,12 @@ test("migrates tui and kv config into cli.json", async () => {
       terminal: { title: false },
       prompt: { editor: false, paste: "full" },
       session: { sidebar: "hide", scrollbar: true, thinking: "show", grouping: "none" },
-      hints: { onboarding: false },
       animations: false,
       mouse: false,
     })
     expect(config).not.toHaveProperty("skipped_version")
     expect(config).not.toHaveProperty("which_key")
+    expect(config).not.toHaveProperty("hints")
     expect((await Bun.file(path.join(directory, "cli.json")).json()).keybinds).toEqual({ leader: "ctrl+o" })
     expect(await Bun.file(path.join(directory, "cli.json")).exists()).toBe(true)
     expect(await Bun.file(path.join(directory, "tui.json")).exists()).toBe(true)

packages/core/package.json

@@ -56,7 +56,6 @@
     "@tsconfig/bun": "catalog:",
     "@types/bun": "catalog:",
     "@types/node": "catalog:",
-    "@types/semver": "catalog:",
     "@types/turndown": "5.0.5",
     "@types/which": "3.0.4",
     "@parcel/watcher-darwin-arm64": "2.5.1",
@@ -100,7 +99,6 @@
     "@ff-labs/fff-node": "0.10.1",
     "@opencode-ai/codemode": "workspace:*",
     "@opencode-ai/effect-drizzle-sqlite": "workspace:*",
-    "@opencode-ai/effect-sqlite-node": "workspace:*",
     "@opencode-ai/ai": "workspace:*",
     "@opencode-ai/schema": "workspace:*",
     "@opencode-ai/plugin": "workspace:*",
@@ -122,7 +120,6 @@
     "immer": "11.1.4",
     "ignore": "7.0.5",
     "jsonc-parser": "3.3.1",
-    "semver": "^7.6.3",
     "turndown": "7.2.0",
     "tree-sitter-bash": "0.25.0",
     "tree-sitter-powershell": "0.25.10",

packages/core/src/control-plane/move-session.ts

@@ -1,181 +0,0 @@
-export * as MoveSession from "./move-session"
-
-import { Context, DateTime, Effect, Layer, Schema } from "effect"
-import { makeGlobalNode } from "@opencode-ai/util/effect/app-node"
-import { FSUtil } from "@opencode-ai/util/fs-util"
-import { Git } from "../git"
-import { Global } from "@opencode-ai/util/global"
-import { Project } from "../project"
-import { Session } from "../session"
-import { SessionExecution } from "../session/execution"
-import { SessionSchema } from "../session/schema"
-import { SessionStore } from "../session/store"
-import { AbsolutePath } from "../schema"
-import path from "path"
-
-export const Destination = Schema.Struct({
-  directory: AbsolutePath,
-}).annotate({ identifier: "MoveSession.Destination" })
-export type Destination = typeof Destination.Type
-
-export const Input = Schema.Struct({
-  sessionID: SessionSchema.ID,
-  destination: Destination,
-  moveChanges: Schema.optional(Schema.Boolean),
-}).annotate({ identifier: "MoveSession.Input" })
-export type Input = typeof Input.Type
-
-export class DestinationProjectMismatchError extends Schema.TaggedErrorClass<DestinationProjectMismatchError>()(
-  "MoveSession.DestinationProjectMismatchError",
-  {
-    expected: Project.ID,
-    actual: Project.ID,
-  },
-) {}
-
-export class DestinationNotFoundError extends Schema.TaggedErrorClass<DestinationNotFoundError>()(
-  "MoveSession.DestinationNotFoundError",
-  { directory: AbsolutePath },
-) {}
-
-export class DestinationNotDirectoryError extends Schema.TaggedErrorClass<DestinationNotDirectoryError>()(
-  "MoveSession.DestinationNotDirectoryError",
-  { directory: AbsolutePath },
-) {}
-
-export class ApplyChangesError extends Schema.TaggedErrorClass<ApplyChangesError>()("MoveSession.ApplyChangesError", {
-  message: Schema.String,
-}) {}
-
-export class CaptureChangesError extends Schema.TaggedErrorClass<CaptureChangesError>()(
-  "MoveSession.CaptureChangesError",
-  {
-    message: Schema.String,
-  },
-) {}
-
-export class ResetSourceChangesError extends Schema.TaggedErrorClass<ResetSourceChangesError>()(
-  "MoveSession.ResetSourceChangesError",
-  {
-    directory: AbsolutePath,
-    message: Schema.String,
-    cause: Schema.optional(Schema.Defect()),
-  },
-) {}
-
-export type Error =
-  | Session.NotFoundError
-  | DestinationProjectMismatchError
-  | DestinationNotFoundError
-  | DestinationNotDirectoryError
-  | Session.DestinationNotFoundError
-  | Session.DestinationNotDirectoryError
-  | CaptureChangesError
-  | ApplyChangesError
-  | ResetSourceChangesError
-
-export interface Interface {
-  readonly moveSession: (input: Input) => Effect.Effect<void, Error>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/ControlPlaneMoveSession") {}
-
-const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const git = yield* Git.Service
-    const fs = yield* FSUtil.Service
-    const global = yield* Global.Service
-    const project = yield* Project.Service
-    const sessions = yield* SessionStore.Service
-    const session = yield* Session.Service
-    const execution = yield* SessionExecution.Service
-
-    const moveSession = Effect.fn("MoveSession.moveSession")(function* (input: Input) {
-      const current = yield* sessions.get(input.sessionID)
-      if (!current) return yield* new Session.NotFoundError({ sessionID: input.sessionID })
-      const value = input.destination.directory.trim()
-      const expanded = value === "~" ? global.home : value.startsWith("~/") ? path.join(global.home, value.slice(2)) : value
-      const directory = AbsolutePath.make(path.resolve(current.location.directory, expanded))
-      const destinationInfo = yield* fs.stat(directory).pipe(Effect.catch(() => Effect.succeed(undefined)))
-      if (!destinationInfo) return yield* new DestinationNotFoundError({ directory })
-      if (destinationInfo.type !== "Directory") return yield* new DestinationNotDirectoryError({ directory })
-      if (current.location.directory === directory) return
-
-      const source = yield* project.resolve(current.location.directory)
-      const destination = yield* project.resolve(directory)
-      if (input.moveChanges && current.projectID !== destination.id) {
-        return yield* new DestinationProjectMismatchError({ expected: current.projectID, actual: destination.id })
-      }
-      // A move must not race active execution: a mid-drain relocation would let
-      // the source Location dispatch a request assembled under stale instructions
-      // and history. Serialize like removal does — stop the drain, then move.
-      yield* execution.interrupt(input.sessionID)
-      yield* execution.awaitIdle(input.sessionID)
-
-      const moveChanges = input.moveChanges && source.directory !== destination.directory
-      const sourceRepository = moveChanges ? yield* git.repo.discover(current.location.directory) : undefined
-      if (moveChanges && !sourceRepository)
-        return yield* new CaptureChangesError({ message: "Source is not a Git repository" })
-      const patch = sourceRepository
-        ? yield* git.change
-            .capture({ repository: sourceRepository, path: current.location.directory })
-            .pipe(Effect.mapError((error) => new CaptureChangesError({ message: error.message })))
-        : Git.ChangeSet.make("")
-      if (patch) {
-        const repository = yield* git.repo.discover(directory)
-        if (!repository) return yield* new ApplyChangesError({ message: "Destination is not a Git repository" })
-        yield* git.change
-          .apply({ repository, path: directory, changes: patch })
-          .pipe(Effect.mapError((error) => new ApplyChangesError({ message: error.message })))
-      }
-
-      yield* session.move({
-        sessionID: input.sessionID,
-        directory,
-      })
-
-      if (patch) {
-        const repository = yield* git.repo.discover(current.location.directory)
-        if (!repository)
-          return yield* new ResetSourceChangesError({
-            directory: current.location.directory,
-            message: "Source is not a Git repository",
-          })
-        yield* git.change
-          .discard({
-            repository,
-            path: current.location.directory,
-            index: "preserve",
-            untracked: "remove",
-          })
-          .pipe(
-            Effect.mapError(
-              (error) =>
-                new ResetSourceChangesError({
-                  directory: current.location.directory,
-                  message: error.message,
-                  cause: error.cause,
-                }),
-            ),
-          )
-      }
-    })
-
-    return Service.of({ moveSession })
-  }),
-)
-
-export const node = makeGlobalNode({
-  service: Service,
-  layer,
-  deps: [
-    FSUtil.node,
-    Git.node,
-    Global.node,
-    Project.node,
-    Session.node,
-    SessionStore.node,
-    SessionExecution.node,
-  ],
-})

packages/core/src/location-services.ts

@@ -148,6 +148,3 @@ export function buildLocationServiceMap(
     ),
   )
 }
-
-// This is temporary for backwards compatibility
-export const locationServiceMapLayer = buildLocationServiceMap()

packages/core/src/plugin/layer-map.example.ts

@@ -1,94 +0,0 @@
-export * as LayerMapExample from "./layer-map.example"
-
-import { Context, Effect, Layer, LayerMap } from "effect"
-import { Npm } from "@opencode-ai/util/npm"
-
-/**
- * Tutorial: split global services from context-specific services.
- *
- * Use this pattern when part of the app should be constructed once at the app edge,
- * while another part should be cached per request/project/workspace key.
- *
- * In this example:
- * - Npm.Service is the global service. It is not keyed by request context and should
- *   be provided once by the application runtime.
- * - ConfigService is context-specific. It is built from a RequestContext key and is
- *   cached by LayerMap for that key.
- * - ConfigServiceMap.layer owns the cache. Provide it once globally, then each
- *   request can provide ConfigServiceMap.get(context) to select the right instance.
- *
- * Lifetime model:
- * - ConfigServiceMap.layer has the app/global lifetime and depends on Npm.Service.
- * - ConfigServiceMap.get(context) has the request/context lifetime and provides
- *   ConfigService for exactly that context key.
- * - The cached ConfigService entry stays alive while something is using it. Once idle,
- *   it remains cached for idleTimeToLive, then its scope is finalized.
- * - invalidate(context) removes the cache entry for future lookups. Active users keep
- *   running on the old instance; the next lookup can create a fresh instance.
- *
- * Key model:
- * - Keys can be strings, structs, classes, arrays, etc.
- * - Prefer primitive or immutable keys. Effect uses Hash / Equal semantics for cache
- *   lookup, so mutating an object after it has been used as a key is a bug.
- */
-
-export type RequestContext = {
-  readonly directory: string
-  readonly workspace: string
-}
-
-export class RequestContextRef extends Context.Service<RequestContextRef, RequestContext>()(
-  "@opencode/example/RequestContextRef",
-) {}
-
-export interface ConfigServiceShape {
-  readonly directory: string
-  readonly workspace: string
-  readonly nextUse: () => Effect.Effect<number>
-  readonly which: Npm.Interface["which"]
-}
-
-export class ConfigService extends Context.Service<ConfigService, ConfigServiceShape>()(
-  "@opencode/example/ConfigService",
-) {}
-
-const configServiceLayer = Layer.effect(
-  ConfigService,
-  Effect.gen(function* () {
-    const context = yield* RequestContextRef
-    const npm = yield* Npm.Service
-
-    let useCount = 0
-
-    return ConfigService.of({
-      directory: context.directory,
-      workspace: context.workspace,
-      nextUse: () => Effect.succeed(++useCount),
-      which: npm.which,
-    })
-  }),
-)
-
-export class ConfigServiceMap extends LayerMap.Service<ConfigServiceMap>()("@opencode/example/ConfigServiceMap", {
-  lookup: (context: RequestContext) =>
-    configServiceLayer.pipe(Layer.provide(Layer.succeed(RequestContextRef, RequestContextRef.of(context)))),
-  idleTimeToLive: "5 minutes",
-}) {}
-
-export const appLayer = ConfigServiceMap.layer
-
-export const readConfig = Effect.fn("LayerMapExample.readConfig")(function* () {
-  const config = yield* ConfigService
-
-  return {
-    directory: config.directory,
-    workspace: config.workspace,
-    useCount: yield* config.nextUse(),
-  }
-})
-
-export const handleRequest = Effect.fn("LayerMapExample.handleRequest")(function* (context: RequestContext) {
-  return yield* readConfig().pipe(Effect.provide(ConfigServiceMap.get(context)))
-})
-
-export const invalidateContext = (context: RequestContext) => ConfigServiceMap.invalidate(context)

packages/core/src/plugin/runtime.ts

@@ -120,7 +120,6 @@ export const providerLayerWithCell = (cell: Cell) =>
   )
 
 export const layer = layerWithCell(defaultCell)
-export const providerLayer = providerLayerWithCell(defaultCell)
 
 export const node = makeGlobalNode({ service: Service, layer, deps: [] })
 

packages/core/src/v1/config/console-state.ts

@@ -1,16 +0,0 @@
-export * as ConfigConsoleStateV1 from "./console-state"
-
-import { Schema } from "effect"
-import { NonNegativeInt } from "../../schema"
-
-export class ConsoleState extends Schema.Class<ConsoleState>("ConsoleState")({
-  consoleManagedProviders: Schema.mutable(Schema.Array(Schema.String)),
-  activeOrgName: Schema.optional(Schema.String),
-  switchableOrgCount: NonNegativeInt,
-}) {}
-
-export const emptyConsoleState: ConsoleState = ConsoleState.make({
-  consoleManagedProviders: [],
-  activeOrgName: undefined,
-  switchableOrgCount: 0,
-})

packages/core/test/move-session.test.ts

@@ -1,291 +0,0 @@
-import { describe, expect } from "bun:test"
-import { $ } from "bun"
-import fs from "fs/promises"
-import path from "path"
-import { eq } from "drizzle-orm"
-import { Effect, Layer } from "effect"
-import { MoveSession } from "@opencode-ai/core/control-plane/move-session"
-import { Database } from "@opencode-ai/core/database/database"
-import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
-import { LayerNode } from "@opencode-ai/util/effect/layer-node"
-import { Bus } from "@opencode-ai/core/bus"
-import { Job } from "@opencode-ai/core/job"
-import { Project } from "@opencode-ai/core/project"
-import { ProjectDirectories } from "@opencode-ai/core/project/directories"
-import { AbsolutePath } from "@opencode-ai/core/schema"
-import { Session } from "@opencode-ai/core/session"
-import { SessionExecution } from "@opencode-ai/core/session/execution"
-import { SessionProjector } from "@opencode-ai/core/session/projector"
-import { SessionTable } from "@opencode-ai/core/session/sql"
-import { SessionStore } from "@opencode-ai/core/session/store"
-import { tmpdir } from "./fixture/tmpdir"
-import { testEffect } from "./lib/effect"
-
-// Records the execution serialization a move must perform before relocating.
-const executionCalls: string[] = []
-const recordingExecution = Layer.succeed(
-  SessionExecution.Service,
-  SessionExecution.Service.of({
-    active: Effect.succeed(new Set()),
-    resume: () => Effect.void,
-    wake: () => Effect.void,
-    interrupt: (sessionID) => Effect.sync(() => void executionCalls.push(`interrupt:${sessionID}`)),
-    awaitIdle: (sessionID) => Effect.sync(() => void executionCalls.push(`awaitIdle:${sessionID}`)),
-  }),
-)
-
-const it = testEffect(
-  AppNodeBuilder.build(
-    LayerNode.group([
-      MoveSession.node,
-      Database.node,
-      Bus.node,
-      ProjectDirectories.node,
-      Project.node,
-      Session.node,
-      SessionProjector.node,
-      SessionStore.node,
-    ]),
-    [[SessionExecution.node, recordingExecution]],
-  ),
-)
-
-function abs(input: string) {
-  return AbsolutePath.make(input)
-}
-
-async function initRepo(directory: string) {
-  await $`git init`.cwd(directory).quiet()
-  await $`git config core.autocrlf false`.cwd(directory).quiet()
-  await $`git config core.fsmonitor false`.cwd(directory).quiet()
-  await $`git config commit.gpgsign false`.cwd(directory).quiet()
-  await $`git config user.email test@opencode.test`.cwd(directory).quiet()
-  await $`git config user.name Test`.cwd(directory).quiet()
-  await fs.writeFile(path.join(directory, "tracked.txt"), "initial\n")
-  await $`git add tracked.txt`.cwd(directory).quiet()
-  await $`git commit -m root`.cwd(directory).quiet()
-}
-
-describe("MoveSession", () => {
-  it.live("moves session changes to another project directory", () =>
-    Effect.gen(function* () {
-      const root = yield* Effect.acquireRelease(
-        Effect.promise(() => tmpdir()),
-        (dir) => Effect.promise(() => dir[Symbol.asyncDispose]()),
-      )
-      yield* Effect.promise(() => initRepo(root.path))
-      const source = abs(yield* Effect.promise(() => fs.realpath(root.path)))
-      const destination = abs(`${root.path}-move-destination`)
-      yield* Effect.addFinalizer(() =>
-        Effect.promise(() => fs.rm(destination, { recursive: true, force: true })).pipe(Effect.ignore),
-      )
-      yield* Effect.promise(() => $`git worktree add --detach ${destination} HEAD`.cwd(root.path).quiet())
-      const moved = abs(yield* Effect.promise(() => fs.realpath(destination)))
-      yield* Effect.promise(() => fs.writeFile(path.join(source, "tracked.txt"), "changed\n"))
-      yield* Effect.promise(() => fs.writeFile(path.join(source, "untracked.txt"), "new\n"))
-
-      const projectID = (yield* Project.Service.use((service) => service.resolve(source))).id
-      const sessionID = Session.ID.make("ses_move")
-      const { db } = yield* Database.Service
-      yield* db
-        .insert(SessionTable)
-        .values({
-          id: sessionID,
-          project_id: projectID,
-          slug: "move",
-          directory: source,
-          title: "move",
-          version: "test",
-          time_created: 1,
-          time_updated: 1,
-        })
-        .run()
-        .pipe(Effect.orDie)
-
-      executionCalls.length = 0
-      yield* MoveSession.Service.use((service) =>
-        service.moveSession({ sessionID, destination: { directory: moved }, moveChanges: true }),
-      )
-
-      // The move stops active execution before any relocation side effect.
-      expect(executionCalls).toEqual([`interrupt:${sessionID}`, `awaitIdle:${sessionID}`])
-      expect(yield* Effect.promise(() => fs.readFile(path.join(moved, "tracked.txt"), "utf8"))).toBe("changed\n")
-      expect(yield* Effect.promise(() => fs.readFile(path.join(moved, "untracked.txt"), "utf8"))).toBe("new\n")
-      expect(yield* Effect.promise(() => fs.readFile(path.join(source, "tracked.txt"), "utf8"))).toBe("initial\n")
-      expect(yield* Effect.promise(() => Bun.file(path.join(source, "untracked.txt")).exists())).toBe(false)
-      expect(
-        yield* db
-          .select({ directory: SessionTable.directory, path: SessionTable.path })
-          .from(SessionTable)
-          .where(eq(SessionTable.id, sessionID))
-          .get(),
-      ).toEqual({ directory: moved, path: "" })
-    }),
-  )
-
-  it.live("moves within a checkout without transferring existing changes", () =>
-    Effect.gen(function* () {
-      const root = yield* Effect.acquireRelease(
-        Effect.promise(() => tmpdir()),
-        (dir) => Effect.promise(() => dir[Symbol.asyncDispose]()),
-      )
-      yield* Effect.promise(() => initRepo(root.path))
-      const source = abs(yield* Effect.promise(() => fs.realpath(root.path)))
-      const destination = abs(path.join(source, "packages"))
-      yield* Effect.promise(() => fs.writeFile(path.join(source, "tracked.txt"), "changed\n"))
-      yield* Effect.promise(() => fs.writeFile(path.join(source, "untracked.txt"), "new\n"))
-
-      const projectID = (yield* Project.Service.use((service) => service.resolve(source))).id
-      const sessionID = Session.ID.make("ses_move_nested")
-      const { db } = yield* Database.Service
-      yield* db
-        .insert(SessionTable)
-        .values({
-          id: sessionID,
-          project_id: projectID,
-          slug: "move-nested",
-          directory: source,
-          title: "move nested",
-          version: "test",
-          time_created: 1,
-          time_updated: 1,
-        })
-        .run()
-        .pipe(Effect.orDie)
-
-      const missing = yield* Session.Service.use((service) =>
-        service.move({ sessionID, directory: abs("packages") }).pipe(Effect.flip),
-      )
-      expect(missing._tag).toBe("Session.DestinationNotFoundError")
-      yield* Effect.promise(() => fs.mkdir(destination))
-
-      yield* MoveSession.Service.use((service) =>
-        service.moveSession({ sessionID, destination: { directory: abs("packages") }, moveChanges: true }),
-      )
-
-      expect(yield* Effect.promise(() => fs.readFile(path.join(source, "tracked.txt"), "utf8"))).toBe("changed\n")
-      expect(yield* Effect.promise(() => fs.readFile(path.join(source, "untracked.txt"), "utf8"))).toBe("new\n")
-      expect(
-        yield* db
-          .select({ directory: SessionTable.directory, path: SessionTable.path })
-          .from(SessionTable)
-          .where(eq(SessionTable.id, sessionID))
-          .get(),
-      ).toEqual({ directory: destination, path: "packages" })
-    }),
-  )
-
-  it.live("moves a session to another project", () =>
-    Effect.gen(function* () {
-      const root = yield* Effect.acquireRelease(
-        Effect.promise(() => tmpdir()),
-        (dir) => Effect.promise(() => dir[Symbol.asyncDispose]()),
-      )
-      yield* Effect.promise(() => initRepo(root.path))
-      const source = abs(yield* Effect.promise(() => fs.realpath(root.path)))
-      const destination = abs(`${root.path}-other-project`)
-      yield* Effect.acquireRelease(
-        Effect.promise(() => fs.mkdir(destination, { recursive: true })),
-        () => Effect.promise(() => fs.rm(destination, { recursive: true, force: true })),
-      )
-
-      const projectID = (yield* Project.Service.use((service) => service.resolve(source))).id
-      const destinationProjectID = (yield* Project.Service.use((service) => service.resolve(destination))).id
-      const sessionID = Session.ID.make("ses_move_project")
-      const { db } = yield* Database.Service
-      yield* db
-        .insert(SessionTable)
-        .values({
-          id: sessionID,
-          project_id: projectID,
-          slug: "move-project",
-          directory: source,
-          title: "move project",
-          version: "test",
-          time_created: 1,
-          time_updated: 1,
-        })
-        .run()
-        .pipe(Effect.orDie)
-
-      yield* Session.Service.use((service) =>
-        service.move({ sessionID, directory: destination }),
-      )
-
-      expect(
-        yield* db
-          .select({ projectID: SessionTable.project_id, directory: SessionTable.directory })
-          .from(SessionTable)
-          .where(eq(SessionTable.id, sessionID))
-          .get(),
-      ).toEqual({ projectID: destinationProjectID, directory: destination })
-    }),
-  )
-
-  it.live("moves nested session changes without cleaning unrelated files", () =>
-    Effect.gen(function* () {
-      const root = yield* Effect.acquireRelease(
-        Effect.promise(() => tmpdir()),
-        (dir) => Effect.promise(() => dir[Symbol.asyncDispose]()),
-      )
-      yield* Effect.promise(() => initRepo(root.path))
-      const source = abs(yield* Effect.promise(() => fs.realpath(root.path)))
-      const sourceDirectory = abs(path.join(source, "packages"))
-      yield* Effect.promise(() => fs.mkdir(sourceDirectory))
-      yield* Effect.promise(() => fs.writeFile(path.join(sourceDirectory, "tracked.txt"), "initial\n"))
-      yield* Effect.promise(() => fs.writeFile(path.join(sourceDirectory, "staged.txt"), "initial\n"))
-      yield* Effect.promise(() => $`git add packages/tracked.txt packages/staged.txt`.cwd(source).quiet())
-      yield* Effect.promise(() => $`git commit -m packages`.cwd(source).quiet())
-      const destination = abs(`${root.path}-move-nested-destination`)
-      yield* Effect.addFinalizer(() =>
-        Effect.promise(() => fs.rm(destination, { recursive: true, force: true })).pipe(Effect.ignore),
-      )
-      yield* Effect.promise(() => $`git worktree add --detach ${destination} HEAD`.cwd(source).quiet())
-      const moved = abs(path.join(yield* Effect.promise(() => fs.realpath(destination)), "packages"))
-      yield* Effect.promise(() => fs.writeFile(path.join(sourceDirectory, "tracked.txt"), "changed\n"))
-      yield* Effect.promise(() => fs.writeFile(path.join(sourceDirectory, "staged.txt"), "staged\n"))
-      yield* Effect.promise(() => $`git add packages/staged.txt`.cwd(source).quiet())
-      yield* Effect.promise(() => fs.writeFile(path.join(sourceDirectory, "untracked.txt"), "new\n"))
-      yield* Effect.promise(() => fs.writeFile(path.join(source, "tracked.txt"), "unrelated\n"))
-      yield* Effect.promise(() => fs.writeFile(path.join(source, "untracked.txt"), "unrelated\n"))
-
-      const projectID = (yield* Project.Service.use((service) => service.resolve(source))).id
-      const sessionID = Session.ID.make("ses_move_nested_checkout")
-      const { db } = yield* Database.Service
-      yield* db
-        .insert(SessionTable)
-        .values({
-          id: sessionID,
-          project_id: projectID,
-          slug: "move-nested-checkout",
-          directory: sourceDirectory,
-          title: "move nested checkout",
-          version: "test",
-          time_created: 1,
-          time_updated: 1,
-        })
-        .run()
-        .pipe(Effect.orDie)
-
-      yield* MoveSession.Service.use((service) =>
-        service.moveSession({ sessionID, destination: { directory: moved }, moveChanges: true }),
-      )
-
-      expect(yield* Effect.promise(() => fs.readFile(path.join(moved, "tracked.txt"), "utf8"))).toBe("changed\n")
-      expect(yield* Effect.promise(() => fs.readFile(path.join(moved, "staged.txt"), "utf8"))).toBe("staged\n")
-      expect(yield* Effect.promise(() => fs.readFile(path.join(moved, "untracked.txt"), "utf8"))).toBe("new\n")
-      expect(yield* Effect.promise(() => fs.readFile(path.join(sourceDirectory, "tracked.txt"), "utf8"))).toBe(
-        "initial\n",
-      )
-      expect(yield* Effect.promise(() => Bun.file(path.join(sourceDirectory, "untracked.txt")).exists())).toBe(false)
-      expect(yield* Effect.promise(() => fs.readFile(path.join(sourceDirectory, "staged.txt"), "utf8"))).toBe(
-        "staged\n",
-      )
-      expect(yield* Effect.promise(() => $`git status --porcelain -- packages/staged.txt`.cwd(source).text())).toBe(
-        "M  packages/staged.txt\n",
-      )
-      expect(yield* Effect.promise(() => fs.readFile(path.join(source, "tracked.txt"), "utf8"))).toBe("unrelated\n")
-      expect(yield* Effect.promise(() => fs.readFile(path.join(source, "untracked.txt"), "utf8"))).toBe("unrelated\n")
-    }),
-  )
-})

packages/theme/src/tui/index.ts

@@ -45,6 +45,7 @@ export type {
   StatefulColor,
 } from "./types.js"
 export { DEFAULT_CATEGORICAL, DEFAULT_THEME } from "./defaults.js"
+export { expandTheme } from "./expand.js"
 export { migrateV1 } from "./v1-migrate.js"
 export { resolveTheme, resolveThemeDocument, themeDecodeError } from "./resolve.js"
 export { selectTheme, selectThemeMode, supportsThemeMode, themeModes } from "./select.js"

packages/tui/package.json

@@ -93,7 +93,6 @@
     "@opentui/solid": "catalog:",
     "@solid-primitives/event-bus": "1.1.2",
     "clipboardy": "4.0.0",
-    "diff": "catalog:",
     "effect": "catalog:",
     "fuzzysort": "catalog:",
     "get-east-asian-width": "catalog:",

packages/tui/src/app.tsx

@@ -72,9 +72,9 @@ import { ThemeErrorToast } from "./component/theme-error-toast"
 import { ThemeProvider, useTheme, useThemes } from "./context/theme"
 import { Home } from "./routes/home"
 import { Session } from "./routes/session"
-import { PromptHistoryProvider } from "./component/prompt/history"
-import { FrecencyProvider } from "./component/prompt/frecency"
-import { PromptStashProvider } from "./component/prompt/stash"
+import { PromptHistoryProvider } from "./prompt/history"
+import { FrecencyProvider } from "./prompt/frecency"
+import { PromptStashProvider } from "./prompt/stash"
 import { Toast, ToastProvider, useToast } from "./ui/toast"
 import { isFallbackTitle } from "@opencode-ai/util/session-title-fallback"
 import * as Model from "./util/model"

packages/tui/src/attention.ts

@@ -5,7 +5,6 @@ import type {
   TuiAttentionNotifyResult,
   TuiAttentionNotifySkipReason,
   TuiAttentionWhen,
-  TuiKV,
   TuiAttentionSoundName,
   TuiAttentionSoundPack,
   TuiAttentionSoundPackInfo,
@@ -115,8 +114,6 @@ export function createTuiAttention(input: {
   renderer: AttentionRenderer
   config: Pick<Config.Resolved, "attention">
   update?: Config.Interface["update"]
-  /** @deprecated Ignored. Sound-pack persistence uses CLI config. */
-  kv?: TuiKV
   audio?: Pick<typeof TuiAudio, "loadSoundFile" | "play">
 }): TuiAttentionHost {
   let focus: FocusState = "unknown"

packages/tui/src/audio.ts

@@ -1,4 +1,4 @@
-import { Audio, type AudioErrorContext, type AudioPlayOptions, type AudioSound, type AudioVoice } from "@opentui/core"
+import { Audio, type AudioErrorContext, type AudioPlayOptions, type AudioSound } from "@opentui/core"
 import { readFile } from "node:fs/promises"
 
 let audio: Audio | null | undefined
@@ -42,10 +42,6 @@ export function play(sound: AudioSound, options?: AudioPlayOptions) {
   return current.play(sound, options)
 }
 
-export function stopVoice(voice: AudioVoice) {
-  return audio?.stopVoice(voice) ?? false
-}
-
 export function dispose() {
   audio?.dispose()
   audio = undefined

packages/tui/src/component/dialog-config.tsx

@@ -43,15 +43,6 @@ export const settings: Setting[] = [
     labels: ["off", "on"],
     keywords: ["motion", "effects"],
   },
-  {
-    title: "Onboarding",
-    category: "Appearance",
-    path: ["hints", "onboarding"],
-    default: true,
-    values: [false, true],
-    labels: ["off", "on"],
-    keywords: ["hints", "getting started", "guidance"],
-  },
   {
     title: "Sidebar",
     category: "Session",

packages/tui/src/component/dialog-stash.tsx

@@ -4,7 +4,7 @@ import { createMemo, createSignal } from "solid-js"
 import { Locale } from "../util/locale"
 import { Keymap } from "../context/keymap"
 import { useTheme } from "../context/theme"
-import { usePromptStash, type StashEntry } from "./prompt/stash"
+import { usePromptStash, type StashEntry } from "../prompt/stash"
 
 function getRelativeTime(timestamp: number): string {
   const now = Date.now()

packages/tui/src/component/prompt/frecency.tsx

@@ -1 +0,0 @@
-export * from "../../prompt/frecency"

packages/tui/src/component/prompt/history.tsx

@@ -1 +0,0 @@
-export * from "../../prompt/history"

packages/tui/src/component/prompt/stash.tsx

@@ -1 +0,0 @@
-export * from "../../prompt/stash"

packages/tui/src/component/session-tabs.tsx

@@ -6,6 +6,7 @@ import { useSessionTabs } from "../context/session-tabs"
 import { useTheme, useThemes } from "../context/theme"
 import {
   adaptiveSessionTabLayout,
+  moveSessionTab,
   NEW_SESSION_TAB_TITLE,
   sessionTabComplete,
   seedSessionTabMotion,
@@ -48,6 +49,10 @@ export function SessionTabs(props: { controller?: SessionTabsController; animati
   const animations = () => props.animations ?? config.animations ?? true
   const [hovered, setHovered] = createSignal<string>()
   const [dragging, setDragging] = createSignal<string>()
+  // A drag reorders a local preview and persists one move on release instead of writing
+  // per slot crossing; the preview holds after release until the store reflects the move,
+  // so the strip never flashes the pre-drag order while the write is in flight.
+  const [preview, setPreview] = createSignal<{ sessionID: string; index: number }>()
   let strip: { screenX: number } | undefined
   const hueStep = () => (mode() === "light" ? 800 : 200)
   const accent = () => theme.hue.accent[hueStep()]
@@ -55,7 +60,18 @@ export function SessionTabs(props: { controller?: SessionTabsController; animati
   const idleNumber = () => tint(theme.text.subdued, theme.background.default, 0.35)
   const newTab = () => tabs.newTab?.() ?? false
   const activeID = createMemo(() => (newTab() ? NEW_SESSION_TAB.sessionID : tabs.current()))
-  const items = createMemo(() => (newTab() ? [...tabs.tabs(), NEW_SESSION_TAB] : tabs.tabs()))
+  const ordered = createMemo(() => {
+    const pending = preview()
+    if (!pending) return tabs.tabs()
+    return moveSessionTab(tabs.tabs(), pending.sessionID, pending.index)
+  })
+  const items = createMemo(() => (newTab() ? [...ordered(), NEW_SESSION_TAB] : ordered()))
+  createEffect(() => {
+    const pending = preview()
+    if (!pending || dragging()) return
+    const index = tabs.tabs().findIndex((tab) => tab.sessionID === pending.sessionID)
+    if (index === -1 || index === Math.min(pending.index, tabs.tabs().length - 1)) setPreview(undefined)
+  })
   const layout = createMemo((previous: ReturnType<typeof adaptiveSessionTabLayout> | undefined) =>
     adaptiveSessionTabLayout(items(), activeID(), dimensions().width, previous?.start),
   )
@@ -279,6 +295,8 @@ export function SessionTabs(props: { controller?: SessionTabsController; animati
           // keeping sloppy clicks indistinguishable from clean ones.
           const release = () => {
             setDragging(undefined)
+            const pending = preview()
+            if (pending?.sessionID === tab.sessionID) tabs.move(pending.sessionID, pending.index)
             if (tab === NEW_SESSION_TAB) return
             tabs.select(tab.sessionID)
           }
@@ -295,7 +313,8 @@ export function SessionTabs(props: { controller?: SessionTabsController; animati
               onMouseDrag={(event) => {
                 if (tab === NEW_SESSION_TAB) return
                 const slot = slotAt(event.x)
-                if (slot !== undefined && slot !== tabNumber() - 1) tabs.move(tab.sessionID, slot)
+                if (slot !== undefined && slot !== tabNumber() - 1)
+                  setPreview({ sessionID: tab.sessionID, index: slot })
               }}
               onMouseDragEnd={release}
             >
@@ -341,6 +360,9 @@ export function SessionTabs(props: { controller?: SessionTabsController; animati
                   fg={closeColor()}
                   selectable={false}
                   onMouseUp={(event) => {
+                    // The close mark only renders while hovered; without motion events a click can
+                    // land here first, and must select the tab instead of closing it invisibly.
+                    if (hovered() !== tab.sessionID) return
                     event.stopPropagation()
                     tabs.close(tab === NEW_SESSION_TAB ? undefined : tab.sessionID)
                   }}

packages/tui/src/config/index.tsx

@@ -162,11 +162,6 @@ export const Info = Schema.Struct({
       }),
     }),
   ).annotate({ description: "Mini transcript presentation settings" }),
-  hints: Schema.optional(
-    Schema.Struct({
-      onboarding: Schema.optional(Schema.Boolean).annotate({ description: "Show getting-started guidance" }),
-    }),
-  ).annotate({ description: "In-product guidance settings" }),
   debug: Schema.optional(
     Schema.Struct({
       devtools: Schema.optional(Schema.Boolean).annotate({ description: "Show the DevTools debug bar" }),
@@ -267,7 +262,3 @@ export function useConfig() {
   if (!value) throw new Error("ConfigProvider is missing")
   return value
 }
-
-export function useConfigOptional() {
-  return useContext(ConfigContext)
-}

packages/tui/src/config/v1/keybind.ts

@@ -105,8 +105,6 @@ export const Definitions = {
   session_compact: keybind("<leader>c", "Compact the session"),
   session_queued_prompts: keybind("<leader>q", "View pending work"),
   session_child_first: keybind("down", "Toggle subagent picker"),
-  session_child_cycle: keybind("right", "Go to next child session"),
-  session_child_cycle_reverse: keybind("left", "Go to previous child session"),
   session_parent: keybind("up", "Go to parent session"),
   session_pin_toggle: keybind("ctrl+f", "Pin or unpin session in the session list"),
   session_quick_switch_1: keybind("<leader>1", "Switch to session in quick slot 1"),
@@ -308,8 +306,6 @@ export const CommandMap = {
   session_compact: "session.compact",
   session_queued_prompts: "session.queued_prompts",
   session_child_first: "session.child.first",
-  session_child_cycle: "session.child.next",
-  session_child_cycle_reverse: "session.child.previous",
   session_parent: "session.parent",
   session_pin_toggle: "session.pin.toggle",
   session_quick_switch_1: "session.quick_switch.1",

packages/tui/src/context/session-tabs-model.ts

@@ -29,9 +29,11 @@ export function openSessionTab(tabs: SessionTab[], tab: SessionTab): SessionTab[
   return tabs.map((item, position) => (position === index ? { ...item, title: tab.title } : item))
 }
 
-export function closeSessionTab(tabs: readonly SessionTab[], sessionID: string) {
+export function closeSessionTab(tabs: SessionTab[], sessionID: string) {
   const index = tabs.findIndex((tab) => tab.sessionID === sessionID)
-  if (index === -1) return { tabs: [...tabs], next: undefined }
+  // Like openSessionTab and moveSessionTab, a no-op returns the same reference so callers can
+  // detect it by identity.
+  if (index === -1) return { tabs, next: undefined }
   return {
     tabs: tabs.filter((tab) => tab.sessionID !== sessionID),
     next: tabs[index + 1]?.sessionID ?? tabs[index - 1]?.sessionID,
@@ -87,9 +89,13 @@ export function cycleSessionTab(tabs: readonly SessionTab[], active: string | un
   return tabs[(start + direction + tabs.length) % tabs.length]
 }
 
+// In-memory navigation history is bounded so a long-lived TUI does not accumulate one entry per
+// session switch forever; the oldest entries fall off first.
+const SESSION_TAB_HISTORY_LIMIT = 100
+
 export function recordSessionTabHistory(history: SessionTabHistory, sessionID: string): SessionTabHistory {
   if (history.entries[history.index] === sessionID) return history
-  const entries = [...history.entries.slice(0, history.index + 1), sessionID]
+  const entries = [...history.entries.slice(0, history.index + 1), sessionID].slice(-SESSION_TAB_HISTORY_LIMIT)
   return { entries, index: entries.length - 1 }
 }
 

packages/tui/src/context/session-tabs.tsx

@@ -73,7 +73,8 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
     function update(mutation: (draft: TabsState) => void) {
       const scope = config.tabs?.scope ?? "global"
       void updateStore((draft) => mutation(scope === "cwd" ? (draft.cwd[paths.cwd] ??= empty()) : draft.global)).catch(
-        () => {},
+        // Failed writes lose only tab layout, but silence would hide tabs resetting every launch.
+        (error) => console.error("Failed to persist session tabs", error),
       )
     }
 
@@ -222,7 +223,7 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
     function remove(sessionID: string, navigate: boolean) {
       const target = root(sessionID)
       const closed = closeSessionTab(state().tabs, target)
-      if (closed.tabs.length === state().tabs.length) return
+      if (closed.tabs === state().tabs) return
       const selected = navigate && current() === target
       const previous = selected
         ? moveSessionTabHistory(recordSessionTabHistory(history, target), closed.tabs, target, -1)

packages/tui/src/editor-zed.ts

@@ -194,10 +194,6 @@ export function resolveZedDbPath() {
   return candidates.find((item) => isFile(item))
 }
 
-export function isZedTerminal() {
-  return process.env.ZED_TERM === "true" || process.env.TERM_PROGRAM?.toLowerCase() === "zed"
-}
-
 function isFile(item: string) {
   try {
     return statSync(item).isFile()
@@ -220,11 +216,6 @@ function zedWorkspacePaths(value: string | null) {
   return value.split(/\r?\n/).filter(Boolean)
 }
 
-export function offsetToPosition(text: string, offset: number) {
-  const stringOffset = utf8ByteOffsetToStringIndex(text, offset)
-  return offsetsToSelection(text, stringOffset, stringOffset).start
-}
-
 function utf8ByteOffsetToStringIndex(text: string, byteOffset: number) {
   if (byteOffset <= 0) return 0
 

packages/tui/src/feature-plugins/sidebar/lsp.tsx

@@ -1,21 +0,0 @@
-import { Plugin, usePlugin } from "@opencode-ai/plugin/tui"
-
-function View() {
-  const context = usePlugin()
-  const theme = context.theme
-  return (
-    <box>
-      <text fg={theme.text.default}>
-        <b>LSP</b>
-      </text>
-      <text fg={theme.text.subdued}>LSP status unavailable</text>
-    </box>
-  )
-}
-
-export default Plugin.define({
-  id: "opencode.sidebar-lsp",
-  setup(context) {
-    context.ui.slot("sidebar.content", () => <View />)
-  },
-})

packages/tui/src/feature-plugins/system/diff-viewer-file-tree-utils.ts

@@ -141,22 +141,6 @@ export function moveFileTreeSelectionToParent(rows: readonly FileTreeRow[], sele
   return rows.findLast((item, itemIndex) => itemIndex < index && item.depth < row.depth)?.id ?? selected
 }
 
-export function moveFileTreeSelectionToFile(
-  rows: readonly FileTreeRow[],
-  selected: number | undefined,
-  offset: number,
-) {
-  const fileRows = rows.filter((row) => row.fileIndex !== undefined)
-  if (fileRows.length === 0) return undefined
-  const selectedIndex = selected === undefined ? -1 : rows.findIndex((row) => row.id === selected)
-  if (selectedIndex === -1) return offset < 0 ? fileRows[fileRows.length - 1]!.id : fileRows[0]!.id
-  const next =
-    offset < 0
-      ? fileRows.findLast((row) => rows.findIndex((item) => item.id === row.id) < selectedIndex)
-      : fileRows.find((row) => rows.findIndex((item) => item.id === row.id) > selectedIndex)
-  return next?.id ?? (offset < 0 ? fileRows[0]!.id : fileRows[fileRows.length - 1]!.id)
-}
-
 export function fileTreeFileSelection(tree: FileTree, fileIndex: number) {
   const node = tree.nodes.find((item) => item.kind === "file" && item.fileIndex === fileIndex)
   if (!node) return undefined

packages/tui/src/logo.ts

@@ -7,5 +7,3 @@ export const go = {
   left: ["    ", "█▀▀▀", "█_^█", "▀▀▀▀"],
   right: ["    ", "█▀▀█", "█__█", "▀▀▀▀"],
 }
-
-export const marks = "_^~,"

packages/tui/src/plugin/builtins.ts

@@ -2,7 +2,6 @@ import HomeFooter from "../feature-plugins/home/footer"
 import PromptFooter from "../feature-plugins/prompt/footer"
 import SidebarContext from "../feature-plugins/sidebar/context"
 import SidebarFooter from "../feature-plugins/sidebar/footer"
-import SidebarLsp from "../feature-plugins/sidebar/lsp"
 import SidebarMcp from "../feature-plugins/sidebar/mcp"
 import DiffViewer from "../feature-plugins/system/diff-viewer"
 import Notifications from "../feature-plugins/system/notifications"
@@ -14,7 +13,6 @@ export const builtins = [
   PromptFooter,
   SidebarContext,
   SidebarMcp,
-  SidebarLsp,
   SidebarFooter,
   Notifications,
   Plugins,

packages/tui/src/plugin/watch.ts

@@ -8,23 +8,46 @@ import { lstat, realpath, stat } from "fs/promises"
 // directories stay quiet. Symlinked files are additionally watched at their
 // resolved target, since edits there emit nothing at the link's location.
 // Directory targets are watched at their root only: edits to nested helper
-// files do not change the entrypoint mtime and are not detected. Watches are
-// never torn down individually (a stale watch costs one fs handle and a
-// spurious onChange); all die with dispose(). Failed or vanished watches are
-// forgotten so a later add() can re-arm once the path exists.
+// files do not change the entrypoint mtime and are not detected. A missing
+// target temporarily watches its nearest existing parent, filtered to the
+// first missing path segment, until the normal source watch can take over.
+// Established source watches die with dispose(). Failed or vanished watches
+// are forgotten so a later add() can re-arm once the path exists.
 export function createSourceWatcher(onChange: () => void) {
   const watchers = new Map<string, ReturnType<typeof watch>>()
   const watched = new Map<string, Set<string> | null>()
+  const missing = new Map<string, { dir: string; watcher: ReturnType<typeof watch> }>()
   let disposed = false
   const forget = (dir: string) => {
     watchers.get(dir)?.close()
     watchers.delete(dir)
     watched.delete(dir)
   }
+  const forgetMissing = (target: string) => {
+    missing.get(target)?.watcher.close()
+    missing.delete(target)
+  }
+  const armMissing = (target: string) => {
+    if (disposed) return
+    const dir = nearestExistingParent(target)
+    if (!dir) return
+    if (missing.get(target)?.dir === dir) return
+    forgetMissing(target)
+    const name = path.relative(dir, target).split(path.sep)[0]!
+    const watcher = watch(dir, (_event, filename) => {
+      if (filename && filename.toString().split(path.sep)[0] !== name) return
+      forgetMissing(target)
+      arm(target)
+      onChange()
+    })
+    watcher.on("error", () => forgetMissing(target))
+    missing.set(target, { dir, watcher })
+  }
   const arm = (target: string) => {
     stat(target)
       .then((info) => {
         if (disposed) return
+        forgetMissing(target)
         const dir = info.isDirectory() ? target : path.dirname(target)
         // Directories accept every filename (null); files accept their basename.
         const name = info.isDirectory() ? null : path.basename(target)
@@ -55,7 +78,7 @@ export function createSourceWatcher(onChange: () => void) {
         watcher.on("error", () => forget(dir))
         watchers.set(dir, watcher)
       })
-      .catch(() => undefined)
+      .catch(() => armMissing(target))
   }
   const add = (target: string) => {
     arm(target)
@@ -70,6 +93,14 @@ export function createSourceWatcher(onChange: () => void) {
   const dispose = () => {
     disposed = true
     for (const watcher of watchers.values()) watcher.close()
+    for (const item of missing.values()) item.watcher.close()
   }
   return { add, dispose }
 }
+
+function nearestExistingParent(target: string) {
+  const dir = path.dirname(target)
+  if (existsSync(dir)) return dir
+  if (dir === path.dirname(dir)) return
+  return nearestExistingParent(dir)
+}

packages/tui/src/routes/session/index.tsx

@@ -887,22 +887,6 @@ export function Session() {
         dialog.clear()
       },
     },
-    {
-      title: "Next subagent",
-      id: "session.child.next",
-      group: "Session",
-      palette: undefined,
-      enabled: !!session()?.parentID,
-      run: () => unavailable("Subagent navigation"),
-    },
-    {
-      title: "Previous subagent",
-      id: "session.child.previous",
-      group: "Session",
-      palette: undefined,
-      enabled: !!session()?.parentID,
-      run: () => unavailable("Subagent navigation"),
-    },
   ])
 
   const commands = createMemo(() =>
@@ -1925,122 +1909,6 @@ function UserMessage(props: { message: SessionMessageUser }) {
   )
 }
 
-function AssistantMessage(props: { message: SessionMessageAssistant; last: boolean }) {
-  const ctx = use()
-  const local = useLocal()
-  const theme = useTheme("elevated")
-  const model = createMemo(
-    () =>
-      ctx
-        .models()
-        .find((model) => model.providerID === props.message.model.providerID && model.id === props.message.model.id)
-        ?.name ?? `${props.message.model.providerID}/${props.message.model.id}`,
-  )
-
-  const final = createMemo(() => {
-    return props.message.finish && !["tool-calls", "unknown"].includes(props.message.finish)
-  })
-
-  const duration = createMemo(() => {
-    if (!final()) return 0
-    if (!props.message.time.completed) return 0
-    return props.message.time.completed - props.message.time.created
-  })
-
-  const exploration = createMemo(() => {
-    const grouped = new Map<string, { first: boolean; parts: SessionMessageAssistantTool[]; active: boolean }>()
-    if (!ctx.groupExploration()) return grouped
-    const runs = props.message.content
-      .map((part) =>
-        part.type === "tool" &&
-        ["read", "glob", "grep"].includes(toolDisplay(part.name)) &&
-        part.state.status !== "streaming"
-          ? part
-          : undefined,
-      )
-      .reduce<SessionMessageAssistantTool[][]>(
-        (runs, part) => {
-          if (part) runs[runs.length - 1].push(part)
-          if (!part && runs[runs.length - 1].length) runs.push([])
-          return runs
-        },
-        [[]],
-      )
-      .filter((run) => run.length > 0)
-    for (const run of runs) {
-      const summary = {
-        parts: run,
-        active: false,
-      }
-      run.forEach((part, index) => grouped.set(part.id, { ...summary, first: index === 0 }))
-    }
-    return grouped
-  })
-
-  return (
-    <>
-      <For each={props.message.content}>
-        {(content, index) => (
-          <Switch>
-            <Match when={content.type === "text"}>
-              <TextPart
-                part={content as SessionMessageAssistantText}
-                last={index() === props.message.content.length - 1}
-              />
-            </Match>
-            <Match when={content.type === "reasoning"}>
-              <ReasoningPart
-                part={content as SessionMessageAssistantReasoning}
-                message={props.message}
-                last={index() === props.message.content.length - 1}
-              />
-            </Match>
-            <Match when={content.type === "tool"}>
-              <Show when={exploration().get((content as SessionMessageAssistantTool).id)?.first !== false}>
-                <Show
-                  when={exploration().get((content as SessionMessageAssistantTool).id)}
-                  fallback={<ToolPart part={content as SessionMessageAssistantTool} />}
-                >
-                  {(summary) => <ExplorationSummary {...summary()} />}
-                </Show>
-              </Show>
-            </Match>
-          </Switch>
-        )}
-      </For>
-      <Show when={props.message.error}>
-        <box
-          border={["left"]}
-          paddingTop={1}
-          paddingBottom={1}
-          paddingLeft={2}
-          backgroundColor={theme.background.default}
-          customBorderChars={SplitBorder.customBorderChars}
-          borderColor={theme.text.feedback.error.default}
-        >
-          <text fg={theme.text.subdued}>{errorMessage(props.message.error)}</text>
-        </box>
-      </Show>
-      <AssistantRetry retry={props.message.retry} />
-      <Switch>
-        <Match when={props.last || final() || props.message.error}>
-          <box paddingLeft={3}>
-            <text>
-              <span style={{ fg: props.message.error ? theme.text.subdued : local.agent.color(props.message.agent) }}>
-                {Locale.titlecase(props.message.agent)}
-              </span>
-              <span style={{ fg: theme.text.subdued }}> · {model()}</span>
-              <Show when={duration()}>
-                <span style={{ fg: theme.text.subdued }}> · {Locale.duration(duration())}</span>
-              </Show>
-            </text>
-          </box>
-        </Match>
-      </Switch>
-    </>
-  )
-}
-
 function AssistantRetry(props: { retry: SessionMessageAssistant["retry"] }) {
   const theme = useTheme()
   return (
@@ -2056,40 +1924,6 @@ function AssistantRetry(props: { retry: SessionMessageAssistant["retry"] }) {
   )
 }
 
-function ExplorationSummary(props: { parts: SessionMessageAssistantTool[]; active: boolean }) {
-  const theme = useTheme()
-  const pathFormatter = usePathFormatter()
-  const label = (part: SessionMessageAssistantTool) => {
-    const input = typeof part.state.input === "string" ? {} : part.state.input
-    const tool = toolDisplay(part.name)
-    if (tool === "read") return `Read ${pathFormatter.format(stringValue(input.path))}`
-    if (tool === "glob") return `Glob "${stringValue(input.pattern)}"`
-    return `Grep "${stringValue(input.pattern)}"`
-  }
-  return (
-    <box flexDirection="column">
-      <InlineToolRow
-        icon="✱"
-        color={theme.text.subdued}
-        complete={!props.active}
-        pending="Exploring"
-        spinner={props.active}
-      >
-        {props.active ? "Exploring" : "Explored"}
-      </InlineToolRow>
-      <For each={props.parts}>
-        {(part, index) => (
-          <box paddingLeft={5}>
-            <text fg={part.state.status === "error" ? theme.text.feedback.error.default : theme.text.subdued}>
-              {index() === props.parts.length - 1 ? "└" : "├"} {label(part)}
-            </text>
-          </box>
-        )}
-      </For>
-    </box>
-  )
-}
-
 const INLINE_TOOL_ICON_WIDTH = 2
 
 function ReasoningPart(props: {
@@ -2954,10 +2788,6 @@ export function isBackgroundSubagent(
   return status === "completed" && metadata.status === "running"
 }
 
-export function formatSubagentRetry(attempt: number, message: string) {
-  return `Retrying (attempt ${attempt}) · ${message}`
-}
-
 type ExecuteCall = { tool: string; status: "running" | "completed" | "error"; input?: Record<string, unknown> }
 
 function executeCalls(value: unknown): ExecuteCall[] {

packages/tui/src/ui/dialog-alert.tsx

@@ -1,7 +1,7 @@
 import { TextAttributes } from "@opentui/core"
 import { Keymap } from "../context/keymap"
 import { useTheme } from "../context/theme"
-import { useDialog, type DialogContext } from "./dialog"
+import { useDialog } from "./dialog"
 
 export type DialogAlertProps = {
   title: string
@@ -56,12 +56,3 @@ export function DialogAlert(props: DialogAlertProps) {
     </box>
   )
 }
-
-DialogAlert.show = (dialog: DialogContext, title: string, message: string) => {
-  return new Promise<void>((resolve) => {
-    dialog.replace(
-      () => <DialogAlert title={title} message={message} onConfirm={() => resolve()} />,
-      () => resolve(),
-    )
-  })
-}

packages/tui/src/ui/dialog-confirm.tsx

@@ -1,7 +1,7 @@
 import { TextAttributes } from "@opentui/core"
 import { Keymap } from "../context/keymap"
 import { useTheme } from "../context/theme"
-import { useDialog, type DialogContext } from "./dialog"
+import { useDialog } from "./dialog"
 import { createStore } from "solid-js/store"
 import { For } from "solid-js"
 import { Locale } from "../util/locale"
@@ -17,8 +17,6 @@ export type DialogConfirmProps = {
   }
 }
 
-export type DialogConfirmResult = boolean | undefined
-
 export function DialogConfirm(props: DialogConfirmProps) {
   const dialog = useDialog()
   const theme = useTheme("elevated")
@@ -93,20 +91,3 @@ export function DialogConfirm(props: DialogConfirmProps) {
     </box>
   )
 }
-
-DialogConfirm.show = (dialog: DialogContext, title: string, message: string, label?: DialogConfirmProps["label"]) => {
-  return new Promise<DialogConfirmResult>((resolve) => {
-    dialog.replace(
-      () => (
-        <DialogConfirm
-          title={title}
-          message={message}
-          onConfirm={() => resolve(true)}
-          onCancel={() => resolve(false)}
-          label={label}
-        />
-      ),
-      () => resolve(undefined),
-    )
-  })
-}

packages/tui/src/ui/fade-file-path.tsx

@@ -1,56 +0,0 @@
-import type { RGBA } from "@opentui/core"
-import { createEffect, createMemo, createSignal, Show } from "solid-js"
-import { useConfig } from "../config"
-import { tint } from "../theme/color"
-import { createAnimatable, tween } from "./animation"
-import { FilePath } from "./file-path"
-
-// 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 fade = createAnimatable(
-    { front: 1 },
-    {
-      enabled: () => config.animations ?? true,
-      transition: tween({ duration: 0.3 }),
-    },
-  )
-  const [text, setText] = createSignal(props.value)
-  const [previous, setPrevious] = createSignal<string>()
-
-  createEffect((current: string | undefined) => {
-    const next = props.value
-    if (next === undefined || next === current) return current
-    setText(next)
-    if (current === undefined) return next
-    setPrevious(current)
-    fade.jump({ front: 0 })
-    fade.animate({ front: 1 })
-    return next
-  }, props.value)
-
-  const display = createMemo(() => (previous() !== undefined && fade.value().front < 0.5 ? previous() : text()))
-  const fg = createMemo(() => {
-    if (previous() === undefined || fade.value().front >= 1) return props.fg
-    return tint(props.bg, props.fg, Math.abs(fade.value().front * 2 - 1))
-  })
-
-  return (
-    <Show when={display() !== undefined}>
-      <FilePath
-        value={display() ?? ""}
-        maxWidth={props.maxWidth}
-        fg={fg()}
-        basenameFg={fade.value().front >= 1 ? props.basenameFg : undefined}
-      />
-    </Show>
-  )
-}

packages/tui/src/util/error.ts

@@ -143,40 +143,3 @@ export function errorMessage(error: unknown): string {
   if (formatted) return formatted
   return "unknown error"
 }
-
-export function errorData(error: unknown) {
-  if (error instanceof Error) {
-    return {
-      type: error.name,
-      message: errorMessage(error),
-      stack: error.stack,
-      cause: error.cause === undefined ? undefined : errorFormat(error.cause),
-      formatted: errorFormat(error),
-    }
-  }
-
-  if (!isRecord(error)) {
-    return {
-      type: typeof error,
-      message: errorMessage(error),
-      formatted: errorFormat(error),
-    }
-  }
-
-  const data = Object.getOwnPropertyNames(error).reduce<Record<string, unknown>>((acc, key) => {
-    const value = error[key]
-    if (value === undefined) return acc
-    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-      acc[key] = value
-      return acc
-    }
-    // oxlint-disable-next-line no-base-to-string -- intentional coercion of arbitrary error properties
-    acc[key] = value instanceof Error ? value.message : String(value)
-    return acc
-  }, {})
-
-  if (typeof data.message !== "string") data.message = errorMessage(error)
-  if (typeof data.type !== "string") data.type = error.constructor?.name
-  data.formatted = errorFormat(error)
-  return data
-}

packages/tui/src/util/format.ts

@@ -1,20 +0,0 @@
-export function formatDuration(secs: number) {
-  if (secs <= 0) return ""
-  if (secs < 60) return `${secs}s`
-  if (secs < 3600) {
-    const mins = Math.floor(secs / 60)
-    const remaining = secs % 60
-    return remaining > 0 ? `${mins}m ${remaining}s` : `${mins}m`
-  }
-  if (secs < 86400) {
-    const hours = Math.floor(secs / 3600)
-    const remaining = Math.floor((secs % 3600) / 60)
-    return remaining > 0 ? `${hours}h ${remaining}m` : `${hours}h`
-  }
-  if (secs < 604800) {
-    const days = Math.floor(secs / 86400)
-    return days === 1 ? "~1 day" : `~${days} days`
-  }
-  const weeks = Math.floor(secs / 604800)
-  return weeks === 1 ? "~1 week" : `~${weeks} weeks`
-}

packages/tui/src/util/locale.ts

@@ -16,19 +16,6 @@ export function datetime(input: number): string {
   return `${localTime} · ${localDate}`
 }
 
-export function todayTimeOrDateTime(input: number): string {
-  const date = new Date(input)
-  const now = new Date()
-  const isToday =
-    date.getFullYear() === now.getFullYear() && date.getMonth() === now.getMonth() && date.getDate() === now.getDate()
-
-  if (isToday) {
-    return time(input)
-  } else {
-    return datetime(input)
-  }
-}
-
 export function number(num: number): string {
   if (num >= 1000000) {
     return (num / 1000000).toFixed(1) + "M"
@@ -108,9 +95,4 @@ export function truncateMiddle(str: string, maxLength: number = 35): string {
   return str.slice(0, keepStart) + ellipsis + str.slice(-keepEnd)
 }
 
-export function pluralize(count: number, singular: string, plural: string): string {
-  const template = count === 1 ? singular : plural
-  return template.replace("{}", count.toString())
-}
-
 export * as Locale from "./locale"

packages/tui/src/util/presentation.ts

@@ -1,7 +1,4 @@
-const logo = {
-  left: ["                   ", "█▀▀█ █▀▀█ █▀▀█ █▀▀▄", "█__█ █__█ █^^^ █__█", "▀▀▀▀ █▀▀▀ ▀▀▀▀ ▀~~▀"],
-  right: ["             ▄     ", "█▀▀▀ █▀▀█ █▀▀█ █▀▀█", "█___ █__█ █__█ █^^^", "▀▀▀▀ ▀▀▀▀ ▀▀▀▀ ▀▀▀▀"],
-}
+import { logo } from "../logo"
 
 const reset = "\x1b[0m"
 const bold = "\x1b[1m"

packages/tui/src/util/revert-diff.ts

@@ -1,18 +0,0 @@
-import { parsePatch } from "diff"
-
-export function getRevertDiffFiles(diffText: string) {
-  if (!diffText) return []
-
-  try {
-    return parsePatch(diffText).map((patch) => {
-      const filename = [patch.newFileName, patch.oldFileName].find((item) => item && item !== "/dev/null") ?? "unknown"
-      return {
-        filename: filename.replace(/^[ab]\//, ""),
-        additions: patch.hunks.reduce((sum, hunk) => sum + hunk.lines.filter((line) => line.startsWith("+")).length, 0),
-        deletions: patch.hunks.reduce((sum, hunk) => sum + hunk.lines.filter((line) => line.startsWith("-")).length, 0),
-      }
-    })
-  } catch {
-    return []
-  }
-}

packages/tui/test/cli/tui/inline-tool-wrap-snapshot.test.tsx

@@ -2,7 +2,6 @@ import { afterEach, describe, expect, test } from "bun:test"
 import { For } from "solid-js"
 import { testRender, type JSX } from "@opentui/solid"
 import {
-  formatSubagentRetry,
   InlineToolRow,
   isBackgroundSubagent,
   parseApplyPatchFiles,
@@ -198,10 +197,6 @@ describe("TUI inline tool wrapping", () => {
     ).toEqual([{ message: "valid", range: { start: { line: 2, character: 3 } } }])
   })
 
-  test("keeps retry status ahead of wrapping messages", () => {
-    expect(formatSubagentRetry(2, "Rate limited by provider")).toBe("Retrying (attempt 2) · Rate limited by provider")
-  })
-
   test("labels only detached or async subagents as background", () => {
     expect(isBackgroundSubagent({ status: "running" }, "running")).toBeFalse()
     expect(isBackgroundSubagent({ status: "running" }, "completed")).toBeTrue()

packages/tui/test/context/session-tabs-model.test.ts

@@ -80,6 +80,11 @@ describe("session tabs", () => {
     expect(closeSessionTab([{ sessionID: "a" }], "a").next).toBeUndefined()
   })
 
+  test("closing an unknown session returns the same tabs reference", () => {
+    const tabs = [{ sessionID: "a" }, { sessionID: "b" }]
+    expect(closeSessionTab(tabs, "missing").tabs).toBe(tabs)
+  })
+
   test("cycles through a filtered tab set in either direction", () => {
     const tabs = ["a", "c", "e"].map((sessionID) => ({ sessionID }))
     expect(cycleSessionTab(tabs, "c", 1)?.sessionID).toBe("e")
@@ -122,6 +127,15 @@ describe("session tabs", () => {
     expect(recordSessionTabHistory(history, "b")).toBe(history)
   })
 
+  test("drops the oldest history entries beyond the limit", () => {
+    const sessions = Array.from({ length: 150 }, (_, index) => `session-${index}`)
+    const history = sessions.reduce(recordSessionTabHistory, { entries: [], index: -1 })
+
+    expect(history.entries.length).toBe(100)
+    expect(history.entries[0]).toBe("session-50")
+    expect(history.entries[history.index]).toBe("session-149")
+  })
+
   test("returns to the latest history entry when no tab is active", () => {
     const tabs = ["a", "b"].map((sessionID) => ({ sessionID }))
     const history = ["a", "b"].reduce(recordSessionTabHistory, { entries: [], index: -1 })

packages/tui/test/context/session-tabs.test.tsx

@@ -1,8 +1,8 @@
 /** @jsxImportSource @opentui/solid */
-import { expect, test } from "bun:test"
+import { afterAll, expect, test } from "bun:test"
 import type { OpenCodeEvent } from "@opencode-ai/client"
 import { testRender } from "@opentui/solid"
-import { mkdtempSync, rmSync, watch } from "fs"
+import { mkdtempSync, readdirSync, rmSync, watch } from "fs"
 import { tmpdir } from "os"
 import path from "path"
 import { ConfigProvider } from "../../src/config"
@@ -25,8 +25,32 @@ async function wait(fn: () => boolean | Promise<boolean>, timeout = 2_000) {
   }
 }
 
+// State directories are removed after the whole suite instead of per test: persistence writes are
+// fire-and-forget behind a file lock, so a teardown-time removal races any still-queued write.
+const stateDirs: string[] = []
+
+afterAll(async () => {
+  for (const dir of stateDirs) {
+    // Drain any lock still held by a late write before deleting the tree beneath it.
+    await wait(() => {
+      try {
+        return readdirSync(path.join(dir, "test", "locks")).length === 0
+      } catch {
+        return true
+      }
+    }).catch(() => undefined)
+    rmSync(dir, { recursive: true, force: true })
+  }
+})
+
+function stateDir(prefix: string) {
+  const dir = mkdtempSync(path.join(tmpdir(), prefix))
+  stateDirs.push(dir)
+  return dir
+}
+
 async function renderSessionTabs(initialSessionID: string, options?: { state?: string; title?: string }) {
-  const state = options?.state ?? mkdtempSync(path.join(tmpdir(), "opencode-session-tabs-"))
+  const state = options?.state ?? stateDir("opencode-session-tabs-")
   const events = createEventStream()
   const calls = createFetch((url) => {
     if (url.pathname !== `/api/session/${initialSessionID}`) return
@@ -84,7 +108,6 @@ async function renderSessionTabs(initialSessionID: string, options?: { state?: s
     emit: (event: OpenCodeEvent) => events.emit({ ...event, location: { directory } }),
     destroy() {
       app.renderer.destroy()
-      if (!options?.state) rmSync(state, { recursive: true, force: true })
     },
   }
 }
@@ -105,7 +128,7 @@ test("stores session tabs globally by default", async () => {
 })
 
 test("concurrent TUIs do not alternate shared tab titles from divergent session caches", async () => {
-  const state = mkdtempSync(path.join(tmpdir(), "opencode-session-tabs-shared-"))
+  const state = stateDir("opencode-session-tabs-shared-")
   let titled: Awaited<ReturnType<typeof renderSessionTabs>> | undefined
   let untitled: Awaited<ReturnType<typeof renderSessionTabs>> | undefined
 
@@ -144,7 +167,6 @@ test("concurrent TUIs do not alternate shared tab titles from divergent session
   } finally {
     titled?.destroy()
     untitled?.destroy()
-    rmSync(state, { recursive: true, force: true })
   }
 })
 

packages/tui/test/feature-plugins/diff-viewer-file-tree-utils.test.ts

@@ -6,7 +6,6 @@ import {
   flattenFileTree,
   moveFileTreeSelection,
   moveFileTreeSelectionToFirstChild,
-  moveFileTreeSelectionToFile,
   moveFileTreeSelectionToParent,
   movePatchFileIndex,
   orderedPatchFileIndexes,
@@ -219,25 +218,6 @@ describe("diff viewer file tree utilities", () => {
     expect(moveFileTreeSelectionToParent(rows, undefined)).toBeUndefined()
   })
 
-  test("moves file selection relative to the highlighted row", () => {
-    const rows = flattenFileTree(
-      buildFileTree([{ file: "src/config/tui.ts" }, { file: "src/session/index.ts" }, { file: "README.md" }]),
-    )
-    const config = rows.find((row) => row.kind === "directory" && row.name === "config")!
-    const session = rows.find((row) => row.kind === "directory" && row.name === "session")!
-    const tui = rows.find((row) => row.name === "tui.ts")!
-    const index = rows.find((row) => row.name === "index.ts")!
-    const readme = rows.find((row) => row.name === "README.md")!
-
-    expect(moveFileTreeSelectionToFile(rows, undefined, 1)).toBe(tui.id)
-    expect(moveFileTreeSelectionToFile(rows, undefined, -1)).toBe(readme.id)
-    expect(moveFileTreeSelectionToFile(rows, config.id, 1)).toBe(tui.id)
-    expect(moveFileTreeSelectionToFile(rows, session.id, -1)).toBe(tui.id)
-    expect(moveFileTreeSelectionToFile(rows, tui.id, 1)).toBe(index.id)
-    expect(moveFileTreeSelectionToFile(rows, index.id, -1)).toBe(tui.id)
-    expect(moveFileTreeSelectionToFile(rows, readme.id, 1)).toBe(readme.id)
-  })
-
   test("selects a file tree node and expands its parents for a patch file", () => {
     const tree = buildFileTree([{ file: "src/config/tui.ts" }, { file: "src/session/index.ts" }, { file: "README.md" }])
     const selection = fileTreeFileSelection(tree, 1)

packages/tui/test/keymap.test.tsx

@@ -46,7 +46,7 @@ test("legacy page key aliases compile as page keys", async () => {
 
 test("formats navigation keys as arrows", async () => {
   let read = () => ({}) as Record<string, string>
-  const commands = ["session.parent", "session.child.first", "session.child.previous", "session.child.next"]
+  const commands = ["session.parent", "session.child.first"]
 
   function Harness() {
     const shortcuts = Keymap.useShortcuts()
@@ -68,8 +68,6 @@ test("formats navigation keys as arrows", async () => {
     expect(read()).toEqual({
       "session.parent": "↑",
       "session.child.first": "↓",
-      "session.child.previous": "←",
-      "session.child.next": "→",
     })
   } finally {
     app.renderer.destroy()

packages/tui/test/plugin-hot-reload.test.tsx

@@ -53,6 +53,7 @@ async function bootApp(directory: string) {
   )
   return {
     task,
+    renderer: setup,
     async [Symbol.asyncDispose]() {
       process.chdir(cwd)
       if (!setup.renderer.isDestroyed) setup.renderer.destroy()
@@ -81,6 +82,32 @@ test("editing a discovered TUI plugin hot-reloads its fresh module", async () =>
   await app.task
 })
 
+test("creating the TUI plugin directory after startup discovers its first plugin", async () => {
+  await using tmp = await tmpdir()
+  const directory = path.join(tmp.path, ".opencode", "plugins", "tui")
+  await mkdir(path.dirname(directory), { recursive: true })
+  const marker = path.join(tmp.path, "marker.txt")
+  const placeholders = ["Fix a TODO in the codebase", "What is the tech stack of this project?", "Fix broken tests"]
+
+  await using app = await bootApp(tmp.path)
+  const frame = await until(
+    async () => {
+      await app.renderer.renderOnce()
+      return app.renderer.captureCharFrame()
+    },
+    (value) => placeholders.some((text) => value?.includes(text)),
+  )
+  expect(placeholders.some((text) => frame?.includes(text))).toBe(true)
+  await mkdir(directory)
+  await writeFile(path.join(directory, "hot.ts"), lifecycleSource(marker, "test.hot", "v1"))
+
+  const read = () => readFile(marker, "utf8")
+  expect(await until(read, (value) => value === "v1:setup\n")).toBe("v1:setup\n")
+
+  process.emit("SIGHUP")
+  await app.task
+})
+
 test("a plugin whose slot render throws does not take down the TUI", async () => {
   await using tmp = await tmpdir()
   const directory = path.join(tmp.path, ".opencode", "plugins", "tui")

packages/tui/test/util/error.test.ts

@@ -1,25 +1,16 @@
 import { describe, expect, test } from "bun:test"
-import { errorData, errorFormat, errorMessage } from "../../src/util/error"
+import { errorFormat, errorMessage } from "../../src/util/error"
 
 describe("util.error", () => {
   test("formats native Error instances", () => {
     const err = new Error("boom")
     expect(errorMessage(err)).toBe("boom")
     expect(errorFormat(err)).toContain("boom")
-
-    const data = errorData(err)
-    expect(data.type).toBe("Error")
-    expect(data.message).toBe("boom")
-    expect(String(data.formatted)).toContain("boom")
   })
 
   test("extracts message from record-like values", () => {
     const err = { message: "bad input", code: "E_BAD" }
     expect(errorMessage(err)).toBe("bad input")
-
-    const data = errorData(err)
-    expect(data.message).toBe("bad input")
-    expect(data.code).toBe("E_BAD")
   })
 
   test("never returns bare {} for opaque object errors", () => {
@@ -41,9 +32,5 @@ describe("util.error", () => {
     }
 
     expect(errorMessage(err)).toBe("ResolveMessage: Cannot resolve module")
-
-    const data = errorData(err)
-    expect(data.message).toBe("ResolveMessage: Cannot resolve module")
-    expect(String(data.formatted)).toContain("ResolveMessage")
   })
 })

packages/tui/test/util/format.test.ts

@@ -1,59 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { formatDuration } from "../../src/util/format"
-
-describe("util.format", () => {
-  describe("formatDuration", () => {
-    test("returns empty string for zero or negative values", () => {
-      expect(formatDuration(0)).toBe("")
-      expect(formatDuration(-1)).toBe("")
-      expect(formatDuration(-100)).toBe("")
-    })
-
-    test("formats seconds under a minute", () => {
-      expect(formatDuration(1)).toBe("1s")
-      expect(formatDuration(30)).toBe("30s")
-      expect(formatDuration(59)).toBe("59s")
-    })
-
-    test("formats minutes under an hour", () => {
-      expect(formatDuration(60)).toBe("1m")
-      expect(formatDuration(61)).toBe("1m 1s")
-      expect(formatDuration(90)).toBe("1m 30s")
-      expect(formatDuration(120)).toBe("2m")
-      expect(formatDuration(330)).toBe("5m 30s")
-      expect(formatDuration(3599)).toBe("59m 59s")
-    })
-
-    test("formats hours under a day", () => {
-      expect(formatDuration(3600)).toBe("1h")
-      expect(formatDuration(3660)).toBe("1h 1m")
-      expect(formatDuration(7200)).toBe("2h")
-      expect(formatDuration(8100)).toBe("2h 15m")
-      expect(formatDuration(86399)).toBe("23h 59m")
-    })
-
-    test("formats days under a week", () => {
-      expect(formatDuration(86400)).toBe("~1 day")
-      expect(formatDuration(172800)).toBe("~2 days")
-      expect(formatDuration(259200)).toBe("~3 days")
-      expect(formatDuration(604799)).toBe("~6 days")
-    })
-
-    test("formats weeks", () => {
-      expect(formatDuration(604800)).toBe("~1 week")
-      expect(formatDuration(1209600)).toBe("~2 weeks")
-      expect(formatDuration(1609200)).toBe("~2 weeks")
-    })
-
-    test("handles boundary values correctly", () => {
-      expect(formatDuration(59)).toBe("59s")
-      expect(formatDuration(60)).toBe("1m")
-      expect(formatDuration(3599)).toBe("59m 59s")
-      expect(formatDuration(3600)).toBe("1h")
-      expect(formatDuration(86399)).toBe("23h 59m")
-      expect(formatDuration(86400)).toBe("~1 day")
-      expect(formatDuration(604799)).toBe("~6 days")
-      expect(formatDuration(604800)).toBe("~1 week")
-    })
-  })
-})

packages/tui/test/util/revert-diff.test.ts

@@ -1,35 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { getRevertDiffFiles } from "../../src/util/revert-diff"
-
-describe("revert diff", () => {
-  test("prefers the actual file path over /dev/null for added and deleted files", () => {
-    const files = getRevertDiffFiles(`diff --git a/new.txt b/new.txt
-new file mode 100644
-index 0000000..3b18e51
---- /dev/null
-+++ b/new.txt
-@@ -0,0 +1 @@
-+new content
-diff --git a/old.txt b/old.txt
-deleted file mode 100644
-index 3b18e51..0000000
---- a/old.txt
-+++ /dev/null
-@@ -1 +0,0 @@
--old content
-`)
-
-    expect(files).toEqual([
-      {
-        filename: "new.txt",
-        additions: 1,
-        deletions: 0,
-      },
-      {
-        filename: "old.txt",
-        additions: 0,
-        deletions: 1,
-      },
-    ])
-  })
-})