test(tui): defer diff hunk coverage

packages/ai/src/provider-package.ts

@@ -1,12 +1,10 @@
 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?: {
     readonly context: number
-    readonly input?: number
     readonly output: number
   }
 }

packages/ai/src/providers/xai.ts

@@ -1,62 +1,38 @@
 import { AuthOptions, type ProviderAuthOption } from "../route/auth-options"
-import { Route, type RouteDefaultsInput } from "../route/client"
-import { Endpoint } from "../route/endpoint"
-import { HttpOptions, ProviderID, type ModelID, type ProviderOptions } from "../schema"
+import type { RouteDefaultsInput } from "../route/client"
+import { HttpOptions, ProviderID, type ModelID } from "../schema"
 import * as OpenAICompatibleProfiles from "./openai-compatible-profile"
 import * as OpenAICompatibleChat from "../protocols/openai-compatible-chat"
-import * as OpenAIChat from "../protocols/openai-chat"
 import * as OpenAIResponses from "../protocols/openai-responses"
 import { XAIImages } from "../protocols/xai-images"
-import type { OpenAIOptionsInput } from "./openai-options"
+import type { OpenAIProviderOptionsInput } from "./openai-options"
 import type { ProviderPackage } from "../provider-package"
 
 export const id = ProviderID.make("xai")
 
-export type XAIProviderOptionsInput = ProviderOptions & {
-  readonly xai?: OpenAIOptionsInput
-}
-
 export type ModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
   ProviderAuthOption<"optional"> & {
     readonly baseURL?: string
-    readonly providerOptions?: XAIProviderOptionsInput
+    readonly providerOptions?: OpenAIProviderOptionsInput
   }
 
 export interface Settings extends ProviderPackage.Settings {
   readonly apiKey?: string
   readonly baseURL?: string
-  readonly providerOptions?: XAIProviderOptionsInput
+  readonly providerOptions?: OpenAIProviderOptionsInput
 }
 
 export type { XAIImageOptions } from "../protocols/xai-images"
 
-const responsesRoute = Route.make({
-  id: "openai-responses",
-  provider: id,
-  providerMetadataKey: "xai",
-  protocol: OpenAIResponses.protocol,
-  endpoint: Endpoint.path("/responses", { baseURL: OpenAICompatibleProfiles.profiles.xai.baseURL }),
-  transport: OpenAIResponses.httpTransport,
-  defaults: { providerOptions: { xai: { store: false } } },
-})
-
-const chatRoute = Route.make({
-  id: "openai-compatible-chat",
-  provider: id,
-  providerMetadataKey: "xai",
-  protocol: OpenAIChat.protocol,
-  endpoint: Endpoint.path("/chat/completions", { baseURL: OpenAICompatibleProfiles.profiles.xai.baseURL }),
-  transport: OpenAICompatibleChat.route.transport,
-})
-
-export const routes = [responsesRoute, chatRoute]
+export const routes = [OpenAIResponses.route, OpenAICompatibleChat.route]
 
 const auth = (options: ProviderAuthOption<"optional">) => AuthOptions.bearer(options, "XAI_API_KEY")
 
 const configuredResponsesRoute = (input: ModelOptions) => {
   const { apiKey: _, auth: _auth, baseURL, ...rest } = input
-  return responsesRoute.with({
+  return OpenAIResponses.route.with({
     ...rest,
+    provider: id,
     endpoint: { baseURL: baseURL ?? OpenAICompatibleProfiles.profiles.xai.baseURL },
     auth: auth(input),
   })
@@ -64,8 +40,9 @@ const configuredResponsesRoute = (input: ModelOptions) => {
 
 const configuredChatRoute = (input: ModelOptions) => {
   const { apiKey: _, auth: _auth, baseURL, ...rest } = input
-  return chatRoute.with({
+  return OpenAICompatibleChat.route.with({
     ...rest,
+    provider: id,
     endpoint: { baseURL: baseURL ?? OpenAICompatibleProfiles.profiles.xai.baseURL },
     auth: auth(input),
   })
@@ -74,8 +51,8 @@ const configuredChatRoute = (input: ModelOptions) => {
 export const configure = (input: ModelOptions = {}) => {
   const responsesRoute = configuredResponsesRoute(input)
   const chatRoute = configuredChatRoute(input)
-  const responses = (modelID: string | ModelID) => responsesRoute.model<XAIProviderOptionsInput>({ id: modelID })
-  const chat = (modelID: string | ModelID) => chatRoute.model<XAIProviderOptionsInput>({ id: modelID })
+  const responses = (modelID: string | ModelID) => responsesRoute.model<OpenAIProviderOptionsInput>({ id: modelID })
+  const chat = (modelID: string | ModelID) => chatRoute.model<OpenAIProviderOptionsInput>({ id: modelID })
   const image = (modelID: string | ModelID) =>
     XAIImages.model({
       id: modelID,
@@ -95,7 +72,7 @@ export const configure = (input: ModelOptions = {}) => {
 }
 
 export const provider = configure()
-export const model: ProviderPackage.Definition<Settings, XAIProviderOptionsInput>["model"] = (modelID, settings) =>
+export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) =>
   configure({
     apiKey: settings.apiKey,
     baseURL: settings.baseURL,

packages/ai/src/route/client.ts

@@ -5,7 +5,7 @@ import { Endpoint, type EndpointPatch } from "./endpoint"
 import { RequestExecutor } from "./executor"
 import { Framing } from "./framing"
 import { HttpTransport } from "./transport"
-import type { HttpRequestTransform, Transport, TransportRuntime } from "./transport"
+import type { Transport, TransportRuntime } from "./transport"
 import { WebSocketExecutor } from "./transport"
 import type { Protocol } from "./protocol"
 import { applyCachePolicy } from "../cache-policy"
@@ -46,11 +46,7 @@ export interface Route<Body, Prepared = unknown> {
   readonly body: RouteBody<Body>
   readonly with: (patch: RoutePatch<Body, Prepared>) => Route<Body, Prepared>
   readonly model: <Options extends ProviderOptions = ProviderOptions>(input: RouteMappedModelInput) => Model<Options>
-  readonly prepareTransport: (
-    body: Body,
-    request: LLMRequest,
-    options?: StreamOptions,
-  ) => Effect.Effect<Prepared, LLMError>
+  readonly prepareTransport: (body: Body, request: LLMRequest) => Effect.Effect<Prepared, LLMError>
   readonly streamPrepared: (
     prepared: Prepared,
     request: LLMRequest,
@@ -149,16 +145,12 @@ export interface Interface {
   readonly generate: GenerateMethod
 }
 
-export interface StreamOptions {
-  readonly transform?: HttpRequestTransform
-}
-
 export interface StreamMethod {
-  (request: LLMRequest, options?: StreamOptions): Stream.Stream<LLMEvent, LLMError>
+  (request: LLMRequest): Stream.Stream<LLMEvent, LLMError>
 }
 
 export interface GenerateMethod {
-  (request: LLMRequest, options?: StreamOptions): Effect.Effect<LLMResponse, LLMError>
+  (request: LLMRequest): Effect.Effect<LLMResponse, LLMError>
 }
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/LLMClient") {}
@@ -294,7 +286,7 @@ function makeFromTransport<Body, Prepared, Frame, Event, State>(
       },
       model: <Options extends ProviderOptions = ProviderOptions>(input: RouteMappedModelInput) =>
         makeRouteModel<Options>(route, input),
-      prepareTransport: (body, request, options) =>
+      prepareTransport: (body, request) =>
         routeInput.transport.prepare({
           body,
           request,
@@ -302,7 +294,6 @@ function makeFromTransport<Body, Prepared, Frame, Event, State>(
           auth: routeInput.auth ?? Auth.none,
           encodeBody,
           headers: routeInput.headers,
-          transform: options?.transform,
         }),
       streamPrepared: (prepared: Prepared, request: LLMRequest, runtime: TransportRuntime) => {
         const route = `${request.model.provider}/${request.model.route.id}`
@@ -368,14 +359,14 @@ export function make<Body, Prepared, Frame, Event, State>(
   })
 }
 
-const compile = Effect.fn("LLM.compile")(function* (request: LLMRequest, options?: StreamOptions) {
+const compile = Effect.fn("LLM.compile")(function* (request: LLMRequest) {
   const resolved = applyCachePolicy(resolveRequestOptions(request))
   const route = resolved.model.route
 
   const body = yield* route.body
     .from(resolved)
     .pipe(Effect.flatMap(ProviderShared.validateWith(Schema.decodeUnknownEffect(route.body.schema))))
-  const prepared = yield* route.prepareTransport(body, resolved, options)
+  const prepared = yield* route.prepareTransport(body, resolved)
 
   return {
     request: resolved,
@@ -398,17 +389,17 @@ export const compileRequest = Effect.fn("LLM.compileRequest")(function* (request
   }
 })
 
-const streamRequestWith = (runtime: TransportRuntime) => (request: LLMRequest, options?: StreamOptions) =>
+const streamRequestWith = (runtime: TransportRuntime) => (request: LLMRequest) =>
   Stream.unwrap(
     Effect.gen(function* () {
-      const compiled = yield* compile(request, options)
+      const compiled = yield* compile(request)
       return compiled.route.streamPrepared(compiled.prepared, compiled.request, runtime)
     }),
   )
 
 const generateWith = (stream: Interface["stream"]) =>
-  Effect.fn("LLM.generate")(function* (request: LLMRequest, options?: StreamOptions) {
-    const state = yield* stream(request, options).pipe(Stream.runFold(LLMResponse.empty, LLMResponse.reduce))
+  Effect.fn("LLM.generate")(function* (request: LLMRequest) {
+    const state = yield* stream(request).pipe(Stream.runFold(LLMResponse.empty, LLMResponse.reduce))
     const response = LLMResponse.complete(state)
     if (response) return response
     return yield* ProviderShared.eventError(
@@ -417,24 +408,24 @@ const generateWith = (stream: Interface["stream"]) =>
     )
   })
 
-export function stream(request: LLMRequest, options?: StreamOptions): Stream.Stream<LLMEvent, LLMError> {
+export function stream(request: LLMRequest): Stream.Stream<LLMEvent, LLMError> {
   return Stream.unwrap(
     Effect.gen(function* () {
-      return (yield* Service).stream(request, options)
+      return (yield* Service).stream(request)
     }),
   ) as Stream.Stream<LLMEvent, LLMError>
 }
 
-export function generate(request: LLMRequest, options?: StreamOptions): Effect.Effect<LLMResponse, LLMError> {
+export function generate(request: LLMRequest): Effect.Effect<LLMResponse, LLMError> {
   return Effect.gen(function* () {
-    return yield* (yield* Service).generate(request, options)
+    return yield* (yield* Service).generate(request)
   }) as Effect.Effect<LLMResponse, LLMError>
 }
 
-export const streamRequest = (request: LLMRequest, options?: StreamOptions) =>
+export const streamRequest = (request: LLMRequest) =>
   Stream.unwrap(
     Effect.gen(function* () {
-      return (yield* Service).stream(request, options)
+      return (yield* Service).stream(request)
     }),
   )
 

packages/ai/src/route/index.ts

@@ -8,7 +8,6 @@ export type {
   AnyRoute,
   Interface as LLMClientShape,
   Service as LLMClientService,
-  StreamOptions,
 } from "./client"
 export * from "./executor"
 export { Auth } from "./auth"
@@ -23,4 +22,4 @@ export type { ApiKeyMode, AuthOverride, ProviderAuthOption } from "./auth-option
 export type { Definition as EndpointFn, EndpointInput } from "./endpoint"
 export type { Definition as FramingDef } from "./framing"
 export type { Protocol as ProtocolDef } from "./protocol"
-export type { HttpRequest, HttpRequestTransform, Transport as TransportDef, TransportRuntime } from "./transport"
+export type { Transport as TransportDef, TransportRuntime } from "./transport"

packages/ai/src/route/transport/http.ts

@@ -120,19 +120,14 @@ export const httpJson = <Body, Frame>(input: HttpJsonInput<Body, Frame>): HttpJs
   id: "http-json",
   with: (patch) => httpJson({ ...input, ...patch }),
   prepare: (prepareInput) =>
-    Effect.gen(function* () {
-      const parts = yield* jsonRequestParts({ ...prepareInput })
-      const request = { url: parts.url, method: "POST", headers: { ...parts.headers }, body: parts.bodyText }
-      yield* (prepareInput.transform?.(request) ?? Effect.void)
-      return {
-        request: ProviderShared.jsonPost({
-          url: request.url,
-          body: request.body ?? "",
-          headers: Headers.fromInput(request.headers),
-        }),
+    jsonRequestParts({
+      ...prepareInput,
+    }).pipe(
+      Effect.map((parts) => ({
+        request: ProviderShared.jsonPost({ url: parts.url, body: parts.bodyText, headers: parts.headers }),
         framing: input.framing,
-      }
-    }),
+      })),
+    ),
   frames: (prepared, request, runtime) =>
     Stream.unwrap(
       runtime.http

packages/ai/src/route/transport/index.ts

@@ -10,15 +10,6 @@ export interface TransportRuntime {
   readonly webSocket?: WebSocketExecutorInterface
 }
 
-export interface HttpRequest {
-  url: string
-  readonly method: string
-  headers: Record<string, string>
-  body: string | undefined
-}
-
-export type HttpRequestTransform = (request: HttpRequest) => Effect.Effect<void>
-
 export interface Transport<Body, Prepared, Frame> {
   readonly id: string
   readonly prepare: (input: TransportPrepareInput<Body>) => Effect.Effect<Prepared, LLMError>
@@ -36,7 +27,6 @@ export interface TransportPrepareInput<Body> {
   readonly auth: Auth.Definition
   readonly encodeBody: (body: Body) => string
   readonly headers?: (input: { readonly request: LLMRequest }) => Record<string, string>
-  readonly transform?: HttpRequestTransform
 }
 
 export * as HttpTransport from "./http"

packages/ai/src/schema/options.ts

@@ -123,7 +123,6 @@ export const mergeGenerationOptions = (...items: ReadonlyArray<GenerationOptions
 
 export class ModelLimits extends Schema.Class<ModelLimits>("LLM.ModelLimits")({
   context: Schema.optional(Schema.Number),
-  input: Schema.optional(Schema.Number),
   output: Schema.optional(Schema.Number),
 }) {}
 

packages/ai/test/compile.test.ts

@@ -137,40 +137,6 @@ describe("request option precedence", () => {
     ),
   )
 
-  it.effect("transforms the final HTTP request after serialization and authentication", () =>
-    LLMClient.generate(
-      LLM.request({
-        model: OpenAIChat.route
-          .with({ endpoint: { baseURL: "https://api.openai.test/v1/" }, auth: Auth.bearer("fresh-key") })
-          .model({ id: "gpt-4o-mini" }),
-        prompt: "Say hello.",
-      }),
-      {
-        transform: (request) =>
-          Effect.sync(() => {
-            expect(request.headers.authorization).toBe("Bearer fresh-key")
-            request.url = "https://proxy.test/v1/chat/completions"
-            request.headers["x-plugin"] = "transformed"
-            request.body = JSON.stringify({ transformed: true })
-          }),
-      },
-    ).pipe(
-      Effect.provide(
-        dynamicResponse((input) =>
-          Effect.gen(function* () {
-            const web = yield* HttpClientRequest.toWeb(input.request).pipe(Effect.orDie)
-            expect(web.url).toBe("https://proxy.test/v1/chat/completions")
-            expect(web.headers.get("x-plugin")).toBe("transformed")
-            expect(decodeJson(input.text)).toEqual({ transformed: true })
-            return input.respond(sseEvents(deltaChunk({}, "stop")), {
-              headers: { "content-type": "text/event-stream" },
-            })
-          }),
-        ),
-      ),
-    ),
-  )
-
   it.effect("rejects raw body overlays for protocol-owned roots", () =>
     Effect.gen(function* () {
       const model = OpenAIChat.route

packages/ai/test/provider-options/xai.types.ts

@@ -3,11 +3,11 @@ import { XAI } from "../../src/providers"
 
 const model = XAI.provider.model("grok-4")
 
-LLM.request({ model, prompt: "Hello", providerOptions: { xai: { reasoningEffort: "high" } } })
+LLM.request({ model, prompt: "Hello", providerOptions: { openai: { reasoningEffort: "high" } } })
 
 LLM.request({
   model,
   prompt: "Hello",
   // @ts-expect-error xAI's OpenAI-compatible reasoning effort must be a string.
-  providerOptions: { xai: { reasoningEffort: true } },
+  providerOptions: { openai: { reasoningEffort: true } },
 })

packages/ai/test/provider-package.test.ts

@@ -47,7 +47,7 @@ describe("provider package entrypoints", () => {
     })
     const xai = XAI.model("grok-4", {
       ...settings,
-      providerOptions: { xai: { reasoningEffort: "high" } },
+      providerOptions: { openai: { reasoningEffort: "high" } },
     })
 
     for (const selected of [openrouter, xai]) {
@@ -57,7 +57,7 @@ describe("provider package entrypoints", () => {
       expect(selected.route.defaults.limits).toEqual(settings.limits)
     }
     expect(openrouter.route.defaults.providerOptions).toEqual({ openrouter: { usage: true } })
-    expect(xai.route.defaults.providerOptions).toMatchObject({ xai: { reasoningEffort: "high", store: false } })
+    expect(xai.route.defaults.providerOptions).toEqual({ openai: { reasoningEffort: "high", store: false } })
   })
 
   test("maps package settings onto the executable model", () => {

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

@@ -11,7 +11,6 @@ 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.
@@ -55,10 +54,7 @@ export function TabNavItem(props: {
     if (!session) return
     return projectForSession(session, serverCtx()?.projects.list() ?? [])
   })
-  const title = createMemo(() => {
-    const session = props.session()
-    return session ? sessionTitle(session.title, session.parentID) : props.fallbackTitle
-  })
+  const title = createMemo(() => props.session()?.title ?? props.fallbackTitle)
 
   const projectName = createMemo(() => {
     const session = props.session()
@@ -147,7 +143,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(() => {
@@ -306,7 +302,7 @@ export function TabNavItem(props: {
       }}
       data={{
         projectName: projectName(),
-        title: title(),
+        title: props.session()?.title,
         path: previewPath(),
         serverName: serverLabel(),
       }}

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

@@ -7,7 +7,6 @@ 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">
 
@@ -24,7 +23,7 @@ export function createHomeSessionSearchController(home: HomeController, sessions
     if (!value) return []
     return sessions.data
       .searchRecords()
-      .filter((record) => `${sessionTitle(record.session.title)} ${record.projectName}`.toLowerCase().includes(value))
+      .filter((record) => `${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, props.session.parentID)
+  const title = () => sessionTitle(props.session.title)
 
   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, props.session.parentID)}
+                  value={sessionTitle(props.session.title)}
                   gutter={10}
                   class="min-w-0 w-full"
                 >

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

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

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

@@ -1,11 +0,0 @@
-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, parentID?: string) {
-  if (!title) return parentID ? "Child session" : "New session"
+export function sessionTitle(title?: string) {
+  if (!title) return title
   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 ?? `${input.parentID ? "Child" : "New"} session - ${new Date(input.time.created).toISOString()}`,
+    title: input.title,
     agent: input.agent,
     model: input.model,
     version: "",

packages/cli/src/acp/service.ts

@@ -213,9 +213,7 @@ export function make(input: { readonly client: OpenCodeClient; readonly connecti
         sessions: page.data.map((session) => ({
           sessionId: session.id,
           cwd: session.location.directory,
-          title:
-            session.title ??
-            `${session.parentID ? "Child" : "New"} session - ${new Date(session.time.created).toISOString()}`,
+          title: session.title,
           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": "e43ed7e2-b9fc-4178-beae-3646e4a976e1",
+  "id": "db37a97f-9b5e-4c87-be8b-4feace35136c",
   "prevIds": [
-    "db37a97f-9b5e-4c87-be8b-4feace35136c"
+    "a4ba73b4-21bc-41ab-a415-94e2ca38d798"
   ],
   "ddl": [
     {
@@ -1302,7 +1302,7 @@
     },
     {
       "type": "text",
-      "notNull": false,
+      "notNull": true,
       "autoincrement": false,
       "default": null,
       "generated": null,

packages/core/src/aisdk-native.ts

@@ -1,69 +0,0 @@
-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),
-          ...mapXAIOptions(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 mapXAIOptions(settings: Readonly<Record<string, unknown>>) {
-  const options = {
-    ...(typeof settings.reasoningEffort === "string" ? { reasoningEffort: settings.reasoningEffort } : {}),
-    ...(typeof settings.store === "boolean" ? { store: settings.store } : {}),
-    ...(typeof settings.promptCacheKey === "string" ? { promptCacheKey: settings.promptCacheKey } : {}),
-  }
-  if (Object.keys(options).length === 0) return {}
-  return { providerOptions: { xai: options } }
-}
-
-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/aisdk.ts

@@ -332,7 +332,7 @@ function modelFromLanguage(info: Info, language: LanguageModelV3) {
               body: projected.body === undefined ? undefined : { ...projected.body },
               headers: info.headers,
             },
-      limits: { context: info.limit.context, input: info.limit.input, output: info.limit.output },
+      limits: { context: info.limit.context, output: info.limit.output },
       providerOptions,
     },
     body: {

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

@@ -58,6 +58,5 @@ 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

@@ -1,14 +0,0 @@
-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,
+          \`title\` text NOT NULL,
           \`version\` text NOT NULL,
           \`share_url\` text,
           \`summary_additions\` integer,

packages/core/src/git.ts

@@ -201,7 +201,7 @@ const layer = Layer.effect(
       locks.withLock(repository.gitDirectory)(effect)
 
     const discover = Effect.fn("Git.repo.discover")(function* (input: AbsolutePath) {
-      const dotgit = yield* fs.up({ targets: [".git"], start: input, mode: "first" }).pipe(
+      const dotgit = yield* fs.up({ targets: [".git"], start: input }).pipe(
         Effect.map((matches) => matches[0]),
         Effect.catch(() => Effect.succeed(undefined)),
       )

packages/core/src/model-resolver.ts

@@ -12,12 +12,12 @@ 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"
 import { Capabilities, ID, Info, Ref, VariantID } from "./model"
 import { Npm } from "@opencode-ai/util/npm"
+import { OpenAICodex } from "./plugin/provider/openai-codex"
 import { Provider } from "./provider"
 
 export class VariantUnavailableError extends Schema.TaggedErrorClass<VariantUnavailableError>()(
@@ -81,7 +81,7 @@ const withDefaults = (model: Info, route: AnyRoute) =>
     headers: providerHeaders(model),
     providerOptions: providerOptions(model),
     http: model.body === undefined ? undefined : { body: model.body },
-    limits: { context: model.limit.context, input: model.limit.input, output: model.limit.output },
+    limits: { context: model.limit.context, output: model.limit.output },
   })
 
 const providerHeaders = (model: Info) => {
@@ -152,7 +152,12 @@ export const fromCatalogModel = (
   const packageName = Provider.packageName(resolved.package)
   const key = apiKey(resolved, credential)
 
+  if (OpenAICodex.isChatGPT(credential) && !Provider.isAISDK(resolved.package) && isNativeOpenAI(resolved.package)) {
+    return Effect.succeed(codexModel(resolved, credential, key))
+  }
+
   if (Provider.isAISDK(resolved.package) && packageName === "@ai-sdk/openai") {
+    if (OpenAICodex.isChatGPT(credential)) return Effect.succeed(codexModel(resolved, credential, key))
     return Effect.succeed(
       withDefaults(resolved, OpenAIResponses.route)
         .with({ auth: key === undefined ? Auth.none : Auth.bearer(key) })
@@ -177,10 +182,7 @@ export const fromCatalogModel = (
         .model({ id: resolved.modelID ?? resolved.id, compatibility: resolved.compatibility }),
     )
   }
-  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 (Provider.isAISDK(resolved.package)) {
     if (!dependencies?.loadAISDK) return Effect.fail(unsupported(resolved))
     const runtime = produce(resolved, (draft) => {
       draft.settings = Provider.mergeOverlay(draft.settings, {
@@ -191,20 +193,20 @@ export const fromCatalogModel = (
     })
     return dependencies.loadAISDK(runtime).pipe(Effect.mapError(() => unsupported(resolved)))
   }
-  if (!native) return Effect.fail(unsupported(resolved))
+  if (!resolved.package) return Effect.fail(unsupported(resolved))
 
-  const specifier = native
+  const specifier = resolved.package
   return Effect.gen(function* () {
     const module = yield* (dependencies?.loadPackage ?? Provider.loadPackage)(specifier).pipe(
       Effect.mapError(() => unsupported(resolved)),
     )
-    const mapped = mapping?.settings ?? configured
+    const configured = { ...resolved.settings, ...credential?.metadata }
     const settings = {
-      ...(credential ? withoutNativeAuthSettings(mapped) : mapped),
+      ...(credential ? withoutNativeAuthSettings(configured) : configured),
       ...nativeCredentialSettings(specifier, credential),
       headers: resolved.headers,
       body: resolved.body,
-      limits: { context: resolved.limit.context, input: resolved.limit.input, output: resolved.limit.output },
+      limits: { context: resolved.limit.context, output: resolved.limit.output },
     }
     return yield* Effect.try({
       try: () => {
@@ -221,6 +223,10 @@ export const fromCatalogModel = (
   })
 }
 
+const isNativeOpenAI = (packageName: string | undefined) =>
+  packageName === "@opencode-ai/ai/providers/openai" ||
+  packageName?.startsWith("@opencode-ai/ai/providers/openai/") === true
+
 const nativeCredentialSettings = (specifier: string, credential: Credential.Value | undefined) => {
   if (!credential) return {}
   if (credential.type === "key") return { apiKey: credential.key }
@@ -242,6 +248,22 @@ const withoutNativeAuthSettings = (settings: Record<string, unknown>) => {
   return rest
 }
 
+const codexModel = (
+  model: Info,
+  credential: Credential.Value | undefined,
+  key: ReturnType<typeof Auth.value> | undefined,
+) => {
+  const account = OpenAICodex.accountID(credential)
+  return withDefaults(model, OpenAIResponses.route)
+    .with({
+      endpoint: { baseURL: OpenAICodex.baseURL },
+      auth: (key === undefined ? Auth.none : Auth.bearer(key)).andThen(
+        account === undefined ? Auth.none : Auth.headers({ "chatgpt-account-id": account }),
+      ),
+    })
+    .model({ id: model.modelID ?? model.id, compatibility: model.compatibility })
+}
+
 const unsupported = (model: Info) =>
   new UnsupportedPackageError({
     providerID: model.providerID,

packages/core/src/plugin/agent.ts

@@ -11,6 +11,8 @@ import { Permission } from "../permission"
 // Combined output files written by the Shell service, e.g. `<data>/shell/<projectID>/<shellID>.out`.
 // Whitelisted so agents can read a command's full captured output without an external-directory prompt.
 const SHELL_OUTPUT_GLOB = path.join(Global.Path.data, "shell", "*", "*")
+const BUILD_SYSTEM =
+  "You are an AI coding agent. Help the user accomplish software engineering tasks by inspecting the workspace, making targeted changes, and using tools according to the configured permissions."
 
 const PROMPT_EXPLORE = `You are a file search specialist. You excel at thoroughly navigating and exploring codebases.
 

packages/core/src/plugin/provider/openai-codex.ts

@@ -0,0 +1,42 @@
+export * as OpenAICodex from "./openai-codex"
+
+// TEMPORARY SEAM (#34765): plugins have no hook into LLM route construction, so
+// Codex routing lives in ModelResolver and catalog filtering.
+// in OpenAIPlugin, sharing this module. Once the native provider packages land
+// (#33689/#33925/#34462) this should collapse into the native OpenAI provider.
+// The eligibility rules mirror V1's CodexAuthPlugin allowlist; models.dev has no
+// plan-eligibility data for OpenAI today, but models other vendors' subscriptions
+// as dedicated providers (e.g. zai-coding-plan) - a future openai-chatgpt-plan
+// provider entry could replace the hardcoded rules with catalog data.
+
+/** ChatGPT-plan requests must target the codex backend instead of the public API. */
+export const baseURL = "https://chatgpt.com/backend-api/codex"
+
+const methodIDs: readonly string[] = ["chatgpt-browser", "chatgpt-headless"]
+
+/** Structural credential shape so both core and plugin-facing credential types fit. */
+type CredentialLike = {
+  readonly type: string
+  readonly methodID?: string
+  readonly metadata?: Record<string, unknown> | undefined
+}
+
+export const isChatGPT = (credential: CredentialLike | undefined) =>
+  credential?.type === "oauth" && credential.methodID !== undefined && methodIDs.includes(credential.methodID)
+
+export const accountID = (credential: CredentialLike | undefined) => {
+  if (!isChatGPT(credential)) return undefined
+  const value = credential?.metadata?.accountID
+  return typeof value === "string" ? value : undefined
+}
+
+const allowed = new Set(["gpt-5.5", "gpt-5.3-codex-spark", "gpt-5.4", "gpt-5.4-mini"])
+const disallowed = new Set(["gpt-5.5-pro", "gpt-5.6"])
+
+/** Which API model ids a ChatGPT subscription may call through the codex backend. */
+export const eligible = (apiID: string) => {
+  if (allowed.has(apiID)) return true
+  if (disallowed.has(apiID)) return false
+  const match = apiID.match(/^gpt-(\d+\.\d+)/)
+  return match ? Number.parseFloat(match[1]) > 5.4 : false
+}

packages/core/src/plugin/provider/openai.ts

@@ -10,16 +10,14 @@ import { Model } from "../../model"
 import { OauthCallbackPage } from "../../oauth/page"
 import { Provider } from "../../provider"
 import type { PluginInternal } from "../internal"
+import { OpenAICodex } from "./openai-codex"
 
 const clientID = "app_EMoamEEZ73f0CkXaXp7hrann"
 const issuer = "https://auth.openai.com"
 const callbackPort = 1455
 const pollingSafetyMargin = 3000
-const codexBaseURL = "https://chatgpt.com/backend-api/codex"
 const browserMethodID = Integration.MethodID.make("chatgpt-browser")
 const headlessMethodID = Integration.MethodID.make("chatgpt-headless")
-const codexAllowed = new Set(["gpt-5.5", "gpt-5.3-codex-spark", "gpt-5.4", "gpt-5.4-mini"])
-const codexDisallowed = new Set(["gpt-5.5-pro", "gpt-5.6"])
 
 type Pkce = {
   verifier: string
@@ -166,18 +164,14 @@ export const OpenAIPlugin = define({
   effect: Effect.fn(function* (ctx) {
     const bus = yield* Bus.Service
     const loading = Semaphore.makeUnsafe(1)
-    let chatgpt: Credential.OAuth | undefined
+    let chatgpt = false
 
     const load = Effect.fn("OpenAIPlugin.load")(function* () {
       const connection = yield* ctx.integration.connection.active("openai")
       const credential = connection
         ? yield* ctx.integration.connection.resolve(connection).pipe(Effect.catch(() => Effect.succeed(undefined)))
         : undefined
-      chatgpt =
-        credential?.type === "oauth" &&
-        (credential.methodID === browserMethodID || credential.methodID === headlessMethodID)
-          ? credential
-          : undefined
+      chatgpt = OpenAICodex.isChatGPT(credential)
     })
 
     yield* ctx.integration.transform((draft) => {
@@ -189,19 +183,16 @@ export const OpenAIPlugin = define({
       for (const item of evt.provider.list()) {
         if (!Provider.isAISDK(item.provider.package)) continue
         if (Provider.packageName(item.provider.package) !== "@ai-sdk/openai") continue
-        evt.provider.update(item.provider.id, (provider) => {
-          provider.package = "@opencode-ai/ai/providers/openai"
+        if (!item.models.has(Model.ID.make("gpt-5-chat-latest"))) continue
+        evt.model.update(item.provider.id, Model.ID.make("gpt-5-chat-latest"), (model) => {
+          // OpenAIPlugin sends OpenAI models through Responses; this alias is a
+          // chat-completions-only model, so hide it only from OpenAI's catalog.
+          model.enabled = false
         })
       }
       if (!chatgpt) return
       const item = evt.provider.get(Provider.ID.openai)
       if (!item) return
-      item.provider.settings = Provider.mergeOverlay(item.provider.settings, { baseURL: codexBaseURL })
-      const account = chatgpt.metadata?.accountID
-      item.provider.headers = Provider.mergeHeaders(
-        item.provider.headers,
-        typeof account === "string" ? { "chatgpt-account-id": account } : undefined,
-      )
       for (const model of item.models.values()) {
         // ChatGPT-plan tokens only authorize codex-eligible models, and the
         // subscription covers usage, so hide the rest and zero the cost.
@@ -210,32 +201,14 @@ export const OpenAIPlugin = define({
             draft.enabled = false
             return
           }
-          const apiID = draft.modelID ?? draft.id
-          const match = apiID.match(/^gpt-(\d+\.\d+)/)
-          if (
-            !codexAllowed.has(apiID) &&
-            (codexDisallowed.has(apiID) || !match || Number.parseFloat(match[1]) <= 5.4)
-          ) {
+          if (!OpenAICodex.eligible(draft.modelID ?? draft.id)) {
             draft.enabled = false
             return
           }
           draft.cost = []
-          // Match Codex CLI so context consumption and subscription usage stay consistent between clients.
-          draft.limit = { ...draft.limit, context: 272_000, input: 272_000 }
         })
       }
     })
-    yield* ctx.session.hook("request", (evt) =>
-      Effect.sync(() => {
-        if (!chatgpt || evt.model.providerID !== Provider.ID.openai) return
-        const url = new URL(evt.url)
-        if (url.origin === "https://api.openai.com") {
-          evt.url = `${codexBaseURL}${url.pathname.replace(/^\/v1/, "")}${url.search}`
-        }
-        evt.headers.originator = "opencode"
-        evt.headers["session-id"] = evt.sessionID
-      }),
-    )
 
     const refresh = () => loading.withPermit(load().pipe(Effect.andThen(ctx.catalog.reload())))
     yield* bus.subscribe(Integration.Event.ConnectionUpdated).pipe(
@@ -243,6 +216,21 @@ export const OpenAIPlugin = define({
       Stream.runForEach(refresh),
       Effect.forkScoped({ startImmediately: true }),
     )
+    yield* ctx.aisdk.hook(
+      "sdk",
+      Effect.fn(function* (evt) {
+        if (evt.package !== "@ai-sdk/openai") return
+        const mod = yield* Effect.promise(() => import("@ai-sdk/openai"))
+        evt.sdk = mod.createOpenAI(evt.options)
+      }),
+    )
+    yield* ctx.aisdk.hook(
+      "language",
+      Effect.fn(function* (evt) {
+        if (evt.model.providerID !== Provider.ID.openai) return
+        evt.language = evt.sdk.responses(evt.model.modelID ?? evt.model.id)
+      }),
+    )
   }),
 } satisfies PluginInternal.InternalPlugin)
 

packages/core/src/project.ts

@@ -49,7 +49,7 @@ export const root = Effect.fn("Project.root")(function* (
   fs: FSUtil.Interface,
   input: AbsolutePath,
 ) {
-  return yield* fs.up({ targets: [".git", ".hg"], start: input, mode: "first" }).pipe(
+  return yield* fs.up({ targets: [".git", ".hg"], start: input }).pipe(
     Effect.map((matches) => matches[0] ? AbsolutePath.make(path.dirname(matches[0])) : undefined),
     Effect.catch(() => Effect.succeed(undefined)),
   )
@@ -224,7 +224,7 @@ const layer = Layer.effect(
     })
 
     const hgDiscover = Effect.fnUntraced(function* (input: AbsolutePath) {
-      const dotHg = yield* fs.up({ targets: [".hg"], start: input, mode: "first" }).pipe(
+      const dotHg = yield* fs.up({ targets: [".hg"], start: input }).pipe(
         Effect.map((matches) => matches[0]),
         Effect.catch(() => Effect.succeed(undefined)),
       )
@@ -246,13 +246,12 @@ const layer = Layer.effect(
       if (repo) {
         const previous = yield* cached(repo.commonDirectory)
         const id = (yield* remote(repo)) ?? previous ?? (yield* root(repo))
-        const canonical =
-          repo.gitDirectory === repo.commonDirectory
-            ? repo.worktree
-            : yield* git.worktree.list(repo).pipe(
-                Effect.map((items) => items.find((item) => item.kind === "main")?.directory ?? repo.worktree),
-                Effect.catch(() => Effect.succeed(repo.worktree)),
-              )
+        const canonical = yield* git.worktree
+          .list(repo)
+          .pipe(
+            Effect.map((items) => items.find((item) => item.kind === "main")?.directory ?? repo.worktree),
+            Effect.catch(() => Effect.succeed(repo.worktree)),
+          )
         return yield* persist({
           previous,
           id: id ?? ID.global,

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,
+          title: input.title ?? `New session - ${new Date(now).toISOString()}`,
           agent: input.agent,
           model: input.model
             ? {

packages/core/src/session/compaction.ts

@@ -351,14 +351,10 @@ const make = (dependencies: Dependencies) => {
     )
     if (!last) return false
     const output = Math.min(input.model.route.defaults.limits?.output ?? 0, OUTPUT_TOKEN_MAX)
-    const limit = Math.min(
-      input.model.route.defaults.limits?.input ?? Number.POSITIVE_INFINITY,
-      context - (output || config.buffer),
-    )
     const used =
       last.tokens.input + last.tokens.output + last.tokens.reasoning + last.tokens.cache.read + last.tokens.cache.write
     if (used <= 0) return false
-    return used >= limit
+    return used >= context - (output || config.buffer)
   }
   const compactManual = Effect.fn("SessionCompaction.compactManual")(function* (input: ManualInput) {
     const content = planContent(input.messages, config.tokens)

packages/core/src/session/history.ts

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

packages/core/src/session/model-request.ts

@@ -1,7 +1,6 @@
 export * as SessionModelRequest from "./model-request"
 
 import { LLM, Message, SystemPart, type LLMRequest } from "@opencode-ai/ai"
-import type { StreamOptions } from "@opencode-ai/ai/route"
 import type { Content } from "@opencode-ai/schema/tool"
 import { SessionError } from "@opencode-ai/schema/session-error"
 import { Cause, Config, Context, Effect, Layer, Result } from "effect"
@@ -38,7 +37,6 @@ const declineDefect = (cause: Cause.Cause<Tool.Error>) => {
 
 interface Prepared {
   readonly request: LLMRequest
-  readonly options: StreamOptions
   /**
    * One request-scoped execution operation. Unknown, hook-removed, and
    * step-limit-violating calls fail individually through the same seam.
@@ -164,26 +162,6 @@ export const layer = Layer.effect(
         tools: hookedTools,
         toolChoice: stepLimitReached ? "none" : undefined,
       })
-      const options: StreamOptions = {
-        transform: (request) =>
-          hooks
-            .trigger("session", "request", {
-              sessionID: session.id,
-              agent: agent.id,
-              model: resolved.ref,
-              ...request,
-            })
-            .pipe(
-              Effect.tap((event) =>
-                Effect.sync(() => {
-                  request.url = event.url
-                  request.headers = event.headers
-                  request.body = event.body
-                }),
-              ),
-              Effect.asVoid,
-            ),
-      }
       if (promptCacheSnapshots) {
         const current = PromptCacheDiagnostics.snapshot(request)
         const comparison = PromptCacheDiagnostics.compare(promptCacheSnapshots.get(session.id), current)
@@ -212,7 +190,6 @@ export const layer = Layer.effect(
       }
       return {
         request,
-        options,
         executeTool,
         stepLimitReached,
       }

packages/core/src/session/projector.ts

@@ -43,8 +43,7 @@ type Usage = {
 
 const ForkBatchSize = 500
 
-const forkTitle = (value?: string) => {
-  if (value === undefined) return
+const forkTitle = (value: string) => {
   const match = value.match(/^(.+) \(fork #(\d+)\)$/)
   if (match) return `${match[1]} (fork #${Number.parseInt(match[2], 10) + 1})`
   return `${value} (fork #1)`
@@ -217,7 +216,7 @@ const projectFork = Effect.fn("SessionProjector.projectFork")(function* (
       slug: Slug.create(),
       directory: parent.directory,
       path: parent.path,
-      title: forkTitle(parent.title ?? undefined),
+      title: forkTitle(parent.title),
       agent: parent.agent,
       model: parent.model,
       version: parent.version,
@@ -658,12 +657,6 @@ const layer = Layer.effectDiscard(
           input: event.data.input,
           timeCreated: event.created,
         })
-        yield* db
-          .update(SessionTable)
-          .set({ time_updated: DateTime.toEpochMillis(event.created) })
-          .where(eq(SessionTable.id, event.data.sessionID))
-          .run()
-          .pipe(Effect.orDie)
       }),
     )
     yield* bus.project(SessionEvent.Compaction.Admitted, (event) =>

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

@@ -93,9 +93,10 @@ 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 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>()
+    // 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>()
     const forkTitle = yield* FiberSet.makeRuntime<never, void, never>()
     /**
      * Drains eligible manual compaction and user input until the Session becomes idle.
@@ -124,7 +125,7 @@ const layer = Layer.effect(
       let step = 1
       while (true) {
         const result = yield* runStep(sessionID, promotable, step)
-        if (step === 1) yield* startTitle(sessionID)
+        yield* startTitleOnce(sessionID)
         yield* runPendingCompaction(sessionID)
         if (!result.needsContinuation && !(yield* SessionPending.has(db, sessionID, "steer"))) return
         promotable = "steer"
@@ -278,7 +279,7 @@ const layer = Layer.effect(
       // event durably, fork one fiber per local tool call, and hold back a virgin
       // context-overflow provider error so settlement may recover it via compaction.
       let overflowFailure: ProviderErrorEvent | undefined
-      const providerStream = llm.stream(prepared.request, prepared.options).pipe(
+      const providerStream = llm.stream(prepared.request).pipe(
         Stream.runForEach((event) =>
           Effect.gen(function* () {
             if (overflowFailure || publisher.hasProviderError()) return
@@ -480,20 +481,11 @@ const layer = Layer.effect(
       }
     })
 
-    /** 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)
-            }),
-          ),
-        ),
-      )
+    /** 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))
     })
 
     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(),
+    title: text().notNull(),
     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, DateTime, Effect, Layer, Stream } from "effect"
+import { Context, Effect, Layer, Stream } from "effect"
 import { Agent } from "../agent"
 import { Database } from "../database/database"
 import { Bus } from "../bus"
@@ -14,10 +14,8 @@ 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
@@ -27,30 +25,24 @@ 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 when the session remains untitled. */
-  readonly generateForFirstPrompt: (sessionID: SessionSchema.ID) => Effect.Effect<void>
+  /** 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>
 }
 
 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"],
-    sessionID: SessionSchema.ID,
+    session: SessionSchema.Info,
   ) {
-    const session = yield* dependencies.store.get(sessionID)
-    if (!session) return
     if (session.parentID) return
-    if (!isUntitled(session)) return
-    const firstUser = yield* SessionHistory.firstUserMessage(db, session.id)
+    const firstUser = yield* SessionHistory.firstUserMessageIfOnly(db, session.id)
     if (!firstUser) return
     const agent = yield* dependencies.agents.get(Agent.ID.make("title"))
     if (!agent) return
@@ -104,19 +96,10 @@ const make = (dependencies: Dependencies) => {
       .map((line) => line.trim())
       .find((line) => line.length > 0)
     if (!title) return
-    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))))
+    yield* dependencies.bus.publish(SessionEvent.Renamed, {
+      sessionID: session.id,
+      title: truncate(title),
+    })
   })
   return { generateForFirstPrompt }
 }
@@ -128,12 +111,11 @@ 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, store, app })
+    const title = make({ bus, llm, agents, models, app })
     return Service.of({
-      generateForFirstPrompt: (sessionID) => title.generateForFirstPrompt(database.db, sessionID),
+      generateForFirstPrompt: (session) => title.generateForFirstPrompt(database.db, session),
     })
   }),
 )
@@ -141,5 +123,5 @@ export const layer = Layer.effect(
 export const node = makeLocationNode({
   service: Service,
   layer,
-  deps: [Bus.node, llmClient, Agent.node, SessionRunnerModel.node, SessionStore.node, Database.node, App.node],
+  deps: [Bus.node, llmClient, Agent.node, SessionRunnerModel.node, Database.node, App.node],
 })

packages/core/test/aisdk-native.test.ts

@@ -1,46 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { AISDKNative } from "@opencode-ai/core/aisdk-native"
-
-describe("AISDKNative", () => {
-  test("maps supported xAI settings", () => {
-    expect(
-      AISDKNative.map("@ai-sdk/xai", {
-        apiKey: "secret",
-        baseURL: "https://xai.example/v1",
-        reasoningEffort: "custom",
-        store: true,
-        promptCacheKey: "cache-key",
-      }),
-    ).toEqual({
-      package: "@opencode-ai/ai/providers/xai",
-      settings: {
-        apiKey: "secret",
-        baseURL: "https://xai.example/v1",
-        providerOptions: {
-          xai: {
-            reasoningEffort: "custom",
-            store: true,
-            promptCacheKey: "cache-key",
-          },
-        },
-      },
-    })
-  })
-
-  test("omits invalid and unsupported xAI settings", () => {
-    expect(
-      AISDKNative.map("@ai-sdk/xai", {
-        reasoningEffort: 10,
-        store: "yes",
-        include: ["unknown"],
-        logprobs: true,
-        topLogprobs: 8,
-        previousResponseId: "response-id",
-        searchParameters: { mode: "auto" },
-      }),
-    ).toEqual({
-      package: "@opencode-ai/ai/providers/xai",
-      settings: {},
-    })
-  })
-})

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

@@ -26,7 +26,6 @@ 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"
@@ -400,40 +399,6 @@ 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/filesystem/filesystem.test.ts

@@ -1,5 +1,5 @@
 import { describe, test, expect } from "bun:test"
-import { Effect, FileSystem, Layer } from "effect"
+import { Effect, FileSystem } from "effect"
 import { LayerNodePlatform } from "@opencode-ai/util/effect/app-node-platform"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
 import { FSUtil } from "@opencode-ai/util/fs-util"
@@ -267,33 +267,6 @@ describe("FSUtil", () => {
         expect(result).toContain(path.join(tmp, "b.txt"))
       }),
     )
-
-    it(
-      "stops at the first match when requested",
-      Effect.gen(function* () {
-        const filesys = yield* FileSystem.FileSystem
-        const tmp = yield* filesys.makeTempDirectoryScoped()
-        yield* filesys.writeFileString(path.join(tmp, "marker"), "root")
-        const child = path.join(tmp, "sub")
-        yield* filesys.makeDirectory(child)
-        yield* filesys.writeFileString(path.join(child, "marker"), "child")
-        const checked: string[] = []
-        const instrumented = FileSystem.FileSystem.of({
-          ...filesys,
-          exists: (target) => Effect.sync(() => checked.push(target)).pipe(Effect.andThen(filesys.exists(target))),
-        })
-        const search = yield* FSUtil.Service.pipe(
-          Effect.provide(
-            FSUtil.layer.pipe(Layer.fresh, Layer.provide(Layer.succeed(FileSystem.FileSystem, instrumented))),
-          ),
-        )
-
-        expect(yield* search.up({ targets: ["marker", "other"], start: child, mode: "first" })).toEqual([
-          path.join(child, "marker"),
-        ])
-        expect(checked).toEqual([path.join(child, "marker")])
-      }),
-    )
   })
 
   describe("glob", () => {

packages/core/test/generate.test.ts

@@ -15,7 +15,7 @@ import { testEffect } from "./lib/effect"
 
 const selected = Info.make({
   ...Info.default(Provider.ID.make("test-provider"), ID.make("gemini")),
-  package: Provider.aisdk("@ai-sdk/mistral"),
+  package: Provider.aisdk("@ai-sdk/google"),
 })
 const runtime = Model.make({ id: "gemini", provider: "test-provider", route: OpenAIChat.route })
 

packages/core/test/mcp.test.ts

@@ -1,7 +1,6 @@
 import path from "node:path"
 import { describe, expect, test } from "bun:test"
 import { Client } from "@modelcontextprotocol/sdk/client/index.js"
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js"
 import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js"
 import { Server } from "@modelcontextprotocol/sdk/server/index.js"
 import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js"
@@ -560,42 +559,6 @@ test("lists, reads, and reports MCP resource changes", async () => {
   )
 })
 
-test("does not reconnect an SSE stream after a JSON-RPC error response", async () => {
-  let requests = 0
-  const transport = new StreamableHTTPClientTransport(new URL("http://mcp.invalid"), {
-    fetch: async () => {
-      requests += 1
-      return new Response(
-        new ReadableStream({
-          start(controller) {
-            controller.enqueue(new TextEncoder().encode("id: prime\nretry: 1\ndata:\n\n"))
-            controller.enqueue(
-              new TextEncoder().encode(
-                'id: error\ndata: {"jsonrpc":"2.0","error":{"code":-32601,"message":"Method not found"},"id":1}\n\n',
-              ),
-            )
-            controller.close()
-          },
-        }),
-        { status: 200, headers: { "content-type": "text/event-stream" } },
-      )
-    },
-    reconnectionOptions: {
-      initialReconnectionDelay: 1,
-      maxReconnectionDelay: 1,
-      reconnectionDelayGrowFactor: 1,
-      maxRetries: 2,
-    },
-  })
-
-  await transport.start()
-  await transport.send({ jsonrpc: "2.0", method: "resources/list", id: 1 })
-  await Bun.sleep(25)
-  await transport.close()
-
-  expect(requests).toBe(1)
-})
-
 test("skips MCP resource requests when the capability is absent", async () => {
   await Effect.runPromise(
     Effect.scoped(

packages/core/test/model-resolver.test.ts

@@ -17,7 +17,6 @@ interface ModelOptions {
   readonly headers?: Info["headers"]
   readonly body?: Info["body"]
   readonly variants?: Info["variants"]
-  readonly limit?: Info["limit"]
 }
 
 const model = (packageName: string | undefined, options: ModelOptions = {}) =>
@@ -37,7 +36,7 @@ const model = (packageName: string | undefined, options: ModelOptions = {}) =>
     cost: [],
     status: "active",
     enabled: true,
-    limit: options.limit ?? { context: 100, output: 20 },
+    limit: { context: 100, output: 20 },
   })
 
 describe("ModelResolver", () => {
@@ -45,7 +44,6 @@ describe("ModelResolver", () => {
     Effect.gen(function* () {
       const catalog = model(Provider.aisdk("@ai-sdk/openai"), {
         settings: { baseURL: "https://openai.example/v1" },
-        limit: { context: 100, input: 80, output: 20 },
       })
       const resolved = yield* ModelResolver.fromCatalogModel(catalog)
 
@@ -57,7 +55,7 @@ describe("ModelResolver", () => {
         endpoint: { baseURL: "https://openai.example/v1" },
         defaults: {
           headers: { "x-test": "header" },
-          limits: { context: 100, input: 80, output: 20 },
+          limits: { context: 100, output: 20 },
           http: { body: { custom_extension: { enabled: true } } },
         },
       })
@@ -309,12 +307,12 @@ describe("ModelResolver", () => {
     }),
   )
 
-  it.effect("applies plugin-projected OpenAI endpoint and headers", () =>
+  it.effect("routes ChatGPT OAuth credentials to the codex backend", () =>
     Effect.gen(function* () {
       const resolved = yield* ModelResolver.fromCatalogModel(
-        model("@opencode-ai/ai/providers/openai", {
-          settings: { baseURL: "https://chatgpt.com/backend-api/codex" },
-          headers: { "chatgpt-account-id": "acct_123" },
+        model(Provider.aisdk("@ai-sdk/openai"), {
+          settings: { baseURL: "https://openai.example/v1" },
+          headers: {},
           body: {},
         }),
         Credential.OAuth.make({
@@ -339,8 +337,37 @@ describe("ModelResolver", () => {
         id: "openai-responses",
         endpoint: { baseURL: "https://chatgpt.com/backend-api/codex" },
       })
-      expect(resolved.route.defaults.headers).toMatchObject({ "chatgpt-account-id": "acct_123" })
       expect(headers.authorization).toBe("Bearer chatgpt-token")
+      expect(headers["chatgpt-account-id"]).toBe("acct_123")
+    }),
+  )
+
+  it.effect("routes native OpenAI provider packages with ChatGPT credentials to the codex backend", () =>
+    Effect.gen(function* () {
+      const resolved = yield* ModelResolver.fromCatalogModel(
+        model("@opencode-ai/ai/providers/openai", {
+          settings: { baseURL: "https://openai.example/v1" },
+        }),
+        Credential.OAuth.make({
+          type: "oauth",
+          methodID: Integration.MethodID.make("chatgpt-browser"),
+          access: "chatgpt-token",
+          refresh: "refresh",
+          expires: Date.now() + 60_000,
+          metadata: { accountID: "acct_123" },
+        }),
+      )
+      const headers = yield* resolved.route.auth.apply({
+        request: LLM.request({ model: resolved, prompt: "Hello" }),
+        method: "POST",
+        url: "https://chatgpt.com/backend-api/codex/responses",
+        body: "{}",
+        headers: Headers.empty,
+      })
+
+      expect(resolved.route.endpoint.baseURL).toBe("https://chatgpt.com/backend-api/codex")
+      expect(headers.authorization).toBe("Bearer chatgpt-token")
+      expect(headers["chatgpt-account-id"]).toBe("acct_123")
     }),
   )
 
@@ -380,6 +407,37 @@ describe("ModelResolver", () => {
     }),
   )
 
+  it.effect("routes ChatGPT OAuth credentials without an account id to the codex backend", () =>
+    Effect.gen(function* () {
+      const resolved = yield* ModelResolver.fromCatalogModel(
+        model(Provider.aisdk("@ai-sdk/openai"), {
+          settings: { baseURL: "https://openai.example/v1" },
+          headers: {},
+          body: {},
+        }),
+        Credential.OAuth.make({
+          type: "oauth",
+          methodID: Integration.MethodID.make("chatgpt-headless"),
+          access: "chatgpt-token",
+          refresh: "refresh",
+          expires: Date.now() + 60_000,
+        }),
+      )
+      const request = LLM.request({ model: resolved, prompt: "Hello" })
+      const headers = yield* resolved.route.auth.apply({
+        request,
+        method: "POST",
+        url: "https://chatgpt.com/backend-api/codex/responses",
+        body: "{}",
+        headers: Headers.empty,
+      })
+
+      expect(resolved.route.endpoint.baseURL).toBe("https://chatgpt.com/backend-api/codex")
+      expect(headers.authorization).toBe("Bearer chatgpt-token")
+      expect(headers["chatgpt-account-id"]).toBeUndefined()
+    }),
+  )
+
   it.effect("keeps non-ChatGPT OAuth credentials on the configured endpoint", () =>
     Effect.gen(function* () {
       const resolved = yield* ModelResolver.fromCatalogModel(
@@ -488,76 +546,6 @@ describe("ModelResolver", () => {
     }),
   )
 
-  it.effect("routes supported AISDK catalog packages through native provider packages", () =>
-    Effect.gen(function* () {
-      const native = yield* ModelResolver.fromCatalogModel(model(Provider.aisdk("@ai-sdk/openai")))
-      const packages = [
-        ["@ai-sdk/google", "@opencode-ai/ai/providers/google", "gemini"],
-        ["@openrouter/ai-sdk-provider", "@opencode-ai/ai/providers/openrouter", "openrouter"],
-        ["@ai-sdk/xai", "@opencode-ai/ai/providers/xai", "xai"],
-      ] as const
-
-      yield* Effect.forEach(packages, ([catalogPackage, nativePackage, optionKey]) =>
-        ModelResolver.fromCatalogModel(
-          model(Provider.aisdk(catalogPackage), {
-            modelID: "api-model",
-            settings: { baseURL: "https://provider.example/v1", reasoningEffort: "high" },
-            headers: { "x-provider": "header" },
-            body: { custom: true },
-          }),
-          Credential.Key.make({ type: "key", key: "secret" }),
-          {
-            loadPackage: (specifier) => {
-              expect(specifier).toBe(nativePackage)
-              return Effect.succeed({
-                model: (modelID, settings) => {
-                  expect(modelID).toBe("api-model")
-                  expect(settings).toMatchObject({
-                    apiKey: "secret",
-                    baseURL: "https://provider.example/v1",
-                    headers: { "x-provider": "header" },
-                    body: { custom: true },
-                    limits: { context: 100, output: 20 },
-                    providerOptions: { [optionKey]: { reasoningEffort: "high" } },
-                  })
-                  return Model.make({ id: modelID, provider: "native-provider", route: native.route })
-                },
-              })
-            },
-            loadAISDK: () => Effect.die("AI SDK loader should not be called"),
-          },
-        ),
-      )
-    }),
-  )
-
-  it.effect("loads supported AISDK catalog packages as native routes", () =>
-    Effect.gen(function* () {
-      const google = yield* ModelResolver.fromCatalogModel(
-        model(Provider.aisdk("@ai-sdk/google"), { settings: { thinkingConfig: { thinkingBudget: 1_024 } } }),
-      )
-      const openrouter = yield* ModelResolver.fromCatalogModel(
-        model(Provider.aisdk("@openrouter/ai-sdk-provider"), {
-          settings: { reasoning: { effort: "high" } },
-        }),
-      )
-      const xai = yield* ModelResolver.fromCatalogModel(
-        model(Provider.aisdk("@ai-sdk/xai"), { settings: { reasoningEffort: "high" } }),
-      )
-
-      expect(google.route.id).toBe("gemini")
-      expect(google.route.defaults.providerOptions).toEqual({
-        gemini: { thinkingConfig: { thinkingBudget: 1_024 } },
-      })
-      expect(openrouter.route.id).toBe("openrouter")
-      expect(openrouter.route.defaults.providerOptions).toEqual({ openrouter: { reasoning: { effort: "high" } } })
-      expect(xai.route.id).toBe("openai-responses")
-      expect(xai.route.defaults.providerOptions).toEqual({
-        xai: { reasoningEffort: "high", store: false },
-      })
-    }),
-  )
-
   it.effect("loads arbitrary AISDK packages through the injected AISDK loader", () =>
     Effect.gen(function* () {
       const native = yield* ModelResolver.fromCatalogModel(
@@ -566,8 +554,8 @@ describe("ModelResolver", () => {
         }),
       )
       const resolved = yield* ModelResolver.fromCatalogModel(
-        model(Provider.aisdk("@ai-sdk/mistral"), {
-          modelID: "mistral-api-model",
+        model(Provider.aisdk("@ai-sdk/google"), {
+          modelID: "gemini-api-model",
           settings: { project: "test" },
           headers: { "x-aisdk": "header" },
           body: { custom: true },
@@ -578,9 +566,9 @@ describe("ModelResolver", () => {
             Effect.sync(() => {
               expect(runtime).toMatchObject({
                 id: "test-model",
-                modelID: "mistral-api-model",
+                modelID: "gemini-api-model",
                 providerID: "test-provider",
-                package: Provider.aisdk("@ai-sdk/mistral"),
+                package: Provider.aisdk("@ai-sdk/google"),
                 settings: { project: "test", apiKey: "fallback-secret" },
                 headers: { "x-aisdk": "header" },
                 body: { custom: true },
@@ -594,15 +582,15 @@ describe("ModelResolver", () => {
         },
       )
 
-      expect(resolved).toMatchObject({ id: "mistral-api-model", provider: "test-provider" })
+      expect(resolved).toMatchObject({ id: "gemini-api-model", provider: "test-provider" })
     }),
   )
 
   it.effect("rejects AISDK packages without an available loader", () =>
     Effect.gen(function* () {
       const failure = yield* ModelResolver.fromCatalogModel(
-        model(Provider.aisdk("@ai-sdk/mistral"), {
-          settings: { baseURL: "https://mistral.example/v1" },
+        model(Provider.aisdk("@ai-sdk/google"), {
+          settings: { baseURL: "https://google.example/v1" },
         }),
       ).pipe(Effect.flip)
 
@@ -610,9 +598,9 @@ describe("ModelResolver", () => {
         _tag: "SessionRunnerModel.UnsupportedPackageError",
         providerID: "test-provider",
         modelID: "test-model",
-        package: "aisdk:@ai-sdk/mistral",
+        package: "aisdk:@ai-sdk/google",
       })
-      expect(failure.message).toBe("Unsupported package for test-provider/test-model: aisdk:@ai-sdk/mistral")
+      expect(failure.message).toBe("Unsupported package for test-provider/test-model: aisdk:@ai-sdk/google")
     }),
   )
 
@@ -624,8 +612,8 @@ describe("ModelResolver", () => {
         }),
       )
       yield* ModelResolver.fromCatalogModel(
-        model(Provider.aisdk("@ai-sdk/mistral"), {
-          settings: { apiKey: "", baseURL: "https://mistral.example/v1" },
+        model(Provider.aisdk("@ai-sdk/google"), {
+          settings: { apiKey: "", baseURL: "https://google.example/v1" },
         }),
         undefined,
         {

packages/core/test/plugin/provider-openai.test.ts

@@ -1,7 +1,7 @@
+import { AISDK } from "@opencode-ai/core/aisdk"
 import { Money } from "@opencode-ai/schema/money"
-import { Agent } from "@opencode-ai/schema/agent"
-import { Session } from "@opencode-ai/schema/session"
 import { describe, expect } from "bun:test"
+import type { LanguageModelV3 } from "@ai-sdk/provider"
 import { Effect } from "effect"
 import { Catalog } from "@opencode-ai/core/catalog"
 import { Credential } from "@opencode-ai/core/credential"
@@ -9,7 +9,6 @@ import { Integration } from "@opencode-ai/core/integration"
 import { Model } from "@opencode-ai/core/model"
 import { Plugin } from "@opencode-ai/core/plugin"
 import { PluginHost } from "@opencode-ai/core/plugin/host"
-import { PluginHooks } from "@opencode-ai/core/plugin/hooks"
 import { OpenAIPlugin } from "@opencode-ai/core/plugin/provider/openai"
 import { Provider } from "@opencode-ai/core/provider"
 import { testEffect } from "../lib/effect"
@@ -19,6 +18,7 @@ const it = testEffect(PluginTestLayer)
 
 const addPlugin = Effect.fn(function* () {
   const plugin = yield* Plugin.Service
+  const aisdk = yield* AISDK.Service
   const host = yield* PluginHost.make(plugin)
   const integrations = yield* Integration.Service
   yield* OpenAIPlugin.effect(host).pipe(Effect.provideService(Integration.Service, integrations))
@@ -29,6 +29,19 @@ function required<T>(value: T | undefined): T {
   return value
 }
 
+function fakeSelectorSdk(calls: string[]) {
+  const make = (method: string) => (id: string) => {
+    calls.push(`${method}:${id}`)
+    return { modelId: id, provider: method, specificationVersion: "v3" } as unknown as LanguageModelV3
+  }
+  return {
+    responses: make("responses"),
+    messages: make("messages"),
+    chat: make("chat"),
+    languageModel: make("languageModel"),
+  }
+}
+
 describe("OpenAIPlugin", () => {
   it.effect("registers browser and headless ChatGPT OAuth methods", () =>
     Effect.gen(function* () {
@@ -48,6 +61,104 @@ describe("OpenAIPlugin", () => {
     }),
   )
 
+  it.effect("creates an OpenAI SDK for @ai-sdk/openai using the provider ID as SDK name", () =>
+    Effect.gen(function* () {
+      const plugin = yield* Plugin.Service
+      const aisdk = yield* AISDK.Service
+      yield* addPlugin()
+      const result = yield* aisdk.runSDK({
+        model: Model.Info.make({
+          ...Model.Info.default(Provider.ID.make("custom-openai"), Model.ID.make("gpt-5")),
+          modelID: Model.ID.make("gpt-5"),
+          package: Provider.aisdk("test-provider"),
+        }),
+        package: "@ai-sdk/openai",
+        options: { name: "custom-openai", apiKey: "test" },
+      })
+      expect(result.sdk?.responses("gpt-5").provider).toBe("custom-openai.responses")
+    }),
+  )
+
+  it.effect("ignores non-OpenAI SDK packages", () =>
+    Effect.gen(function* () {
+      const plugin = yield* Plugin.Service
+      const aisdk = yield* AISDK.Service
+      yield* addPlugin()
+      const result = yield* aisdk.runSDK({
+        model: Model.Info.make({
+          ...Model.Info.default(Provider.ID.openai, Model.ID.make("gpt-5")),
+          modelID: Model.ID.make("gpt-5"),
+          package: Provider.aisdk("test-provider"),
+        }),
+        package: "@ai-sdk/openai-compatible",
+        options: { name: "openai" },
+      })
+      expect(result.sdk).toBeUndefined()
+    }),
+  )
+
+  it.effect("uses the Responses API for language models", () =>
+    Effect.gen(function* () {
+      const plugin = yield* Plugin.Service
+      const aisdk = yield* AISDK.Service
+      const calls: string[] = []
+      yield* addPlugin()
+      const result = yield* aisdk.runLanguage({
+        model: Model.Info.make({
+          ...Model.Info.default(Provider.ID.openai, Model.ID.make("alias")),
+          modelID: Model.ID.make("gpt-5"),
+          package: Provider.aisdk("test-provider"),
+        }),
+        sdk: fakeSelectorSdk(calls),
+        options: {},
+      })
+      expect(calls).toEqual(["responses:gpt-5"])
+      expect(result.language).toBeDefined()
+    }),
+  )
+
+  it.effect("ignores non-OpenAI providers", () =>
+    Effect.gen(function* () {
+      const plugin = yield* Plugin.Service
+      const aisdk = yield* AISDK.Service
+      const calls: string[] = []
+      yield* addPlugin()
+      const result = yield* aisdk.runLanguage({
+        model: Model.Info.make({
+          ...Model.Info.default(Provider.ID.anthropic, Model.ID.make("gpt-5")),
+          modelID: Model.ID.make("gpt-5"),
+          package: Provider.aisdk("test-provider"),
+        }),
+        sdk: fakeSelectorSdk(calls),
+        options: {},
+      })
+      expect(calls).toEqual([])
+      expect(result.language).toBeUndefined()
+    }),
+  )
+
+  it.effect("disables gpt-5-chat-latest during catalog transforms", () =>
+    Effect.gen(function* () {
+      const catalog = yield* Catalog.Service
+      yield* catalog.transform((catalog) => {
+        const item = Provider.Info.make({
+          ...Provider.Info.empty(Provider.ID.openai),
+          package: Provider.aisdk("@ai-sdk/openai"),
+        })
+        catalog.provider.update(item.id, (draft) => {
+          draft.package = item.package
+        })
+        catalog.model.update(item.id, Model.ID.make("gpt-5"), () => {})
+        catalog.model.update(item.id, Model.ID.make("gpt-5-chat-latest"), () => {})
+      })
+      yield* addPlugin()
+      expect(required(yield* catalog.model.get(Provider.ID.openai, Model.ID.make("gpt-5"))).enabled).toBe(true)
+      expect(
+        required(yield* catalog.model.get(Provider.ID.openai, Model.ID.make("gpt-5-chat-latest"))).enabled,
+      ).toBe(false)
+    }),
+  )
+
   it.effect("filters the OpenAI catalog to codex-eligible models under a ChatGPT connection", () =>
     Effect.gen(function* () {
       const catalog = yield* Catalog.Service
@@ -61,7 +172,6 @@ describe("OpenAIPlugin", () => {
           draft.package = item.package
         })
         catalog.model.update(item.id, Model.ID.make("gpt-5.5"), (model) => {
-          model.limit = { context: 1_050_000, input: 922_000, output: 128_000 }
           model.cost = [
             {
               input: Money.USDPerMillionTokens.make(1),
@@ -74,17 +184,12 @@ describe("OpenAIPlugin", () => {
           ]
         })
         catalog.model.update(item.id, Model.ID.make("gpt-5.5-pro"), () => {})
-        catalog.model.update(item.id, Model.ID.make("gpt-5.4"), (model) => {
-          model.limit = { context: 1_050_000, input: 922_000, output: 64_000 }
-        })
         catalog.model.update(item.id, Model.ID.make("gpt-5.4-pro"), (model) => {
           model.modelID = Model.ID.make("gpt-5.4")
           model.body = { reasoning: { mode: "pro" } }
         })
         catalog.model.update(item.id, Model.ID.make("gpt-5.6"), () => {})
-        catalog.model.update(item.id, Model.ID.make("gpt-5.6-sol"), (model) => {
-          model.limit = { context: 1_050_000, input: 922_000, output: 128_000 }
-        })
+        catalog.model.update(item.id, Model.ID.make("gpt-5.6-sol"), () => {})
         catalog.model.update(item.id, Model.ID.make("gpt-4.1"), () => {})
       })
       yield* credentials.create({
@@ -100,47 +205,8 @@ describe("OpenAIPlugin", () => {
       })
       yield* addPlugin()
 
-      const request = yield* (yield* PluginHooks.Service).trigger("session", "request", {
-        sessionID: Session.ID.make("ses_test"),
-        agent: Agent.ID.make("build"),
-        model: Model.Ref.make({ providerID: Provider.ID.openai, id: Model.ID.make("gpt-5.5") }),
-        url: "https://api.openai.com/v1/responses",
-        method: "POST",
-        headers: {},
-        body: "{}",
-      })
-      const custom = yield* (yield* PluginHooks.Service).trigger("session", "request", {
-        sessionID: Session.ID.make("ses_test"),
-        agent: Agent.ID.make("build"),
-        model: Model.Ref.make({ providerID: Provider.ID.make("custom-openai"), id: Model.ID.make("gpt-5.5") }),
-        url: "https://custom.example/v1/responses",
-        method: "POST",
-        headers: {},
-        body: "{}",
-      })
-      const proxy = yield* (yield* PluginHooks.Service).trigger("session", "request", {
-        sessionID: Session.ID.make("ses_test"),
-        agent: Agent.ID.make("build"),
-        model: Model.Ref.make({ providerID: Provider.ID.openai, id: Model.ID.make("gpt-5.5") }),
-        url: "https://proxy.example/v1/responses?region=us",
-        method: "POST",
-        headers: {},
-        body: "{}",
-      })
-
-      const provider = required(yield* catalog.provider.get(Provider.ID.openai))
-      expect(provider.package).toBe("@opencode-ai/ai/providers/openai")
-      expect(provider.settings).toMatchObject({ baseURL: "https://chatgpt.com/backend-api/codex" })
-      expect(provider.headers).toMatchObject({ "chatgpt-account-id": "acct_123" })
-      expect(request.url).toBe("https://chatgpt.com/backend-api/codex/responses")
-      expect(request.headers).toMatchObject({ originator: "opencode", "session-id": "ses_test" })
-      expect(custom.headers).toEqual({})
-      expect(proxy.url).toBe("https://proxy.example/v1/responses?region=us")
-      expect(proxy.headers).toMatchObject({ originator: "opencode", "session-id": "ses_test" })
       const eligible = required(yield* catalog.model.get(Provider.ID.openai, Model.ID.make("gpt-5.5")))
-      expect(eligible.package).toBe("@opencode-ai/ai/providers/openai")
       expect(eligible.cost).toEqual([])
-      expect(eligible.limit).toEqual({ context: 272_000, input: 272_000, output: 128_000 })
       expect(eligible.enabled).toBe(true)
       expect(required(yield* catalog.model.get(Provider.ID.openai, Model.ID.make("gpt-5.5-pro"))).enabled).toBe(
         false,
@@ -148,15 +214,10 @@ describe("OpenAIPlugin", () => {
       expect(required(yield* catalog.model.get(Provider.ID.openai, Model.ID.make("gpt-5.4-pro"))).enabled).toBe(
         false,
       )
-      expect(required(yield* catalog.model.get(Provider.ID.openai, Model.ID.make("gpt-5.4"))).limit).toEqual({
-        context: 272_000,
-        input: 272_000,
-        output: 64_000,
-      })
       expect(required(yield* catalog.model.get(Provider.ID.openai, Model.ID.make("gpt-5.6"))).enabled).toBe(false)
-      const gpt56 = required(yield* catalog.model.get(Provider.ID.openai, Model.ID.make("gpt-5.6-sol")))
-      expect(gpt56.enabled).toBe(true)
-      expect(gpt56.limit).toEqual({ context: 272_000, input: 272_000, output: 128_000 })
+      expect(required(yield* catalog.model.get(Provider.ID.openai, Model.ID.make("gpt-5.6-sol"))).enabled).toBe(
+        true,
+      )
       expect(required(yield* catalog.model.get(Provider.ID.openai, Model.ID.make("gpt-4.1"))).enabled).toBe(false)
     }),
   )
@@ -173,9 +234,7 @@ describe("OpenAIPlugin", () => {
         catalog.provider.update(item.id, (draft) => {
           draft.package = item.package
         })
-        catalog.model.update(item.id, Model.ID.make("gpt-5.5"), (model) => {
-          model.limit = { context: 1_050_000, input: 922_000, output: 128_000 }
-        })
+        catalog.model.update(item.id, Model.ID.make("gpt-5.5"), () => {})
         catalog.model.update(item.id, Model.ID.make("gpt-4.1"), () => {})
       })
       yield* credentials.create({
@@ -184,23 +243,29 @@ describe("OpenAIPlugin", () => {
       })
       yield* addPlugin()
 
-      const request = yield* (yield* PluginHooks.Service).trigger("session", "request", {
-        sessionID: Session.ID.make("ses_test"),
-        agent: Agent.ID.make("build"),
-        model: Model.Ref.make({ providerID: Provider.ID.openai, id: Model.ID.make("gpt-5.5") }),
-        url: "https://api.openai.com/v1/responses",
-        method: "POST",
-        headers: {},
-        body: "{}",
-      })
-
-      const model = required(yield* catalog.model.get(Provider.ID.openai, Model.ID.make("gpt-5.5")))
-      expect(model.package).toBe("@opencode-ai/ai/providers/openai")
-      expect(model.enabled).toBe(true)
-      expect(model.limit).toEqual({ context: 1_050_000, input: 922_000, output: 128_000 })
-      expect(request.headers).toEqual({})
+      expect(required(yield* catalog.model.get(Provider.ID.openai, Model.ID.make("gpt-5.5"))).enabled).toBe(true)
       expect(required(yield* catalog.model.get(Provider.ID.openai, Model.ID.make("gpt-4.1"))).enabled).toBe(true)
     }),
   )
 
+  it.effect("does not disable gpt-5-chat-latest for non-OpenAI providers", () =>
+    Effect.gen(function* () {
+      const catalog = yield* Catalog.Service
+      yield* catalog.transform((catalog) => {
+        const item = Provider.Info.make({
+          ...Provider.Info.empty(Provider.ID.make("custom-openai")),
+          package: Provider.aisdk("test-provider"),
+        })
+        catalog.provider.update(item.id, (draft) => {
+          draft.package = item.package
+        })
+        catalog.model.update(item.id, Model.ID.make("gpt-5-chat-latest"), () => {})
+      })
+      yield* addPlugin()
+      expect(
+        required(yield* catalog.model.get(Provider.ID.make("custom-openai"), Model.ID.make("gpt-5-chat-latest")))
+          .enabled,
+      ).toBe(true)
+    }),
+  )
 })

packages/core/test/project.test.ts

@@ -143,7 +143,6 @@ describe("Project.resolve", () => {
 
       expect(result.id).toBe(Project.ID.make(yield* Effect.promise(() => rootCommit(tmp.path))))
       expect(result.directory).toBe(yield* real(tmp.path))
-      expect(result.canonical).toBe(result.directory)
       expect(result.previous).toBeUndefined()
       expect(result.vcs?.type).toBe("git")
     }),

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

@@ -19,11 +19,9 @@ import { Session } from "@opencode-ai/core/session"
 import { Project } from "@opencode-ai/core/project"
 import { ProjectTable } from "@opencode-ai/core/project/sql"
 import { App } from "@opencode-ai/core/app"
-import { Agent } from "@opencode-ai/core/agent"
-import { Location } from "@opencode-ai/core/location"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { Money } from "@opencode-ai/schema/money"
-import { DateTime, Effect, Fiber, Layer, Schema, Stream } from "effect"
+import { DateTime, Effect, Fiber, Layer, Stream } from "effect"
 import { asc, eq } from "drizzle-orm"
 import { testEffect } from "./lib/effect"
 
@@ -132,43 +130,6 @@ test("compaction prompt requires the checkpoint headings in order", () => {
   expect(prompt).toContain("Keep every section, even when empty.")
 })
 
-it.effect("auto compaction respects explicit model input limits", () =>
-  Effect.gen(function* () {
-    const compaction = yield* SessionCompaction.Service
-    const session = Session.Info.make({
-      id: Session.ID.make("ses_input_limit"),
-      projectID: Project.ID.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) },
-      location: Location.Ref.make({ directory: AbsolutePath.make("/tmp") }),
-    })
-    const input = (tokens: number) => ({
-      session,
-      model: Model.make({
-        id: "test-model",
-        provider: "test-provider",
-        route: OpenAIChat.route.with({ limits: { context: 1_000, input: 100, output: 100 } }),
-      }),
-      cost: [],
-      messages: [
-        Schema.decodeUnknownSync(SessionMessage.Assistant)({
-          id: SessionMessage.ID.make("msg_assistant"),
-          type: "assistant",
-          agent: Agent.defaultID,
-          model: { id: "test-model", providerID: "test-provider" },
-          content: [],
-          tokens: { input: tokens, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
-          time: { created: 0, completed: 0 },
-        }),
-      ],
-    })
-
-    expect(compaction.required(input(99))).toBe(false)
-    expect(compaction.required(input(100))).toBe(true)
-  }),
-)
-
 it.effect("manual compaction summarizes short context instead of no-op", () =>
   Effect.gen(function* () {
     requests = []

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

@@ -71,27 +71,6 @@ 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
@@ -192,30 +171,6 @@ describe("Session.create", () => {
     }),
   )
 
-  it.effect("orders sessions by their latest prompt", () =>
-    Effect.gen(function* () {
-      const session = yield* Session.Service
-      const { db } = yield* Database.Service
-      const active = yield* session.create({ location, title: "active" })
-      const newer = yield* session.create({ location, title: "newer" })
-
-      yield* db
-        .update(SessionTable)
-        .set({ time_created: -2, time_updated: -2 })
-        .where(eq(SessionTable.id, active.id))
-        .run()
-      yield* db
-        .update(SessionTable)
-        .set({ time_created: -1, time_updated: -1 })
-        .where(eq(SessionTable.id, newer.id))
-        .run()
-
-      yield* session.prompt({ sessionID: active.id, text: "continue", resume: false })
-
-      expect((yield* session.list()).data.map((item) => item.id)).toEqual([active.id, newer.id])
-    }),
-  )
-
   it.effect("filters direct child sessions by parent ID", () =>
     Effect.gen(function* () {
       const session = yield* Session.Service
@@ -317,23 +272,6 @@ 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,59 +796,6 @@ 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 { Deferred, Effect, Fiber, Layer, Stream } from "effect"
+import { Effect, Layer, Stream } from "effect"
 import { testEffect } from "./lib/effect"
 
 let requests: LLMRequest[] = []
@@ -39,30 +39,27 @@ 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 titleStream()
+    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" },
+      }),
+    )
   },
   generate: () => Effect.die("unused"),
 })
@@ -92,7 +89,7 @@ const it = testEffect(
   ),
 )
 
-const insertSession = (id: Session.ID, title?: string, created?: number) =>
+const insertSession = (id: Session.ID) =>
   Effect.gen(function* () {
     const { db } = yield* Database.Service
     yield* db
@@ -108,8 +105,7 @@ const insertSession = (id: Session.ID, title?: string, created?: number) =>
         project_id: Project.ID.global,
         slug: id,
         directory: "/project",
-        title,
-        time_created: created,
+        title: "New session - fake",
         version: "test",
       })
       .onConflictDoNothing()
@@ -135,7 +131,6 @@ 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) => {
@@ -149,8 +144,11 @@ 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(sessionID)
+    yield* title.generateForFirstPrompt(session)
 
     expect(requests).toHaveLength(1)
     expect(requests[0]?.http?.headers).toEqual({
@@ -169,10 +167,9 @@ it.effect("generates a title from the sole user message and renames the session"
   }),
 )
 
-it.effect("generates from the first user message after later messages exist", () =>
+it.effect("does not generate once a second user message exists", () =>
   Effect.gen(function* () {
     requests = []
-    titleStream = successfulTitle
     const agentService = yield* Agent.Service
     yield* agentService.transform((editor) => {
       editor.update(Agent.ID.make("title"), (agent) => {
@@ -187,46 +184,21 @@ it.effect("generates from the first user message after later messages exist", ()
     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(sessionID)
+    yield* title.generateForFirstPrompt(session)
 
-    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")
+    expect(requests).toHaveLength(0)
+    const untouched = yield* store.get(sessionID)
+    expect(untouched?.title).toBe("New session - fake")
   }),
 )
 
 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) => {
@@ -251,6 +223,7 @@ 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()
@@ -258,8 +231,12 @@ 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(sessionID)
+    yield* title.generateForFirstPrompt(session)
 
     expect(requests).toHaveLength(0)
   }),
@@ -268,100 +245,19 @@ 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(sessionID)
+    yield* title.generateForFirstPrompt(session)
 
     expect(requests).toHaveLength(0)
     const untouched = yield* store.get(sessionID)
-    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")
+    expect(untouched?.title).toBe("New session - fake")
   }),
 )

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,11 +158,6 @@ 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] ?? []
@@ -172,7 +167,7 @@ export default function () {
               }
             }
             const modelIDs = Array.from(models)
-            const encodedTitle = encodeURIComponent(Base64.encode(encodeURIComponent(title().substring(0, 700))))
+            const encodedTitle = encodeURIComponent(Base64.encode(encodeURIComponent(info().title.substring(0, 700))))
             let modelParam: string
             if (modelIDs.length === 1) {
               modelParam = modelIDs[0]
@@ -189,7 +184,9 @@ export default function () {
 
           return (
             <>
-              <Title>{title()} | OpenCode</Title>
+              <Show when={info().title}>
+                <Title>{info().title} | OpenCode</Title>
+              </Show>
               <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()} />
@@ -243,7 +240,7 @@ export default function () {
                               </div>
                             </div>
                           </div>
-                          <div class="text-left text-16-medium text-text-strong">{title()}</div>
+                          <div class="text-left text-16-medium text-text-strong">{info().title}</div>
                         </div>
                       )
 

packages/plugin/src/effect/session.ts

@@ -1,6 +1,5 @@
 import type { SessionApi } from "@opencode-ai/client/effect/api"
 import type { Message, SystemPart } from "@opencode-ai/ai"
-import type { HttpRequest } from "@opencode-ai/ai/route"
 import type { Agent } from "@opencode-ai/schema/agent"
 import type { Model } from "@opencode-ai/schema/model"
 import type { Session } from "@opencode-ai/schema/session"
@@ -16,15 +15,8 @@ export interface SessionContext {
   tools: Record<string, { description: string; input: JsonSchema.JsonSchema }>
 }
 
-export interface SessionRequest extends HttpRequest {
-  readonly sessionID: Session.ID
-  readonly agent: Agent.ID
-  readonly model: Model.Ref
-}
-
 export interface SessionHooks {
   readonly context: SessionContext
-  readonly request: SessionRequest
 }
 
 export type SessionDomain = Pick<

packages/plugin/src/promise/session.ts

@@ -1,6 +1,5 @@
 import type { SessionApi } from "@opencode-ai/client/promise/api"
 import type { Message, SystemPart } from "@opencode-ai/ai"
-import type { HttpRequest } from "@opencode-ai/ai/route"
 import type { Agent } from "@opencode-ai/schema/agent"
 import type { Model } from "@opencode-ai/schema/model"
 import type { Session } from "@opencode-ai/schema/session"
@@ -16,15 +15,8 @@ export interface SessionContext {
   tools: Record<string, { description: string; input: JsonSchema.JsonSchema }>
 }
 
-export interface SessionRequest extends HttpRequest {
-  readonly sessionID: Session.ID
-  readonly agent: Agent.ID
-  readonly model: Model.Ref
-}
-
 export interface SessionHooks {
   readonly context: SessionContext
-  readonly request: SessionRequest
 }
 
 export type SessionDomain = Pick<

packages/schema/src/session.ts

@@ -42,7 +42,7 @@ export const Info = Schema.Struct({
     updated: DateTimeUtcFromMillis,
     archived: DateTimeUtcFromMillis.pipe(optional),
   }),
-  title: Schema.String.pipe(optional),
+  title: Schema.String,
   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: optional(Schema.String),
+  title: 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 { AbsolutePath, optional } from "../src/schema.js"
+import { optional } from "../src/schema.js"
 
 describe("contract hygiene", () => {
   test("restricts agent colors to six-digit hex values", () => {
@@ -52,18 +52,6 @@ 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/simulation/src/frontend/renderer.ts

@@ -41,7 +41,6 @@ export const create = Effect.fn("SimulationRenderer.create")(function* (
         ...options,
         width: cols,
         height: rows,
-        kittyKeyboard: Boolean(options.useKittyKeyboard),
         ...(recording
           ? {
               stdout: recording as unknown as NodeJS.WriteStream,

packages/simulation/test/actions.test.ts

@@ -43,25 +43,6 @@ test("normalizes named keys for OpenTUI", async () => {
   ])
 })
 
-test("headless input mirrors the configured kitty keyboard protocol", async () => {
-  await Effect.runPromise(
-    Effect.scoped(
-      Effect.gen(function* () {
-        const renderer = yield* SimulationRenderer.create({ useKittyKeyboard: {} })
-        const harness = createHarness(renderer)
-        let key: { readonly name: string; readonly source: string } | undefined
-        renderer.keyInput.once("keypress", (event) => {
-          key = event
-        })
-
-        yield* execute(harness, { type: "ui.press", key: "escape" })
-
-        expect(key).toMatchObject({ name: "escape", source: "kitty" })
-      }),
-    ),
-  )
-})
-
 test("clicks a target at relative coordinates through descendant text", async () => {
   await Effect.runPromise(
     Effect.scoped(

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 { DialogOpen } from "./component/dialog-open"
+import { DialogProject } from "./component/dialog-project"
 import { SessionTabs } from "./component/session-tabs"
 import { ThemeErrorToast } from "./component/theme-error-toast"
 import { ThemeProvider, useTheme, useThemes } from "./context/theme"
@@ -95,15 +95,16 @@ import { StorageProvider } from "./context/storage"
 
 registerOpencodeSpinner()
 
-const appGlobalBindingCommands = ["session.list", "session.new", "open.menu"] as const
+const appGlobalBindingCommands = ["session.list", "session.new"] 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",
-  "session.tab.reopen",
   "session.tab.select.1",
   "session.tab.select.2",
   "session.tab.select.3",
@@ -523,11 +524,8 @@ 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") {
@@ -536,13 +534,14 @@ function App(props: { pair?: DialogPairCredentials }) {
     }
 
     if (route.data.type === "session") {
-      const title = session?.title
-      if (!title || isDefaultTitle(title)) {
+      const session = data.session.get(route.data.sessionID)
+      if (!session || isDefaultTitle(session.title)) {
         renderer.setTerminalTitle("OpenCode")
         return
       }
 
-      renderer.setTerminalTitle(`OC | ${title.length > 40 ? title.slice(0, 37) + "..." : title}`)
+      const title = session.title.length > 40 ? session.title.slice(0, 37) + "..." : session.title
+      renderer.setTerminalTitle(`OC | ${title}`)
       return
     }
 
@@ -646,18 +645,17 @@ 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: "open.menu",
-        title: "Open session or project",
+        name: "project.switch",
+        title: "Switch project",
         category: "Session",
-        slash: { name: "open", aliases: ["projects", "project"] },
+        slash: { name: "projects", aliases: ["project"] },
         run: () => {
-          dialog.replace(() => <DialogOpen />)
+          dialog.replace(() => <DialogProject />)
         },
       },
       ...Array.from({ length: 9 }, (_, i) => ({
@@ -670,7 +668,7 @@ function App(props: { pair?: DialogPairCredentials }) {
       })),
       {
         name: "session.tab.next",
-        title: "Next tab",
+        title: "Next open session tab",
         category: "Session",
         palette: undefined,
         enabled: sessionTabs.enabled,
@@ -678,15 +676,31 @@ function App(props: { pair?: DialogPairCredentials }) {
       },
       {
         name: "session.tab.previous",
-        title: "Previous tab",
+        title: "Previous open session tab",
         category: "Session",
         palette: undefined,
         enabled: sessionTabs.enabled,
         run: () => sessionTabs.cycle(-1),
       },
+      {
+        name: "session.tab.history.back",
+        title: "Back in session tab history",
+        category: "Session",
+        palette: undefined,
+        enabled: sessionTabs.enabled,
+        run: () => sessionTabs.history(-1),
+      },
+      {
+        name: "session.tab.history.forward",
+        title: "Forward in session tab history",
+        category: "Session",
+        palette: undefined,
+        enabled: sessionTabs.enabled,
+        run: () => sessionTabs.history(1),
+      },
       {
         name: "session.tab.next_unread",
-        title: "Next unread tab",
+        title: "Next unread session tab",
         category: "Session",
         palette: undefined,
         enabled: sessionTabs.enabled,
@@ -694,7 +708,7 @@ function App(props: { pair?: DialogPairCredentials }) {
       },
       {
         name: "session.tab.previous_unread",
-        title: "Previous unread tab",
+        title: "Previous unread session tab",
         category: "Session",
         palette: undefined,
         enabled: sessionTabs.enabled,
@@ -702,21 +716,14 @@ function App(props: { pair?: DialogPairCredentials }) {
       },
       {
         name: "session.tab.close",
-        title: "Close tab",
+        title: "Close current session tab",
         category: "Session",
         enabled: sessionTabs.enabled,
         run: () => sessionTabs.close(),
       },
-      {
-        name: "session.tab.reopen",
-        title: "Reopen closed tab",
-        category: "Session",
-        enabled: sessionTabs.enabled,
-        run: () => sessionTabs.reopen(),
-      },
       ...Array.from({ length: 9 }, (_, i) => ({
         name: `session.tab.select.${i + 1}`,
-        title: `Switch to tab ${i + 1}`,
+        title: `Switch to session tab ${i + 1}`,
         category: "Session",
         palette: undefined,
         enabled: sessionTabs.enabled,
@@ -1145,11 +1152,10 @@ 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: title ? `Session "${title}" was deleted` : "The current session was deleted",
+        message: "The current session was deleted",
       })
     }
   })
@@ -1213,13 +1219,7 @@ function App(props: { pair?: DialogPairCredentials }) {
         <box flexGrow={1} minWidth={0} flexDirection="column">
           <Show when={plugins.ready()}>
             <box flexGrow={1} minHeight={0} flexDirection="column">
-              <Show
-                when={
-                  sessionTabs.enabled() &&
-                  (sessionTabs.tabs().length > 0 || sessionTabs.newTab()) &&
-                  route.data.type !== "plugin"
-                }
-              >
+              <Show when={sessionTabs.enabled() && sessionTabs.tabs().length > 0 && route.data.type !== "plugin"}>
                 <SessionTabs />
               </Show>
               <Switch>

packages/tui/src/component/bg-pulse-render.ts

@@ -0,0 +1,436 @@
+import { OptimizedBuffer, RGBA, TextAttributes } from "@opentui/core"
+import { go } from "../logo"
+
+const PERIOD = 4600
+const RINGS = 3
+const WIDTH = 3.8
+const TAIL = 9.5
+const AMP = 0.55
+const TAIL_AMP = 0.16
+const BREATH_AMP = 0.05
+const BREATH_SPEED = 0.0008
+// Offset so the bg ring emits from the estimated GO center when the logo shimmer peaks.
+const PHASE_OFFSET = 0.29
+const LOGO_GAP = 1
+const LOGO_TOP_BIAS = -1
+const LOGO_LEFT_WIDTH = go.left[0]?.length ?? 0
+const LOGO_LINES = go.left.map((line, index) => line + " ".repeat(LOGO_GAP) + go.right[index])
+const LOGO_WIDTH = LOGO_LINES[0]?.length ?? 0
+const LOGO_HEIGHT = LOGO_LINES.length
+const SPACE = " ".codePointAt(0)!
+const TOP_HALF = "▀".codePointAt(0)!
+const FULL_BLOCK = "█".codePointAt(0)!
+const RING_SCALE = 1 / RINGS
+const TAIL_SCALE = 1 / TAIL
+const LOGO_REACH = Math.hypot(LOGO_WIDTH, LOGO_HEIGHT * 2) + 3
+
+const enum LogoCellKind {
+  Background,
+  Top,
+  ShadowTop,
+  Solid,
+  Char,
+}
+
+type LogoTemplateCell = {
+  x: number
+  y: number
+  kind: LogoCellKind
+  charCode: number
+  attributes: number
+  topDist: number
+  bottomDist: number
+}
+
+const LOGO_TEMPLATE: LogoTemplateCell[] = LOGO_LINES.flatMap((line, y) =>
+  Array.from(line)
+    .map((char, x) => {
+      if (char === " ") return
+      const kind =
+        char === "_"
+          ? LogoCellKind.Background
+          : char === "^"
+            ? LogoCellKind.Top
+            : char === "~"
+              ? LogoCellKind.ShadowTop
+              : char === "█"
+                ? LogoCellKind.Solid
+                : LogoCellKind.Char
+      return {
+        x,
+        y,
+        kind,
+        charCode: char.codePointAt(0) ?? SPACE,
+        attributes: x > LOGO_LEFT_WIDTH ? TextAttributes.BOLD : 0,
+        topDist: Math.hypot(x + 0.5 - LOGO_WIDTH / 2, y * 2 - LOGO_HEIGHT),
+        bottomDist: Math.hypot(x + 0.5 - LOGO_WIDTH / 2, y * 2 + 1 - LOGO_HEIGHT),
+      }
+    })
+    .filter((cell): cell is LogoTemplateCell => !!cell),
+)
+
+export type Rgb = [number, number, number]
+
+export type GoUpsellArtRenderOptions = {
+  deltaTime?: number
+  rgb?: boolean
+  cache?: boolean
+}
+
+const CACHE_FRAME_COUNT = Math.round(PERIOD / (1000 / 30))
+const CACHE_FRAMES_PER_RENDER = 1
+
+export function toRgb(color: RGBA): Rgb {
+  const [r, g, b] = color.toInts()
+  return [r, g, b]
+}
+
+function clamp(n: number) {
+  return Math.max(0, Math.min(1, n))
+}
+
+function writeRgb(buffer: Uint16Array, offset: number, r: number, g: number, b: number, a = 255) {
+  buffer[offset] = r
+  buffer[offset + 1] = g
+  buffer[offset + 2] = b
+  buffer[offset + 3] = a
+}
+
+function mixChannel(base: number, overlay: number, alpha: number) {
+  return Math.round(base + (overlay - base) * clamp(alpha))
+}
+
+function writeLogoTint(
+  buffer: Uint16Array,
+  offset: number,
+  base: Rgb,
+  primary: Rgb,
+  primaryMix: number,
+  peakMix: number,
+) {
+  const p = clamp(primaryMix)
+  const q = clamp(peakMix)
+  const r = mixChannel(mixChannel(base[0], primary[0], p), 255, q)
+  const g = mixChannel(mixChannel(base[1], primary[1], p), 255, q)
+  const b = mixChannel(mixChannel(base[2], primary[2], p), 255, q)
+  writeRgb(buffer, offset, r, g, b)
+}
+
+function sameRgb(a: Rgb, b: Rgb) {
+  return a[0] === b[0] && a[1] === b[1] && a[2] === b[2]
+}
+
+export class GoUpsellArtPainter {
+  private panelRgb: Rgb = [0, 0, 0]
+  private primaryRgb: Rgb = [255, 255, 255]
+  private logoBaseRgb: Rgb = [180, 180, 180]
+  private elapsed = 0
+  private distances = new Float32Array(0)
+  private edgeFalloff = new Float32Array(0)
+  private geometryWidth = 0
+  private geometryHeight = 0
+  private reach = 1
+  private logoX = 0
+  private logoY = 0
+  private logoIndexes = new Int32Array(0)
+  private logoRgb: boolean | undefined
+  private pulsePeak = 0
+  private pulsePrimary = 0
+  private cacheDirty = true
+  private frameCache: Array<{ fg: Uint16Array; bg: Uint16Array }> = []
+  private cacheBuildIndex = 0
+
+  setBackgroundPanel(value: RGBA | Rgb | undefined) {
+    if (!value) return false
+    const next = value instanceof RGBA ? toRgb(value) : value
+    if (sameRgb(this.panelRgb, next)) return false
+    this.panelRgb = next
+    this.invalidateCache()
+    return true
+  }
+
+  setLogoBase(value: RGBA | Rgb | undefined) {
+    if (!value) return false
+    const next = value instanceof RGBA ? toRgb(value) : value
+    if (sameRgb(this.logoBaseRgb, next)) return false
+    this.logoBaseRgb = next
+    this.invalidateCache()
+    return true
+  }
+
+  setPrimary(value: RGBA | Rgb | undefined) {
+    if (!value) return false
+    const next = value instanceof RGBA ? toRgb(value) : value
+    if (sameRgb(this.primaryRgb, next)) return false
+    this.primaryRgb = next
+    this.invalidateCache()
+    return true
+  }
+
+  render(frameBuffer: OptimizedBuffer, options: GoUpsellArtRenderOptions = {}) {
+    const rgb = options.rgb === true
+    this.elapsed = (this.elapsed + (options.deltaTime ?? 0)) % PERIOD
+    this.rebuildGeometry(frameBuffer, rgb)
+    if (options.cache !== false) {
+      this.drawCached(frameBuffer, rgb)
+      return
+    }
+    this.drawBackground(frameBuffer, this.elapsed)
+    this.drawLogo(frameBuffer, this.elapsed, rgb)
+  }
+
+  private invalidateCache() {
+    this.cacheDirty = true
+    this.cacheBuildIndex = 0
+    this.frameCache = []
+  }
+
+  private rebuildGeometry(frameBuffer: OptimizedBuffer, rgb: boolean) {
+    const width = frameBuffer.width
+    const height = frameBuffer.height
+    const geometryChanged = width !== this.geometryWidth || height !== this.geometryHeight
+    const logoTemplateChanged = this.logoRgb !== rgb
+    if (!geometryChanged && !logoTemplateChanged) return
+
+    if (geometryChanged) {
+      this.geometryWidth = width
+      this.geometryHeight = height
+      this.logoX = Math.max(0, Math.floor((width - LOGO_WIDTH) / 2))
+      this.logoY = Math.max(
+        0,
+        Math.min(Math.max(0, height - LOGO_HEIGHT), Math.round((height - LOGO_HEIGHT) / 2) + LOGO_TOP_BIAS),
+      )
+
+      const centerX = this.logoX + LOGO_WIDTH / 2
+      const centerY = this.logoY + LOGO_HEIGHT / 2
+      this.reach = Math.hypot(Math.max(centerX, width - centerX), Math.max(centerY, height - centerY) * 2) + TAIL
+      this.distances = new Float32Array(width * height)
+      this.edgeFalloff = new Float32Array(width * height)
+
+      for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+          const index = y * width + x
+          const dist = Math.hypot(x + 0.5 - centerX, (y + 0.5 - centerY) * 2)
+          this.distances[index] = dist
+          this.edgeFalloff[index] = Math.max(0, 1 - (dist / (this.reach * 0.85)) ** 2)
+        }
+      }
+    }
+
+    this.logoRgb = rgb
+    this.invalidateCache()
+    this.rebuildCellTemplate(frameBuffer, rgb)
+  }
+
+  private drawCached(frameBuffer: OptimizedBuffer, rgb: boolean) {
+    if (this.cacheDirty) this.startFrameCache(frameBuffer, rgb)
+    if (this.cacheBuildIndex < CACHE_FRAME_COUNT) {
+      this.buildFrameCache(frameBuffer, rgb)
+      this.drawBackground(frameBuffer, this.elapsed)
+      this.drawLogo(frameBuffer, this.elapsed, rgb)
+      return
+    }
+
+    const frame = this.frameCache[Math.floor((this.elapsed / PERIOD) * CACHE_FRAME_COUNT) % CACHE_FRAME_COUNT]
+    if (frame) {
+      frameBuffer.buffers.fg.set(frame.fg)
+      frameBuffer.buffers.bg.set(frame.bg)
+    }
+  }
+
+  private startFrameCache(frameBuffer: OptimizedBuffer, rgb: boolean) {
+    this.frameCache = []
+    this.cacheBuildIndex = 0
+    this.rebuildCellTemplate(frameBuffer, rgb)
+    this.cacheDirty = false
+  }
+
+  private buildFrameCache(frameBuffer: OptimizedBuffer, rgb: boolean) {
+    const end = Math.min(CACHE_FRAME_COUNT, this.cacheBuildIndex + CACHE_FRAMES_PER_RENDER)
+    for (; this.cacheBuildIndex < end; this.cacheBuildIndex++) {
+      const t = (this.cacheBuildIndex / CACHE_FRAME_COUNT) * PERIOD
+      this.drawBackground(frameBuffer, t)
+      this.drawLogo(frameBuffer, t, rgb)
+      this.frameCache.push({
+        fg: new Uint16Array(frameBuffer.buffers.fg),
+        bg: new Uint16Array(frameBuffer.buffers.bg),
+      })
+    }
+  }
+
+  private rebuildCellTemplate(frameBuffer: OptimizedBuffer, rgb: boolean) {
+    const buffers = frameBuffer.buffers
+    buffers.char.fill(SPACE)
+    buffers.attributes.fill(0)
+
+    if (this.geometryWidth < LOGO_WIDTH || this.geometryHeight < LOGO_HEIGHT) {
+      this.logoIndexes = new Int32Array(0)
+      return
+    }
+
+    this.logoIndexes = new Int32Array(LOGO_TEMPLATE.length)
+    for (let i = 0; i < LOGO_TEMPLATE.length; i++) {
+      const cell = LOGO_TEMPLATE[i]!
+      const index = (this.logoY + cell.y) * this.geometryWidth + this.logoX + cell.x
+      this.logoIndexes[i] = index
+      buffers.attributes[index] = cell.attributes
+      buffers.char[index] =
+        cell.kind === LogoCellKind.Background
+          ? SPACE
+          : cell.kind === LogoCellKind.Top || cell.kind === LogoCellKind.ShadowTop
+            ? TOP_HALF
+            : cell.kind === LogoCellKind.Solid
+              ? rgb
+                ? TOP_HALF
+                : FULL_BLOCK
+              : cell.charCode
+    }
+  }
+
+  private drawBackground(frameBuffer: OptimizedBuffer, t: number) {
+    const buffers = frameBuffer.buffers
+    const fg = buffers.fg
+    const bg = buffers.bg
+    const distances = this.distances
+    const edgeFalloff = this.edgeFalloff
+    const baseR = this.panelRgb[0]
+    const baseG = this.panelRgb[1]
+    const baseB = this.panelRgb[2]
+    const deltaR = this.primaryRgb[0] - baseR
+    const deltaG = this.primaryRgb[1] - baseG
+    const deltaB = this.primaryRgb[2] - baseB
+    const breath = (0.5 + 0.5 * Math.sin(t * BREATH_SPEED)) * BREATH_AMP
+
+    const phase0 = (t / PERIOD - PHASE_OFFSET + 1) % 1
+    const phase1 = (t / PERIOD + 1 / RINGS - PHASE_OFFSET + 1) % 1
+    const phase2 = (t / PERIOD + 2 / RINGS - PHASE_OFFSET + 1) % 1
+    const envelope0 = Math.sin(phase0 * Math.PI)
+    const envelope1 = Math.sin(phase1 * Math.PI)
+    const envelope2 = Math.sin(phase2 * Math.PI)
+    const eased0 = envelope0 * envelope0 * (3 - 2 * envelope0)
+    const eased1 = envelope1 * envelope1 * (3 - 2 * envelope1)
+    const eased2 = envelope2 * envelope2 * (3 - 2 * envelope2)
+    const head0 = phase0 * this.reach
+    const head1 = phase1 * this.reach
+    const head2 = phase2 * this.reach
+
+    for (let index = 0; index < distances.length; index++) {
+      const dist = distances[index]
+      const delta0 = dist - head0
+      const abs0 = delta0 < 0 ? -delta0 : delta0
+      const crest0 = abs0 < WIDTH ? 0.5 + 0.5 * Math.cos((delta0 / WIDTH) * Math.PI) : 0
+      const tail0 = delta0 < 0 && delta0 > -TAIL ? (1 + delta0 * TAIL_SCALE) ** 2.3 : 0
+
+      const delta1 = dist - head1
+      const abs1 = delta1 < 0 ? -delta1 : delta1
+      const crest1 = abs1 < WIDTH ? 0.5 + 0.5 * Math.cos((delta1 / WIDTH) * Math.PI) : 0
+      const tail1 = delta1 < 0 && delta1 > -TAIL ? (1 + delta1 * TAIL_SCALE) ** 2.3 : 0
+
+      const delta2 = dist - head2
+      const abs2 = delta2 < 0 ? -delta2 : delta2
+      const crest2 = abs2 < WIDTH ? 0.5 + 0.5 * Math.cos((delta2 / WIDTH) * Math.PI) : 0
+      const tail2 = delta2 < 0 && delta2 > -TAIL ? (1 + delta2 * TAIL_SCALE) ** 2.3 : 0
+
+      const level =
+        (crest0 * AMP + tail0 * TAIL_AMP) * eased0 +
+        (crest1 * AMP + tail1 * TAIL_AMP) * eased1 +
+        (crest2 * AMP + tail2 * TAIL_AMP) * eased2
+      const rawStrength = (level * RING_SCALE + breath) * edgeFalloff[index]
+      const strength = (rawStrength > 1 ? 1 : rawStrength) * 0.7
+      const offset = index * 4
+      const r = Math.round(baseR + deltaR * strength)
+      const g = Math.round(baseG + deltaG * strength)
+      const b = Math.round(baseB + deltaB * strength)
+      bg[offset] = fg[offset] = r
+      bg[offset + 1] = fg[offset + 1] = g
+      bg[offset + 2] = fg[offset + 2] = b
+      bg[offset + 3] = fg[offset + 3] = 255
+    }
+  }
+
+  private setLogoPulse(dist: number, head0: number, eased0: number, head1: number, eased1: number) {
+    let peak = 0.04
+    let primary = 0
+
+    const delta0 = dist - head0
+    const core0 = Math.exp(-(Math.abs(delta0 / 1.2) ** 1.8))
+    const soft0 = Math.exp(-(Math.abs(delta0 / 7) ** 1.6))
+    const tail0 = delta0 < 0 && delta0 > -7 ? (1 + delta0 / 7) ** 2.6 : 0
+    peak += core0 * 0.65 * eased0
+    primary += (soft0 * 0.16 + tail0 * 0.22) * eased0
+
+    const delta1 = dist - head1
+    const core1 = Math.exp(-(Math.abs(delta1 / 1.2) ** 1.8))
+    const soft1 = Math.exp(-(Math.abs(delta1 / 7) ** 1.6))
+    const tail1 = delta1 < 0 && delta1 > -7 ? (1 + delta1 / 7) ** 2.6 : 0
+    peak += core1 * 0.65 * eased1
+    primary += (soft1 * 0.16 + tail1 * 0.22) * eased1
+
+    this.pulsePeak = peak > 1 ? 1 : peak
+    this.pulsePrimary = primary > 1 ? 1 : primary
+  }
+
+  private drawLogo(frameBuffer: OptimizedBuffer, t: number, rgb: boolean) {
+    if (this.logoIndexes.length === 0) return
+
+    const buffers = frameBuffer.buffers
+    const fg = buffers.fg
+    const bg = buffers.bg
+    const shadow: Rgb = [
+      mixChannel(this.panelRgb[0], this.logoBaseRgb[0], 0.25),
+      mixChannel(this.panelRgb[1], this.logoBaseRgb[1], 0.25),
+      mixChannel(this.panelRgb[2], this.logoBaseRgb[2], 0.25),
+    ]
+    const phase0 = (t / PERIOD) % 1
+    const phase1 = (t / PERIOD + 0.5) % 1
+    const envelope0 = Math.sin(phase0 * Math.PI)
+    const envelope1 = Math.sin(phase1 * Math.PI)
+    const eased0 = envelope0 * envelope0 * (3 - 2 * envelope0)
+    const eased1 = envelope1 * envelope1 * (3 - 2 * envelope1)
+    const head0 = phase0 * LOGO_REACH
+    const head1 = phase1 * LOGO_REACH
+
+    for (let i = 0; i < LOGO_TEMPLATE.length; i++) {
+      const cell = LOGO_TEMPLATE[i]!
+      const index = this.logoIndexes[i]!
+      const offset = index * 4
+      this.setLogoPulse(cell.topDist, head0, eased0, head1, eased1)
+      const topPeak = this.pulsePeak
+      const topPrimary = this.pulsePrimary
+      this.setLogoPulse(cell.bottomDist, head0, eased0, head1, eased1)
+      const bottomPeak = this.pulsePeak
+      const bottomPrimary = this.pulsePrimary
+
+      if (cell.kind === LogoCellKind.Background) {
+        writeLogoTint(bg, offset, shadow, this.primaryRgb, 0, Math.max(topPeak, bottomPeak) * 0.18)
+        continue
+      }
+
+      if (cell.kind === LogoCellKind.Top) {
+        writeLogoTint(fg, offset, this.logoBaseRgb, this.primaryRgb, topPrimary, topPeak)
+        writeLogoTint(bg, offset, shadow, this.primaryRgb, 0, bottomPeak * 0.18)
+        continue
+      }
+
+      if (cell.kind === LogoCellKind.ShadowTop) {
+        writeLogoTint(fg, offset, shadow, this.primaryRgb, 0, topPeak * 0.18)
+        continue
+      }
+
+      if (cell.kind === LogoCellKind.Solid && rgb) {
+        writeLogoTint(fg, offset, this.logoBaseRgb, this.primaryRgb, topPrimary, topPeak)
+        writeLogoTint(bg, offset, this.logoBaseRgb, this.primaryRgb, bottomPrimary, bottomPeak)
+        continue
+      }
+
+      writeLogoTint(
+        fg,
+        offset,
+        this.logoBaseRgb,
+        this.primaryRgb,
+        (topPrimary + bottomPrimary) / 2,
+        (topPeak + bottomPeak) / 2,
+      )
+    }
+  }
+}

packages/tui/src/component/bg-pulse.tsx

@@ -0,0 +1,102 @@
+import {
+  FrameBufferRenderable,
+  RGBA,
+  type OptimizedBuffer,
+  type RenderContext,
+  type RenderableOptions,
+} from "@opentui/core"
+import { extend, useRenderer } from "@opentui/solid"
+import { onCleanup, onMount } from "solid-js"
+import { useTheme, useThemes } from "../context/theme"
+import { tint } from "../theme/color"
+import { GoUpsellArtPainter } from "./bg-pulse-render"
+
+type GoUpsellArtOptions = RenderableOptions<FrameBufferRenderable> & {
+  backgroundPanel?: RGBA
+  primary?: RGBA
+  logoBase?: RGBA
+}
+
+class GoUpsellArtRenderable extends FrameBufferRenderable {
+  private painter = new GoUpsellArtPainter()
+
+  constructor(ctx: RenderContext, options: GoUpsellArtOptions = {}) {
+    const width = typeof options.width === "number" ? options.width : 1
+    const height = typeof options.height === "number" ? options.height : 1
+    super(ctx, {
+      ...options,
+      width,
+      height,
+      live: options.live ?? true,
+      respectAlpha: false,
+    })
+
+    if (options.width !== undefined && typeof options.width !== "number") this.width = options.width
+    if (options.height !== undefined && typeof options.height !== "number") this.height = options.height
+    this.painter.setBackgroundPanel(options.backgroundPanel)
+    this.painter.setPrimary(options.primary)
+    this.painter.setLogoBase(options.logoBase)
+  }
+
+  set backgroundPanel(value: RGBA | undefined) {
+    if (this.painter.setBackgroundPanel(value)) this.requestRender()
+  }
+
+  set logoBase(value: RGBA | undefined) {
+    if (this.painter.setLogoBase(value)) this.requestRender()
+  }
+
+  set primary(value: RGBA | undefined) {
+    if (this.painter.setPrimary(value)) this.requestRender()
+  }
+
+  protected override renderSelf(buffer: OptimizedBuffer, deltaTime = 0): void {
+    if (!this.visible || this.isDestroyed) return
+
+    this.painter.render(this.frameBuffer, {
+      deltaTime,
+      rgb: this._ctx.capabilities?.rgb === true,
+    })
+    super.renderSelf(buffer)
+  }
+}
+
+declare module "@opentui/solid" {
+  interface OpenTUIComponents {
+    go_upsell_art: typeof GoUpsellArtRenderable
+  }
+}
+
+extend({ go_upsell_art: GoUpsellArtRenderable })
+
+export function BgPulse() {
+  const themes = useThemes()
+  const theme = useTheme("elevated")
+  const mode = themes.mode
+  const renderer = useRenderer()
+  let targetFps = renderer.targetFps
+  let maxFps = renderer.maxFps
+
+  onMount(() => {
+    targetFps = renderer.targetFps
+    maxFps = renderer.maxFps
+    renderer.targetFps = 30
+    renderer.maxFps = 30
+  })
+
+  onCleanup(() => {
+    renderer.targetFps = targetFps
+    renderer.maxFps = maxFps
+  })
+
+  return (
+    <go_upsell_art
+      width="100%"
+      height="100%"
+      backgroundPanel={theme.background.default}
+      primary={theme.hue.interactive[mode() === "light" ? 800 : 200]}
+      logoBase={tint(theme.background.default, theme.text.default, 0.62)}
+      live
+    />
+  )
+}

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

@@ -1,165 +0,0 @@
-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?.canonical === "/" ? undefined : project?.name || path.basename(project?.canonical ?? "")
-      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: `${name ? `${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 footer = abbreviateHome(project.canonical, paths.home)
-        // Dialog padding, the gutter column, title padding, and the separating space use nine columns.
-        const width = Math.min(60, dimensions().width - 2) - 9 - stringWidth(title)
-        return {
-          title,
-          footer: truncateFilePath(footer, width),
-          searchText: footer,
-          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

@@ -0,0 +1,67 @@
+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"
+
+export function DialogProject() {
+  const dialog = useDialog()
+  const data = useData()
+  const route = useRoute()
+  const paths = useTuiPaths()
+  const location = useLocation()
+  const toast = useToast()
+
+  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) => ({
+        title: project.name ?? path.basename(project.canonical),
+        description: abbreviateHome(project.canonical, paths.home),
+        value: project.canonical,
+        category: project.id === current()?.id ? "Current" : "Projects",
+      }))
+  })
+
+  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-retry-action.tsx

@@ -0,0 +1,164 @@
+import { RGBA, TextAttributes } from "@opentui/core"
+import open from "open"
+import { createSignal } from "solid-js"
+import { Keymap } from "../context/keymap"
+import { useTheme } from "../context/theme"
+import { useDialog, type DialogContext } from "../ui/dialog"
+import { Link } from "../ui/link"
+import { BgPulse } from "./bg-pulse"
+
+const GO_URL = "https://opencode.ai/go"
+const PAD_X = 3
+const PAD_TOP_OUTER = 1
+const FOREGROUND_ALPHA = 186
+
+export type DialogRetryActionProps = {
+  title: string
+  message: string
+  label: string
+  link?: string
+  onClose?: (dontShowAgain?: boolean) => void
+}
+
+function runAction(props: DialogRetryActionProps, dialog: ReturnType<typeof useDialog>) {
+  if (props.link) open(props.link).catch(() => {})
+  props.onClose?.()
+  dialog.clear()
+}
+
+function dismiss(props: DialogRetryActionProps, dialog: ReturnType<typeof useDialog>) {
+  props.onClose?.(true)
+  dialog.clear()
+}
+
+function panelOverlay(color: RGBA) {
+  const [r, g, b] = color.toInts()
+  return RGBA.fromInts(r, g, b, FOREGROUND_ALPHA)
+}
+
+export function DialogRetryAction(props: DialogRetryActionProps) {
+  const dialog = useDialog()
+  const theme = useTheme("elevated")
+  const showGoTreatment = () => props.link === GO_URL
+  const textBg = () => (showGoTreatment() ? panelOverlay(theme.background.default) : undefined)
+  const [selected, setSelected] = createSignal<"dismiss" | "action">("action")
+
+  Keymap.createLayer(() => ({
+    mode: "modal",
+    commands: [
+      {
+        bind: "left",
+        title: "Previous retry option",
+        group: "Dialog",
+        run: () => setSelected((value) => (value === "action" ? "dismiss" : "action")),
+      },
+      {
+        bind: "right",
+        title: "Next retry option",
+        group: "Dialog",
+        run: () => setSelected((value) => (value === "action" ? "dismiss" : "action")),
+      },
+      {
+        bind: "tab",
+        title: "Next retry option",
+        group: "Dialog",
+        run: () => setSelected((value) => (value === "action" ? "dismiss" : "action")),
+      },
+      {
+        bind: "return",
+        title: "Confirm retry option",
+        group: "Dialog",
+        run: () => {
+          if (selected() === "action") runAction(props, dialog)
+          else dismiss(props, dialog)
+        },
+      },
+    ],
+  }))
+
+  return (
+    <box>
+      {showGoTreatment() ? (
+        <box position="absolute" top={-PAD_TOP_OUTER} left={0} right={0} bottom={0} zIndex={0}>
+          <BgPulse />
+        </box>
+      ) : null}
+      <box zIndex={1} paddingLeft={PAD_X} paddingRight={PAD_X} paddingBottom={1} gap={1}>
+        <box flexDirection="row" justifyContent="space-between">
+          <text attributes={TextAttributes.BOLD} fg={theme.text.default} bg={textBg()}>
+            {props.title}
+          </text>
+          <text fg={theme.text.subdued} bg={textBg()} onMouseUp={() => dialog.clear()}>
+            esc
+          </text>
+        </box>
+        <box gap={0}>
+          <text fg={theme.text.subdued} bg={textBg()}>
+            {props.message}
+          </text>
+        </box>
+        {props.link ? (
+          showGoTreatment() ? (
+            <box alignItems="center" justifyContent="flex-end" height={7} paddingBottom={1}>
+              <Link href={props.link} fg={theme.markdown.link} bg={textBg()} wrapMode="none" />
+            </box>
+          ) : (
+            <box width="100%" flexDirection="row" justifyContent="center" paddingBottom={1}>
+              <Link href={props.link} fg={theme.markdown.link} wrapMode="none" />
+            </box>
+          )
+        ) : (
+          <box paddingBottom={1} />
+        )}
+        <box flexDirection="row" justifyContent="space-between">
+          <box
+            paddingLeft={2}
+            paddingRight={2}
+            backgroundColor={
+              selected() === "dismiss" ? theme.background.action.primary.focused : RGBA.fromInts(0, 0, 0, 0)
+            }
+            onMouseOver={() => setSelected("dismiss")}
+            onMouseUp={() => dismiss(props, dialog)}
+          >
+            <text
+              fg={selected() === "dismiss" ? theme.text.action.primary.focused : theme.text.subdued}
+              bg={selected() === "dismiss" ? undefined : textBg()}
+              attributes={selected() === "dismiss" ? TextAttributes.BOLD : undefined}
+            >
+              don't show again
+            </text>
+          </box>
+          <box
+            paddingLeft={2}
+            paddingRight={2}
+            backgroundColor={
+              selected() === "action" ? theme.background.action.primary.focused : RGBA.fromInts(0, 0, 0, 0)
+            }
+            onMouseOver={() => setSelected("action")}
+            onMouseUp={() => runAction(props, dialog)}
+          >
+            <text
+              fg={selected() === "action" ? theme.text.action.primary.focused : theme.text.default}
+              bg={selected() === "action" ? undefined : textBg()}
+              attributes={selected() === "action" ? TextAttributes.BOLD : undefined}
+            >
+              {props.label}
+            </text>
+          </box>
+        </box>
+      </box>
+    </box>
+  )
+}
+
+DialogRetryAction.show = (
+  dialog: DialogContext,
+  props: Pick<DialogRetryActionProps, "title" | "message" | "label" | "link">,
+) => {
+  return new Promise<boolean>((resolve) => {
+    dialog.replace(
+      () => <DialogRetryAction {...props} onClose={(dontShow) => resolve(dontShow ?? false)} />,
+      () => resolve(false),
+    )
+  })
+}

packages/tui/src/component/dialog-session-delete-failed.tsx

@@ -0,0 +1,113 @@
+import { TextAttributes } from "@opentui/core"
+import { Keymap } from "../context/keymap"
+import { useTheme } from "../context/theme"
+import { useDialog } from "../ui/dialog"
+import { createStore } from "solid-js/store"
+import { For } from "solid-js"
+
+export function DialogSessionDeleteFailed(props: {
+  session: string
+  workspace: string
+  onDelete?: () => boolean | void | Promise<boolean | void>
+  onRestore?: () => boolean | void | Promise<boolean | void>
+  onDone?: () => void
+}) {
+  const dialog = useDialog()
+  const theme = useTheme("elevated")
+  const [store, setStore] = createStore({
+    active: "delete" as "delete" | "restore",
+  })
+
+  const options = [
+    {
+      id: "delete" as const,
+      title: "Delete workspace",
+      description: "Delete the workspace and all sessions attached to it.",
+      run: props.onDelete,
+    },
+    {
+      id: "restore" as const,
+      title: "Restore to new workspace",
+      description: "Try to restore this session into a new workspace.",
+      run: props.onRestore,
+    },
+  ]
+
+  async function confirm() {
+    const result = await options.find((item) => item.id === store.active)?.run?.()
+    if (result === false) return
+    props.onDone?.()
+    if (!props.onDone) dialog.clear()
+  }
+
+  Keymap.createLayer(() => ({
+    mode: "modal",
+    commands: [
+      { bind: "return", title: "Confirm recovery option", group: "Dialog", run: () => void confirm() },
+      { bind: "left", title: "Delete broken session", group: "Dialog", run: () => setStore("active", "delete") },
+      { bind: "up", title: "Delete broken session", group: "Dialog", run: () => setStore("active", "delete") },
+      {
+        bind: "right",
+        title: "Restore broken session",
+        group: "Dialog",
+        run: () => setStore("active", "restore"),
+      },
+      {
+        bind: "down",
+        title: "Restore broken session",
+        group: "Dialog",
+        run: () => setStore("active", "restore"),
+      },
+    ],
+  }))
+
+  return (
+    <box paddingLeft={2} paddingRight={2} gap={1}>
+      <box flexDirection="row" justifyContent="space-between">
+        <text attributes={TextAttributes.BOLD} fg={theme.text.default}>
+          Failed to Delete Session
+        </text>
+        <text fg={theme.text.subdued} onMouseUp={() => dialog.clear()}>
+          esc
+        </text>
+      </box>
+      <text fg={theme.text.subdued} wrapMode="word">
+        {`The session "${props.session}" could not be deleted because the workspace "${props.workspace}" is not available.`}
+      </text>
+      <text fg={theme.text.subdued} wrapMode="word">
+        Choose how you want to recover this broken workspace session.
+      </text>
+      <box flexDirection="column" paddingBottom={1} gap={1}>
+        <For each={options}>
+          {(item) => (
+            <box
+              flexDirection="column"
+              paddingLeft={1}
+              paddingRight={1}
+              paddingTop={1}
+              paddingBottom={1}
+              backgroundColor={item.id === store.active ? theme.background.action.primary.focused : undefined}
+              onMouseUp={() => {
+                setStore("active", item.id)
+                void confirm()
+              }}
+            >
+              <text
+                attributes={TextAttributes.BOLD}
+                fg={item.id === store.active ? theme.text.action.primary.focused : theme.text.default}
+              >
+                {item.title}
+              </text>
+              <text
+                fg={item.id === store.active ? theme.text.action.primary.focused : theme.text.subdued}
+                wrapMode="word"
+              >
+                {item.description}
+              </text>
+            </box>
+          )}
+        </For>
+      </box>
+    </box>
+  )
+}

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

@@ -17,8 +17,6 @@ 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"
 
 export function DialogSessionList() {
   const dialog = useDialog()
@@ -35,8 +33,7 @@ export function DialogSessionList() {
   const shortcuts = Keymap.useShortcuts()
   const [search, setSearch] = createDebouncedSignal("", 150)
   const [toDelete, setToDelete] = createSignal<string>()
-  const [prefs, updatePrefs] = useStorage().store("session-list", { initial: { allProjects: false } })
-  const allProjects = () => prefs.allProjects
+  const [allProjects, setAllProjects] = createSignal(false)
 
   const [searchResults, { mutate: setSearchResults }] = createResource(
     () => ({ query: search().trim(), allProjects: allProjects() }),
@@ -78,7 +75,7 @@ export function DialogSessionList() {
           (session.projectID === current?.project.id && session.location.directory === current.directory),
       )
     if (!query) return sessions
-    return sessions.filter((session) => !session.parentID && sessionTitle(session).toLowerCase().includes(query))
+    return sessions.filter((session) => !session.parentID && session.title.toLowerCase().includes(query))
   })
   const sessions = createMemo(() => {
     const query = filter().trim()
@@ -140,7 +137,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` : sessionTitle(session),
+        title: deleting ? `Press ${shortcuts.get("session.delete")} again to confirm` : session.title,
         value: session.id,
         category,
         footer,
@@ -192,9 +189,7 @@ export function DialogSessionList() {
           title: allProjects() ? "Show current directory sessions" : "Show all project sessions",
           group: "Dialog",
           run: () => {
-            void updatePrefs((draft) => {
-              draft.allProjects = !draft.allProjects
-            }).catch(() => {})
+            setAllProjects((value) => !value)
           },
         },
       ]}

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

@@ -0,0 +1,52 @@
+import { createMemo, createResource } from "solid-js"
+import { DialogSelect } from "../ui/dialog-select"
+import { useDialog } from "../ui/dialog"
+import { useClient } from "../context/client"
+import { useData } from "../context/data"
+import { createStore } from "solid-js/store"
+
+export function DialogTag(props: { onSelect?: (value: string) => void }) {
+  const client = useClient()
+  const dialog = useDialog()
+  const data = useData()
+
+  const [store] = createStore({
+    filter: "",
+  })
+
+  const [files] = createResource(
+    () => [store.filter],
+    async () => {
+      const result = await client.api.file
+        .find({
+          query: store.filter,
+          type: "file",
+          limit: 5,
+          location: {
+            directory: data.location.default().directory,
+            workspace: data.location.default().workspaceID,
+          },
+        })
+        .catch(() => undefined)
+      return result?.data.map((item) => item.path) ?? []
+    },
+  )
+
+  const options = createMemo(() =>
+    (files() ?? []).map((file) => ({
+      value: file,
+      title: file,
+    })),
+  )
+
+  return (
+    <DialogSelect
+      title="Autocomplete"
+      options={options()}
+      onSelect={(option) => {
+        props.onSelect?.(option.value)
+        dialog.clear()
+      }}
+    />
+  )
+}

packages/tui/src/component/patch-diff.tsx

@@ -0,0 +1,73 @@
+/** @jsxImportSource @opentui/solid */
+import { DiffRenderable, LineNumberRenderable, type ColorInput } from "@opentui/core"
+import type { JSX } from "@opentui/solid"
+import { createMemo, For, Show, splitProps } from "solid-js"
+import { splitPatchHunks } from "../util/diff"
+import { stringWidth } from "../util/string-width"
+
+type Props = Omit<JSX.IntrinsicElements["diff"], "diff" | "lineNumberBg"> & {
+  diff: string
+  hunkFg: ColorInput
+  lineNumberBg: ColorInput
+}
+
+export function PatchDiff(props: Props) {
+  const [local, diffProps] = splitProps(props, ["diff", "hunkFg", "lineNumberBg"])
+  const hunks = createMemo(() => splitPatchHunks(local.diff))
+  const nodes = new Set<DiffRenderable>()
+  const syncGutters = (attempt = 0) => {
+    requestAnimationFrame(() => {
+      const sides = [...nodes]
+        .filter((item) => !item.isDestroyed)
+        .flatMap((item) => item.getChildren().filter((side) => side instanceof LineNumberRenderable))
+      const lineNumbers = sides.map((side) => new Map([...side.getLineNumbers()].filter(([line]) => line >= 0)))
+      const digits = lineNumbers.map((numbers) => Math.max(0, ...numbers.values()).toString().length)
+      const after = sides.map((side) =>
+        Math.max(
+          0,
+          ...[...side.getLineSigns()]
+            .filter(([line]) => line >= 0)
+            .map(([, sign]) => stringWidth(sign.after ?? "")),
+        ),
+      )
+      const maxDigits = Math.max(...digits)
+      const maxAfter = Math.max(...after)
+      if (!maxDigits && attempt < 2) return syncGutters(attempt + 1)
+      if (!maxDigits) return
+      sides.forEach((side) => {
+        const index = sides.indexOf(side)
+        const signs = new Map([...side.getLineSigns()].filter(([line]) => line >= 0))
+        signs.set(-1, { after: " ".repeat(maxAfter + maxDigits - digits[index]) })
+        side.setLineNumbers(lineNumbers[index])
+        side.setLineSigns(signs)
+      })
+    })
+  }
+  const register = (node: DiffRenderable) => {
+    nodes.add(node)
+    syncGutters()
+  }
+
+  return (
+    <For each={hunks()}>
+      {(hunk, index) => (
+        <>
+          <Show when={index() > 0}>
+            <box width="100%" height={1} backgroundColor={local.lineNumberBg}>
+              <text fg={local.hunkFg} bg={local.lineNumberBg}>
+                {` ${hunk.header ?? ""}`}
+              </text>
+            </box>
+          </Show>
+          <diff
+            {...diffProps}
+            ref={register}
+            diff={hunk.patch}
+            minHeight={hunk.rows}
+            lineNumberBg={local.lineNumberBg}
+          />
+        </>
+      )}
+    </For>
+  )
+}

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

@@ -240,6 +240,7 @@ export function Prompt(props: PromptProps) {
               return undefined
             })
             if (!location) return
+            move.setDirectory(location.directory, location.directory !== location.project.directory)
             currentLocation.set(location)
             return
           }
@@ -962,10 +963,7 @@ export function Prompt(props: PromptProps) {
       const directory = await move.getDirectory()
       if (move.pending() && !directory) return false
       finishMoveProgress = Boolean(move.progress())
-      // 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 location = data.location.default()
 
       const created = await client.api.session
         .create({
@@ -1301,12 +1299,7 @@ export function Prompt(props: PromptProps) {
     return `Ask anything... "${list()[store.placeholder % list().length]}"`
   })
   const locationLabel = createMemo(() => {
-    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
+    if (!props.sessionID || 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,11 +6,9 @@ import { useSessionTabs } from "../context/session-tabs"
 import { useTheme, useThemes } from "../context/theme"
 import {
   adaptiveSessionTabLayout,
-  NEW_SESSION_TAB_TITLE,
   sessionTabComplete,
   seedSessionTabMotion,
   sessionTabOverflowWidth,
-  type SessionTab,
   type SessionTabUnread,
 } from "../context/session-tabs-model"
 import { createAnimatable, spring, tween } from "../ui/animation"
@@ -26,19 +24,10 @@ type ContextController = ReturnType<typeof useSessionTabs>
 export type SessionTabsStatus = Omit<ReturnType<ContextController["status"]>, "unread"> & {
   unread: SessionTabUnread | undefined
 }
-export const EMPTY_SESSION_TAB_STATUS: SessionTabsStatus = {
-  unread: undefined,
-  promptPulse: 0,
-  attention: false,
-  busy: false,
-}
 export type SessionTabsController = Pick<ContextController, "tabs" | "current" | "select" | "close" | "move"> & {
-  newTab?: () => boolean
   status(sessionID: string): SessionTabsStatus
 }
 
-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()
   const dimensions = useTerminalDimensions()
@@ -53,9 +42,8 @@ export function SessionTabs(props: { controller?: SessionTabsController; animati
   const accent = () => theme.hue.accent[hueStep()]
   const activeNumber = () => theme.hue.interactive[hueStep()]
   const idleNumber = () => tint(theme.text.subdued, theme.background.default, 0.35)
-  const newTab = () => tabs.newTab?.() ?? false
-  const activeID = createMemo(() => (newTab() ? NEW_SESSION_TAB.sessionID : tabs.current()))
-  const items = createMemo(() => (newTab() ? [...tabs.tabs(), NEW_SESSION_TAB] : tabs.tabs()))
+  const activeID = createMemo(tabs.current)
+  const items = tabs.tabs
   const layout = createMemo((previous: ReturnType<typeof adaptiveSessionTabLayout> | undefined) =>
     adaptiveSessionTabLayout(items(), activeID(), dimensions().width, previous?.start),
   )
@@ -63,7 +51,7 @@ export function SessionTabs(props: { controller?: SessionTabsController; animati
     () =>
       new Map(
         layout().tabs.map((tab) => {
-          const status = tab === NEW_SESSION_TAB ? EMPTY_SESSION_TAB_STATUS : tabs.status(tab.sessionID)
+          const status = tabs.status(tab.sessionID)
           return [
             tab.sessionID,
             {
@@ -210,11 +198,6 @@ 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 })
@@ -279,7 +262,6 @@ export function SessionTabs(props: { controller?: SessionTabsController; animati
           // keeping sloppy clicks indistinguishable from clean ones.
           const release = () => {
             setDragging(undefined)
-            if (tab === NEW_SESSION_TAB) return
             tabs.select(tab.sessionID)
           }
           return (
@@ -293,7 +275,6 @@ export function SessionTabs(props: { controller?: SessionTabsController; animati
               onMouseDown={() => setDragging(tab.sessionID)}
               onMouseUp={release}
               onMouseDrag={(event) => {
-                if (tab === NEW_SESSION_TAB) return
                 const slot = slotAt(event.x)
                 if (slot !== undefined && slot !== tabNumber() - 1) tabs.move(tab.sessionID, slot)
               }}
@@ -302,7 +283,6 @@ export function SessionTabs(props: { controller?: SessionTabsController; animati
               <TabPulse
                 enabled={animations()}
                 active={status().busy && !status().attention}
-                promptPulse={status().promptPulse}
                 complete={status().complete && !status().attention}
                 glow={glows()}
                 breathe={status().attention}
@@ -342,7 +322,7 @@ export function SessionTabs(props: { controller?: SessionTabsController; animati
                   selectable={false}
                   onMouseUp={(event) => {
                     event.stopPropagation()
-                    tabs.close(tab === NEW_SESSION_TAB ? undefined : tab.sessionID)
+                    tabs.close(tab.sessionID)
                   }}
                 >
                   {hovered() === tab.sessionID ? "×" : ""}

packages/tui/src/component/tab-pulse.tsx

@@ -4,7 +4,6 @@ import { extend } from "@opentui/solid"
 type TabPulseOptions = RenderableOptions<TabPulseRenderable> & {
   enabled?: boolean
   active?: boolean
-  promptPulse?: number
   complete?: boolean
   glow?: boolean
   breathe?: boolean
@@ -29,7 +28,6 @@ const COMPLETION_OPACITY = 0.18
 const EDGE_FLASH_DURATION = 800
 const EDGE_FLASH_ATTACK = 0.1
 const EDGE_FLASH_OPACITY = 0.1
-const PROMPT_FLASH_SCALE = 2
 const GLOW_IGNITION_DURATION = 600
 const GLOW_IGNITION_PEAK = 1.5
 const GLOW_IGNITION_ATTACK = 0.3
@@ -104,11 +102,6 @@ class Envelope {
     this.scale = scale
   }
 
-  restart(scale = 1) {
-    this.clock = 0
-    this.scale = scale
-  }
-
   stop() {
     this.clock = undefined
   }
@@ -134,7 +127,6 @@ const envelopeActive = (envelope: Envelope) => envelope.active
 class TabPulseRenderable extends Renderable {
   private _enabled: boolean
   private _active: boolean
-  private _promptPulse: number
   private _complete: boolean
   private _glow: boolean
   private _breathe: boolean
@@ -162,7 +154,6 @@ class TabPulseRenderable extends Renderable {
     super(ctx, { ...options, height: 1, live: enabled && active })
     this._enabled = enabled
     this._active = active
-    this._promptPulse = options.promptPulse ?? 0
     this._complete = options.complete ?? false
     this._glow = options.glow ?? false
     this._breathe = options.breathe ?? false
@@ -231,15 +222,6 @@ class TabPulseRenderable extends Renderable {
     this.requestRender()
   }
 
-  set promptPulse(value: number) {
-    if (value === this._promptPulse) return
-    this._promptPulse = value
-    if (!this._enabled) return
-    this.edgeFlash.restart(PROMPT_FLASH_SCALE)
-    this.live = true
-    this.requestRender()
-  }
-
   set complete(value: boolean) {
     if (value === this._complete) return
     this._complete = value
@@ -386,7 +368,6 @@ extend({ tab_pulse: TabPulseRenderable })
 export function TabPulse(props: {
   enabled?: boolean
   active: boolean
-  promptPulse?: number
   complete?: boolean
   glow?: boolean
   breathe?: boolean
@@ -404,7 +385,6 @@ export function TabPulse(props: {
       width="100%"
       enabled={props.enabled ?? true}
       active={props.active}
-      promptPulse={props.promptPulse ?? 0}
       complete={props.complete ?? false}
       glow={props.glow ?? false}
       breathe={props.breathe ?? false}

packages/tui/src/config/index.tsx

@@ -127,13 +127,13 @@ export const Info = Schema.Struct({
   tabs: Schema.optional(
     Schema.Struct({
       enabled: Schema.optional(Schema.Boolean).annotate({
-        description: "Use a persistent tab strip instead of pinned quick-switch sessions",
+        description: "Use a persistent session tab strip instead of pinned quick-switch sessions",
       }),
       scope: Schema.optional(Schema.Literals(["global", "cwd"])).annotate({
-        description: "Share tabs globally or keep a separate set for each working directory",
+        description: "Share session tabs globally or keep a separate set for each working directory",
       }),
     }),
-  ).annotate({ description: "Tab strip settings" }),
+  ).annotate({ description: "Session tab settings" }),
   mini: Schema.optional(
     Schema.Struct({
       thinking: Schema.optional(Schema.Literals(["show", "hide"])).annotate({

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

@@ -87,13 +87,13 @@ 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_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"),
-  session_tab_reopen: keybind("ctrl+shift+t", "Reopen last closed tab"),
+  session_tab_next: keybind("ctrl+tab,<leader>right", "Switch to next open session tab"),
+  session_tab_previous: keybind("ctrl+shift+tab,<leader>left", "Switch to previous open session tab"),
+  session_tab_history_back: keybind("ctrl+o", "Go back in session tab history"),
+  session_tab_history_forward: keybind("ctrl+i", "Go forward in session tab history"),
+  session_tab_next_unread: keybind("<leader>down", "Switch to next unread session tab"),
+  session_tab_previous_unread: keybind("<leader>up", "Switch to previous unread session tab"),
+  session_tab_close: keybind("<leader>w", "Close current session tab"),
   session_timeline: keybind("<leader>g", "Show session timeline"),
   session_fork: keybind("none", "Fork session from message"),
   session_rename: keybind("ctrl+r", "Rename session"),
@@ -118,15 +118,15 @@ export const Definitions = {
   session_quick_switch_7: keybind("<leader>7", "Switch to session in quick slot 7"),
   session_quick_switch_8: keybind("<leader>8", "Switch to session in quick slot 8"),
   session_quick_switch_9: keybind("<leader>9", "Switch to session in quick slot 9"),
-  session_tab_select_1: keybind("<leader>1,ctrl+1", "Switch to tab 1"),
-  session_tab_select_2: keybind("<leader>2,ctrl+2", "Switch to tab 2"),
-  session_tab_select_3: keybind("<leader>3,ctrl+3", "Switch to tab 3"),
-  session_tab_select_4: keybind("<leader>4,ctrl+4", "Switch to tab 4"),
-  session_tab_select_5: keybind("<leader>5,ctrl+5", "Switch to tab 5"),
-  session_tab_select_6: keybind("<leader>6,ctrl+6", "Switch to tab 6"),
-  session_tab_select_7: keybind("<leader>7,ctrl+7", "Switch to tab 7"),
-  session_tab_select_8: keybind("<leader>8,ctrl+8", "Switch to tab 8"),
-  session_tab_select_9: keybind("<leader>9,ctrl+9", "Switch to tab 9"),
+  session_tab_select_1: keybind("<leader>1,ctrl+1", "Switch to session tab 1"),
+  session_tab_select_2: keybind("<leader>2,ctrl+2", "Switch to session tab 2"),
+  session_tab_select_3: keybind("<leader>3,ctrl+3", "Switch to session tab 3"),
+  session_tab_select_4: keybind("<leader>4,ctrl+4", "Switch to session tab 4"),
+  session_tab_select_5: keybind("<leader>5,ctrl+5", "Switch to session tab 5"),
+  session_tab_select_6: keybind("<leader>6,ctrl+6", "Switch to session tab 6"),
+  session_tab_select_7: keybind("<leader>7,ctrl+7", "Switch to session tab 7"),
+  session_tab_select_8: keybind("<leader>8,ctrl+8", "Switch to session tab 8"),
+  session_tab_select_9: keybind("<leader>9,ctrl+9", "Switch to session tab 9"),
 
   stash_delete: keybind("ctrl+d", "Delete stash entry"),
   model_provider_list: keybind("ctrl+a", "Open provider list from model dialog"),
@@ -290,13 +290,13 @@ 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",
-  session_tab_reopen: "session.tab.reopen",
   session_timeline: "session.timeline",
   session_fork: "session.fork",
   session_rename: "session.rename",

packages/tui/src/context/data.tsx

@@ -1089,11 +1089,6 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
         list(location?: LocationRef) {
           return Object.values(store.location[locationKey(location ?? defaultLocation())]?.shell ?? {})
         },
-        listBySession(sessionID: string) {
-          return Object.values(store.location)
-            .flatMap((data) => Object.values(data.shell ?? {}))
-            .filter((shell) => shell.metadata.sessionID === sessionID)
-        },
         get(id: string) {
           return Object.values(store.location)
             .map((data) => data.shell?.[id])

packages/tui/src/context/directory.ts

@@ -0,0 +1,13 @@
+import { createMemo } from "solid-js"
+import { useData } from "./data"
+import { abbreviateHome } from "../runtime"
+import { useTuiPaths } from "./runtime"
+
+export function useDirectory() {
+  const data = useData()
+  const paths = useTuiPaths()
+  return createMemo(() => {
+    const directory = data.location.info()?.directory ?? data.location.default().directory ?? paths.cwd
+    return abbreviateHome(directory, paths.home)
+  })
+}

packages/tui/src/context/location.tsx

@@ -5,8 +5,6 @@ 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
 }>()
 
@@ -39,9 +37,6 @@ export function LocationProvider(props: ParentProps) {
         get current() {
           return current()
         },
-        get ref() {
-          return ref()
-        },
         set,
       }}
     >

packages/tui/src/context/route.tsx

@@ -7,7 +7,6 @@ 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,8 +5,6 @@ export type SessionTab = {
 
 export type SessionTabUnread = "activity" | "error"
 
-export const NEW_SESSION_TAB_TITLE = "New session"
-
 export type SessionTabHistory = {
   entries: readonly string[]
   index: number
@@ -38,39 +36,6 @@ export function closeSessionTab(tabs: readonly SessionTab[], sessionID: string)
   }
 }
 
-export type ClosedSessionTab = {
-  tab: SessionTab
-  index: number
-}
-
-const CLOSED_SESSION_TAB_LIMIT = 10
-
-export function recordClosedSessionTab(
-  stack: readonly ClosedSessionTab[],
-  tab: SessionTab,
-  index: number,
-): ClosedSessionTab[] {
-  return [...stack.filter((entry) => entry.tab.sessionID !== tab.sessionID), { tab, index }].slice(
-    -CLOSED_SESSION_TAB_LIMIT,
-  )
-}
-
-/**
- * Pop the most recently closed tab that is not already open and restore it at its original
- * position. Entries for already-open sessions are consumed so repeated reopens walk the stack.
- */
-export function reopenSessionTab(stack: readonly ClosedSessionTab[], tabs: readonly SessionTab[]) {
-  const remaining = [...stack]
-  while (remaining.length > 0) {
-    const entry = remaining.pop()!
-    if (tabs.some((tab) => tab.sessionID === entry.tab.sessionID)) continue
-    const next = [...tabs]
-    next.splice(Math.min(entry.index, tabs.length), 0, entry.tab)
-    return { stack: remaining, tabs: next, sessionID: entry.tab.sessionID }
-  }
-  return { stack: remaining, tabs: undefined, sessionID: undefined }
-}
-
 export function moveSessionTab(tabs: SessionTab[], sessionID: string, index: number): SessionTab[] {
   const from = tabs.findIndex((tab) => tab.sessionID === sessionID)
   const to = Math.max(0, Math.min(tabs.length - 1, index))

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

@@ -1,9 +1,8 @@
-import { createEffect, createMemo, createSignal, onCleanup } from "solid-js"
+import { createEffect, createMemo, onCleanup } from "solid-js"
 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"
@@ -14,12 +13,8 @@ import {
   cycleSessionTab,
   moveSessionTab,
   moveSessionTabHistory,
-  NEW_SESSION_TAB_TITLE,
   openSessionTab,
-  recordClosedSessionTab,
   recordSessionTabHistory,
-  reopenSessionTab,
-  type ClosedSessionTab,
   type SessionTab,
   type SessionTabHistory,
   type SessionTabUnread,
@@ -60,10 +55,7 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
       key: "sessionID",
     })
     const fallback = empty()
-    const [promptPulses, setPromptPulses] = createSignal<Record<string, number>>({})
     let history: SessionTabHistory = { entries: [], index: -1 }
-    // User-closed tabs eligible for reopening; in-memory like history, deleted sessions pruned.
-    let closedTabs: ClosedSessionTab[] = []
 
     function state() {
       if (config.tabs?.scope === "global") return store.global
@@ -79,19 +71,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)
       const family = members.length > 0 ? members : [session]
       return {
         unread: state().unread[session],
-        promptPulse: promptPulses()[session] ?? 0,
         attention: family.some(
           (id) => (data.session.permission.list(id)?.length ?? 0) > 0 || (data.session.form.list(id)?.length ?? 0) > 0,
         ),
@@ -115,8 +100,7 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
       if (route.data.type !== "session" || route.data.sessionID === "dummy") return
       const sessionID = root(route.data.sessionID)
       history = recordSessionTabHistory(history, sessionID)
-      const session = data.session.get(sessionID)
-      const title = session?.title ?? (newTab() ? NEW_SESSION_TAB_TITLE : session ? sessionTitle(session) : undefined)
+      const title = data.session.get(sessionID)?.title
       const tabs = openSessionTab(state().tabs, { sessionID, title })
       if (tabs === state().tabs && !state().unread[sessionID]) return
       update((draft) => {
@@ -129,8 +113,7 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
       if (!enabled()) return
       const next = state().tabs.reduce<SessionTab[]>((tabs, tab) => {
         const sessionID = root(tab.sessionID)
-        const session = data.session.get(sessionID)
-        return openSessionTab(tabs, { sessionID, title: session ? sessionTitle(session) : tab.title })
+        return openSessionTab(tabs, { sessionID, title: data.session.get(sessionID)?.title ?? tab.title })
       }, [])
       const unread = Object.entries(state().unread).reduce<Record<string, SessionTabUnread>>((result, entry) => {
         const sessionID = root(entry[0])
@@ -139,8 +122,15 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
       }, {})
       if (isDeepEqual(next, state().tabs) && isDeepEqual(unread, state().unread)) return
       update((draft) => {
-        draft.tabs = next
-        draft.unread = unread
+        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
+        }, {})
       })
     })
 
@@ -186,14 +176,6 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
     onCleanup(event.on("session.execution.succeeded", (evt) => markUnread(evt.data.sessionID, "activity")))
     onCleanup(event.on("session.execution.interrupted", (evt) => markUnread(evt.data.sessionID, "activity")))
     onCleanup(event.on("session.execution.failed", (evt) => markUnread(evt.data.sessionID, "error")))
-    onCleanup(
-      event.on("session.input.admitted", (evt) => {
-        if (!enabled() || evt.data.input.type !== "user") return
-        const sessionID = root(evt.data.sessionID)
-        if (current() === sessionID || !state().tabs.some((tab) => tab.sessionID === sessionID)) return
-        setPromptPulses((pulses) => ({ ...pulses, [sessionID]: (pulses[sessionID] ?? 0) + 1 }))
-      }),
-    )
     onCleanup(
       event.on("session.error", (evt) => {
         if (evt.data.sessionID) markUnread(evt.data.sessionID, "error")
@@ -201,8 +183,6 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
     )
     onCleanup(
       event.on("session.deleted", (evt) => {
-        const target = root(evt.data.sessionID)
-        closedTabs = closedTabs.filter((entry) => entry.tab.sessionID !== target)
         remove(evt.data.sessionID, enabled())
       }),
     )
@@ -221,12 +201,6 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
         draft.tabs = closeSessionTab(draft.tabs, target).tabs
         delete draft.unread[target]
       })
-      setPromptPulses((pulses) => {
-        if (pulses[target] === undefined) return pulses
-        const next = { ...pulses }
-        delete next[target]
-        return next
-      })
       if (selected) route.navigate(next ? { type: "session", sessionID: next } : { type: "home" })
     }
 
@@ -235,9 +209,6 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
       tabs() {
         return state().tabs
       },
-      newTab() {
-        return newTab()
-      },
       current,
       status,
       select(sessionID: string) {
@@ -248,28 +219,12 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
         if (!enabled()) return
         const target = sessionID ? root(sessionID) : current()
         if (!target) {
-          const previous = moveSessionTabHistory(history, state().tabs, undefined, -1)
-          history = previous.history
-          const session = previous.sessionID ?? state().tabs.at(-1)?.sessionID
-          if (route.data.type === "home" && session) route.navigate({ type: "session", sessionID: session })
+          const previous = state().tabs.at(-1)
+          if (route.data.type === "home" && previous) route.navigate({ type: "session", sessionID: previous.sessionID })
           return
         }
-        const index = state().tabs.findIndex((tab) => tab.sessionID === target)
-        const tab = state().tabs[index]
-        if (tab) closedTabs = recordClosedSessionTab(closedTabs, tab, index)
         remove(target, true)
       },
-      reopen() {
-        if (!enabled()) return
-        const result = reopenSessionTab(closedTabs, state().tabs)
-        closedTabs = result.stack
-        const tabs = result.tabs
-        if (!tabs || !result.sessionID) return
-        update((draft) => {
-          draft.tabs = tabs
-        })
-        route.navigate({ type: "session", sessionID: result.sessionID })
-      },
       move(sessionID: string, index: number) {
         if (!enabled()) return
         const session = root(sessionID)
@@ -292,6 +247,12 @@ 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/feature-plugins/system/storybook/session-tabs.tsx

@@ -2,11 +2,7 @@ import { Plugin } from "@opencode-ai/plugin/tui"
 import { useTerminalDimensions } from "@opentui/solid"
 import { batch, createSignal, For, onCleanup } from "solid-js"
 import { createStore, reconcile } from "solid-js/store"
-import {
-  EMPTY_SESSION_TAB_STATUS,
-  SessionTabs,
-  type SessionTabsController,
-} from "../../../component/session-tabs"
+import { SessionTabs, type SessionTabsController } from "../../../component/session-tabs"
 import { moveSessionTab } from "../../../context/session-tabs-model"
 import type { Story } from "./index"
 
@@ -27,6 +23,7 @@ const FIXTURE_TABS = [
   { sessionID: "fixture-12", title: "Prepare review" },
 ]
 
+const EMPTY_STATUS: FixtureStatus = { unread: undefined, attention: false, busy: false }
 const RUN_DURATION = 1_800
 const RESUME_DURATION = 900
 
@@ -69,7 +66,7 @@ function SessionTabsStory(props: { context: Plugin.Context }) {
     if (!resumed && roll < 0.25) {
       setStatuses((current) => ({
         ...current,
-        [sessionID]: { ...(current[sessionID] ?? EMPTY_SESSION_TAB_STATUS), attention: true },
+        [sessionID]: { ...(current[sessionID] ?? EMPTY_STATUS), attention: true },
       }))
       setLastEvent(`tab ${number(sessionID)} needs input; select it to resolve`)
       return
@@ -80,7 +77,7 @@ function SessionTabsStory(props: { context: Plugin.Context }) {
       setOutcomes((current) => ({ ...current, [sessionID]: failed ? "failed" : "completed" }))
       setStatuses((current) => ({
         ...current,
-        [sessionID]: { ...(current[sessionID] ?? EMPTY_SESSION_TAB_STATUS), busy: false, unread },
+        [sessionID]: { ...(current[sessionID] ?? EMPTY_STATUS), busy: false, unread },
       }))
       // An untitled session earns its title after its first completed run, like a real summarization.
       const index = number(sessionID) - 1
@@ -113,7 +110,7 @@ function SessionTabsStory(props: { context: Plugin.Context }) {
     tabs,
     current: active,
     status(sessionID) {
-      return statuses()[sessionID] ?? EMPTY_SESSION_TAB_STATUS
+      return statuses()[sessionID] ?? EMPTY_STATUS
     },
     select,
     move(sessionID: string, index: number) {
@@ -153,7 +150,7 @@ function SessionTabsStory(props: { context: Plugin.Context }) {
   const startRun = (sessionID: string) => {
     setStatuses((current) => ({
       ...current,
-      [sessionID]: { ...(current[sessionID] ?? EMPTY_SESSION_TAB_STATUS), busy: true, unread: undefined },
+      [sessionID]: { ...(current[sessionID] ?? EMPTY_STATUS), busy: true, unread: undefined },
     }))
     setOutcomes((current) => {
       const next = { ...current }
@@ -226,7 +223,7 @@ function SessionTabsStory(props: { context: Plugin.Context }) {
 
   const selectedState = () => {
     const current = active()
-    const status = current ? controller.status(current) : EMPTY_SESSION_TAB_STATUS
+    const status = current ? controller.status(current) : EMPTY_STATUS
     const activity = status.busy
       ? "running"
       : status.unread === "activity"
@@ -354,7 +351,7 @@ function SessionTabsStory(props: { context: Plugin.Context }) {
         paddingRight={1}
         flexDirection="row"
       >
-        <text fg={elevatedTheme.text.subdued}>storybook / tabs</text>
+        <text fg={elevatedTheme.text.subdued}>storybook / session tabs</text>
         <box flexGrow={1} />
         <text fg={elevatedTheme.text.subdued}>
           space/s run | t add | d close | r reset | ←/→ 1-0 move | drag reorders | esc back
@@ -366,6 +363,6 @@ function SessionTabsStory(props: { context: Plugin.Context }) {
 
 export const sessionTabsStory: Story = {
   id: "session-tabs",
-  title: "Tabs",
+  title: "Session tabs",
   render: (context) => <SessionTabsStory context={context} />,
 }

packages/tui/src/mini/footer.permission.tsx

@@ -32,6 +32,7 @@ import { footerWidthPolicy } from "./footer.width"
 import { toolFiletype } from "./tool"
 import { transparent, type RunBlockTheme, type RunFooterTheme } from "./theme"
 import type { MiniPermissionRequest, PermissionReply } from "./types"
+import { PatchDiff } from "../component/patch-diff"
 
 function buttons(
   list: PermissionOption[],
@@ -405,8 +406,9 @@ export function RunPermissionBody(props: {
                       </Show>
                     }
                   >
-                    <diff
+                    <PatchDiff
                       diff={info().diff!}
+                      hunkFg={props.block.diffLineNumber}
                       view="unified"
                       filetype={ft()}
                       syntaxStyle={props.block.syntax}

packages/tui/src/mini/scrollback.writer.tsx

@@ -13,6 +13,7 @@ import { entryColor, entryLook, entrySyntax } from "./scrollback.shared"
 import { toolFiletype, toolStructuredFinal } from "./tool"
 import { RUN_THEME_FALLBACK, transparent, type RunTheme } from "./theme"
 import type { EntryLayout, RunEntryBody, ScrollbackOptions, StreamCommit, TurnSummary } from "./types"
+import { PatchDiff } from "../component/patch-diff"
 
 export function entryGroupKey(commit: StreamCommit): string | undefined {
   if (!commit.partID) {
@@ -178,8 +179,9 @@ export function RunEntryContent(props: {
               </text>
               {item.diff.trim() ? (
                 <box width="100%" paddingLeft={1}>
-                  <diff
+                  <PatchDiff
                     diff={item.diff}
+                    hunkFg={theme().block.diffLineNumber}
                     view="unified"
                     filetype={toolFiletype(item.file)}
                     syntaxStyle={syntax()}

packages/tui/src/plugin/builtins.ts

@@ -18,8 +18,6 @@ export const builtins = [
   SidebarFooter,
   Notifications,
   Plugins,
-  // The storybook is a development tool; keep its route and palette commands out of
-  // normal launches and register it only for OPENCODE_STORY runs.
-  ...(process.env.OPENCODE_STORY ? [Storybook] : []),
+  Storybook,
   DiffViewer,
 ]

packages/tui/src/routes/home.tsx

@@ -1,5 +1,5 @@
 import { Prompt, type PromptRef } from "../component/prompt"
-import { createEffect, createMemo, createSignal, onMount, Show, untrack } from "solid-js"
+import { createEffect, createMemo, createSignal, onMount, Show } from "solid-js"
 import { Logo } from "../component/logo"
 import { useArgs } from "../context/args"
 import { useRouteData } from "../context/route"
@@ -31,13 +31,7 @@ export function Home() {
   const forms = createMemo(() => data.session.form.list("global", currentLocation()) ?? [])
   let sent = false
 
-  // 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))
-  })
+  createEffect(() => location.set(currentLocation()))
 
   onMount(() => {
     editor.clearSelection()

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

@@ -16,7 +16,9 @@ export function ShellTab(props: { sessionID: string }) {
   const composer = useComposerTab()
   const shortcuts = Keymap.useShortcuts()
 
-  const entries = createMemo(() => data.shell.listBySession(props.sessionID).filter((shell) => shell.status === "running"))
+  const entries = createMemo(() =>
+    data.shell.list().filter((shell) => shell.metadata.sessionID === props.sessionID && shell.status === "running"),
+  )
 
   const [store, setStore] = createStore({ selected: 0 })
   let scroll: ScrollBoxRenderable | undefined

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

@@ -8,7 +8,6 @@ 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
@@ -39,14 +38,13 @@ 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 title = sessionTitle(sibling)
-        const agentMatch = title.match(/@(\w+) subagent/)
+        const agentMatch = sibling.title.match(/@(\w+) subagent/)
         const agent = sibling.agent
           ? Locale.titlecase(sibling.agent)
           : agentMatch
             ? Locale.titlecase(agentMatch[1])
             : "Subagent"
-        const name = agentMatch ? title.replace(agentMatch[0], "").trim() || title : title
+        const name = agentMatch ? sibling.title.replace(agentMatch[0], "").trim() || sibling.title : sibling.title
         result.push({
           sessionID: sibling.id,
           agent,
@@ -58,14 +56,13 @@ export function SubagentsTab(props: { sessionID: string }) {
     } else {
       const children = data.session.list().filter((s) => s.parentID === props.sessionID)
       for (const child of children) {
-        const title = sessionTitle(child)
-        const agentMatch = title.match(/@(\w+) subagent/)
+        const agentMatch = child.title.match(/@(\w+) subagent/)
         const agent = child.agent
           ? Locale.titlecase(child.agent)
           : agentMatch
             ? Locale.titlecase(agentMatch[1])
             : "Subagent"
-        const name = agentMatch ? title.replace(agentMatch[0], "").trim() || title : title
+        const name = agentMatch ? child.title.replace(agentMatch[0], "").trim() || child.title : child.title
         result.push({
           sessionID: child.id,
           agent,

packages/tui/src/routes/session/dialog-subagent.tsx

@@ -0,0 +1,26 @@
+import { DialogSelect } from "../../ui/dialog-select"
+import { useRoute } from "../../context/route"
+
+export function DialogSubagent(props: { sessionID: string }) {
+  const route = useRoute()
+
+  return (
+    <DialogSelect
+      title="Subagent Actions"
+      options={[
+        {
+          title: "Open",
+          value: "subagent.view",
+          description: "the subagent's session",
+          onSelect: (dialog) => {
+            route.navigate({
+              type: "session",
+              sessionID: props.sessionID,
+            })
+            dialog.clear()
+          },
+        },
+      ]}
+    />
+  )
+}

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

@@ -0,0 +1,91 @@
+import { createMemo, Match, onCleanup, onMount, Show, Switch } from "solid-js"
+import { useTheme } from "../../context/theme"
+import { useData } from "../../context/data"
+import { useDirectory } from "../../context/directory"
+import { useConnected } from "../../component/use-connected"
+import { createStore } from "solid-js/store"
+import { useRoute } from "../../context/route"
+import { usePermission } from "../../context/permission"
+
+export function Footer() {
+  const theme = useTheme()
+  const data = useData()
+  const route = useRoute()
+  const permission = usePermission()
+  const mcp = createMemo(
+    () => (data.location.mcp.server.list() ?? []).filter((x) => x.status.status === "connected").length,
+  )
+  const mcpError = createMemo(() => (data.location.mcp.server.list() ?? []).some((x) => x.status.status === "failed"))
+  const permissions = createMemo(() => {
+    if (route.data.type !== "session") return []
+    return data.session.permission.list(route.data.sessionID) ?? []
+  })
+  const directory = useDirectory()
+  const connected = useConnected()
+
+  const [store, setStore] = createStore({
+    welcome: false,
+  })
+
+  onMount(() => {
+    // Track all timeouts to ensure proper cleanup
+    const timeouts: ReturnType<typeof setTimeout>[] = []
+
+    function tick() {
+      if (connected()) return
+      if (!store.welcome) {
+        setStore("welcome", true)
+        timeouts.push(setTimeout(() => tick(), 5000))
+        return
+      }
+
+      if (store.welcome) {
+        setStore("welcome", false)
+        timeouts.push(setTimeout(() => tick(), 10_000))
+        return
+      }
+    }
+    timeouts.push(setTimeout(() => tick(), 10_000))
+
+    onCleanup(() => {
+      timeouts.forEach(clearTimeout)
+    })
+  })
+
+  return (
+    <box flexDirection="row" justifyContent="space-between" gap={1} flexShrink={0}>
+      <text fg={theme.text.subdued}>{directory()}</text>
+      <box gap={2} flexDirection="row" flexShrink={0}>
+        <Switch>
+          <Match when={store.welcome}>
+            <text fg={theme.text.default}>
+              Get started <span style={{ fg: theme.text.subdued }}>/connect</span>
+            </text>
+          </Match>
+          <Match when={connected()}>
+            <Show when={permission.mode !== "auto" && permissions().length > 0}>
+              <text fg={theme.text.feedback.warning.default}>
+                <span style={{ fg: theme.text.feedback.warning.default }}>△</span> {permissions().length} Permission
+                {permissions().length > 1 ? "s" : ""}
+              </text>
+            </Show>
+            <Show when={mcp()}>
+              <text fg={theme.text.default}>
+                <Switch>
+                  <Match when={mcpError()}>
+                    <span style={{ fg: theme.text.feedback.error.default }}>⊙ </span>
+                  </Match>
+                  <Match when={true}>
+                    <span style={{ fg: theme.text.feedback.success.default }}>⊙ </span>
+                  </Match>
+                </Switch>
+                {mcp()} MCP
+              </text>
+            </Show>
+            <text fg={theme.text.subdued}>/status</text>
+          </Match>
+        </Switch>
+      </box>
+    </box>
+  )
+}

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

@@ -22,6 +22,7 @@ import { useData } from "../../context/data"
 import { SplitBorder } from "../../ui/border"
 import { useTuiPaths, useTuiTerminalEnvironment } from "../../context/runtime"
 import { Spinner, SPINNER_FRAMES } from "../../component/spinner"
+import { PatchDiff } from "../../component/patch-diff"
 import { ThemeContextProvider, useTheme, useThemes } from "../../context/theme"
 import { BoxRenderable, ScrollBoxRenderable, addDefaultParsers, TextAttributes, RGBA } from "@opentui/core"
 import { Prompt, type PromptRef } from "../../component/prompt"
@@ -51,7 +52,6 @@ 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"
@@ -93,7 +93,6 @@ 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)
 
@@ -523,32 +522,6 @@ 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",
@@ -3055,8 +3028,9 @@ function Edit(props: ToolProps) {
         {(item) => (
           <BlockTool path={{ label: "← Edit", value: pathFormatter.format(path()) }} part={props.part}>
             <box paddingLeft={1}>
-              <diff
+              <PatchDiff
                 diff={item().patch}
+                hunkFg={theme.diff.text.hunkHeader}
                 view={view()}
                 filetype={filetype(path())}
                 syntaxStyle={syntax()}
@@ -3144,8 +3118,9 @@ function ApplyPatch(props: ToolProps) {
                   }
                 >
                   <box paddingLeft={1}>
-                    <diff
+                    <PatchDiff
                       diff={file.patch}
+                      hunkFg={theme.diff.text.hunkHeader}
                       view={view()}
                       filetype={filetype(file.relativePath)}
                       syntaxStyle={syntax()}
@@ -3335,7 +3310,7 @@ function formatSessionTranscript(session: SessionInfo, messages: SessionMessageI
     })
     return [`## Assistant\n\n${content.join("\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`
+  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`
 }
 
 export function parseApplyPatchFiles(value: unknown) {

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

@@ -14,6 +14,7 @@ import { useConfig } from "../../config"
 import { Keymap } from "../../context/keymap"
 import { usePathFormatter } from "../../context/path-format"
 import { SimulationSemantics } from "../../simulation/semantics"
+import { PatchDiff } from "../../component/patch-diff"
 
 type PermissionStage = "permission" | "always" | "reject"
 
@@ -50,8 +51,9 @@ function EditBody(props: { file?: string; diff?: string; patch?: string }) {
             },
           }}
         >
-          <diff
+          <PatchDiff
             diff={diff()}
+            hunkFg={theme.diff.text.hunkHeader}
             view={view()}
             filetype={ft()}
             syntaxStyle={syntax()}

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

@@ -3,7 +3,6 @@ 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"
 
@@ -39,7 +38,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>{sessionTitle(session()!)}</b>
+                <b>{session()!.title}</b>
               </text>
               <Show when={session()!.location.workspaceID}>
                 <text fg={theme.text.subdued}>{session()!.location.workspaceID}</text>

packages/tui/src/routes/session/subagent-footer.tsx

@@ -0,0 +1,115 @@
+import { createMemo, createSignal, Show } from "solid-js"
+import { useRouteData } from "../../context/route"
+import { useData } from "../../context/data"
+import { useTheme } from "../../context/theme"
+import { SplitBorder } from "../../ui/border"
+import { Locale } from "../../util/locale"
+import { useTerminalDimensions } from "@opentui/solid"
+import { Keymap } from "../../context/keymap"
+import { contextUsage, formatContextUsage } from "../../util/session"
+
+const money = new Intl.NumberFormat("en-US", {
+  style: "currency",
+  currency: "USD",
+})
+
+export function SubagentFooter() {
+  const route = useRouteData("session")
+  const data = useData()
+  const session = createMemo(() => data.session.get(route.sessionID))
+
+  const subagentInfo = createMemo(() => {
+    const s = session()
+    if (!s) return "Subagent"
+    const agentMatch = s.title.match(/@(\w+) subagent/)
+    return agentMatch ? Locale.titlecase(agentMatch[1]) : "Subagent"
+  })
+
+  const usage = createMemo(() => {
+    const current = session()
+    if (!current) return
+    const cost = current.cost
+    const formattedCost = cost > 0 ? money.format(cost) : undefined
+    const context = contextUsage(
+      data.session.message.list(route.sessionID),
+      data.location.model.list(current.location),
+      current.revert?.messageID,
+    )
+
+    return {
+      context: context ? formatContextUsage(context.tokens, context.percent) : undefined,
+      cost: formattedCost,
+    }
+  })
+
+  const theme = useTheme("elevated")
+  const keymap = Keymap.use()
+  const shortcuts = Keymap.useShortcuts()
+  const [hover, setHover] = createSignal<"parent" | "prev" | "next" | null>(null)
+  useTerminalDimensions()
+
+  return (
+    <box flexShrink={0}>
+      <box
+        paddingTop={1}
+        paddingBottom={1}
+        paddingLeft={2}
+        paddingRight={1}
+        {...SplitBorder}
+        border={["left"]}
+        borderColor={theme.border.default}
+        flexShrink={0}
+        backgroundColor={theme.background.default}
+      >
+        <box flexDirection="row" justifyContent="space-between" gap={1}>
+          <box flexDirection="row" gap={1}>
+            <text fg={theme.text.default}>
+              <b>{subagentInfo()}</b>
+            </text>
+            <Show when={usage()}>
+              {(item) => (
+                <text fg={theme.text.subdued} wrapMode="none">
+                  {[item().context, item().cost].filter(Boolean).join(" · ")}
+                </text>
+              )}
+            </Show>
+          </box>
+          <box flexDirection="row" gap={2}>
+            <box
+              onMouseOver={() => setHover("parent")}
+              onMouseOut={() => setHover(null)}
+              onMouseUp={() => keymap.dispatch("session.parent")}
+              backgroundColor={
+                hover() === "parent" ? theme.background.action.primary.hovered : theme.background.default
+              }
+            >
+              <text fg={theme.text.default}>
+                Parent <span style={{ fg: theme.text.subdued }}>{shortcuts.get("session.parent")}</span>
+              </text>
+            </box>
+            <box
+              onMouseOver={() => setHover("prev")}
+              onMouseOut={() => setHover(null)}
+              onMouseUp={() => keymap.dispatch("session.child.previous")}
+              backgroundColor={hover() === "prev" ? theme.background.action.primary.hovered : theme.background.default}
+            >
+              <text fg={theme.text.default}>
+                Prev <span style={{ fg: theme.text.subdued }}>{shortcuts.get("session.child.previous")}</span>
+              </text>
+            </box>
+            <box
+              onMouseOver={() => setHover("next")}
+              onMouseOut={() => setHover(null)}
+              onMouseUp={() => keymap.dispatch("session.child.next")}
+              backgroundColor={hover() === "next" ? theme.background.action.primary.hovered : theme.background.default}
+            >
+              <text fg={theme.text.default}>
+                Next <span style={{ fg: theme.text.subdued }}>{shortcuts.get("session.child.next")}</span>
+              </text>
+            </box>
+          </box>
+        </box>
+      </box>
+    </box>
+  )
+}

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

@@ -1,10 +1,10 @@
-import { CliRenderEvents, InputRenderable, RGBA, ScrollBoxRenderable, TextAttributes } from "@opentui/core"
+import { 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 { useRenderer, useTerminalDimensions } from "@opentui/solid"
+import { useTerminalDimensions } from "@opentui/solid"
 import * as fuzzysort from "fuzzysort"
 import { isDeepEqual } from "remeda"
 import { useDialog, type DialogContext } from "./dialog"
@@ -100,7 +100,6 @@ 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,
@@ -111,18 +110,7 @@ export function DialogSelect<T>(props: DialogSelectProps<T>) {
   const actionFocused = createMemo(() => focusedAction() !== undefined)
   let selection: { value: T; category?: string } | undefined
   let resetSelection = false
-  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()
-  }
+  let visibilityGeneration = 0
 
   createEffect(
     on(
@@ -240,7 +228,7 @@ export function DialogSelect<T>(props: DialogSelectProps<T>) {
     on(
       () => props.options,
       () => {
-        if (!props.preserveSelection && props.current === undefined) {
+        if (!props.preserveSelection) {
           const count = flat().length
           if (count === 0) return
           const next = reconcileSelection(store.selected, count)
@@ -276,8 +264,16 @@ export function DialogSelect<T>(props: DialogSelectProps<T>) {
           setStore("selected", index)
           selection = option
           if (!moved) return
-          if ((!props.preserveSelection && props.current === undefined) || store.filter.length > 0) return
-          scrollAfterLayout(false, option.value)
+          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)
+            })
+          })
           return
         }
         const next = reconcileSelection(store.selected, flat().length)
@@ -288,26 +284,22 @@ export function DialogSelect<T>(props: DialogSelectProps<T>) {
     ),
   )
   onCleanup(() => {
-    if (!pendingScroll) return
-    renderer.off(CliRenderEvents.FRAME, pendingScroll)
-    pendingScroll = undefined
+    visibilityGeneration++
   })
 
   createEffect(
     on([() => store.filter, () => props.current], ([filter, current]) => {
       if (filter.length > 0) resetSelection = true
-      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)
+      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)
     }),
   )
 

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

@@ -62,14 +62,9 @@ export function truncateFilePath(value: string, maxWidth: number) {
   const separatorWidth = stringWidth(separator)
   let width = stringWidth(prefix + basename)
   for (let index = segments.length - 2; index >= 0; index--) {
-    const segment = segments[index]!
-    const next = stringWidth(segment) + separatorWidth
-    if (width + next > maxWidth) {
-      const available = maxWidth - width - separatorWidth
-      if (available > 1) selected.unshift(takeStart(segment, available - 1) + "…")
-      break
-    }
-    selected.unshift(segment)
+    const next = stringWidth(segments[index]!) + separatorWidth
+    if (width + next > maxWidth) break
+    selected.unshift(segments[index]!)
     width += next
   }
   return prefix + selected.join(separator)

packages/tui/src/util/diff.ts

@@ -0,0 +1,56 @@
+export interface PatchHunk {
+  readonly patch: string
+  readonly header?: string
+  readonly rows?: number
+}
+
+export function splitPatchHunks(patch: string): PatchHunk[] {
+  const starts = [
+    ...patch.matchAll(/^@@ -\d+(?:,\d+)? \+\d+(?:,\d+)? @@.*$/gm),
+  ].map((match) => match.index)
+  if (starts.length <= 1) return [{ patch }]
+
+  const prefix = patch.slice(0, starts[0])
+  return starts.map((start, index) => {
+    const end = starts[index + 1] ?? patch.length
+    const lineEnd = patch.indexOf("\n", start)
+    return {
+      header: patch.slice(start, lineEnd === -1 ? end : lineEnd),
+      patch: prefix + patch.slice(start, end),
+      rows: splitRows(patch.slice(start, end)),
+    }
+  })
+}
+
+function splitRows(hunk: string) {
+  const lines = hunk.replace(/\n$/, "").split("\n").slice(1)
+  let rows = 0
+  let index = 0
+
+  while (index < lines.length) {
+    const prefix = lines[index][0]
+    if (prefix === " " || !prefix) {
+      rows++
+      index++
+      continue
+    }
+    if (prefix === "\\") {
+      index++
+      continue
+    }
+
+    let additions = 0
+    let deletions = 0
+    while (
+      index < lines.length &&
+      (lines[index][0] === "+" || lines[index][0] === "-")
+    ) {
+      if (lines[index][0] === "+") additions++
+      if (lines[index][0] === "-") deletions++
+      index++
+    }
+    rows += Math.max(additions, deletions)
+  }
+
+  return rows
+}

packages/tui/src/util/session.ts

@@ -1,16 +1,8 @@
-import type { ModelInfo, SessionInfo, SessionMessageAssistant, SessionMessageInfo } from "@opencode-ai/client"
+import type { ModelInfo, SessionMessageAssistant, SessionMessageInfo } from "@opencode-ai/client"
 import { Locale } from "./locale"
 
-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 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 lastAssistantWithUsage(messages: ReadonlyArray<SessionMessageInfo>, boundary?: string) {