fix(core): exclude deleted projects from listing

packages/core/src/project.ts

@@ -148,7 +148,7 @@ const layer = Layer.effect(
         .orderBy(desc(ProjectTable.time_updated), asc(ProjectTable.id))
         .all()
         .pipe(Effect.orDie)
-      return rows.map(fromRow)
+      return yield* Effect.filter(rows.map(fromRow), (project) => fs.existsSafe(project.canonical))
     })
 
     const directories = Effect.fn("Project.directories")(function* (input: DirectoriesInput) {

packages/core/test/project.test.ts

@@ -15,8 +15,16 @@ import { testEffect } from "./lib/effect"
 const it = testEffect(Layer.merge(AppNodeBuilder.build(Project.node), AppNodeBuilder.build(Database.node)))
 
 describe("Project.list", () => {
-  it.effect("returns complete projects ordered by recent update", () =>
+  it.live("returns existing projects ordered by recent update", () =>
     Effect.gen(function* () {
+      const tmp = yield* Effect.acquireRelease(
+        Effect.promise(() => tmpdir()),
+        (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
+      )
+      const older = abs(path.join(tmp.path, "older"))
+      const newer = abs(path.join(tmp.path, "newer"))
+      const deleted = abs(path.join(tmp.path, "deleted"))
+      yield* Effect.promise(() => Promise.all([fs.mkdir(older), fs.mkdir(newer)]))
       const db = (yield* Database.Service).db
       const project = yield* Project.Service
       yield* db
@@ -24,42 +32,49 @@ describe("Project.list", () => {
         .values([
           {
             id: Project.ID.make("older"),
-            worktree: abs("/older"),
+            worktree: older,
             vcs: "git",
             name: "Older",
             icon_color: "#000000",
             commands: { start: "bun dev" },
-            sandboxes: [abs("/older/sandbox")],
+            sandboxes: [abs(path.join(older, "sandbox"))],
             time_created: 1,
             time_updated: 1,
           },
           {
             id: Project.ID.make("newer"),
-            worktree: abs("/newer"),
+            worktree: newer,
             sandboxes: [],
             time_created: 2,
             time_updated: 2,
             time_initialized: 3,
           },
+          {
+            id: Project.ID.make("deleted"),
+            worktree: deleted,
+            sandboxes: [],
+            time_created: 3,
+            time_updated: 3,
+          },
         ])
         .run()
 
       expect(yield* project.list()).toEqual([
         {
           id: Project.ID.make("newer"),
-          canonical: abs("/newer"),
+          canonical: newer,
           time: { created: 2, updated: 2, initialized: 3 },
           sandboxes: [],
         },
         {
           id: Project.ID.make("older"),
-          canonical: abs("/older"),
+          canonical: older,
           vcs: "git",
           name: "Older",
           icon: { color: "#000000" },
           commands: { start: "bun dev" },
           time: { created: 1, updated: 1 },
-          sandboxes: [abs("/older/sandbox")],
+          sandboxes: [abs(path.join(older, "sandbox"))],
         },
       ])
     }),

packages/tui/src/component/dialog-move-session.tsx

@@ -2,8 +2,8 @@ import { useTerminalDimensions } from "@opentui/solid"
 import { TextAttributes } from "@opentui/core"
 import { createMemo, createResource, createSignal, onMount, Show } from "solid-js"
 import path from "path"
-import { DialogSelect, type DialogSelectOption } from "../ui/dialog-select"
-import { useDialog } from "../ui/dialog"
+import { DialogSelect, dialogSelectContentWidth, type DialogSelectOption } from "../ui/dialog-select"
+import { dialogWidth, useDialog } from "../ui/dialog"
 import { useClient } from "../context/client"
 import { Keymap } from "../context/keymap"
 import { useTheme } from "../context/theme"
@@ -159,7 +159,10 @@ export function DialogMoveSession(props: DialogMoveSessionProps) {
       if (b.location === b.root.directory) return 1
       return a.location.localeCompare(b.location)
     })
-    const titleWidth = Math.max(1, Math.min(116, dimensions().width - 2) - 12)
+    const titleWidth = Math.max(
+      1,
+      dialogSelectContentWidth(Math.min(dialogWidth("xlarge"), dimensions().width - 2)),
+    )
 
     return list.map((item) => {
       const title = abbreviateHome(item.location, paths.home)

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

@@ -2,8 +2,8 @@ import path from "path"
 import { createMemo, createResource, createSignal, onMount } from "solid-js"
 import type { SessionInfo } from "@opencode-ai/client"
 import { useTerminalDimensions } from "@opentui/solid"
-import { useDialog } from "../ui/dialog"
-import { DialogSelect } from "../ui/dialog-select"
+import { dialogWidth, useDialog } from "../ui/dialog"
+import { DialogSelect, dialogSelectContentWidth } from "../ui/dialog-select"
 import { useRoute } from "../context/route"
 import { useData } from "../context/data"
 import { useClient } from "../context/client"
@@ -105,8 +105,8 @@ export function DialogOpen() {
       .map((project) => {
         const title = project.name ?? path.basename(project.canonical)
         const footer = abbreviateHome(project.canonical, paths.home)
-        // Dialog padding, the gutter column, title padding, and the separating space use nine columns.
-        const width = Math.min(60, dimensions().width - 2) - 9 - stringWidth(title)
+        const width =
+          dialogSelectContentWidth(Math.min(dialogWidth("large"), dimensions().width - 2)) - stringWidth(title)
         return {
           title,
           footer: truncateFilePath(footer, width),

packages/tui/src/context/data.tsx

@@ -375,8 +375,11 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
             .catch((error) => console.error("Failed to load projected model switch message", error))
           break
         case "session.renamed":
-          if (store.session.info[event.data.sessionID])
-            setStore("session", "info", event.data.sessionID, "title", event.data.title)
+          // Preserve the live title when it races the session's initial read.
+          void result.session.sync(event.data.sessionID).then(() => {
+            if (store.session.info[event.data.sessionID])
+              setStore("session", "info", event.data.sessionID, "title", event.data.title)
+          })
           break
         case "session.moved":
           if (store.session.info[event.data.sessionID]) {

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

@@ -78,6 +78,21 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
     }
 
     const root = (sessionID: string) => data.session.root(sessionID)
+    const title = (sessionID: string, persisted?: string, fallback?: string) => {
+      const session = data.session.get(sessionID)
+      return session?.title ?? persisted ?? fallback ?? (session ? withTimestampedFallback(session) : undefined)
+    }
+    const normalize = (value: TabsState) => ({
+      tabs: value.tabs.reduce<SessionTab[]>((tabs, tab) => {
+        const sessionID = root(tab.sessionID)
+        return openSessionTab(tabs, { sessionID, title: title(sessionID, tab.title) })
+      }, []),
+      unread: Object.entries(value.unread).reduce<Record<string, SessionTabUnread>>((result, entry) => {
+        const sessionID = root(entry[0])
+        result[sessionID] = result[sessionID] === "error" ? "error" : entry[1]
+        return result
+      }, {}),
+    })
     const current = () => (route.data.type === "session" ? root(route.data.sessionID) : undefined)
     const newTab = createMemo((open = false) => {
       if (route.data.type === "home") return true
@@ -115,36 +130,29 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
       if (route.data.type !== "session" || route.data.sessionID === "dummy") return
       const sessionID = root(route.data.sessionID)
       history = recordSessionTabHistory(history, sessionID)
-      const session = data.session.get(sessionID)
-      const title =
-        session?.title ?? (newTab() ? NEW_SESSION_TAB_TITLE : session ? withTimestampedFallback(session) : undefined)
-      const tabs = openSessionTab(state().tabs, { sessionID, title })
+      const fallback = newTab() ? NEW_SESSION_TAB_TITLE : undefined
+      const tabs = openSessionTab(state().tabs, {
+        sessionID,
+        title: title(sessionID, state().tabs.find((tab) => tab.sessionID === sessionID)?.title, fallback),
+      })
       if (tabs === state().tabs && !state().unread[sessionID]) return
       update((draft) => {
-        draft.tabs = openSessionTab(draft.tabs, { sessionID, title })
+        draft.tabs = openSessionTab(draft.tabs, {
+          sessionID,
+          title: title(sessionID, draft.tabs.find((tab) => tab.sessionID === sessionID)?.title, fallback),
+        })
         delete draft.unread[sessionID]
       })
     })
 
     createEffect(() => {
       if (!enabled()) return
-      const next = state().tabs.reduce<SessionTab[]>((tabs, tab) => {
-        const sessionID = root(tab.sessionID)
-        const session = data.session.get(sessionID)
-        return openSessionTab(tabs, {
-          sessionID,
-          title: session ? withTimestampedFallback(session) : tab.title,
-        })
-      }, [])
-      const unread = Object.entries(state().unread).reduce<Record<string, SessionTabUnread>>((result, entry) => {
-        const sessionID = root(entry[0])
-        result[sessionID] = result[sessionID] === "error" ? "error" : entry[1]
-        return result
-      }, {})
-      if (isDeepEqual(next, state().tabs) && isDeepEqual(unread, state().unread)) return
+      const next = normalize(state())
+      if (isDeepEqual(next, state())) return
       update((draft) => {
-        draft.tabs = next
-        draft.unread = unread
+        const next = normalize(draft)
+        draft.tabs = next.tabs
+        draft.unread = next.unread
       })
     })
 

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

@@ -83,6 +83,11 @@ export interface DialogSelectOption<T = any> {
   onSelect?: (ctx: DialogContext) => void
 }
 
+export function dialogSelectContentWidth(dialogWidth: number) {
+  // Scroll padding, row padding, the gutter, title padding, and the separating gap.
+  return dialogWidth - 12
+}
+
 export type DialogSelectRef<T> = {
   filter: string
   filtered: DialogSelectOption<T>[]

packages/tui/src/ui/dialog.tsx

@@ -8,9 +8,17 @@ import { useToast } from "./toast"
 import { useClipboard } from "../context/clipboard"
 import { useConfig } from "../config"
 
+export type DialogSize = "medium" | "large" | "xlarge"
+
+export function dialogWidth(size: DialogSize) {
+  if (size === "xlarge") return 116
+  if (size === "large") return 88
+  return 60
+}
+
 export function Dialog(
   props: ParentProps<{
-    size?: "medium" | "large" | "xlarge"
+    size?: DialogSize
     centered?: boolean
     onClose: () => void
   }>,
@@ -20,12 +28,6 @@ export function Dialog(
   const renderer = useRenderer()
 
   let dismiss = false
-  const width = () => {
-    if (props.size === "xlarge") return 116
-    if (props.size === "large") return 88
-    return 60
-  }
-
   return (
     <box
       onMouseDown={() => {
@@ -57,7 +59,7 @@ export function Dialog(
           dismiss = false
           e.stopPropagation()
         }}
-        width={width()}
+        width={dialogWidth(props.size ?? "medium")}
         maxWidth={dimensions().width - 2}
         backgroundColor={theme.background.default}
         paddingTop={1}
@@ -74,7 +76,7 @@ function init() {
       element: JSX.Element
       onClose?: () => void
     }[],
-    size: "medium" as "medium" | "large" | "xlarge",
+    size: "medium" as DialogSize,
     centered: false,
   })
 

packages/tui/test/app-lifecycle.test.tsx

@@ -138,6 +138,94 @@ test("session lifecycle updates the terminal title and prints the epilogue after
   }
 })
 
+test("session title generated while an untitled session is loading remains visible", async () => {
+  const setup = await createTestRenderer({ width: 80, height: 24, useThread: false })
+  const core = await import("@opentui/core")
+  mock.module("@opentui/core", () => ({ ...core, createCliRenderer: async () => setup.renderer }))
+  const titles: string[] = []
+  const setTitle = setup.renderer.setTerminalTitle.bind(setup.renderer)
+  const generatedTitle = Promise.withResolvers<void>()
+  setup.renderer.setTerminalTitle = (title) => {
+    titles.push(title)
+    if (title === "OC | Generated title") generatedTitle.resolve()
+    setTitle(title)
+  }
+  const sessionRequested = Promise.withResolvers<void>()
+  const renameSyncRequested = Promise.withResolvers<void>()
+  const releaseSession = Promise.withResolvers<void>()
+  let sessionRequests = 0
+  const session = {
+    id: "dummy",
+    projectID: "project",
+    location: { directory },
+    cost: 0,
+    tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+    time: { created: 0, updated: 0 },
+  }
+  const events = createEventStream()
+  const calls = createFetch(async (url) => {
+    if (url.pathname === "/api/session") return json({ data: [], cursor: {} })
+    if (url.pathname === "/api/session/dummy") {
+      sessionRequests++
+      sessionRequested.resolve()
+      if (sessionRequests === 2) renameSyncRequested.resolve()
+      await releaseSession.promise
+      return json({ data: session })
+    }
+    if (url.pathname === "/api/session/dummy/message") return json({ data: [], cursor: {} })
+    if (url.pathname === "/api/session/dummy/pending") return json({ data: [] })
+    if (url.pathname === "/api/session/dummy/permission") return json({ data: [] })
+  }, events)
+  const server = Bun.serve({ port: 0, fetch: (request) => calls.fetch(request) })
+
+  try {
+    const { run } = await import("../src/app")
+    const task = Effect.runPromise(
+      run({
+        app: { name: "test", version: "test", channel: "test" },
+        server: { endpoint: { url: server.url.toString() } },
+        config: { get: async () => ({}), update: async () => ({}) },
+        packages: { resolve: async () => undefined },
+        args: { sessionID: "dummy" },
+        log: () => {},
+      }).pipe(Effect.provide(AppNodeBuilder.build(Global.node)), Effect.provide(FileSystem.layerNoop({}))),
+    )
+
+    await sessionRequested.promise
+    events.emit({
+      id: "evt_renamed",
+      created: 1,
+      type: "session.renamed",
+      durable: { aggregateID: "dummy", seq: 1, version: 1 },
+      data: { sessionID: "dummy", title: "Generated title" },
+    })
+    await Promise.race([
+      renameSyncRequested.promise,
+      Bun.sleep(2_000).then(() => {
+        throw new Error("rename sync did not start")
+      }),
+    ])
+    releaseSession.resolve()
+    await Promise.race([
+      generatedTitle.promise,
+      Bun.sleep(2_000).then(() => {
+        throw new Error("generated title was not shown")
+      }),
+    ])
+    await Bun.sleep(20)
+
+    const generated = titles.lastIndexOf("OC | Generated title")
+    expect(generated).toBeGreaterThan(-1)
+    expect(titles.slice(generated + 1)).not.toContain("OpenCode")
+    setup.renderer.destroy()
+    await task
+  } finally {
+    if (!setup.renderer.isDestroyed) setup.renderer.destroy()
+    await server.stop()
+    mock.restore()
+  }
+})
+
 test("session startup prompt is submitted exactly once", async () => {
   const setup = await createTestRenderer({ width: 80, height: 24, useThread: false })
   const core = await import("@opentui/core")

packages/tui/test/cli/tui/dialog-select.test.tsx

@@ -5,7 +5,10 @@ import { expect, test } from "bun:test"
 import { mkdir } from "node:fs/promises"
 import path from "node:path"
 import { createSignal, onCleanup, onMount } from "solid-js"
-import type { DialogSelectOption } from "../../../src/ui/dialog-select"
+import { dialogWidth } from "../../../src/ui/dialog"
+import { dialogSelectContentWidth, type DialogSelectOption } from "../../../src/ui/dialog-select"
+import { truncateFilePath } from "../../../src/ui/file-path"
+import { stringWidth } from "../../../src/util/string-width"
 import { tmpdir } from "../../fixture/fixture"
 import { TestTuiContexts } from "../../fixture/tui-environment"
 import { createTuiResolvedConfig } from "../../fixture/tui-runtime"
@@ -147,6 +150,28 @@ async function mountSelect(root: string, initial: DialogSelectOption<string>[],
   return { app, moved, replaceOptions, selected }
 }
 
+test("budgets option content for constrained and full-width large dialogs", () => {
+  expect(dialogSelectContentWidth(Math.min(dialogWidth("large"), 62 - 2)) - 7).toBe(41)
+  expect(dialogSelectContentWidth(Math.min(dialogWidth("large"), 100 - 2)) - 7).toBe(69)
+})
+
+test("renders the complete truncated footer within the option row", async () => {
+  await using tmp = await tmpdir()
+  const title = "Project"
+  const footer = truncateFilePath(
+    "/tmp/opencode/projects/a-very-long-project-directory/distinctive-tail.tsx",
+    dialogSelectContentWidth(dialogWidth("medium")) - stringWidth(title),
+  )
+  const select = await mountSelect(tmp.path, [{ title, footer, value: "project" }])
+
+  try {
+    await select.app.waitForFrame((frame) => frame.includes(footer))
+    expect(select.app.captureCharFrame()).toContain(footer)
+  } finally {
+    select.app.renderer.destroy()
+  }
+})
+
 test("renders actions with a current selection", async () => {
   await using tmp = await tmpdir()
   const app = await renderSelect(

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

@@ -2,41 +2,56 @@
 import { expect, test } from "bun:test"
 import type { OpenCodeEvent } from "@opencode-ai/client"
 import { testRender } from "@opentui/solid"
-import { mkdtempSync, rmSync } from "fs"
+import { mkdtempSync, rmSync, watch } from "fs"
 import { tmpdir } from "os"
 import path from "path"
 import { ConfigProvider } from "../../src/config"
 import { ClientProvider, useClient } from "../../src/context/client"
-import { DataProvider } from "../../src/context/data"
+import { DataProvider, useData } from "../../src/context/data"
 import { RouteProvider, useRoute } from "../../src/context/route"
 import { TuiAppProvider } from "../../src/context/runtime"
 import { SessionTabsProvider, useSessionTabs } from "../../src/context/session-tabs"
 import { NEW_SESSION_TAB_TITLE } from "../../src/context/session-tabs-model"
 import { StorageProvider } from "../../src/context/storage"
-import { createApi, createEventStream, createFetch, directory } from "../fixture/tui-client"
+import { createApi, createEventStream, createFetch, directory, json } from "../fixture/tui-client"
 import { TestTuiContexts } from "../fixture/tui-environment"
 import { createTuiResolvedConfig } from "../fixture/tui-runtime"
 
-async function wait(fn: () => boolean, timeout = 2_000) {
+async function wait(fn: () => boolean | Promise<boolean>, timeout = 2_000) {
   const start = Date.now()
-  while (!fn()) {
+  while (!(await fn())) {
     if (Date.now() - start > timeout) throw new Error("timed out waiting for condition")
     await Bun.sleep(10)
   }
 }
 
-async function renderSessionTabs(initialSessionID: string) {
-  const state = mkdtempSync(path.join(tmpdir(), "opencode-session-tabs-"))
+async function renderSessionTabs(initialSessionID: string, options?: { state?: string; title?: string }) {
+  const state = options?.state ?? mkdtempSync(path.join(tmpdir(), "opencode-session-tabs-"))
   const events = createEventStream()
-  const calls = createFetch(undefined, events)
+  const calls = createFetch((url) => {
+    if (url.pathname !== `/api/session/${initialSessionID}`) return
+    return json({
+      data: {
+        id: initialSessionID,
+        title: options?.title,
+        projectID: "project",
+        location: { directory },
+        cost: 0,
+        tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+        time: { created: 0, updated: 0 },
+      },
+    })
+  }, events)
   let tabs!: ReturnType<typeof useSessionTabs>
   let route!: ReturnType<typeof useRoute>
   let client!: ReturnType<typeof useClient>
+  let data!: ReturnType<typeof useData>
 
   function Probe() {
     tabs = useSessionTabs()
     route = useRoute()
     client = useClient()
+    data = useData()
     return <box />
   }
 
@@ -64,11 +79,12 @@ async function renderSessionTabs(initialSessionID: string) {
   return {
     tabs,
     route,
+    data,
     state,
     emit: (event: OpenCodeEvent) => events.emit({ ...event, location: { directory } }),
     destroy() {
       app.renderer.destroy()
-      rmSync(state, { recursive: true, force: true })
+      if (!options?.state) rmSync(state, { recursive: true, force: true })
     },
   }
 }
@@ -88,6 +104,50 @@ 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-"))
+  let titled: Awaited<ReturnType<typeof renderSessionTabs>> | undefined
+  let untitled: Awaited<ReturnType<typeof renderSessionTabs>> | undefined
+
+  try {
+    titled = await renderSessionTabs("shared", { state, title: "Generated title" })
+    untitled = await renderSessionTabs("shared", { state })
+    const file = path.join(state, "test", "tui", "tabs.json")
+    await titled.data.session.sync("shared")
+    await wait(async () => {
+      if (!(await Bun.file(file).exists())) return false
+      return (await Bun.file(file).json()).global.tabs[0]?.title === "Generated title"
+    })
+    const observed = ["Generated title"]
+    const pending = new Set<Promise<void>>()
+    const watcher = watch(path.dirname(file), (_, name) => {
+      if (name !== path.basename(file)) return
+      const read = Bun.file(file)
+        .json()
+        .then((value) => {
+          const title = value.global.tabs[0]?.title
+          if (title && observed.at(-1) !== title) observed.push(title)
+        })
+        .catch(() => undefined)
+        .finally(() => pending.delete(read))
+      pending.add(read)
+    })
+    try {
+      await untitled.data.session.sync("shared")
+      await Bun.sleep(500)
+    } finally {
+      watcher.close()
+      await Promise.allSettled(pending)
+    }
+
+    expect(observed).toEqual(["Generated title"])
+  } finally {
+    titled?.destroy()
+    untitled?.destroy()
+    rmSync(state, { recursive: true, force: true })
+  }
+})
+
 test("user prompt admissions pulse an already-busy background tab", async () => {
   const setup = await renderSessionTabs("background")
   const admitted = (sessionID: string, inputID: string): OpenCodeEvent => ({