fix(tui): align session picker scope

packages/ai/src/provider-package.ts

@@ -1,6 +1,7 @@
 import type { Model, ProviderOptions } from "./schema"
 
 export interface Settings extends Readonly<Record<string, unknown>> {
+  readonly baseURL?: string
   readonly headers?: Readonly<Record<string, string>>
   readonly body?: Readonly<Record<string, unknown>>
   readonly limits?: {

packages/app/src/components/titlebar-tab-nav.tsx

@@ -11,6 +11,7 @@ import { SessionTabAvatar } from "@/pages/layout/session-tab-avatar"
 import type { Session } from "@opencode-ai/sdk/v2"
 import { canOpenTabRename, forwardTabRef } from "./titlebar-tab-gesture"
 import { TabPreviewPopover } from "./titlebar-tab-popover"
+import { sessionTitle } from "@/utils/session-title"
 import "./titlebar-tab-nav.css"
 
 // MouseEvent.button uses 1 for the middle/wheel button.
@@ -54,7 +55,10 @@ export function TabNavItem(props: {
     if (!session) return
     return projectForSession(session, serverCtx()?.projects.list() ?? [])
   })
-  const title = createMemo(() => props.session()?.title ?? props.fallbackTitle)
+  const title = createMemo(() => {
+    const session = props.session()
+    return session ? sessionTitle(session.title, session.parentID) : props.fallbackTitle
+  })
 
   const projectName = createMemo(() => {
     const session = props.session()
@@ -143,7 +147,7 @@ export function TabNavItem(props: {
     if (!canOpenTabRename(props.dragging, editing(), rename.isPending)) return
     const session = props.session()
     if (!session) return
-    titleEl.textContent = session.title
+    titleEl.textContent = session.title ?? ""
     setEditing(true)
 
     requestAnimationFrame(() => {
@@ -302,7 +306,7 @@ export function TabNavItem(props: {
       }}
       data={{
         projectName: projectName(),
-        title: props.session()?.title,
+        title: title(),
         path: previewPath(),
         serverName: serverLabel(),
       }}

packages/app/src/pages/home/home-session-search-controller.ts

@@ -7,6 +7,7 @@ import { createMemo, onCleanup } from "solid-js"
 import { createStore } from "solid-js/store"
 import type { HomeController } from "./home-controller"
 import { homeSessionSearchKey, type HomeSessionRecord, type HomeSessionsController } from "./home-sessions-controller"
+import { sessionTitle } from "@/utils/session-title"
 
 type HomeSessionSearchSource = Pick<HomeSessionsController, "data" | "session">
 
@@ -23,7 +24,7 @@ export function createHomeSessionSearchController(home: HomeController, sessions
     if (!value) return []
     return sessions.data
       .searchRecords()
-      .filter((record) => `${record.session.title} ${record.projectName}`.toLowerCase().includes(value))
+      .filter((record) => `${sessionTitle(record.session.title)} ${record.projectName}`.toLowerCase().includes(value))
   })
   const active = createMemo(() => {
     const records = results()

packages/app/src/pages/layout/sidebar-items.tsx

@@ -104,7 +104,7 @@ const SessionRow = (props: {
   warmPress: () => void
   warmFocus: () => void
 }): JSX.Element => {
-  const title = () => sessionTitle(props.session.title)
+  const title = () => sessionTitle(props.session.title, props.session.parentID)
 
   return (
     <A
@@ -229,7 +229,7 @@ export const SessionItem = (props: SessionItemProps): JSX.Element => {
               fallback={
                 <Tooltip
                   placement={props.mobile ? "bottom" : "right"}
-                  value={sessionTitle(props.session.title)}
+                  value={sessionTitle(props.session.title, props.session.parentID)}
                   gutter={10}
                   class="min-w-0 w-full"
                 >

packages/app/src/pages/session/timeline/message-timeline.tsx

@@ -297,7 +297,11 @@ export function MessageTimeline(props: {
     return sync().session.get(id)
   })
   const titleValue = createMemo(() => info()?.title)
-  const titleLabel = createMemo(() => sessionTitle(titleValue()))
+  const titleLabel = createMemo(() => {
+    const session = info()
+    if (!session) return
+    return sessionTitle(titleValue(), session.parentID)
+  })
   const shareUrl = createMemo(() => info()?.share?.url)
   const shareEnabled = createMemo(() => sync().data.config.share !== "disabled")
   const parentID = createMemo(() => info()?.parentID)
@@ -311,7 +315,10 @@ export function MessageTimeline(props: {
     if (!id) return emptyMessages
     return sync().data.message[id] ?? emptyMessages
   })
-  const parentTitle = createMemo(() => sessionTitle(parent()?.title) ?? language.t("command.session.new"))
+  const parentTitle = createMemo(() => {
+    const session = parent()
+    return session ? sessionTitle(session.title, session.parentID) : language.t("command.session.new")
+  })
   const getMsgParts = (msgId: string) => sync().data.part[msgId] ?? emptyParts
   const getMsgPart = (messageID: string, partID: string) => getMsgParts(messageID).find((part) => part.id === partID)
   const childTaskDescription = createMemo(() => {
@@ -329,7 +336,7 @@ export function MessageTimeline(props: {
     if (value) return value
     return language.t("command.session.new")
   })
-  const showHeader = createMemo(() => !!(titleValue() || parentID()))
+  const showHeader = createMemo(() => !!(titleLabel() || parentID()))
   const projection = createTimelineProjection({
     messages: sessionMessages,
     userMessages: () => props.userMessages,
@@ -912,9 +919,10 @@ export function MessageTimeline(props: {
   }
 
   function DialogDeleteSession(props: { sessionID: string }) {
-    const name = createMemo(
-      () => sessionTitle(sync().session.get(props.sessionID)?.title) ?? language.t("command.session.new"),
-    )
+    const name = createMemo(() => {
+      const session = sync().session.get(props.sessionID)
+      return session ? sessionTitle(session.title, session.parentID) : language.t("command.session.new")
+    })
     const handleDelete = async () => {
       await deleteSession(props.sessionID)
       dialog.close()

packages/app/src/utils/session-title.test.ts

@@ -0,0 +1,11 @@
+import { describe, expect, test } from "bun:test"
+import { sessionTitle } from "./session-title"
+
+describe("sessionTitle", () => {
+  test("uses a display fallback without persisting it", () => {
+    expect(sessionTitle(undefined)).toBe("New session")
+    expect(sessionTitle(undefined, "ses_parent")).toBe("Child session")
+    expect(sessionTitle("New session - 2026-07-30T18:45:03.662Z")).toBe("New session")
+    expect(sessionTitle("Generated title")).toBe("Generated title")
+  })
+})

packages/app/src/utils/session-title.ts

@@ -1,7 +1,7 @@
 const pattern = /^(New session|Child session) - \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/
 
-export function sessionTitle(title?: string) {
-  if (!title) return title
+export function sessionTitle(title?: string, parentID?: string) {
+  if (!title) return parentID ? "Child session" : "New session"
   const match = title.match(pattern)
   return match?.[1] ?? title
 }

packages/app/src/utils/session.ts

@@ -13,7 +13,7 @@ export function normalizeSessionInfo(input: SessionInfo | Session): Session {
     parentID: input.parentID,
     cost: input.cost,
     tokens: input.tokens,
-    title: input.title,
+    title: input.title ?? `${input.parentID ? "Child" : "New"} session - ${new Date(input.time.created).toISOString()}`,
     agent: input.agent,
     model: input.model,
     version: "",

packages/cli/src/acp/service.ts

@@ -213,7 +213,9 @@ export function make(input: { readonly client: OpenCodeClient; readonly connecti
         sessions: page.data.map((session) => ({
           sessionId: session.id,
           cwd: session.location.directory,
-          title: session.title,
+          title:
+            session.title ??
+            `${session.parentID ? "Child" : "New"} session - ${new Date(session.time.created).toISOString()}`,
           updatedAt: new Date(session.time.updated).toISOString(),
         })),
         ...(page.cursor.next ? { nextCursor: page.cursor.next } : {}),

packages/client/src/promise/generated/types.ts

@@ -1757,7 +1757,7 @@ export type SessionInfo = {
   cost: MoneyUSD
   tokens: TokenUsageInfo
   time: { created: number; updated: number; archived?: number }
-  title: string
+  title?: string
   location: LocationRef
   subpath?: string
   revert?: SessionRevert
@@ -2006,7 +2006,7 @@ export type SessionV1Info = {
   cost?: number
   tokens?: { input: number; output: number; reasoning: number; cache: { read: number; write: number } }
   share?: { url: string }
-  title: string
+  title?: string
   agent?: string
   model?: { id: string; providerID: string; variant?: string }
   version: string

packages/core/schema.json

@@ -1,9 +1,9 @@
 {
   "version": "7",
   "dialect": "sqlite",
-  "id": "db37a97f-9b5e-4c87-be8b-4feace35136c",
+  "id": "e43ed7e2-b9fc-4178-beae-3646e4a976e1",
   "prevIds": [
-    "a4ba73b4-21bc-41ab-a415-94e2ca38d798"
+    "db37a97f-9b5e-4c87-be8b-4feace35136c"
   ],
   "ddl": [
     {
@@ -1302,7 +1302,7 @@
     },
     {
       "type": "text",
-      "notNull": true,
+      "notNull": false,
       "autoincrement": false,
       "default": null,
       "generated": null,

packages/core/src/aisdk-native.ts

@@ -0,0 +1,59 @@
+export * as AISDKNative from "./aisdk-native"
+
+export interface Mapping {
+  readonly package: string
+  readonly settings: Readonly<Record<string, unknown>>
+}
+
+export function map(packageName: string | undefined, settings: Readonly<Record<string, unknown>>): Mapping | undefined {
+  const baseSettings = mapBaseSettings(settings)
+  switch (packageName) {
+    case "@ai-sdk/google":
+      return {
+        package: "@opencode-ai/ai/providers/google",
+        settings: {
+          ...baseSettings,
+          ...mapAPIKey(settings),
+          ...mapProviderOptions("gemini", settings),
+        },
+      }
+    case "@openrouter/ai-sdk-provider":
+      return {
+        package: "@opencode-ai/ai/providers/openrouter",
+        settings: {
+          ...baseSettings,
+          ...mapAPIKey(settings),
+          ...mapProviderOptions("openrouter", settings),
+        },
+      }
+    case "@ai-sdk/xai":
+      return {
+        package: "@opencode-ai/ai/providers/xai",
+        settings: {
+          ...baseSettings,
+          ...mapAPIKey(settings),
+          ...mapProviderOptions("xai", settings),
+        },
+      }
+  }
+}
+
+function mapBaseSettings(settings: Readonly<Record<string, unknown>>) {
+  return {
+    ...(typeof settings.baseURL === "string" ? { baseURL: settings.baseURL } : {}),
+  }
+}
+
+function mapAPIKey(settings: Readonly<Record<string, unknown>>) {
+  return typeof settings.apiKey === "string" ? { apiKey: settings.apiKey } : {}
+}
+
+function mapProviderOptions(namespace: string, settings: Readonly<Record<string, unknown>>) {
+  const values = Object.fromEntries(
+    Object.entries(settings).filter(
+      ([key]) => !["apiKey", "authToken", "baseURL", "chunkTimeout", "fetch", "timeout"].includes(key),
+    ),
+  )
+  if (Object.keys(values).length === 0) return {}
+  return { providerOptions: { [namespace]: values } }
+}

packages/core/src/database/migration.gen.ts

@@ -58,5 +58,6 @@ export const migrations = (
     import("./migration/20260722011141_delete_tool_progress_events"),
     import("./migration/20260722170000_canonical_tool_results"),
     import("./migration/20260729022634_session_fork_boundary"),
+    import("./migration/20260730195856_optional_session_title"),
   ])
 ).map((module) => module.default) satisfies DatabaseMigration.Migration[]

packages/core/src/database/migration/20260730195856_optional_session_title.ts

@@ -0,0 +1,14 @@
+import { Effect } from "effect"
+import type { DatabaseMigration } from "../migration"
+
+export default {
+  id: "20260730195856_optional_session_title",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`ALTER TABLE \`session\` RENAME COLUMN \`title\` TO \`title_old\``)
+      yield* tx.run(`ALTER TABLE \`session\` ADD COLUMN \`title\` text`)
+      yield* tx.run(`UPDATE \`session\` SET \`title\` = \`title_old\``)
+      yield* tx.run(`ALTER TABLE \`session\` DROP COLUMN \`title_old\``)
+    })
+  },
+} satisfies DatabaseMigration.Migration

packages/core/src/database/schema.gen.ts

@@ -217,7 +217,7 @@ export default {
           \`slug\` text NOT NULL,
           \`directory\` text NOT NULL,
           \`path\` text,
-          \`title\` text NOT NULL,
+          \`title\` text,
           \`version\` text NOT NULL,
           \`share_url\` text,
           \`summary_additions\` integer,

packages/core/src/model-resolver.ts

@@ -12,6 +12,7 @@ import { Auth, type AnyRoute } from "@opencode-ai/ai/route"
 import { Context, Effect, Layer, Schema } from "effect"
 import { produce } from "immer"
 import { AISDK } from "./aisdk"
+import { AISDKNative } from "./aisdk-native"
 import { Catalog } from "./catalog"
 import { Credential } from "./credential"
 import { Integration } from "./integration"
@@ -182,8 +183,10 @@ export const fromCatalogModel = (
         .model({ id: resolved.modelID ?? resolved.id, compatibility: resolved.compatibility }),
     )
   }
-  const native = Provider.isAISDK(resolved.package) ? nativePackage(packageName) : resolved.package
-  if (Provider.isAISDK(resolved.package) && !native) {
+  const configured = { ...resolved.settings, ...credential?.metadata }
+  const mapping = Provider.isAISDK(resolved.package) ? AISDKNative.map(packageName, configured) : undefined
+  const native = mapping?.package ?? resolved.package
+  if (Provider.isAISDK(resolved.package) && !mapping) {
     if (!dependencies?.loadAISDK) return Effect.fail(unsupported(resolved))
     const runtime = produce(resolved, (draft) => {
       draft.settings = Provider.mergeOverlay(draft.settings, {
@@ -201,15 +204,13 @@ export const fromCatalogModel = (
     const module = yield* (dependencies?.loadPackage ?? Provider.loadPackage)(specifier).pipe(
       Effect.mapError(() => unsupported(resolved)),
     )
-    const configured = { ...resolved.settings, ...credential?.metadata }
-    const providerOptions = nativeProviderOptions(packageName, configured)
+    const mapped = mapping?.settings ?? configured
     const settings = {
-      ...(credential ? withoutNativeAuthSettings(configured) : configured),
+      ...(credential ? withoutNativeAuthSettings(mapped) : mapped),
       ...nativeCredentialSettings(specifier, credential),
       headers: resolved.headers,
       body: resolved.body,
       limits: { context: resolved.limit.context, output: resolved.limit.output },
-      ...(providerOptions ? { providerOptions } : {}),
     }
     return yield* Effect.try({
       try: () => {
@@ -226,26 +227,6 @@ export const fromCatalogModel = (
   })
 }
 
-const nativePackage = (packageName: string | undefined) => {
-  if (packageName === "@ai-sdk/google") return "@opencode-ai/ai/providers/google"
-  if (packageName === "@openrouter/ai-sdk-provider") return "@opencode-ai/ai/providers/openrouter"
-  if (packageName === "@ai-sdk/xai") return "@opencode-ai/ai/providers/xai"
-  return undefined
-}
-
-const nativeProviderOptions = (packageName: string | undefined, settings: Readonly<Record<string, unknown>>) => {
-  const values = Object.fromEntries(
-    Object.entries(settings).filter(
-      ([key]) => !["apiKey", "authToken", "baseURL", "chunkTimeout", "fetch", "timeout"].includes(key),
-    ),
-  )
-  if (Object.keys(values).length === 0) return undefined
-  if (packageName === "@ai-sdk/google") return { gemini: values }
-  if (packageName === "@openrouter/ai-sdk-provider") return { openrouter: values }
-  if (packageName === "@ai-sdk/xai") return { xai: values }
-  return undefined
-}
-
 const isNativeOpenAI = (packageName: string | undefined) =>
   packageName === "@opencode-ai/ai/providers/openai" ||
   packageName?.startsWith("@opencode-ai/ai/providers/openai/") === true

packages/core/src/session.ts

@@ -374,7 +374,7 @@ const layer = Layer.effect(
           directory: location.directory,
           path: path.relative(project.directory, location.directory).replaceAll("\\", "/"),
           workspaceID: location.workspaceID ? Workspace.ID.make(location.workspaceID) : undefined,
-          title: input.title ?? `New session - ${new Date(now).toISOString()}`,
+          title: input.title,
           agent: input.agent,
           model: input.model
             ? {

packages/core/src/session/history.ts

@@ -117,21 +117,20 @@ export const preview = Effect.fn("SessionHistory.preview")(function* (
     .pipe(Effect.catch((error) => (error instanceof Instructions.InitializationBlocked ? error : Effect.die(error))))
 })
 
-/** Returns the session's sole user message, or `undefined` once a second one exists. */
-export const firstUserMessageIfOnly = Effect.fn("SessionHistory.firstUserMessageIfOnly")(function* (
+/** Returns the session's first user message. */
+export const firstUserMessage = Effect.fn("SessionHistory.firstUserMessage")(function* (
   db: DatabaseService,
   sessionID: SessionSchema.ID,
 ) {
-  const rows = yield* db
+  const row = yield* db
     .select()
     .from(SessionMessageTable)
     .where(and(eq(SessionMessageTable.session_id, sessionID), eq(SessionMessageTable.type, "user")))
     .orderBy(asc(SessionMessageTable.seq))
-    .limit(2)
-    .all()
+    .get()
     .pipe(Effect.orDie)
-  if (rows.length !== 1) return undefined
-  const message = yield* decodeMessageRow(rows[0]).pipe(Effect.catch(() => Effect.succeed(undefined)))
+  if (!row) return undefined
+  const message = yield* decodeMessageRow(row).pipe(Effect.catch(() => Effect.succeed(undefined)))
   return message?.type === "user" ? message : undefined
 })
 

packages/core/src/session/info.ts

@@ -17,7 +17,7 @@ export function fromRow(row: typeof SessionTable.$inferSelect): SessionSchema.In
   return SessionSchema.Info.make({
     id: SessionSchema.ID.make(row.id),
     projectID: Project.ID.make(row.project_id),
-    title: row.title,
+    title: row.title ?? undefined,
     parentID: row.parent_id ? SessionSchema.ID.make(row.parent_id) : undefined,
     fork:
       row.fork_session_id && row.fork_boundary

packages/core/src/session/projector.ts

@@ -43,7 +43,8 @@ type Usage = {
 
 const ForkBatchSize = 500
 
-const forkTitle = (value: string) => {
+const forkTitle = (value?: string) => {
+  if (value === undefined) return
   const match = value.match(/^(.+) \(fork #(\d+)\)$/)
   if (match) return `${match[1]} (fork #${Number.parseInt(match[2], 10) + 1})`
   return `${value} (fork #1)`
@@ -216,7 +217,7 @@ const projectFork = Effect.fn("SessionProjector.projectFork")(function* (
       slug: Slug.create(),
       directory: parent.directory,
       path: parent.path,
-      title: forkTitle(parent.title),
+      title: forkTitle(parent.title ?? undefined),
       agent: parent.agent,
       model: parent.model,
       version: parent.version,

packages/core/src/session/runner/llm.ts

@@ -93,10 +93,9 @@ const layer = Layer.effect(
     const db = (yield* Database.Service).db
     const compaction = yield* SessionCompaction.Service
     const title = yield* SessionTitle.Service
-    // Title generation is a side effect of the first step; it must not delay step continuation.
-    // Tracked per process so repeated wakes before the second user message arrives don't
-    // re-fire a redundant LLM call; `SessionTitle` itself is idempotent based on durable history.
-    const titleStarted = new Set<SessionSchema.ID>()
+    // Title generation is a side effect of a successful step; it must not delay continuation.
+    // The in-flight set coalesces overlapping steps while title presence records success durably.
+    const titlesRunning = new Set<SessionSchema.ID>()
     const forkTitle = yield* FiberSet.makeRuntime<never, void, never>()
     /**
      * Drains eligible manual compaction and user input until the Session becomes idle.
@@ -125,7 +124,7 @@ const layer = Layer.effect(
       let step = 1
       while (true) {
         const result = yield* runStep(sessionID, promotable, step)
-        yield* startTitleOnce(sessionID)
+        if (step === 1) yield* startTitle(sessionID)
         yield* runPendingCompaction(sessionID)
         if (!result.needsContinuation && !(yield* SessionPending.has(db, sessionID, "steer"))) return
         promotable = "steer"
@@ -481,11 +480,20 @@ const layer = Layer.effect(
       }
     })
 
-    /** Fires title generation once per process after the first step makes a user message visible. */
-    const startTitleOnce = Effect.fnUntraced(function* (sessionID: SessionSchema.ID) {
-      if (titleStarted.has(sessionID)) return
-      titleStarted.add(sessionID)
-      forkTitle(title.generateForFirstPrompt(yield* getSession(sessionID)).pipe(Effect.ignore))
+    /** Starts one title request at a time after a successful step makes user input visible. */
+    const startTitle = Effect.fnUntraced(function* (sessionID: SessionSchema.ID) {
+      if (titlesRunning.has(sessionID)) return
+      titlesRunning.add(sessionID)
+      forkTitle(
+        title.generateForFirstPrompt(sessionID).pipe(
+          Effect.ignore,
+          Effect.ensuring(
+            Effect.sync(() => {
+              titlesRunning.delete(sessionID)
+            }),
+          ),
+        ),
+      )
     })
 
     const getSession = Effect.fn("SessionRunner.getSession")(function* (sessionID: SessionSchema.ID) {

packages/core/src/session/sql.ts

@@ -36,7 +36,7 @@ export const SessionTable = sqliteTable(
     slug: text().notNull(),
     directory: directoryColumn().notNull(),
     path: pathColumn(),
-    title: text().notNull(),
+    title: text(),
     version: text().notNull(),
     share_url: text(),
     summary_additions: integer(),

packages/core/src/session/title.ts

@@ -1,7 +1,7 @@
 export * as SessionTitle from "./title"
 
 import { LLM, LLMClient, LLMError, LLMEvent, Message, type LLMRequest } from "@opencode-ai/ai"
-import { Context, Effect, Layer, Stream } from "effect"
+import { Context, DateTime, Effect, Layer, Stream } from "effect"
 import { Agent } from "../agent"
 import { Database } from "../database/database"
 import { Bus } from "../bus"
@@ -14,8 +14,10 @@ import { SessionModelHeaders } from "./model-headers"
 import { SessionRunnerModel } from "./runner/model"
 import { SessionSchema } from "./schema"
 import { SessionUsage } from "./usage"
+import { SessionStore } from "./store"
 
 const MAX_LENGTH = 100
+const titleChanged = Symbol("Session title changed")
 
 type Dependencies = {
   readonly app: App.Info
@@ -25,24 +27,30 @@ type Dependencies = {
   }
   readonly agents: Agent.Interface
   readonly models: SessionRunnerModel.Interface
+  readonly store: SessionStore.Interface
 }
 
 export interface Interface {
-  /** Generates a title from the session's first user message and renames the session. Runs at most once per session. */
-  readonly generateForFirstPrompt: (session: SessionSchema.Info) => Effect.Effect<void>
+  /** Generates a title from the session's first user message when the session remains untitled. */
+  readonly generateForFirstPrompt: (sessionID: SessionSchema.ID) => Effect.Effect<void>
 }
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/SessionTitle") {}
 
 const truncate = (value: string) => (value.length <= MAX_LENGTH ? value : `${value.slice(0, MAX_LENGTH - 3)}...`)
+const isUntitled = (session: SessionSchema.Info) =>
+  session.title === undefined || session.title === `New session - ${DateTime.formatIso(session.time.created)}`
 
 const make = (dependencies: Dependencies) => {
   const generateForFirstPrompt = Effect.fn("SessionTitle.generateForFirstPrompt")(function* (
     db: Database.Interface["db"],
-    session: SessionSchema.Info,
+    sessionID: SessionSchema.ID,
   ) {
+    const session = yield* dependencies.store.get(sessionID)
+    if (!session) return
     if (session.parentID) return
-    const firstUser = yield* SessionHistory.firstUserMessageIfOnly(db, session.id)
+    if (!isUntitled(session)) return
+    const firstUser = yield* SessionHistory.firstUserMessage(db, session.id)
     if (!firstUser) return
     const agent = yield* dependencies.agents.get(Agent.ID.make("title"))
     if (!agent) return
@@ -96,10 +104,19 @@ const make = (dependencies: Dependencies) => {
       .map((line) => line.trim())
       .find((line) => line.length > 0)
     if (!title) return
-    yield* dependencies.bus.publish(SessionEvent.Renamed, {
-      sessionID: session.id,
-      title: truncate(title),
-    })
+    const expectedSequence = (yield* Bus.latestSequence(db, sessionID)) + 1
+    const current = yield* dependencies.store.get(sessionID)
+    if (!current || !isUntitled(current)) return
+    yield* dependencies.bus
+      .publish(
+        SessionEvent.Renamed,
+        {
+          sessionID: session.id,
+          title: truncate(title),
+        },
+        { commit: (sequence) => (sequence === expectedSequence ? Effect.void : Effect.die(titleChanged)) },
+      )
+      .pipe(Effect.catchDefect((defect) => (defect === titleChanged ? Effect.void : Effect.die(defect))))
   })
   return { generateForFirstPrompt }
 }
@@ -111,11 +128,12 @@ export const layer = Layer.effect(
     const llm = yield* LLMClient.Service
     const agents = yield* Agent.Service
     const models = yield* SessionRunnerModel.Service
+    const store = yield* SessionStore.Service
     const database = yield* Database.Service
     const app = yield* App.Metadata
-    const title = make({ bus, llm, agents, models, app })
+    const title = make({ bus, llm, agents, models, store, app })
     return Service.of({
-      generateForFirstPrompt: (session) => title.generateForFirstPrompt(database.db, session),
+      generateForFirstPrompt: (sessionID) => title.generateForFirstPrompt(database.db, sessionID),
     })
   }),
 )
@@ -123,5 +141,5 @@ export const layer = Layer.effect(
 export const node = makeLocationNode({
   service: Service,
   layer,
-  deps: [Bus.node, llmClient, Agent.node, SessionRunnerModel.node, Database.node, App.node],
+  deps: [Bus.node, llmClient, Agent.node, SessionRunnerModel.node, SessionStore.node, Database.node, App.node],
 })

packages/core/test/database-migration.test.ts

@@ -26,6 +26,7 @@ import timeSuspendedMigration from "@opencode-ai/core/database/migration/2026070
 import instructionSyncMigration from "@opencode-ai/core/database/migration/20260710025429_instruction_sync"
 import deleteToolProgressEventsMigration from "@opencode-ai/core/database/migration/20260722011141_delete_tool_progress_events"
 import canonicalToolResultsMigration from "@opencode-ai/core/database/migration/20260722170000_canonical_tool_results"
+import optionalSessionTitleMigration from "@opencode-ai/core/database/migration/20260730195856_optional_session_title"
 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"
@@ -399,6 +400,40 @@ describe("DatabaseMigration", () => {
     ).rejects.toThrow("Database is not empty and has no session table")
   })
 
+  test("makes session titles nullable without deleting dependent rows", async () => {
+    await run(
+      Effect.gen(function* () {
+        const db = yield* makeDb
+        yield* db.run(sql`PRAGMA foreign_keys = ON`)
+        yield* db.run(sql`
+          CREATE TABLE session (
+            id text PRIMARY KEY,
+            title text NOT NULL
+          )
+        `)
+        yield* db.run(sql`
+          CREATE TABLE message (
+            id text PRIMARY KEY,
+            session_id text NOT NULL REFERENCES session(id) ON DELETE CASCADE
+          )
+        `)
+        yield* db.run(sql`INSERT INTO session VALUES ('ses_existing', 'Existing title')`)
+        yield* db.run(sql`INSERT INTO message VALUES ('msg_existing', 'ses_existing')`)
+
+        yield* DatabaseMigration.applyOnly(db, [optionalSessionTitleMigration])
+
+        expect(yield* db.get(sql`SELECT title FROM session WHERE id = 'ses_existing'`)).toEqual({
+          title: "Existing title",
+        })
+        expect(yield* db.get(sql`SELECT id FROM message WHERE id = 'msg_existing'`)).toEqual({ id: "msg_existing" })
+        expect(
+          yield* db.get<{ notnull: number }>(sql`SELECT "notnull" FROM pragma_table_info('session') WHERE name = 'title'`),
+        ).toEqual({ notnull: 0 })
+        expect(yield* db.get<{ foreign_keys: number }>(sql`PRAGMA foreign_keys`)).toEqual({ foreign_keys: 1 })
+      }),
+    )
+  })
+
   test("backfills existing Context Epoch rows to the build agent", async () => {
     await run(
       Effect.gen(function* () {

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

@@ -71,6 +71,27 @@ function withTmp<A, E, R>(f: (directory: string) => Effect.Effect<A, E, R>) {
 }
 
 describe("Session.create", () => {
+  it.effect("persists a missing title until one is generated or supplied", () =>
+    Effect.gen(function* () {
+      const session = yield* Session.Service
+      const { db } = yield* Database.Service
+
+      const created = yield* session.create({ location })
+      const row = yield* db.select().from(SessionTable).where(eq(SessionTable.id, created.id)).get().pipe(Effect.orDie)
+      const event = yield* db
+        .select({ data: EventTable.data })
+        .from(EventTable)
+        .where(eq(EventTable.aggregate_id, created.id))
+        .get()
+        .pipe(Effect.orDie)
+
+      expect(created.title).toBeUndefined()
+      expect(row?.title).toBeNull()
+      expect(event?.data).not.toHaveProperty("info.title")
+      expect((yield* session.create({ location, title: "Explicit title" })).title).toBe("Explicit title")
+    }),
+  )
+
   it.effect("creates a fresh projected session when the ID is omitted", () =>
     Effect.gen(function* () {
       const session = yield* Session.Service
@@ -296,6 +317,23 @@ describe("Session.create", () => {
     }),
   )
 
+  it.effect("keeps a fork untitled when its parent is untitled", () =>
+    Effect.gen(function* () {
+      const session = yield* Session.Service
+      const bus = yield* Bus.Service
+      const { db } = yield* Database.Service
+      const parent = yield* session.create({ location })
+      yield* session.prompt({ sessionID: parent.id, text: "First", resume: false })
+      yield* SessionPending.promote(db, bus, parent.id, "steer")
+
+      const forked = yield* session.fork({ sessionID: parent.id, boundary: { type: "through" } })
+      const row = yield* db.select().from(SessionTable).where(eq(SessionTable.id, forked.id)).get().pipe(Effect.orDie)
+
+      expect(forked.title).toBeUndefined()
+      expect(row?.title).toBeNull()
+    }),
+  )
+
   it.effect("rejects forking an empty session", () =>
     Effect.gen(function* () {
       const session = yield* Session.Service

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

@@ -796,6 +796,59 @@ const verifyPartialFlushOnInterruption = (kind: FragmentKind) =>
   })
 
 describe("SessionRunnerLLM", () => {
+  it.effect("retries title generation from the first prompt after execution and title failures", () =>
+    Effect.gen(function* () {
+      const session = yield* setup
+      const agents = yield* Agent.Service
+      const { db } = yield* Database.Service
+      yield* db.update(SessionTable).set({ title: null }).where(eq(SessionTable.id, sessionID)).run().pipe(Effect.orDie)
+      yield* agents.transform((draft) =>
+        draft.update(Agent.ID.make("title"), (agent) => {
+          agent.mode = "primary"
+          agent.hidden = true
+          agent.system = "Generate a title."
+        }),
+      )
+
+      yield* admit(session, "First prompt")
+      yield* TestLLM.push(Stream.fail(invalidRequest()))
+      expect((yield* session.resume(sessionID).pipe(Effect.exit))._tag).toBe("Failure")
+
+      yield* admit(session, "Second prompt")
+      const titleFailed = yield* Deferred.make<void>()
+      yield* TestLLM.push(
+        TestLLM.text("Recovered", "text-recovered"),
+        Stream.make(LLMEvent.providerError({ message: "Title provider unavailable" })).pipe(
+          Stream.ensuring(Deferred.succeed(titleFailed, undefined)),
+        ),
+      )
+      yield* session.resume(sessionID)
+      yield* Deferred.await(titleFailed)
+      yield* Effect.yieldNow
+      expect((yield* session.get(sessionID)).title).toBeUndefined()
+
+      const bus = yield* Bus.Service
+      const renamed = yield* bus.subscribe(SessionEvent.Renamed).pipe(
+        Stream.filter((event) => event.data.sessionID === sessionID),
+        Stream.take(1),
+        Stream.runCollect,
+        Effect.forkScoped({ startImmediately: true }),
+      )
+      yield* admit(session, "Third prompt")
+      yield* TestLLM.push(
+        TestLLM.text("Recovered again", "text-recovered-again"),
+        TestLLM.text("Generated title", "text-title"),
+      )
+      yield* session.resume(sessionID)
+      yield* Fiber.join(renamed)
+
+      expect(requests).toHaveLength(5)
+      expect(requests[2]?.messages).toContainEqual(Message.user("First prompt"))
+      expect(requests[4]?.messages).toContainEqual(Message.user("First prompt"))
+      expect((yield* session.get(sessionID)).title).toBe("Generated title")
+    }),
+  )
+
   it.effect("applies session context hooks without exposing unavailable tools", () =>
     Effect.gen(function* () {
       const session = yield* setup

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

@@ -20,7 +20,7 @@ import { ProjectTable } from "@opencode-ai/core/project/sql"
 import { App } from "@opencode-ai/core/app"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { Money } from "@opencode-ai/schema/money"
-import { Effect, Layer, Stream } from "effect"
+import { Deferred, Effect, Fiber, Layer, Stream } from "effect"
 import { testEffect } from "./lib/effect"
 
 let requests: LLMRequest[] = []
@@ -39,27 +39,30 @@ const cost = [
     },
   },
 ]
+const successfulTitle = () =>
+  Stream.make(
+    LLMEvent.textDelta({ id: "title", text: "Generated Title\n" }),
+    LLMEvent.stepFinish({
+      index: 0,
+      reason: { normalized: "stop" },
+      usage: {
+        inputTokens: 15,
+        outputTokens: 6,
+        nonCachedInputTokens: 10,
+        cacheReadInputTokens: 3,
+        cacheWriteInputTokens: 2,
+        reasoningTokens: 2,
+      },
+    }),
+    LLMEvent.finish({
+      reason: { normalized: "stop" },
+    }),
+  )
+let titleStream: () => Stream.Stream<LLMEvent> = successfulTitle
 const client = Layer.mock(LLMClient.Service)({
   stream: (request: LLMRequest) => {
     requests.push(request)
-    return Stream.make(
-      LLMEvent.textDelta({ id: "title", text: "Generated Title\n" }),
-      LLMEvent.stepFinish({
-        index: 0,
-        reason: { normalized: "stop" },
-        usage: {
-          inputTokens: 15,
-          outputTokens: 6,
-          nonCachedInputTokens: 10,
-          cacheReadInputTokens: 3,
-          cacheWriteInputTokens: 2,
-          reasoningTokens: 2,
-        },
-      }),
-      LLMEvent.finish({
-        reason: { normalized: "stop" },
-      }),
-    )
+    return titleStream()
   },
   generate: () => Effect.die("unused"),
 })
@@ -89,7 +92,7 @@ const it = testEffect(
   ),
 )
 
-const insertSession = (id: Session.ID) =>
+const insertSession = (id: Session.ID, title?: string, created?: number) =>
   Effect.gen(function* () {
     const { db } = yield* Database.Service
     yield* db
@@ -105,7 +108,8 @@ const insertSession = (id: Session.ID) =>
         project_id: Project.ID.global,
         slug: id,
         directory: "/project",
-        title: "New session - fake",
+        title,
+        time_created: created,
         version: "test",
       })
       .onConflictDoNothing()
@@ -131,6 +135,7 @@ const prompt = (sessionID: Session.ID, text: string) =>
 it.effect("generates a title from the sole user message and renames the session", () =>
   Effect.gen(function* () {
     requests = []
+    titleStream = successfulTitle
     const agentService = yield* Agent.Service
     yield* agentService.transform((editor) => {
       editor.update(Agent.ID.make("title"), (agent) => {
@@ -144,11 +149,8 @@ it.effect("generates a title from the sole user message and renames the session"
     yield* prompt(sessionID, "Help me debug the failing build")
 
     const store = yield* SessionStore.Service
-    const session = yield* store
-      .get(sessionID)
-      .pipe(Effect.flatMap((session) => (session ? Effect.succeed(session) : Effect.die("session missing"))))
     const title = yield* SessionTitle.Service
-    yield* title.generateForFirstPrompt(session)
+    yield* title.generateForFirstPrompt(sessionID)
 
     expect(requests).toHaveLength(1)
     expect(requests[0]?.http?.headers).toEqual({
@@ -167,9 +169,10 @@ it.effect("generates a title from the sole user message and renames the session"
   }),
 )
 
-it.effect("does not generate once a second user message exists", () =>
+it.effect("generates from the first user message after later messages exist", () =>
   Effect.gen(function* () {
     requests = []
+    titleStream = successfulTitle
     const agentService = yield* Agent.Service
     yield* agentService.transform((editor) => {
       editor.update(Agent.ID.make("title"), (agent) => {
@@ -184,21 +187,46 @@ it.effect("does not generate once a second user message exists", () =>
     yield* prompt(sessionID, "Second message")
 
     const store = yield* SessionStore.Service
-    const session = yield* store
-      .get(sessionID)
-      .pipe(Effect.flatMap((session) => (session ? Effect.succeed(session) : Effect.die("session missing"))))
     const title = yield* SessionTitle.Service
-    yield* title.generateForFirstPrompt(session)
+    yield* title.generateForFirstPrompt(sessionID)
 
-    expect(requests).toHaveLength(0)
-    const untouched = yield* store.get(sessionID)
-    expect(untouched?.title).toBe("New session - fake")
+    expect(requests).toHaveLength(1)
+    expect(JSON.stringify(requests[0]?.messages)).toContain("First message")
+    expect(JSON.stringify(requests[0]?.messages)).not.toContain("Second message")
+    expect((yield* store.get(sessionID))?.title).toBe("Generated Title")
+  }),
+)
+
+it.effect("retries a legacy persisted fallback title", () =>
+  Effect.gen(function* () {
+    requests = []
+    titleStream = successfulTitle
+    const agentService = yield* Agent.Service
+    yield* agentService.transform((editor) => {
+      editor.update(Agent.ID.make("title"), (agent) => {
+        agent.mode = "primary"
+        agent.hidden = true
+        agent.system = "You are a title generator."
+      })
+    })
+    const sessionID = Session.ID.make("ses_title_legacy")
+    const created = Date.parse("2026-07-30T18:45:03.662Z")
+    yield* insertSession(sessionID, "New session - 2026-07-30T18:45:03.662Z", created)
+    yield* prompt(sessionID, "Retry the legacy title")
+
+    const title = yield* SessionTitle.Service
+    yield* title.generateForFirstPrompt(sessionID)
+
+    const store = yield* SessionStore.Service
+    expect(requests).toHaveLength(1)
+    expect((yield* store.get(sessionID))?.title).toBe("Generated Title")
   }),
 )
 
 it.effect("does not generate for a child session", () =>
   Effect.gen(function* () {
     requests = []
+    titleStream = successfulTitle
     const agentService = yield* Agent.Service
     yield* agentService.transform((editor) => {
       editor.update(Agent.ID.make("title"), (agent) => {
@@ -223,7 +251,6 @@ it.effect("does not generate for a child session", () =>
         parent_id: Session.ID.make("ses_title_parent"),
         slug: sessionID,
         directory: "/project",
-        title: "Child session - fake",
         version: "test",
       })
       .onConflictDoNothing()
@@ -231,12 +258,8 @@ it.effect("does not generate for a child session", () =>
       .pipe(Effect.orDie)
     yield* prompt(sessionID, "Do this subtask")
 
-    const store = yield* SessionStore.Service
-    const session = yield* store
-      .get(sessionID)
-      .pipe(Effect.flatMap((session) => (session ? Effect.succeed(session) : Effect.die("session missing"))))
     const title = yield* SessionTitle.Service
-    yield* title.generateForFirstPrompt(session)
+    yield* title.generateForFirstPrompt(sessionID)
 
     expect(requests).toHaveLength(0)
   }),
@@ -245,19 +268,100 @@ it.effect("does not generate for a child session", () =>
 it.effect("does not generate when the title agent is removed", () =>
   Effect.gen(function* () {
     requests = []
+    titleStream = successfulTitle
     const sessionID = Session.ID.make("ses_title_no_agent")
     yield* insertSession(sessionID)
     yield* prompt(sessionID, "Help me debug the failing build")
 
     const store = yield* SessionStore.Service
-    const session = yield* store
-      .get(sessionID)
-      .pipe(Effect.flatMap((session) => (session ? Effect.succeed(session) : Effect.die("session missing"))))
     const title = yield* SessionTitle.Service
-    yield* title.generateForFirstPrompt(session)
+    yield* title.generateForFirstPrompt(sessionID)
 
     expect(requests).toHaveLength(0)
     const untouched = yield* store.get(sessionID)
-    expect(untouched?.title).toBe("New session - fake")
+    expect(untouched?.title).toBeUndefined()
+  }),
+)
+
+it.effect("does not overwrite an explicit title", () =>
+  Effect.gen(function* () {
+    requests = []
+    titleStream = successfulTitle
+    const sessionID = Session.ID.make("ses_title_explicit")
+    yield* insertSession(sessionID)
+    yield* prompt(sessionID, "Help me debug the failing build")
+    const events = yield* Bus.Service
+    yield* events.publish(SessionEvent.Renamed, { sessionID, title: "New session - 2099-01-01T00:00:00.000Z" })
+
+    const title = yield* SessionTitle.Service
+    yield* title.generateForFirstPrompt(sessionID)
+
+    const store = yield* SessionStore.Service
+    expect(requests).toHaveLength(0)
+    expect((yield* store.get(sessionID))?.title).toBe("New session - 2099-01-01T00:00:00.000Z")
+  }),
+)
+
+it.effect("retries after a failed title request", () =>
+  Effect.gen(function* () {
+    requests = []
+    const agentService = yield* Agent.Service
+    yield* agentService.transform((editor) => {
+      editor.update(Agent.ID.make("title"), (agent) => {
+        agent.mode = "primary"
+        agent.hidden = true
+        agent.system = "You are a title generator."
+      })
+    })
+    const sessionID = Session.ID.make("ses_title_retry")
+    yield* insertSession(sessionID)
+    yield* prompt(sessionID, "Retry this title")
+    const title = yield* SessionTitle.Service
+    titleStream = () => Stream.make(LLMEvent.providerError({ message: "Provider unavailable" }))
+
+    yield* title.generateForFirstPrompt(sessionID)
+    titleStream = successfulTitle
+    yield* title.generateForFirstPrompt(sessionID)
+
+    const store = yield* SessionStore.Service
+    expect(requests).toHaveLength(2)
+    expect((yield* store.get(sessionID))?.title).toBe("Generated Title")
+  }),
+)
+
+it.effect("preserves a manual rename completed while generation is in flight", () =>
+  Effect.gen(function* () {
+    requests = []
+    const agentService = yield* Agent.Service
+    yield* agentService.transform((editor) => {
+      editor.update(Agent.ID.make("title"), (agent) => {
+        agent.mode = "primary"
+        agent.hidden = true
+        agent.system = "You are a title generator."
+      })
+    })
+    const sessionID = Session.ID.make("ses_title_manual_rename")
+    yield* insertSession(sessionID)
+    yield* prompt(sessionID, "Generate this title")
+    const started = yield* Deferred.make<void>()
+    const release = yield* Deferred.make<void>()
+    titleStream = () =>
+      Stream.unwrap(
+        Deferred.succeed(started, undefined).pipe(
+          Effect.andThen(Deferred.await(release)),
+          Effect.as(successfulTitle()),
+        ),
+      )
+    const title = yield* SessionTitle.Service
+    const fiber = yield* title.generateForFirstPrompt(sessionID).pipe(Effect.forkScoped)
+    yield* Deferred.await(started)
+    const events = yield* Bus.Service
+    yield* events.publish(SessionEvent.Renamed, { sessionID, title: "Manual title" })
+    yield* Deferred.succeed(release, undefined)
+    yield* Fiber.join(fiber)
+
+    const store = yield* SessionStore.Service
+    expect(requests).toHaveLength(1)
+    expect((yield* store.get(sessionID))?.title).toBe("Manual title")
   }),
 )

packages/core/test/tool-subagent.test.ts

@@ -47,7 +47,7 @@ const executionNode = makeGlobalNode({
       const completed = new Set<Session.ID>()
       const complete = Effect.fn("SubagentTest.complete")(function* (sessionID: Session.ID) {
         if (completed.has(sessionID)) return
-        if ((yield* store.get(sessionID))?.title.includes("fail")) {
+        if ((yield* store.get(sessionID))?.title?.includes("fail")) {
           yield* new SessionRunnerModel.ModelNotSelectedError({ sessionID })
           return
         }

packages/enterprise/src/routes/share/[shareID].tsx

@@ -158,6 +158,11 @@ export default function () {
           const match = createMemo(() => Binary.search(data().session, data().sessionID, (s) => s.id))
           if (!match().found) throw new Error(`Session ${data().sessionID} not found`)
           const info = createMemo(() => data().session[match().index])
+          const title = createMemo(
+            () =>
+              info().title ??
+              `${info().parentID ? "Child" : "New"} session - ${new Date(info().time.created).toISOString()}`,
+          )
           const ogImage = createMemo(() => {
             const models = new Set<string>()
             const messages = data().message[data().sessionID] ?? []
@@ -167,7 +172,7 @@ export default function () {
               }
             }
             const modelIDs = Array.from(models)
-            const encodedTitle = encodeURIComponent(Base64.encode(encodeURIComponent(info().title.substring(0, 700))))
+            const encodedTitle = encodeURIComponent(Base64.encode(encodeURIComponent(title().substring(0, 700))))
             let modelParam: string
             if (modelIDs.length === 1) {
               modelParam = modelIDs[0]
@@ -184,9 +189,7 @@ export default function () {
 
           return (
             <>
-              <Show when={info().title}>
-                <Title>{info().title} | OpenCode</Title>
-              </Show>
+              <Title>{title()} | OpenCode</Title>
               <Meta name="description" content="opencode - The AI coding agent built for the terminal." />
               <Meta property="og:image" content={ogImage()} />
               <Meta name="twitter:image" content={ogImage()} />
@@ -240,7 +243,7 @@ export default function () {
                               </div>
                             </div>
                           </div>
-                          <div class="text-left text-16-medium text-text-strong">{info().title}</div>
+                          <div class="text-left text-16-medium text-text-strong">{title()}</div>
                         </div>
                       )
 

packages/schema/src/session.ts

@@ -42,7 +42,7 @@ export const Info = Schema.Struct({
     updated: DateTimeUtcFromMillis,
     archived: DateTimeUtcFromMillis.pipe(optional),
   }),
-  title: Schema.String,
+  title: Schema.String.pipe(optional),
   location: Location.Ref,
   subpath: RelativePath.pipe(optional),
   revert: Revert.pipe(optional),

packages/schema/src/v1/session.ts

@@ -552,7 +552,7 @@ export const SessionInfo = Schema.Struct({
   cost: optional(Schema.Finite),
   tokens: optional(SessionTokens),
   share: optional(SessionShare),
-  title: Schema.String,
+  title: optional(Schema.String),
   agent: optional(Schema.String),
   model: optional(SessionModel),
   version: Schema.String,

packages/schema/test/contract-hygiene.test.ts

@@ -17,7 +17,7 @@ import { Money } from "../src/money.js"
 import { Skill } from "../src/skill.js"
 import { Shell } from "../src/shell.js"
 import { PersistedRevert } from "../src/session-revert.js"
-import { optional } from "../src/schema.js"
+import { AbsolutePath, optional } from "../src/schema.js"
 
 describe("contract hygiene", () => {
   test("restricts agent colors to six-digit hex values", () => {
@@ -52,6 +52,18 @@ describe("contract hygiene", () => {
         metadata: undefined,
       }),
     ).toEqual({ text: "completed" })
+
+    expect(
+      Schema.encodeSync(Session.Info)({
+        id: Session.ID.make("ses_untitled"),
+        projectID: Project.ID.make("global"),
+        cost: Money.USD.zero,
+        tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+        time: { created: DateTime.makeUnsafe(0), updated: DateTime.makeUnsafe(0) },
+        title: undefined,
+        location: { directory: AbsolutePath.make("/project") },
+      }),
+    ).not.toHaveProperty("title")
   })
 
   test("pending session items omit the internal admission sequence", () => {

packages/tui/src/app.tsx

@@ -66,7 +66,7 @@ import { DialogThemeList } from "./component/dialog-theme-list"
 import { DialogHelp } from "./ui/dialog-help"
 import { DialogAgent } from "./component/dialog-agent"
 import { DialogSessionList } from "./component/dialog-session-list"
-import { DialogProject } from "./component/dialog-project"
+import { DialogOpen } from "./component/dialog-open"
 import { SessionTabs } from "./component/session-tabs"
 import { ThemeErrorToast } from "./component/theme-error-toast"
 import { ThemeProvider, useTheme, useThemes } from "./context/theme"
@@ -95,13 +95,11 @@ import { StorageProvider } from "./context/storage"
 
 registerOpencodeSpinner()
 
-const appGlobalBindingCommands = ["session.list", "session.new"] as const
+const appGlobalBindingCommands = ["session.list", "session.new", "open.menu"] as const
 
 const sessionTabBindingCommands = [
   "session.tab.next",
   "session.tab.previous",
-  "session.tab.history.back",
-  "session.tab.history.forward",
   "session.tab.next_unread",
   "session.tab.previous_unread",
   "session.tab.close",
@@ -525,8 +523,11 @@ function App(props: { pair?: DialogPairCredentials }) {
     renderer.useMouse = config.data.mouse
   })
 
+  let active: { id: string; title?: string } | undefined
   // Update terminal window title based on current route and session
   createEffect(() => {
+    const session = route.data.type === "session" ? data.session.get(route.data.sessionID) : undefined
+    if (session) active = { id: session.id, title: session.title }
     if (!terminalTitleEnabled()) return
 
     if (route.data.type === "home") {
@@ -535,14 +536,13 @@ function App(props: { pair?: DialogPairCredentials }) {
     }
 
     if (route.data.type === "session") {
-      const session = data.session.get(route.data.sessionID)
-      if (!session || isDefaultTitle(session.title)) {
+      const title = session?.title
+      if (!title || isDefaultTitle(title)) {
         renderer.setTerminalTitle("OpenCode")
         return
       }
 
-      const title = session.title.length > 40 ? session.title.slice(0, 37) + "..." : session.title
-      renderer.setTerminalTitle(`OC | ${title}`)
+      renderer.setTerminalTitle(`OC | ${title.length > 40 ? title.slice(0, 37) + "..." : title}`)
       return
     }
 
@@ -646,17 +646,18 @@ function App(props: { pair?: DialogPairCredentials }) {
         run: () => {
           route.navigate({
             type: "home",
+            location: route.data.type === "session" ? data.session.get(route.data.sessionID)?.location : undefined,
           })
           dialog.clear()
         },
       },
       {
-        name: "project.switch",
-        title: "Switch project",
+        name: "open.menu",
+        title: "Open session or project",
         category: "Session",
-        slash: { name: "projects", aliases: ["project"] },
+        slash: { name: "open", aliases: ["projects", "project"] },
         run: () => {
-          dialog.replace(() => <DialogProject />)
+          dialog.replace(() => <DialogOpen />)
         },
       },
       ...Array.from({ length: 9 }, (_, i) => ({
@@ -683,22 +684,6 @@ function App(props: { pair?: DialogPairCredentials }) {
         enabled: sessionTabs.enabled,
         run: () => sessionTabs.cycle(-1),
       },
-      {
-        name: "session.tab.history.back",
-        title: "Back in tab history",
-        category: "Session",
-        palette: undefined,
-        enabled: sessionTabs.enabled,
-        run: () => sessionTabs.history(-1),
-      },
-      {
-        name: "session.tab.history.forward",
-        title: "Forward in tab history",
-        category: "Session",
-        palette: undefined,
-        enabled: sessionTabs.enabled,
-        run: () => sessionTabs.history(1),
-      },
       {
         name: "session.tab.next_unread",
         title: "Next unread tab",
@@ -1160,10 +1145,11 @@ function App(props: { pair?: DialogPairCredentials }) {
 
   event.on("session.deleted", (evt) => {
     if (route.data.type === "session" && route.data.sessionID === evt.data.sessionID) {
+      const title = active?.id === evt.data.sessionID ? active.title : undefined
       route.navigate({ type: "home" })
       toast.show({
         variant: "info",
-        message: "The current session was deleted",
+        message: title ? `Session "${title}" was deleted` : "The current session was deleted",
       })
     }
   })

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

@@ -105,7 +105,7 @@ export const settings: Setting[] = [
     title: "Scope",
     category: "Tabs",
     path: ["tabs", "scope"],
-    default: "cwd",
+    default: "global",
     values: ["cwd", "global"],
     labels: ["current directory", "global"],
   },

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

@@ -0,0 +1,165 @@
+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 { useRoute } from "../context/route"
+import { useData } from "../context/data"
+import { useClient } from "../context/client"
+import { useLocation } from "../context/location"
+import { useSessionTabs } from "../context/session-tabs"
+import { useTheme, useThemes } from "../context/theme"
+import { Keymap } from "../context/keymap"
+import { Locale } from "../util/locale"
+import { abbreviateHome } from "../runtime"
+import { useTuiPaths } from "../context/runtime"
+import { truncateFilePath } from "../ui/file-path"
+import { stringWidth } from "../util/string-width"
+import { sessionTitle } from "../util/session"
+import { Spinner } from "./spinner"
+
+const RECENT_LIMIT = 8
+
+type OpenTarget = { type: "session"; sessionID: string } | { type: "project"; directory: string }
+
+export function DialogOpen() {
+  const dialog = useDialog()
+  const route = useRoute()
+  const data = useData()
+  const client = useClient()
+  const location = useLocation()
+  const sessionTabs = useSessionTabs()
+  const themes = useThemes()
+  const theme = useTheme("elevated")
+  const mode = themes.mode
+  const paths = useTuiPaths()
+  const dimensions = useTerminalDimensions()
+  const shortcuts = Keymap.useShortcuts()
+  const [filter, setFilter] = createSignal("")
+
+  data.project.invalidate()
+  void data.project.sync().catch(() => {})
+
+  // One background fetch fills in recent sessions from other projects; the menu renders
+  // immediately from the local store and never blocks on the network.
+  const [fetched] = createResource(
+    () =>
+      client.api.session
+        .list({ limit: 50, order: "desc", parentID: null })
+        .then((response) => response.data)
+        .catch(() => [] as SessionInfo[]),
+    { initialValue: [] },
+  )
+
+  const openTabs = createMemo(() => new Set(sessionTabs.tabs().map((tab) => tab.sessionID)))
+  const currentSessionID = createMemo(() => (route.data.type === "session" ? route.data.sessionID : undefined))
+  const sessions = createMemo(() => {
+    const seen = new Set<string>()
+    return [...data.session.list(), ...fetched()]
+      .filter((session) => {
+        if (session.parentID || seen.has(session.id)) return false
+        seen.add(session.id)
+        return true
+      })
+      .toSorted((a, b) => b.time.updated - a.time.updated)
+  })
+
+  const options = createMemo(() => {
+    const tabs = openTabs()
+    // With an empty query the menu shows what is not already one keystroke away: open tabs are
+    // visible in the strip, so recents exclude them. Typing widens the pool to every session so
+    // matching a tab by name still switches to it.
+    const recent = filter().trim()
+      ? sessions()
+      : sessions()
+          .filter((session) => !tabs.has(session.id))
+          .slice(0, RECENT_LIMIT)
+    const sessionOptions = recent.map((session) => {
+      const project = data.project.get(session.projectID)
+      const name = project?.name || path.basename(project?.canonical ?? session.location.directory)
+      const running = data.session.family(session.id).some((id) => data.session.status(id) === "running")
+      return {
+        title: sessionTitle(session),
+        value: { type: "session", sessionID: session.id } as OpenTarget,
+        category: "Sessions",
+        footer: `${Locale.truncate(name, 20)} · ${timeAgo(session.time.updated)}`,
+        gutter: running
+          ? () => <Spinner />
+          : tabs.has(session.id)
+            ? () => <text fg={theme.hue.accent[mode() === "light" ? 800 : 200]}>▪</text>
+            : undefined,
+      }
+    })
+
+    const current = location.current?.project
+    const seen = new Set<string>()
+    const projectOptions = data.project
+      .list()
+      .filter((project) => {
+        if (project.canonical === "/" || project.id === current?.id || seen.has(project.canonical)) return false
+        seen.add(project.canonical)
+        return true
+      })
+      .map((project) => {
+        const title = project.name ?? path.basename(project.canonical)
+        const description = 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)
+        return {
+          title,
+          description: truncateFilePath(description, width),
+          searchText: description,
+          value: { type: "project", directory: project.canonical } as OpenTarget,
+          category: "Projects",
+        }
+      })
+
+    return [...sessionOptions, ...projectOptions]
+  })
+
+  onMount(() => dialog.setSize("large"))
+
+  return (
+    <DialogSelect
+      title="Open"
+      placeholder="Search sessions and projects…"
+      options={options()}
+      current={currentSessionID() ? ({ type: "session", sessionID: currentSessionID()! } as OpenTarget) : undefined}
+      focusCurrent={false}
+      onFilter={setFilter}
+      noMatchView={
+        <box paddingLeft={4} paddingRight={4}>
+          <text fg={theme.text.subdued}>
+            {shortcuts.get("session.list")
+              ? `No matches · search all sessions with ${shortcuts.get("session.list")}`
+              : "No matches"}
+          </text>
+        </box>
+      }
+      onSelect={(option) => {
+        dialog.clear()
+        if (option.value.type === "session") {
+          route.navigate({ type: "session", sessionID: option.value.sessionID })
+          return
+        }
+        const target = { directory: option.value.directory }
+        route.navigate({ type: "home", location: target })
+        location.set(target)
+      }}
+    />
+  )
+}
+
+function timeAgo(timestamp: number) {
+  const minutes = Math.floor((Date.now() - timestamp) / 60_000)
+  if (minutes < 1) return "now"
+  if (minutes < 60) return `${minutes}m`
+  const hours = Math.floor(minutes / 60)
+  if (hours < 24) return `${hours}h`
+  const days = Math.floor(hours / 24)
+  if (days < 30) return `${days}d`
+  const months = Math.floor(days / 30)
+  if (months < 12) return `${months}mo`
+  return `${Math.floor(days / 365)}y`
+}

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

@@ -1,77 +0,0 @@
-import path from "path"
-import { createMemo } from "solid-js"
-import { DialogSelect } from "../ui/dialog-select"
-import { useDialog } from "../ui/dialog"
-import { useData } from "../context/data"
-import { useRoute } from "../context/route"
-import { abbreviateHome } from "../runtime"
-import { useTuiPaths } from "../context/runtime"
-import { useLocation } from "../context/location"
-import { useToast } from "../ui/toast"
-import { useTerminalDimensions } from "@opentui/solid"
-import { truncateFilePath } from "../ui/file-path"
-import { stringWidth } from "../util/string-width"
-
-export function DialogProject() {
-  const dialog = useDialog()
-  const data = useData()
-  const route = useRoute()
-  const paths = useTuiPaths()
-  const location = useLocation()
-  const toast = useToast()
-  const dimensions = useTerminalDimensions()
-
-  data.project.invalidate()
-  void data.project.sync().catch(toast.error)
-
-  const current = () => location.current?.project
-
-  const options = createMemo(() => {
-    const seen = new Set<string>()
-    return data.project
-      .list()
-      .filter((project) => {
-        if (project.canonical === "/" || seen.has(project.canonical)) return false
-        seen.add(project.canonical)
-        return true
-      })
-      .toSorted((a, b) => {
-        if (a.id === current()?.id) return -1
-        if (b.id === current()?.id) return 1
-        return 0
-      })
-      .map((project) => {
-        const title = project.name ?? path.basename(project.canonical)
-        const description = abbreviateHome(project.canonical, paths.home)
-        // Dialog padding, the current marker, title padding, and the separating space use nine columns.
-        const width = Math.min(60, dimensions().width - 2) - 9 - stringWidth(title)
-        return {
-          title,
-          description: truncateFilePath(description, width),
-          searchText: description,
-          value: project.canonical,
-        }
-      })
-  })
-
-  return (
-    <DialogSelect
-      title="Switch project"
-      placeholder="Search projects…"
-      options={options()}
-      current={current()?.canonical}
-      emptyView={
-        <box paddingLeft={4} paddingRight={4} paddingTop={1}>
-          <text>No projects found</text>
-        </box>
-      }
-      onSelect={(option) => {
-        dialog.clear()
-        if (option.value === current()?.canonical) return
-        const target = { directory: option.value }
-        route.navigate({ type: "home", location: target })
-        location.set(target)
-      }}
-    />
-  )
-}

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

@@ -17,6 +17,9 @@ import { DialogSessionRename } from "./dialog-session-rename"
 import { Spinner } from "./spinner"
 import { errorMessage } from "../util/error"
 import { useSessionTabs } from "../context/session-tabs"
+import { useStorage } from "../context/storage"
+import { sessionTitle } from "../util/session"
+import { useConfig } from "../config"
 
 export function DialogSessionList() {
   const dialog = useDialog()
@@ -28,12 +31,16 @@ export function DialogSessionList() {
   const client = useClient()
   const local = useLocal()
   const sessionTabs = useSessionTabs()
+  const config = useConfig().data
   const toast = useToast()
   const [filter, setFilter] = createSignal("")
   const shortcuts = Keymap.useShortcuts()
   const [search, setSearch] = createDebouncedSignal("", 150)
   const [toDelete, setToDelete] = createSignal<string>()
-  const [allProjects, setAllProjects] = createSignal(false)
+  const [prefs, updatePrefs] = useStorage().store("session-list", {
+    initial: { allProjects: config.tabs?.scope !== "cwd" },
+  })
+  const allProjects = () => prefs.allProjects
 
   const [searchResults, { mutate: setSearchResults }] = createResource(
     () => ({ query: search().trim(), allProjects: allProjects() }),
@@ -75,7 +82,7 @@ export function DialogSessionList() {
           (session.projectID === current?.project.id && session.location.directory === current.directory),
       )
     if (!query) return sessions
-    return sessions.filter((session) => !session.parentID && session.title.toLowerCase().includes(query))
+    return sessions.filter((session) => !session.parentID && sessionTitle(session).toLowerCase().includes(query))
   })
   const sessions = createMemo(() => {
     const query = filter().trim()
@@ -137,7 +144,7 @@ export function DialogSessionList() {
       const slot = sessionTabs.enabled() ? undefined : slotByID.get(session.id)
       const deleting = toDelete() === session.id
       return {
-        title: deleting ? `Press ${shortcuts.get("session.delete")} again to confirm` : session.title,
+        title: deleting ? `Press ${shortcuts.get("session.delete")} again to confirm` : sessionTitle(session),
         value: session.id,
         category,
         footer,
@@ -189,7 +196,9 @@ export function DialogSessionList() {
           title: allProjects() ? "Show current directory sessions" : "Show all project sessions",
           group: "Dialog",
           run: () => {
-            setAllProjects((value) => !value)
+            void updatePrefs((draft) => {
+              draft.allProjects = !draft.allProjects
+            }).catch(() => {})
           },
         },
       ]}
@@ -231,7 +240,9 @@ export function DialogSessionList() {
               .remove({ sessionID: option.value })
               .then(() => {
                 setSearchResults((result) =>
-                  result ? { ...result, sessions: result.sessions.filter((session) => session.id !== option.value) } : result,
+                  result
+                    ? { ...result, sessions: result.sessions.filter((session) => session.id !== option.value) }
+                    : result,
                 )
               })
               .catch((error) => {

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

@@ -240,7 +240,6 @@ export function Prompt(props: PromptProps) {
               return undefined
             })
             if (!location) return
-            move.setDirectory(location.directory, location.directory !== location.project.directory)
             currentLocation.set(location)
             return
           }
@@ -963,7 +962,10 @@ export function Prompt(props: PromptProps) {
       const directory = await move.getDirectory()
       if (move.pending() && !directory) return false
       finishMoveProgress = Boolean(move.progress())
-      const location = data.location.default()
+      // The location context is where the next session is created: seeded by the home
+      // route (launch cwd, inherited session location, or picked project) and updated
+      // by /cd before a session exists.
+      const location = currentLocation.ref ?? data.location.default()
 
       const created = await client.api.session
         .create({
@@ -1299,7 +1301,12 @@ export function Prompt(props: PromptProps) {
     return `Ask anything... "${list()[store.placeholder % list().length]}"`
   })
   const locationLabel = createMemo(() => {
-    if (!props.sessionID || status() !== "idle") return
+    if (!props.sessionID) {
+      // No session yet: show where the next session will be created.
+      const directory = currentLocation.ref?.directory ?? data.location.default().directory
+      return abbreviateHome(directory, paths.home)
+    }
+    if (status() !== "idle") return
     const directory = data.session.get(props.sessionID)?.location.directory
     return directory ? abbreviateHome(directory, paths.home) : undefined
   })

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,
+  NEW_SESSION_TAB_TITLE,
   sessionTabComplete,
   seedSessionTabMotion,
   sessionTabOverflowWidth,
@@ -36,7 +37,7 @@ export type SessionTabsController = Pick<ContextController, "tabs" | "current" |
   status(sessionID: string): SessionTabsStatus
 }
 
-const NEW_SESSION_TAB: SessionTab = { sessionID: "new", title: "New session" }
+const NEW_SESSION_TAB: SessionTab = { sessionID: "new", title: NEW_SESSION_TAB_TITLE }
 
 export function SessionTabs(props: { controller?: SessionTabsController; animations?: boolean } = {}) {
   const tabs = props.controller ?? useSessionTabs()
@@ -209,6 +210,11 @@ export function SessionTabs(props: { controller?: SessionTabsController; animati
           createEffect((previous: string) => {
             const next = title()
             if (next === previous) return next
+            if (previous === NEW_SESSION_TAB_TITLE) {
+              setOutgoingTitle(undefined)
+              wipe.jump({ front: 1 })
+              return next
+            }
             setOutgoingTitle(previous)
             wipe.jump({ front: 0 })
             wipe.animate({ front: 1 })

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

@@ -87,10 +87,9 @@ export const Definitions = {
   session_move: keybind("none", "Move session"),
   session_new: keybind("<leader>n", "Create a new session"),
   session_list: keybind("<leader>l", "List all sessions"),
+  open_menu: keybind("ctrl+o", "Open recent sessions and projects"),
   session_tab_next: keybind("ctrl+tab,<leader>right,alt+shift+]", "Switch to next open tab"),
   session_tab_previous: keybind("ctrl+shift+tab,<leader>left,alt+shift+[", "Switch to previous open tab"),
-  session_tab_history_back: keybind("ctrl+o", "Go back in tab history"),
-  session_tab_history_forward: keybind("ctrl+i", "Go forward in tab history"),
   session_tab_next_unread: keybind("<leader>down", "Switch to next unread tab"),
   session_tab_previous_unread: keybind("<leader>up", "Switch to previous unread tab"),
   session_tab_close: keybind("<leader>w", "Close current tab"),
@@ -291,10 +290,9 @@ export const CommandMap = {
   session_move: "session.move",
   session_new: "session.new",
   session_list: "session.list",
+  open_menu: "open.menu",
   session_tab_next: "session.tab.next",
   session_tab_previous: "session.tab.previous",
-  session_tab_history_back: "session.tab.history.back",
-  session_tab_history_forward: "session.tab.history.forward",
   session_tab_next_unread: "session.tab.next_unread",
   session_tab_previous_unread: "session.tab.previous_unread",
   session_tab_close: "session.tab.close",

packages/tui/src/context/location.tsx

@@ -5,6 +5,8 @@ import { useData } from "./data"
 
 const context = createContext<{
   readonly current: LocationGetOutput | undefined
+  // The target location as set, available before the server-synced info in `current` arrives.
+  readonly ref: LocationRef | undefined
   set: (location?: LocationRef) => void
 }>()
 
@@ -37,6 +39,9 @@ export function LocationProvider(props: ParentProps) {
         get current() {
           return current()
         },
+        get ref() {
+          return ref()
+        },
         set,
       }}
     >

packages/tui/src/context/route.tsx

@@ -7,6 +7,7 @@ import { useTuiStartup } from "./runtime"
 export type HomeRoute = {
   type: "home"
   prompt?: PromptInfo
+  // Location carried over from the previous session or project picker so a new session lands there.
   location?: LocationRef
 }
 

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

@@ -5,6 +5,8 @@ export type SessionTab = {
 
 export type SessionTabUnread = "activity" | "error"
 
+export const NEW_SESSION_TAB_TITLE = "New session"
+
 export type SessionTabHistory = {
   entries: readonly string[]
   index: number

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

@@ -3,6 +3,7 @@ import { isDeepEqual } from "remeda"
 import { createSimpleContext } from "./helper"
 import { useClient } from "./client"
 import { useData } from "./data"
+import { sessionTitle } from "../util/session"
 import { useEvent } from "./event"
 import { useRoute } from "./route"
 import { useConfig } from "../config"
@@ -13,6 +14,7 @@ import {
   cycleSessionTab,
   moveSessionTab,
   moveSessionTabHistory,
+  NEW_SESSION_TAB_TITLE,
   openSessionTab,
   recordClosedSessionTab,
   recordSessionTabHistory,
@@ -64,12 +66,12 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
     let closedTabs: ClosedSessionTab[] = []
 
     function state() {
-      if (config.tabs?.scope === "global") return store.global
-      return store.cwd[paths.cwd] ?? fallback
+      if (config.tabs?.scope === "cwd") return store.cwd[paths.cwd] ?? fallback
+      return store.global
     }
 
     function update(mutation: (draft: TabsState) => void) {
-      const scope = config.tabs?.scope ?? "cwd"
+      const scope = config.tabs?.scope ?? "global"
       void updateStore((draft) => mutation(scope === "cwd" ? (draft.cwd[paths.cwd] ??= empty()) : draft.global)).catch(
         () => {},
       )
@@ -77,6 +79,12 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
 
     const root = (sessionID: string) => data.session.root(sessionID)
     const current = () => (route.data.type === "session" ? root(route.data.sessionID) : undefined)
+    const newTab = createMemo((open = false) => {
+      if (route.data.type === "home") return true
+      if (!open) return false
+      const sessionID = current()
+      return sessionID !== undefined && !state().tabs.some((tab) => tab.sessionID === sessionID)
+    }, false)
     const status = (sessionID: string) => {
       const session = root(sessionID)
       const members = data.session.family(session)
@@ -107,7 +115,8 @@ 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 title = data.session.get(sessionID)?.title
+      const session = data.session.get(sessionID)
+      const title = session?.title ?? (newTab() ? NEW_SESSION_TAB_TITLE : session ? sessionTitle(session) : undefined)
       const tabs = openSessionTab(state().tabs, { sessionID, title })
       if (tabs === state().tabs && !state().unread[sessionID]) return
       update((draft) => {
@@ -120,7 +129,8 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
       if (!enabled()) return
       const next = state().tabs.reduce<SessionTab[]>((tabs, tab) => {
         const sessionID = root(tab.sessionID)
-        return openSessionTab(tabs, { sessionID, title: data.session.get(sessionID)?.title ?? tab.title })
+        const session = data.session.get(sessionID)
+        return openSessionTab(tabs, { sessionID, title: session ? sessionTitle(session) : tab.title })
       }, [])
       const unread = Object.entries(state().unread).reduce<Record<string, SessionTabUnread>>((result, entry) => {
         const sessionID = root(entry[0])
@@ -129,15 +139,8 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
       }, {})
       if (isDeepEqual(next, state().tabs) && isDeepEqual(unread, state().unread)) return
       update((draft) => {
-        draft.tabs = draft.tabs.reduce<SessionTab[]>((tabs, tab) => {
-          const sessionID = root(tab.sessionID)
-          return openSessionTab(tabs, { sessionID, title: data.session.get(sessionID)?.title ?? tab.title })
-        }, [])
-        draft.unread = Object.entries(draft.unread).reduce<Record<string, SessionTabUnread>>((result, entry) => {
-          const sessionID = root(entry[0])
-          result[sessionID] = result[sessionID] === "error" ? "error" : entry[1]
-          return result
-        }, {})
+        draft.tabs = next
+        draft.unread = unread
       })
     })
 
@@ -233,7 +236,7 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
         return state().tabs
       },
       newTab() {
-        return route.data.type === "home"
+        return newTab()
       },
       current,
       status,
@@ -289,12 +292,6 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
         )
         if (tab) route.navigate({ type: "session", sessionID: tab.sessionID })
       },
-      history(direction: 1 | -1) {
-        if (!enabled()) return
-        const next = moveSessionTabHistory(history, state().tabs, current(), direction)
-        history = next.history
-        if (next.sessionID) route.navigate({ type: "session", sessionID: next.sessionID })
-      },
       selectIndex(index: number) {
         if (!enabled()) return
         const tab = state().tabs[index]

packages/tui/src/routes/home.tsx

@@ -1,5 +1,5 @@
 import { Prompt, type PromptRef } from "../component/prompt"
-import { createEffect, createMemo, createSignal, onMount, Show } from "solid-js"
+import { createEffect, createMemo, createSignal, onMount, Show, untrack } from "solid-js"
 import { Logo } from "../component/logo"
 import { useArgs } from "../context/args"
 import { useRouteData } from "../context/route"
@@ -31,7 +31,13 @@ export function Home() {
   const forms = createMemo(() => data.session.form.list("global", currentLocation()) ?? [])
   let sent = false
 
-  createEffect(() => location.set(currentLocation()))
+  // Track only the route location and (when absent) the default location; location.set
+  // reads other signals internally and tracking them would re-assert the route location
+  // after the user overrides it with /cd.
+  createEffect(() => {
+    const target = currentLocation()
+    untrack(() => location.set(target))
+  })
 
   onMount(() => {
     editor.clearSelection()

packages/tui/src/routes/session/composer/subagents-tab.tsx

@@ -8,6 +8,7 @@ import { useTheme } from "../../../context/theme"
 import { Locale } from "../../../util/locale"
 import { Keymap } from "../../../context/keymap"
 import { useComposerTab } from "./index"
+import { sessionTitle } from "../../../util/session"
 
 interface SubagentEntry {
   sessionID: string
@@ -38,13 +39,14 @@ export function SubagentsTab(props: { sessionID: string }) {
     if (current.parentID) {
       const siblings = data.session.list().filter((s) => s.parentID === current.parentID)
       for (const sibling of siblings) {
-        const agentMatch = sibling.title.match(/@(\w+) subagent/)
+        const title = sessionTitle(sibling)
+        const agentMatch = title.match(/@(\w+) subagent/)
         const agent = sibling.agent
           ? Locale.titlecase(sibling.agent)
           : agentMatch
             ? Locale.titlecase(agentMatch[1])
             : "Subagent"
-        const name = agentMatch ? sibling.title.replace(agentMatch[0], "").trim() || sibling.title : sibling.title
+        const name = agentMatch ? title.replace(agentMatch[0], "").trim() || title : title
         result.push({
           sessionID: sibling.id,
           agent,
@@ -56,13 +58,14 @@ export function SubagentsTab(props: { sessionID: string }) {
     } else {
       const children = data.session.list().filter((s) => s.parentID === props.sessionID)
       for (const child of children) {
-        const agentMatch = child.title.match(/@(\w+) subagent/)
+        const title = sessionTitle(child)
+        const agentMatch = title.match(/@(\w+) subagent/)
         const agent = child.agent
           ? Locale.titlecase(child.agent)
           : agentMatch
             ? Locale.titlecase(agentMatch[1])
             : "Subagent"
-        const name = agentMatch ? child.title.replace(agentMatch[0], "").trim() || child.title : child.title
+        const name = agentMatch ? title.replace(agentMatch[0], "").trim() || title : title
         result.push({
           sessionID: child.id,
           agent,

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

@@ -51,6 +51,7 @@ import { useClient } from "../../context/client"
 import { useEditorContext } from "../../context/editor"
 import { openEditor } from "../../editor"
 import { useDialog } from "../../ui/dialog"
+import { DialogConfirm } from "../../ui/dialog-confirm"
 import { DialogSessionRename } from "../../component/dialog-session-rename"
 import { DialogMessage } from "./dialog-message"
 import { DialogFork } from "./dialog-fork"
@@ -92,6 +93,7 @@ import { switchLabel } from "../../util/model"
 import { findMessageBoundary, messageNavigationSlack } from "./message-navigation"
 import { stringWidth } from "../../util/string-width"
 import { useArgs } from "../../context/args"
+import { sessionTitle } from "../../util/session"
 
 addDefaultParsers(parsers.parsers)
 
@@ -521,6 +523,32 @@ export function Session() {
       slash: { name: "rename" },
       run: () => DialogSessionRename.show(dialog, route.sessionID, session()?.title),
     },
+    {
+      title: "Delete session",
+      id: "session.delete",
+      group: "Session",
+      slash: { name: "delete" },
+      run: async () => {
+        const current = session()
+        if (!current) return
+        const confirmed = await DialogConfirm.show(
+          dialog,
+          "Delete Session",
+          `Delete "${current.title}"? This action cannot be undone.`,
+        )
+        if (confirmed !== true) return
+        const error = await client.api.session.remove({ sessionID: route.sessionID }).then(
+          () => undefined,
+          (error) => error,
+        )
+        if (!error) return
+        toast.show({
+          message: `Failed to delete session: ${errorMessage(error)}`,
+          variant: "error",
+          duration: 5000,
+        })
+      },
+    },
     {
       title: "Jump to message",
       id: "session.timeline",
@@ -3307,7 +3335,7 @@ function formatSessionTranscript(session: SessionInfo, messages: SessionMessageI
     })
     return [`## Assistant\n\n${content.join("\n\n")}`]
   })
-  return `# ${session.title}\n\n**Session ID:** ${session.id}\n**Created:** ${new Date(session.time.created).toLocaleString()}\n**Updated:** ${new Date(session.time.updated).toLocaleString()}\n\n---\n\n${body.join("\n\n---\n\n")}\n`
+  return `# ${sessionTitle(session)}\n\n**Session ID:** ${session.id}\n**Created:** ${new Date(session.time.created).toLocaleString()}\n**Updated:** ${new Date(session.time.updated).toLocaleString()}\n\n---\n\n${body.join("\n\n---\n\n")}\n`
 }
 
 export function parseApplyPatchFiles(value: unknown) {

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

@@ -3,6 +3,7 @@ import { createMemo, Show } from "solid-js"
 import { useTheme } from "../../context/theme"
 import { useConfig } from "../../config"
 import { PluginSlot } from "../../plugin/context"
+import { sessionTitle } from "../../util/session"
 
 import { getScrollAcceleration } from "../../util/scroll"
 
@@ -38,7 +39,7 @@ export function Sidebar(props: { sessionID: string; overlay?: boolean }) {
           <box flexShrink={0} gap={1} paddingRight={1}>
             <box paddingRight={1}>
               <text fg={theme.text.default}>
-                <b>{session()!.title}</b>
+                <b>{sessionTitle(session()!)}</b>
               </text>
               <Show when={session()!.location.workspaceID}>
                 <text fg={theme.text.subdued}>{session()!.location.workspaceID}</text>

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

@@ -1,10 +1,10 @@
-import { InputRenderable, RGBA, ScrollBoxRenderable, TextAttributes } from "@opentui/core"
+import { CliRenderEvents, InputRenderable, RGBA, ScrollBoxRenderable, TextAttributes } from "@opentui/core"
 import { Keymap, type KeymapCommand } from "../context/keymap"
 import { useTheme, useThemes } from "../context/theme"
 import { entries, filter, flatMap, groupBy, pipe } from "remeda"
 import { batch, createEffect, createMemo, createSignal, For, Show, type JSX, on, onCleanup } from "solid-js"
 import { createStore } from "solid-js/store"
-import { useTerminalDimensions } from "@opentui/solid"
+import { useRenderer, useTerminalDimensions } from "@opentui/solid"
 import * as fuzzysort from "fuzzysort"
 import { isDeepEqual } from "remeda"
 import { useDialog, type DialogContext } from "./dialog"
@@ -100,6 +100,7 @@ export function DialogSelect<T>(props: DialogSelectProps<T>) {
   const mode = themes.mode
   const config = useConfig().data
   const scrollAcceleration = createMemo(() => getScrollAcceleration(config))
+  const renderer = useRenderer()
 
   const [store, setStore] = createStore({
     selected: 0,
@@ -110,7 +111,18 @@ export function DialogSelect<T>(props: DialogSelectProps<T>) {
   const actionFocused = createMemo(() => focusedAction() !== undefined)
   let selection: { value: T; category?: string } | undefined
   let resetSelection = false
-  let visibilityGeneration = 0
+  let pendingScroll: (() => void) | undefined
+
+  function scrollAfterLayout(center: boolean, value: T) {
+    if (pendingScroll) renderer.off(CliRenderEvents.FRAME, pendingScroll)
+    pendingScroll = () => {
+      pendingScroll = undefined
+      if (!isDeepEqual(selected()?.value, value)) return
+      scrollToSelection(center)
+    }
+    renderer.once(CliRenderEvents.FRAME, pendingScroll)
+    renderer.requestRender()
+  }
 
   createEffect(
     on(
@@ -228,7 +240,7 @@ export function DialogSelect<T>(props: DialogSelectProps<T>) {
     on(
       () => props.options,
       () => {
-        if (!props.preserveSelection) {
+        if (!props.preserveSelection && props.current === undefined) {
           const count = flat().length
           if (count === 0) return
           const next = reconcileSelection(store.selected, count)
@@ -264,16 +276,8 @@ export function DialogSelect<T>(props: DialogSelectProps<T>) {
           setStore("selected", index)
           selection = option
           if (!moved) return
-          const value = option.value
-          const generation = ++visibilityGeneration
-          requestAnimationFrame(() => {
-            requestAnimationFrame(() => {
-              if (generation !== visibilityGeneration) return
-              if (!props.preserveSelection || store.filter.length > 0) return
-              if (!isDeepEqual(selected()?.value, value)) return
-              scrollToSelection(false)
-            })
-          })
+          if ((!props.preserveSelection && props.current === undefined) || store.filter.length > 0) return
+          scrollAfterLayout(false, option.value)
           return
         }
         const next = reconcileSelection(store.selected, flat().length)
@@ -284,22 +288,26 @@ export function DialogSelect<T>(props: DialogSelectProps<T>) {
     ),
   )
   onCleanup(() => {
-    visibilityGeneration++
+    if (!pendingScroll) return
+    renderer.off(CliRenderEvents.FRAME, pendingScroll)
+    pendingScroll = undefined
   })
 
   createEffect(
     on([() => store.filter, () => props.current], ([filter, current]) => {
       if (filter.length > 0) resetSelection = true
-      setTimeout(() => {
-        if (filter.length > 0) {
-          moveTo(0, true, false)
-        } else if (current && props.focusCurrent !== false) {
-          const currentIndex = flat().findIndex((opt) => isDeepEqual(opt.value, current))
-          if (currentIndex >= 0) {
-            moveTo(currentIndex, true)
-          }
-        }
-      }, 0)
+      if (filter.length > 0) {
+        const option = flat()[0]
+        if (!option) return
+        moveTo(0, true, false)
+        scrollAfterLayout(true, option.value)
+        return
+      }
+      if (!current || props.focusCurrent === false) return
+      const currentIndex = flat().findIndex((opt) => isDeepEqual(opt.value, current))
+      if (currentIndex < 0) return
+      moveTo(currentIndex, true)
+      scrollAfterLayout(true, current)
     }),
   )
 

packages/tui/src/util/session.ts

@@ -1,8 +1,16 @@
-import type { ModelInfo, SessionMessageAssistant, SessionMessageInfo } from "@opencode-ai/client"
+import type { ModelInfo, SessionInfo, SessionMessageAssistant, SessionMessageInfo } from "@opencode-ai/client"
 import { Locale } from "./locale"
 
-export function isDefaultTitle(title: string) {
-  return /^(New session - |Child session - )\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(title)
+export function isDefaultTitle(title?: string) {
+  return (
+    title === undefined || /^(New session - |Child session - )\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(title)
+  )
+}
+
+export function sessionTitle(session: Pick<SessionInfo, "parentID" | "time" | "title">) {
+  return (
+    session.title ?? `${session.parentID ? "Child" : "New"} session - ${new Date(session.time.created).toISOString()}`
+  )
 }
 
 export function lastAssistantWithUsage(messages: ReadonlyArray<SessionMessageInfo>, boundary?: string) {

packages/tui/test/cli/tui/command-palette.test.tsx

@@ -73,16 +73,12 @@ test("searches settings globally and opens the matching setting", async () => {
     expect(app.captureCharFrame()).not.toContain("Animations")
     await app.waitFor(() => app.renderer.currentFocusedEditor instanceof InputRenderable)
 
-    for (const key of "side") app.mockInput.pressKey(key)
-    await app.waitForFrame((frame) => frame.includes("Sidebar"))
-    expect(app.captureCharFrame()).not.toContain("New session")
-    expect(app.captureCharFrame()).not.toContain("Switch model")
-    expect(app.captureCharFrame()).not.toContain("Markdown")
-
+    app.mockInput.pressArrow("down")
+    for (const key of "sounds") app.mockInput.pressKey(key)
     app.mockInput.pressEnter()
-    await app.waitForFrame((frame) => frame.includes("Settings") && frame.includes("Color mode"))
+    await app.waitForFrame((frame) => frame.includes("Settings") && frame.includes("Sounds"))
     app.mockInput.pressEnter()
-    await app.waitFor(() => current.session?.sidebar === "hide")
+    await app.waitFor(() => current.attention?.sound === false)
   } finally {
     app.renderer.destroy()
   }

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

@@ -79,7 +79,7 @@ async function renderSelect(
   return app
 }
 
-async function mountSelect(root: string, initial: DialogSelectOption<string>[]) {
+async function mountSelect(root: string, initial: DialogSelectOption<string>[], current?: string) {
   const state = path.join(root, "state")
   await mkdir(state, { recursive: true })
   const config = createTuiResolvedConfig()
@@ -114,6 +114,7 @@ async function mountSelect(root: string, initial: DialogSelectOption<string>[])
           <DialogSelect
             title="Mutable options"
             options={options()}
+            current={current}
             onMove={(option) => moved.push(option.value)}
             onSelect={(option) => selected.push(option.value)}
           />
@@ -309,3 +310,20 @@ test("keeps the cursor index while options are temporarily empty", async () => {
     select.app.renderer.destroy()
   }
 })
+
+test("keeps the current option selected when options reorder", async () => {
+  await using tmp = await tmpdir()
+  const options = ["first", "current", "third"].map((value) => ({ title: value, value }))
+  const select = await mountSelect(tmp.path, options, "current")
+
+  try {
+    select.replaceOptions([options[1], options[2], options[0]])
+    await select.app.waitForFrame((frame) => frame.indexOf("current") < frame.indexOf("third"))
+    select.app.mockInput.pressEnter()
+    await select.app.waitFor(() => select.selected.length === 1)
+
+    expect(select.selected).toEqual(["current"])
+  } finally {
+    select.app.renderer.destroy()
+  }
+})

packages/tui/test/config.test.tsx

@@ -110,8 +110,6 @@ test("navigates session tabs with leader arrows", () => {
   expect(config.keybinds.get("session.tab.previous")).toMatchObject([
     { key: "ctrl+shift+tab,<leader>left,alt+shift+[" },
   ])
-  expect(config.keybinds.get("session.tab.history.back")).toMatchObject([{ key: "ctrl+o" }])
-  expect(config.keybinds.get("session.tab.history.forward")).toMatchObject([{ key: "ctrl+i" }])
   expect(config.keybinds.get("session.tab.next_unread")).toMatchObject([{ key: "<leader>down" }])
   expect(config.keybinds.get("session.tab.previous_unread")).toMatchObject([{ key: "<leader>up" }])
 })

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

@@ -11,6 +11,7 @@ import { DataProvider } 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 { TestTuiContexts } from "../fixture/tui-environment"
@@ -63,6 +64,7 @@ async function renderSessionTabs(initialSessionID: string) {
   return {
     tabs,
     route,
+    state,
     emit: (event: OpenCodeEvent) => events.emit({ ...event, location: { directory } }),
     destroy() {
       app.renderer.destroy()
@@ -71,6 +73,21 @@ async function renderSessionTabs(initialSessionID: string) {
   }
 }
 
+test("stores session tabs globally by default", async () => {
+  const setup = await renderSessionTabs("first")
+
+  try {
+    const file = path.join(setup.state, "test", "tui", "tabs.json")
+    await wait(() => Bun.file(file).size > 0)
+    expect(await Bun.file(file).json()).toEqual({
+      global: { tabs: [{ sessionID: "first" }], unread: {} },
+      cwd: {},
+    })
+  } finally {
+    setup.destroy()
+  }
+})
+
 test("user prompt admissions pulse an already-busy background tab", async () => {
   const setup = await renderSessionTabs("background")
   const admitted = (sessionID: string, inputID: string): OpenCodeEvent => ({
@@ -105,9 +122,7 @@ test("user prompt admissions pulse an already-busy background tab", async () =>
     expect(setup.tabs.status("background").promptPulse).toBe(0)
 
     setup.emit(admitted("background", "msg_1"))
-    await wait(
-      () => setup.tabs.status("background").promptPulse === 1 && setup.tabs.status("background").busy,
-    )
+    await wait(() => setup.tabs.status("background").promptPulse === 1 && setup.tabs.status("background").busy)
 
     setup.emit(admitted("background", "msg_2"))
     await wait(() => setup.tabs.status("background").promptPulse === 2)
@@ -142,11 +157,11 @@ test("tracks a temporary new session tab across close and creation", async () =>
     setup.route.navigate({ type: "home" })
     await wait(() => setup.tabs.newTab())
     setup.route.navigate({ type: "session", sessionID: "third" })
-    await wait(
-      () => setup.tabs.current() === "third" && setup.tabs.tabs().some((tab) => tab.sessionID === "third"),
-    )
+    expect(setup.tabs.newTab()).toBe(true)
+    await wait(() => setup.tabs.current() === "third" && setup.tabs.tabs().some((tab) => tab.sessionID === "third"))
 
     expect(setup.tabs.newTab()).toBe(false)
+    expect(setup.tabs.tabs().find((tab) => tab.sessionID === "third")?.title).toBe(NEW_SESSION_TAB_TITLE)
   } finally {
     setup.destroy()
   }

packages/tui/test/util/session.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test"
 import type { SessionMessageInfo } from "@opencode-ai/client"
-import { isDefaultTitle, lastAssistantWithUsage } from "../../src/util/session"
+import { isDefaultTitle, lastAssistantWithUsage, sessionTitle } from "../../src/util/session"
 
 const assistant = (id: string, input: number): SessionMessageInfo => ({
   id,
@@ -14,11 +14,21 @@ const assistant = (id: string, input: number): SessionMessageInfo => ({
 
 describe("util.session", () => {
   test("recognizes generated parent and child titles", () => {
+    expect(isDefaultTitle(undefined)).toBeTrue()
     expect(isDefaultTitle("New session - 2026-06-06T12:34:56.789Z")).toBeTrue()
     expect(isDefaultTitle("Child session - 2026-06-06T12:34:56.789Z")).toBeTrue()
     expect(isDefaultTitle("New session - custom")).toBeFalse()
   })
 
+  test("derives display-only titles for untitled sessions", () => {
+    expect(sessionTitle({ title: undefined, time: { created: 0, updated: 0 } })).toBe(
+      "New session - 1970-01-01T00:00:00.000Z",
+    )
+    expect(sessionTitle({ title: undefined, parentID: "ses_parent", time: { created: 0, updated: 0 } })).toBe(
+      "Child session - 1970-01-01T00:00:00.000Z",
+    )
+  })
+
   test("tracks usage across undo and redo boundaries", () => {
     const messages = [assistant("msg_z", 10), assistant("msg_a", 30)]