refactor(session): simplify pending withdrawal

fix(tui): undo pending session input
2026-07-30 23:16:46 -04:00 · 2026-07-30 16:13:18 -04:00 · 2026-07-30 16:13:18 -04:00
91 changed files with 1119 additions and 1231 deletions
@@ -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
  }
 }
@@ -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)
    }),
  )

@@ -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"
@@ -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
@@ -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"
@@ -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),
 }) {}

@@ -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
@@ -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(),
      }}
@@ -153,4 +153,42 @@ describe("v2 session reducer", () => {

    expect(result).toMatchObject({ sessionID: "ses_1", missing: "msg_user", touched: [] })
  })
+
+  test("forgets withdrawn input before a later promotion", () => {
+    const reducer = createV2SessionReducer()
+    reducer.reduce(
+      [],
+      event({
+        ...base,
+        id: "evt_admitted",
+        type: "session.input.admitted",
+        data: {
+          sessionID: "ses_1",
+          inputID: "msg_user",
+          input: { type: "user", delivery: "steer", data: { text: "hello" } },
+        },
+      }),
+    )
+    reducer.reduce(
+      [],
+      event({
+        ...base,
+        id: "evt_withdrawn",
+        type: "session.input.withdrawn",
+        data: { sessionID: "ses_1", inputID: "msg_user" },
+      }),
+    )
+
+    const result = reducer.reduce(
+      [],
+      event({
+        ...base,
+        id: "evt_promoted",
+        type: "session.input.promoted",
+        data: { sessionID: "ses_1", inputID: "msg_user" },
+      }),
+    )
+
+    expect(result).toMatchObject({ sessionID: "ses_1", missing: "msg_user", touched: [] })
+  })
 })
@@ -29,6 +29,9 @@ export function createV2SessionReducer() {
      case "session.input.admitted":
        pending.set(key(sessionID, event.data.inputID), event.data.input)
        return result([...source])
+      case "session.input.withdrawn":
+        pending.delete(key(sessionID, event.data.inputID))
+        return
      case "session.input.promoted": {
        const input = pending.get(key(sessionID, event.data.inputID))
        pending.delete(key(sessionID, event.data.inputID))
@@ -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()
@@ -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"
                >
@@ -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()
@@ -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")
-  })
-})
@@ -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
 }
@@ -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: "",
@@ -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 } : {}),
@@ -370,6 +370,15 @@ export type Endpoint5_26Output =
            readonly input: SessionPending.Message
          }
        }
+      | {
+          readonly id: Event.ID
+          readonly created: DateTime.Utc
+          readonly metadata?: { readonly [x: string]: unknown } | undefined
+          readonly type: "session.input.withdrawn"
+          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
+          readonly location?: Location.Ref | undefined
+          readonly data: { readonly sessionID: Session.ID; readonly inputID: SessionMessage.ID }
+        }
      | {
          readonly id: Event.ID
          readonly created: DateTime.Utc
@@ -841,6 +850,12 @@ export type Endpoint5_29Input = { readonly sessionID: Session.ID; readonly messa
 export type Endpoint5_29Output = SessionMessage.Info
 export type SessionMessageOperation<E = never> = (input: Endpoint5_29Input) => Effect.Effect<Endpoint5_29Output, E>

+export type Endpoint5_30Input = { readonly sessionID: Session.ID; readonly inputID: SessionMessage.ID }
+export type Endpoint5_30Output = boolean
+export type SessionPendingWithdrawOperation<E = never> = (
+  input: Endpoint5_30Input,
+) => Effect.Effect<Endpoint5_30Output, E>
+
 export interface SessionApi<E = never> {
  readonly list: SessionListOperation<E>
  readonly create: SessionCreateOperation<E>
@@ -865,7 +880,10 @@ export interface SessionApi<E = never> {
    readonly commit: SessionRevertCommitOperation<E>
  }
  readonly context: SessionContextOperation<E>
-  readonly pending: { readonly list: SessionPendingListOperation<E> }
+  readonly pending: {
+    readonly list: SessionPendingListOperation<E>
+    readonly withdraw: SessionPendingWithdrawOperation<E>
+  }
  readonly instructions: {
    readonly entry: {
      readonly list: SessionInstructionsEntryListOperation<E>
@@ -76,6 +76,8 @@ import type {
  Endpoint5_28Output,
  Endpoint5_29Input,
  Endpoint5_29Output,
+  Endpoint5_30Input,
+  Endpoint5_30Output,
  Endpoint6_0Input,
  Endpoint6_0Output,
  Endpoint7_0Input,
@@ -550,6 +552,14 @@ const Endpoint5_29 = (raw: RawClient["server.session"]) => (input: Endpoint5_29I
    ),
  )

+const Endpoint5_30 = (raw: RawClient["server.session"]) => (input: Endpoint5_30Input) =>
+  preserveEffect<Endpoint5_30Output>()(
+    raw["session.pending.withdraw"]({ params: { sessionID: input["sessionID"], inputID: input["inputID"] } }).pipe(
+      Effect.mapError(mapClientError),
+      Effect.map((value) => value.data),
+    ),
+  )
+
 const adaptGroup5 = (raw: RawClient["server.session"]) => ({
  list: Endpoint5_0(raw),
  create: Endpoint5_1(raw),
@@ -570,7 +580,7 @@ const adaptGroup5 = (raw: RawClient["server.session"]) => ({
  wait: Endpoint5_16(raw),
  revert: { stage: Endpoint5_17(raw), clear: Endpoint5_18(raw), commit: Endpoint5_19(raw) },
  context: Endpoint5_20(raw),
-  pending: { list: Endpoint5_21(raw) },
+  pending: { list: Endpoint5_21(raw), withdraw: Endpoint5_30(raw) },
  instructions: { entry: { list: Endpoint5_22(raw), put: Endpoint5_23(raw), remove: Endpoint5_24(raw) } },
  generate: Endpoint5_25(raw),
  log: Endpoint5_26(raw),
@@ -70,6 +70,8 @@ import type {
  SessionBackgroundOutput,
  SessionMessageInput,
  SessionMessageOutput,
+  SessionPendingWithdrawInput,
+  SessionPendingWithdrawOutput,
  MessageListInput,
  MessageListOutput,
  ModelListInput,
@@ -732,6 +734,17 @@ export function make(options: ClientOptions) {
            },
            requestOptions,
          ).then((value) => value.data),
+        withdraw: (input: SessionPendingWithdrawInput, requestOptions?: RequestOptions) =>
+          request<{ readonly data: SessionPendingWithdrawOutput }>(
+            {
+              method: "POST",
+              path: `/api/session/${encodeURIComponent(input.sessionID)}/pending/${encodeURIComponent(input.inputID)}/withdraw`,
+              successStatus: 200,
+              declaredStatuses: [404, 400, 401],
+              empty: false,
+            },
+            requestOptions,
+          ).then((value) => value.data),
      },
      instructions: {
        entry: {
@@ -637,6 +637,16 @@ export type SessionInputPromoted = {
  data: { sessionID: string; inputID: string }
 }

+export type SessionInputWithdrawn = {
+  id: string
+  created: number
+  metadata?: { [x: string]: any }
+  type: "session.input.withdrawn"
+  durable: { aggregateID: string; seq: number; version: 1 }
+  location?: LocationRef
+  data: { sessionID: string; inputID: string }
+}
+
 export type SessionExecutionStarted = {
  id: string
  created: number
@@ -1757,7 +1767,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 +2016,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
@@ -2157,6 +2167,7 @@ export type SessionEventDurable =
  | SessionForked
  | SessionInputPromoted
  | SessionInputAdmitted
+  | SessionInputWithdrawn
  | SessionExecutionStarted
  | SessionExecutionSucceeded
  | SessionExecutionFailed
@@ -2252,6 +2263,7 @@ export type V2Event =
  | SessionForked
  | SessionInputPromoted
  | SessionInputAdmitted
+  | SessionInputWithdrawn
  | SessionExecutionStarted
  | SessionExecutionSucceeded
  | SessionExecutionFailed
@@ -3207,6 +3219,13 @@ export type SessionMessageInput = {

 export type SessionMessageOutput = { data: SessionMessageInfo }["data"]

+export type SessionPendingWithdrawInput = {
+  readonly sessionID: { readonly sessionID: string; readonly inputID: string }["sessionID"]
+  readonly inputID: { readonly sessionID: string; readonly inputID: string }["inputID"]
+}
+
+export type SessionPendingWithdrawOutput = { data: boolean }["data"]
+
 export type MessageListInput = {
  readonly sessionID: { readonly sessionID: string }["sessionID"]
  readonly limit?: {
@@ -300,7 +300,7 @@ test("session instructions methods use the public HTTP contract", async () => {
  ])
 })

-test("session.pending.list uses the public HTTP contract", async () => {
+test("session.pending uses the public HTTP contract", async () => {
  const requests: Array<{ method: string; url: string }> = []
  const pending = [
    {
@@ -317,14 +317,22 @@ test("session.pending.list uses the public HTTP contract", async () => {
    fetch: async (input, init) => {
      const request = input instanceof Request ? input : new Request(input, init)
      requests.push({ method: request.method, url: request.url })
-      return Response.json({ data: pending })
+      return Response.json({ data: request.method === "GET" ? pending : true })
    },
  })

  const result = await client.session.pending.list({ sessionID: "ses_test" })
+  const withdrawn = await client.session.pending.withdraw({ sessionID: "ses_test", inputID: "msg_pending" })

  expect(result).toEqual(pending)
-  expect(requests).toEqual([{ method: "GET", url: "http://localhost:3000/api/session/ses_test/pending" }])
+  expect(withdrawn).toBe(true)
+  expect(requests).toEqual([
+    { method: "GET", url: "http://localhost:3000/api/session/ses_test/pending" },
+    {
+      method: "POST",
+      url: "http://localhost:3000/api/session/ses_test/pending/msg_pending/withdraw",
+    },
+  ])
 })

 test("event.subscribe exposes the Promise event stream wire projection", async () => {
@@ -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,
@@ -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 } }
-}
@@ -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: {
@@ -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[]
@@ -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
@@ -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,
@@ -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,8 @@ 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) {
+  const native = Provider.isAISDK(resolved.package) ? nativePackage(packageName) : resolved.package
+  if (Provider.isAISDK(resolved.package) && !native) {
    if (!dependencies?.loadAISDK) return Effect.fail(unsupported(resolved))
    const runtime = produce(resolved, (draft) => {
      draft.settings = Provider.mergeOverlay(draft.settings, {
@@ -198,13 +201,15 @@ export const fromCatalogModel = (
    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 providerOptions = nativeProviderOptions(packageName, configured)
    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 },
+      ...(providerOptions ? { providerOptions } : {}),
    }
    return yield* Effect.try({
      try: () => {
@@ -221,6 +226,30 @@ export const fromCatalogModel = (
  })
 }

+const nativePackage = (packageName: string | undefined) => {
+  if (packageName === "@ai-sdk/google") return "@opencode-ai/ai/providers/google"
+  if (packageName === "@openrouter/ai-sdk-provider") return "@opencode-ai/ai/providers/openrouter"
+  if (packageName === "@ai-sdk/xai") return "@opencode-ai/ai/providers/xai"
+  return undefined
+}
+
+const nativeProviderOptions = (packageName: string | undefined, settings: Readonly<Record<string, unknown>>) => {
+  const values = Object.fromEntries(
+    Object.entries(settings).filter(
+      ([key]) => !["apiKey", "authToken", "baseURL", "chunkTimeout", "fetch", "timeout"].includes(key),
+    ),
+  )
+  if (Object.keys(values).length === 0) return undefined
+  if (packageName === "@ai-sdk/google") return { gemini: values }
+  if (packageName === "@openrouter/ai-sdk-provider") return { openrouter: values }
+  if (packageName === "@ai-sdk/xai") return { xai: values }
+  return undefined
+}
+
+const isNativeOpenAI = (packageName: string | undefined) =>
+  packageName === "@opencode-ai/ai/providers/openai" ||
+  packageName?.startsWith("@opencode-ai/ai/providers/openai/") === true
+
 const nativeCredentialSettings = (specifier: string, credential: Credential.Value | undefined) => {
  if (!credential) return {}
  if (credential.type === "key") return { apiKey: credential.key }
@@ -242,6 +271,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,
@@ -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
+}
@@ -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)

@@ -209,6 +209,10 @@ export interface Interface {
   * unhandled compaction barriers.
   */
  readonly pending: (sessionID: SessionSchema.ID) => Effect.Effect<SessionPending.Info[], NotFoundError>
+  readonly withdraw: (input: {
+    sessionID: SessionSchema.ID
+    inputID: SessionMessage.ID
+  }) => Effect.Effect<boolean, NotFoundError>
  /**
   * Durable, ordered session log read. Replays durable session bus after
   * the exclusive `after` cursor, emits a `Synced` marker at the captured
@@ -374,7 +378,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
            ? {
@@ -540,6 +544,10 @@ const layer = Layer.effect(
        yield* result.get(sessionID)
        return yield* SessionPending.list(db, sessionID)
      }),
+      withdraw: Effect.fn("Session.withdraw")(function* (input) {
+        yield* result.get(input.sessionID)
+        return yield* SessionPending.withdraw(db, bus, input)
+      }),
      log: (input) =>
        Stream.unwrap(
          result
@@ -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)
@@ -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
 })

@@ -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
@@ -175,6 +175,7 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
      "session.forked": () => Effect.void,
      "session.input.promoted": () => Effect.void,
      "session.input.admitted": () => Effect.void,
+      "session.input.withdrawn": () => Effect.void,
      "session.execution.started": () => Effect.void,
      "session.execution.succeeded": () => clearCurrentRetry,
      "session.execution.failed": () => clearCurrentRetry,
@@ -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,
      }
@@ -1,6 +1,6 @@
 export * as SessionPending from "./pending"

-import { and, asc, eq, or } from "drizzle-orm"
+import { and, asc, eq, or, sql } from "drizzle-orm"
 import { DateTime, Effect, Schema } from "effect"
 import {
  Compaction,
@@ -38,10 +38,15 @@ const encodeUser = Schema.encodeSync(UserData)
 const decodeSynthetic = Schema.decodeUnknownSync(SyntheticData)
 const encodeSynthetic = Schema.encodeSync(SyntheticData)
 const decodeAdmittedEvent = Schema.decodeUnknownOption(SessionEvent.InputAdmitted.data)
+const decodeWithdrawnEvent = Schema.decodeUnknownOption(SessionEvent.InputWithdrawn.data)
 const admittedEventType = Bus.versionedType(
  SessionEvent.InputAdmitted.type,
  SessionEvent.InputAdmitted.durable.version,
 )
+const withdrawnEventType = Bus.versionedType(
+  SessionEvent.InputWithdrawn.type,
+  SessionEvent.InputWithdrawn.durable.version,
+)
 const inboxLocks = KeyedMutex.makeUnsafe<SessionSchema.ID>()

 export class LifecycleConflict extends Schema.TaggedErrorClass<LifecycleConflict>()(
@@ -103,6 +108,38 @@ export const compaction = Effect.fn("SessionPending.compaction")(function* (
  return entry.type === "compaction" ? entry : undefined
 })

+const admittedFromHistory = Effect.fn("SessionPending.admittedFromHistory")(function* (
+  db: DatabaseService,
+  sessionID: SessionSchema.ID,
+  id: SessionMessage.ID,
+) {
+  const row = yield* db
+    .select()
+    .from(EventTable)
+    .where(
+      and(
+        eq(EventTable.aggregate_id, sessionID),
+        eq(EventTable.type, admittedEventType),
+        sql`json_extract(${EventTable.data}, '$.inputID') = ${id}`,
+      ),
+    )
+    .limit(1)
+    .get()
+    .pipe(Effect.orDie)
+  if (row) {
+    const decoded = decodeAdmittedEvent(row.data)
+    if (decoded._tag !== "Some" || decoded.value.inputID !== id)
+      return yield* Effect.die(new LifecycleConflict({ id }))
+    const base = { id, sessionID, timeCreated: DateTime.makeUnsafe(row.created) }
+    return decoded.value.input.type === "user"
+      ? User.make({ ...base, ...decoded.value.input })
+      : Synthetic.make({ ...base, ...decoded.value.input })
+  }
+  // A projected message without an admitted event in this aggregate (for
+  // example fork-copied history) is not a retryable admission.
+  return yield* Effect.die(new LifecycleConflict({ id }))
+})
+
 /**
 * Reconstruct the admitted record for a pending row that was already consumed
 * by promotion. The projected `session_message` row proves promotion happened;
@@ -123,27 +160,30 @@ const promotedFromHistory = Effect.fn("SessionPending.promotedFromHistory")(func
  if (message === undefined) return undefined
  if (message.session_id !== sessionID || (message.type !== "user" && message.type !== "synthetic"))
    return yield* Effect.die(new LifecycleConflict({ id }))
-  const rows = yield* db
-    .select()
+  return yield* admittedFromHistory(db, sessionID, id)
+})
+
+const wasWithdrawn = Effect.fn("SessionPending.wasWithdrawn")(function* (
+  db: DatabaseService,
+  sessionID: SessionSchema.ID,
+  id: SessionMessage.ID,
+) {
+  const row = yield* db
+    .select({ data: EventTable.data })
    .from(EventTable)
-    .where(and(eq(EventTable.aggregate_id, sessionID), eq(EventTable.type, admittedEventType)))
-    .all()
+    .where(
+      and(
+        eq(EventTable.aggregate_id, sessionID),
+        eq(EventTable.type, withdrawnEventType),
+        sql`json_extract(${EventTable.data}, '$.inputID') = ${id}`,
+      ),
+    )
+    .limit(1)
+    .get()
    .pipe(Effect.orDie)
-  for (const row of rows) {
-    const decoded = decodeAdmittedEvent(row.data)
-    if (decoded._tag !== "Some" || decoded.value.inputID !== id) continue
-    const base = {
-      id,
-      sessionID,
-      timeCreated: DateTime.makeUnsafe(row.created),
-    }
-    return decoded.value.input.type === "user"
-      ? User.make({ ...base, ...decoded.value.input })
-      : Synthetic.make({ ...base, ...decoded.value.input })
-  }
-  // A projected message without an admitted event in this aggregate (for
-  // example fork-copied history) is not a retryable admission.
-  return yield* Effect.die(new LifecycleConflict({ id }))
+  if (!row) return false
+  const decoded = decodeWithdrawnEvent(row.data)
+  return decoded._tag === "Some" && decoded.value.inputID === id
 })

 export const admit = Effect.fn("SessionPending.admit")(function* (
@@ -162,6 +202,8 @@ export const admit = Effect.fn("SessionPending.admit")(function* (
  }
  const promoted = yield* promotedFromHistory(db, request.sessionID, request.id)
  if (promoted !== undefined) return promoted
+  if (yield* wasWithdrawn(db, request.sessionID, request.id))
+    return yield* admittedFromHistory(db, request.sessionID, request.id)
  return yield* bus
    .publish(SessionEvent.InputAdmitted, {
      inputID: request.id,
@@ -309,14 +351,13 @@ export const projectCompactionAdmitted = Effect.fn("SessionPending.projectCompac
 * message insert inside the same event transaction; the deleted row is what
 * makes the table pending-only.
 */
-export const projectPromoted = Effect.fn("SessionPending.projectPromoted")(function* (
+const consumeInput = Effect.fn("SessionPending.consumeInput")(function* (
  db: DatabaseService,
  input: {
    readonly id: SessionMessage.ID
    readonly sessionID: SessionSchema.ID
  },
 ) {
-  if (yield* compaction(db, input.sessionID)) return yield* Effect.die(new LifecycleConflict({ id: input.id }))
  const deleted = yield* db
    .delete(SessionPendingTable)
    .where(and(eq(SessionPendingTable.id, input.id), eq(SessionPendingTable.session_id, input.sessionID)))
@@ -329,6 +370,27 @@ export const projectPromoted = Effect.fn("SessionPending.projectPromoted")(funct
  return stored
 })

+export const projectPromoted = Effect.fn("SessionPending.projectPromoted")(function* (
+  db: DatabaseService,
+  input: {
+    readonly id: SessionMessage.ID
+    readonly sessionID: SessionSchema.ID
+  },
+) {
+  if (yield* compaction(db, input.sessionID)) return yield* Effect.die(new LifecycleConflict({ id: input.id }))
+  return yield* consumeInput(db, input)
+})
+
+export const projectWithdrawn = Effect.fn("SessionPending.projectWithdrawn")(function* (
+  db: DatabaseService,
+  input: {
+    readonly id: SessionMessage.ID
+    readonly sessionID: SessionSchema.ID
+  },
+) {
+  return yield* consumeInput(db, input)
+})
+
 export const settleCompaction = Effect.fn("SessionPending.settleCompaction")(function* (
  db: DatabaseService,
  input: { readonly sessionID: SessionSchema.ID },
@@ -406,6 +468,30 @@ export const equivalent = (
  return false
 }

+export const withdraw = Effect.fn("SessionPending.withdraw")(function* (
+  db: DatabaseService,
+  bus: Bus.Interface,
+  input: { readonly sessionID: SessionSchema.ID; readonly inputID: SessionMessage.ID },
+) {
+  return yield* inboxLocks.withLock(input.sessionID)(
+    Effect.gen(function* () {
+      const pending = yield* find(db, input.inputID)
+      if (!pending) return yield* wasWithdrawn(db, input.sessionID, input.inputID)
+      if (pending.sessionID !== input.sessionID || pending.type === "compaction") return false
+      yield* bus
+        .publish(SessionEvent.InputWithdrawn, input)
+        .pipe(
+          Effect.catchDefect((defect) =>
+            wasWithdrawn(db, input.sessionID, input.inputID).pipe(
+              Effect.flatMap((withdrawn) => (withdrawn ? Effect.void : Effect.die(defect))),
+            ),
+          ),
+        )
+      return true
+    }),
+  )
+})
+
 const publish = Effect.fn("SessionPending.publish")(function* (
  db: DatabaseService,
  bus: Bus.Interface,
@@ -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,
@@ -666,6 +665,12 @@ const layer = Layer.effectDiscard(
          .pipe(Effect.orDie)
      }),
    )
+    yield* bus.project(SessionEvent.InputWithdrawn, (event) =>
+      SessionPending.projectWithdrawn(db, {
+        id: event.data.inputID,
+        sessionID: event.data.sessionID,
+      }),
+    )
    yield* bus.project(SessionEvent.Compaction.Admitted, (event) =>
      Effect.gen(function* () {
        if (event.durable === undefined)
@@ -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) {
@@ -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(),
@@ -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],
 })
@@ -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: {},
-    })
-  })
-})
@@ -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* () {
@@ -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(
@@ -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)
+    }),
+  )
 })
@@ -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 = []
@@ -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
@@ -317,23 +296,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
@@ -996,6 +996,52 @@ describe("Session.pending", () => {
    }),
  )

+  it.effect("withdraws an interrupted input before promotion without resurrecting exact retries", () =>
+    Effect.gen(function* () {
+      yield* setup
+      const session = yield* Session.Service
+
+      const admitted = yield* session.prompt({
+        id: SessionMessage.ID.make("msg_withdrawn"),
+        sessionID,
+        text: "Withdraw me",
+        resume: false,
+      })
+
+      yield* session.interrupt(sessionID)
+      expect(yield* session.withdraw({ sessionID, inputID: admitted.id })).toBe(true)
+      expect(yield* session.pending(sessionID)).toEqual([])
+      expect(yield* session.messages({ sessionID })).toEqual([])
+      expect(yield* session.withdraw({ sessionID, inputID: admitted.id })).toBe(true)
+
+      const retried = yield* session.prompt({
+        id: admitted.id,
+        sessionID,
+        text: "Withdraw me",
+        resume: false,
+      })
+      expect(retried.id).toBe(admitted.id)
+      expect(yield* session.pending(sessionID)).toEqual([])
+      expect(yield* eventCount(Bus.versionedType(SessionEvent.InputAdmitted.type, 1))).toBe(1)
+      expect(yield* eventCount(Bus.versionedType(SessionEvent.InputWithdrawn.type, 1))).toBe(1)
+    }),
+  )
+
+  it.effect("leaves promoted input for revert when withdrawal loses the race", () =>
+    Effect.gen(function* () {
+      yield* setup
+      const session = yield* Session.Service
+      const bus = yield* Bus.Service
+      const { db } = yield* Database.Service
+      const admitted = yield* session.prompt({ sessionID, text: "Promote me", resume: false })
+
+      yield* SessionPending.promote(db, bus, sessionID, "steer")
+
+      expect(yield* session.withdraw({ sessionID, inputID: admitted.id })).toBe(false)
+      expect(yield* session.messages({ sessionID })).toMatchObject([{ id: admitted.id, type: "user" }])
+    }),
+  )
+
  it.effect("lists an unhandled compaction barrier until it settles", () =>
    Effect.gen(function* () {
      yield* setup
@@ -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
@@ -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")
  }),
 )
@@ -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
        }
@@ -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>
                      )

@@ -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<
@@ -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<
@@ -628,6 +628,22 @@ export const makeSessionGroup = <I extends HttpApiMiddleware.AnyId, S>(sessionLo
          }),
        ),
    )
+    .add(
+      HttpApiEndpoint.post("session.pending.withdraw", "/api/session/:sessionID/pending/:inputID/withdraw", {
+        params: { sessionID: Session.ID, inputID: SessionMessage.ID },
+        success: Schema.Struct({ data: Schema.Boolean }),
+        error: SessionNotFoundError,
+      })
+        .middleware(sessionLocationMiddleware)
+        .annotateMerge(
+          OpenApi.annotations({
+            identifier: "v2.session.pending.withdraw",
+            summary: "Withdraw pending session input",
+            description:
+              "Withdraw one admitted input before promotion. Returns true when the input was withdrawn or had already been withdrawn, and false when it is no longer pending so callers can fall back to reverting projected history.",
+          }),
+        ),
+    )
    .annotateMerge(
      OpenApi.annotations({
        title: "session",
@@ -155,6 +155,16 @@ export const InputAdmitted = Event.durable({
 })
 export type InputAdmitted = typeof InputAdmitted.Type

+export const InputWithdrawn = Event.durable({
+  type: "session.input.withdrawn",
+  ...options,
+  schema: {
+    ...Base,
+    inputID: SessionMessage.ID,
+  },
+})
+export type InputWithdrawn = typeof InputWithdrawn.Type
+
 export namespace Execution {
  export const Started = Event.durable({ type: "session.execution.started", ...options, schema: Base })
  export type Started = typeof Started.Type
@@ -556,6 +566,7 @@ export const Definitions = Event.inventory(
  Forked,
  InputPromoted,
  InputAdmitted,
+  InputWithdrawn,
  Execution.Started,
  Execution.Succeeded,
  Execution.Failed,
@@ -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),
@@ -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,
@@ -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", () => {
@@ -108,6 +108,7 @@ describe("public event manifest", () => {
        "session.forked.2",
        "session.input.promoted.1",
        "session.input.admitted.1",
+        "session.input.withdrawn.1",
        "session.execution.started.1",
        "session.execution.succeeded.1",
        "session.execution.failed.1",
@@ -608,6 +608,23 @@ export const SessionHandler = HttpApiBuilder.group(Api, "server.session", (handl
          }
        }),
      )
+      .handle(
+        "session.pending.withdraw",
+        Effect.fn(function* (ctx) {
+          return {
+            data: yield* session.withdraw(ctx.params).pipe(
+              Effect.catchTag("Session.NotFoundError", (error) =>
+                Effect.fail(
+                  new SessionNotFoundError({
+                    sessionID: error.sessionID,
+                    message: `Session not found: ${error.sessionID}`,
+                  }),
+                ),
+              ),
+            ),
+          }
+        }),
+      )
      .handle(
        "session.instructions.entry.list",
        Effect.fn(function* (ctx) {
@@ -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,11 +95,13 @@ 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",
@@ -523,11 +525,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 +535,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 +646,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) => ({
@@ -684,6 +683,22 @@ function App(props: { pair?: DialogPairCredentials }) {
        enabled: sessionTabs.enabled,
        run: () => sessionTabs.cycle(-1),
      },
+      {
+        name: "session.tab.history.back",
+        title: "Back in tab history",
+        category: "Session",
+        palette: undefined,
+        enabled: sessionTabs.enabled,
+        run: () => sessionTabs.history(-1),
+      },
+      {
+        name: "session.tab.history.forward",
+        title: "Forward in tab history",
+        category: "Session",
+        palette: undefined,
+        enabled: sessionTabs.enabled,
+        run: () => sessionTabs.history(1),
+      },
      {
        name: "session.tab.next_unread",
        title: "Next unread tab",
@@ -1145,11 +1160,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",
      })
    }
  })
@@ -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`
-}
@@ -0,0 +1,77 @@
+import path from "path"
+import { createMemo } from "solid-js"
+import { DialogSelect } from "../ui/dialog-select"
+import { useDialog } from "../ui/dialog"
+import { useData } from "../context/data"
+import { useRoute } from "../context/route"
+import { abbreviateHome } from "../runtime"
+import { useTuiPaths } from "../context/runtime"
+import { useLocation } from "../context/location"
+import { useToast } from "../ui/toast"
+import { useTerminalDimensions } from "@opentui/solid"
+import { truncateFilePath } from "../ui/file-path"
+import { stringWidth } from "../util/string-width"
+
+export function DialogProject() {
+  const dialog = useDialog()
+  const data = useData()
+  const route = useRoute()
+  const paths = useTuiPaths()
+  const location = useLocation()
+  const toast = useToast()
+  const dimensions = useTerminalDimensions()
+
+  data.project.invalidate()
+  void data.project.sync().catch(toast.error)
+
+  const current = () => location.current?.project
+
+  const options = createMemo(() => {
+    const seen = new Set<string>()
+    return data.project
+      .list()
+      .filter((project) => {
+        if (project.canonical === "/" || seen.has(project.canonical)) return false
+        seen.add(project.canonical)
+        return true
+      })
+      .toSorted((a, b) => {
+        if (a.id === current()?.id) return -1
+        if (b.id === current()?.id) return 1
+        return 0
+      })
+      .map((project) => {
+        const title = project.name ?? path.basename(project.canonical)
+        const description = abbreviateHome(project.canonical, paths.home)
+        // Dialog padding, the current marker, title padding, and the separating space use nine columns.
+        const width = Math.min(60, dimensions().width - 2) - 9 - stringWidth(title)
+        return {
+          title,
+          description: truncateFilePath(description, width),
+          searchText: description,
+          value: project.canonical,
+        }
+      })
+  })
+
+  return (
+    <DialogSelect
+      title="Switch project"
+      placeholder="Search projects…"
+      options={options()}
+      current={current()?.canonical}
+      emptyView={
+        <box paddingLeft={4} paddingRight={4} paddingTop={1}>
+          <text>No projects found</text>
+        </box>
+      }
+      onSelect={(option) => {
+        dialog.clear()
+        if (option.value === current()?.canonical) return
+        const target = { directory: option.value }
+        route.navigate({ type: "home", location: target })
+        location.set(target)
+      }}
+    />
+  )
+}
@@ -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)
          },
        },
      ]}
@@ -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
  })
@@ -6,7 +6,6 @@ import { useSessionTabs } from "../context/session-tabs"
 import { useTheme, useThemes } from "../context/theme"
 import {
  adaptiveSessionTabLayout,
-  NEW_SESSION_TAB_TITLE,
  sessionTabComplete,
  seedSessionTabMotion,
  sessionTabOverflowWidth,
@@ -37,7 +36,7 @@ export type SessionTabsController = Pick<ContextController, "tabs" | "current" |
  status(sessionID: string): SessionTabsStatus
 }

-const NEW_SESSION_TAB: SessionTab = { sessionID: "new", title: NEW_SESSION_TAB_TITLE }
+const NEW_SESSION_TAB: SessionTab = { sessionID: "new", title: "New session" }

 export function SessionTabs(props: { controller?: SessionTabsController; animations?: boolean } = {}) {
  const tabs = props.controller ?? useSessionTabs()
@@ -210,11 +209,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 })
@@ -87,9 +87,10 @@ export const Definitions = {
  session_move: keybind("none", "Move session"),
  session_new: keybind("<leader>n", "Create a new session"),
  session_list: keybind("<leader>l", "List all sessions"),
-  open_menu: keybind("ctrl+o", "Open recent sessions and projects"),
  session_tab_next: keybind("ctrl+tab,<leader>right,alt+shift+]", "Switch to next open tab"),
  session_tab_previous: keybind("ctrl+shift+tab,<leader>left,alt+shift+[", "Switch to previous open tab"),
+  session_tab_history_back: keybind("ctrl+o", "Go back in tab history"),
+  session_tab_history_forward: keybind("ctrl+i", "Go forward in tab history"),
  session_tab_next_unread: keybind("<leader>down", "Switch to next unread tab"),
  session_tab_previous_unread: keybind("<leader>up", "Switch to previous unread tab"),
  session_tab_close: keybind("<leader>w", "Close current tab"),
@@ -290,9 +291,10 @@ 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",
@@ -188,6 +188,12 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
        index.set(item.id, messages.length)
        messages.push(item)
      },
+      reindex(messages: SessionMessageInfo[], index: Map<string, number>, start: number) {
+        for (let position = start; position < messages.length; position++) {
+          const item = messages[position]
+          if (item) index.set(item.id, position)
+        }
+      },
      activeAssistant(messages: SessionMessageInfo[]) {
        const item = messages.findLast((item) => item.type === "assistant" && !item.time.completed)
        return item?.type === "assistant" ? item : undefined
@@ -395,8 +401,7 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
            existing.time.created = event.created
            draft.splice(position, 1)
            draft.push(existing)
-            index.clear()
-            draft.forEach((message, indexValue) => index.set(message.id, indexValue))
+            message.reindex(draft, index, position)
          })
          setStore(
            "session",
@@ -438,6 +443,25 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
            )
          })
          break
+        case "session.input.withdrawn": {
+          removePending(event.data.sessionID, event.data.inputID)
+          if (store.session.input[event.data.sessionID]?.includes(event.data.inputID))
+            message.update(event.data.sessionID, (draft, index) => {
+              const position = index.get(event.data.inputID)
+              if (position === undefined) return
+              draft.splice(position, 1)
+              index.delete(event.data.inputID)
+              message.reindex(draft, index, position)
+            })
+          if (store.session.input[event.data.sessionID]?.includes(event.data.inputID))
+            setStore(
+              "session",
+              "input",
+              event.data.sessionID,
+              (store.session.input[event.data.sessionID] ?? []).filter((id) => id !== event.data.inputID),
+            )
+          break
+        }
        case "session.instructions.updated":
          const instructions = event.metadata?.instructions
          if (
@@ -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,
      }}
    >
@@ -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
 }

@@ -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
@@ -3,7 +3,6 @@ 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,7 +13,6 @@ import {
  cycleSessionTab,
  moveSessionTab,
  moveSessionTabHistory,
-  NEW_SESSION_TAB_TITLE,
  openSessionTab,
  recordClosedSessionTab,
  recordSessionTabHistory,
@@ -79,12 +77,6 @@ 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)
@@ -115,8 +107,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 +120,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 +129,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
+        }, {})
      })
    })

@@ -236,7 +233,7 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
        return state().tabs
      },
      newTab() {
-        return newTab()
+        return route.data.type === "home"
      },
      current,
      status,
@@ -292,6 +289,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]
@@ -643,6 +643,10 @@ export function createSubagentTracker(input: SubagentTrackerInput): SubagentTrac
      if (event.data.input.type === "user") child.prompts.set(event.data.inputID, event.data.input.data.text)
      return
    }
+    if (event.type === "session.input.withdrawn") {
+      child.prompts.delete(event.data.inputID)
+      return
+    }
    if (event.type === "session.input.promoted") {
      const prompt = child.prompts.get(event.data.inputID)
      if (prompt === undefined) return
@@ -911,6 +911,12 @@ export async function createSessionTransport(input: StreamInput): Promise<Sessio
      })
      return
    }
+    if (event.type === "session.input.withdrawn") {
+      state.admitted.delete(event.data.inputID)
+      state.pending.delete(event.data.inputID)
+      syncPending()
+      return
+    }
    if (event.type === "session.input.promoted") {
      const waiting = state.wait?.messageID === event.data.inputID
      if (state.wait) promoteWait(state.wait, true, event.data.inputID)
@@ -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()
@@ -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,
@@ -8,6 +8,7 @@ import { errorMessage } from "../../util/error"
 import { DialogFork } from "./dialog-fork"
 import type { PromptInfo } from "../../prompt/history"
 import { projectedPromptInput } from "../../prompt/codec"
+import { undoMessage } from "./undo"

 export function DialogMessage(props: {
  messageID: string
@@ -42,9 +43,10 @@ export function DialogMessage(props: {
                pasted: [],
              })
            }
-            void client.api.session.revert
-              .stage({ sessionID: props.sessionID, messageID: props.messageID })
-              .catch((error) => toast.show({ message: errorMessage(error), variant: "error", duration: 5000 }))
+            void undoMessage(client.api, {
+              sessionID: props.sessionID,
+              messageID: props.messageID,
+            }).catch((error) => toast.show({ message: errorMessage(error), variant: "error", duration: 5000 }))
            dialog.clear()
          },
        },
@@ -51,7 +51,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"
@@ -65,6 +64,7 @@ import { useToast } from "../../ui/toast"
 import stripAnsi from "strip-ansi"
 import { usePromptRef } from "../../context/prompt"
 import { projectedPromptInput } from "../../prompt/codec"
+import { undoMessage } from "./undo"
 import { useEpilogue } from "../../context/epilogue"
 import { normalizePath } from "../../util/path"
 import { PermissionPrompt } from "./permission"
@@ -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",
@@ -618,9 +591,10 @@ export function Session() {
          dialog.clear()
          return
        }
-        void client.api.session.revert
-          .stage({ sessionID: route.sessionID, messageID: message.id })
-          .catch((error) => toast.show({ message: errorMessage(error), variant: "error", duration: 5000 }))
+        void undoMessage(client.api, {
+          sessionID: route.sessionID,
+          messageID: message.id,
+        }).catch((error) => toast.show({ message: errorMessage(error), variant: "error", duration: 5000 }))
        prompt()?.set({
          ...projectedPromptInput(message),
          pasted: [],
@@ -3335,7 +3309,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) {
@@ -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>
@@ -0,0 +1,11 @@
+import type { OpenCodeClient } from "@opencode-ai/client"
+
+export function undoMessage(
+  client: OpenCodeClient,
+  input: { readonly sessionID: string; readonly messageID: string },
+) {
+  const revert = () => client.session.revert.stage(input).then(() => undefined)
+  return client.session.pending
+    .withdraw({ sessionID: input.sessionID, inputID: input.messageID })
+    .then((withdrawn) => (withdrawn ? undefined : revert()))
+}
@@ -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)
    }),
  )

@@ -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) {
@@ -73,12 +73,16 @@ test("searches settings globally and opens the matching setting", async () => {
    expect(app.captureCharFrame()).not.toContain("Animations")
    await app.waitFor(() => app.renderer.currentFocusedEditor instanceof InputRenderable)

-    app.mockInput.pressArrow("down")
-    for (const key of "sounds") app.mockInput.pressKey(key)
+    for (const key of "side") app.mockInput.pressKey(key)
+    await app.waitForFrame((frame) => frame.includes("Sidebar"))
+    expect(app.captureCharFrame()).not.toContain("New session")
+    expect(app.captureCharFrame()).not.toContain("Switch model")
+    expect(app.captureCharFrame()).not.toContain("Markdown")
+
    app.mockInput.pressEnter()
-    await app.waitForFrame((frame) => frame.includes("Settings") && frame.includes("Sounds"))
+    await app.waitForFrame((frame) => frame.includes("Settings") && frame.includes("Color mode"))
    app.mockInput.pressEnter()
-    await app.waitFor(() => current.attention?.sound === false)
+    await app.waitFor(() => current.session?.sidebar === "hide")
  } finally {
    app.renderer.destroy()
  }
@@ -853,6 +853,65 @@ test("completes exploration when a queued prompt is promoted", async () => {
  }
 })

+test("removes optimistic input when it is withdrawn", async () => {
+  const events = createEventStream()
+  const sessionID = "session-withdrawal"
+  const calls = createFetch((url) => {
+    if (url.pathname === `/api/session/${sessionID}/message`) return json({ data: [], cursor: {} })
+  }, events)
+  let data!: ReturnType<typeof useData>
+  let client!: ReturnType<typeof useClient>
+
+  function Probe() {
+    data = useData()
+    client = useClient()
+    return <box />
+  }
+
+  const app = await testRender(() => (
+    <TestTuiContexts>
+      <ClientProvider api={createApi(calls.fetch)}>
+        <ProjectProvider>
+          <DataProvider>
+            <Probe />
+          </DataProvider>
+        </ProjectProvider>
+      </ClientProvider>
+    </TestTuiContexts>
+  ))
+
+  try {
+    await wait(() => client.connection.status() === "connected")
+    emitEvent(events, {
+      id: "evt_prompt_admitted",
+      created: 1,
+      type: "session.input.admitted",
+      durable: durable(sessionID, 1),
+      data: {
+        sessionID,
+        inputID: "message-user",
+        input: { type: "user", data: { text: "Never mind" }, delivery: "steer" },
+      },
+    })
+    await wait(() => data.session.message.get(sessionID, "message-user") !== undefined)
+    expect(data.session.input.has(sessionID, "message-user")).toBe(true)
+
+    emitEvent(events, {
+      id: "evt_prompt_withdrawn",
+      created: 2,
+      type: "session.input.withdrawn",
+      durable: durable(sessionID, 2),
+      data: { sessionID, inputID: "message-user" },
+    })
+
+    await wait(() => data.session.message.get(sessionID, "message-user") === undefined)
+    expect(data.session.input.has(sessionID, "message-user")).toBe(false)
+    expect(data.session.pending.list(sessionID)).toEqual([])
+  } finally {
+    app.renderer.destroy()
+  }
+})
+
 test("classifies live tool rows independently of their call ID", async () => {
  const events = createEventStream()
  const sessionID = "session-tool-call-id"
@@ -79,7 +79,7 @@ async function renderSelect(
  return app
 }

-async function mountSelect(root: string, initial: DialogSelectOption<string>[], current?: string) {
+async function mountSelect(root: string, initial: DialogSelectOption<string>[]) {
  const state = path.join(root, "state")
  await mkdir(state, { recursive: true })
  const config = createTuiResolvedConfig()
@@ -114,7 +114,6 @@ async function mountSelect(root: string, initial: DialogSelectOption<string>[],
          <DialogSelect
            title="Mutable options"
            options={options()}
-            current={current}
            onMove={(option) => moved.push(option.value)}
            onSelect={(option) => selected.push(option.value)}
          />
@@ -310,20 +309,3 @@ test("keeps the cursor index while options are temporarily empty", async () => {
    select.app.renderer.destroy()
  }
 })
-
-test("keeps the current option selected when options reorder", async () => {
-  await using tmp = await tmpdir()
-  const options = ["first", "current", "third"].map((value) => ({ title: value, value }))
-  const select = await mountSelect(tmp.path, options, "current")
-
-  try {
-    select.replaceOptions([options[1], options[2], options[0]])
-    await select.app.waitForFrame((frame) => frame.indexOf("current") < frame.indexOf("third"))
-    select.app.mockInput.pressEnter()
-    await select.app.waitFor(() => select.selected.length === 1)
-
-    expect(select.selected).toEqual(["current"])
-  } finally {
-    select.app.renderer.destroy()
-  }
-})
@@ -0,0 +1,26 @@
+import { expect, test } from "bun:test"
+import { OpenCode } from "@opencode-ai/client"
+import { undoMessage } from "../../../src/routes/session/undo"
+
+test.each([
+  { withdrawn: true, expected: ["withdraw"] },
+  { withdrawn: false, expected: ["withdraw", "revert"] },
+])("routes undo for withdrawn=$withdrawn", async ({ withdrawn, expected }) => {
+  const calls: string[] = []
+  const client = OpenCode.make({
+    baseUrl: "http://localhost:3000",
+    fetch: Object.assign(
+      async (input: URL | RequestInfo, init?: BunFetchRequestInit | RequestInit) => {
+        const request = input instanceof Request ? input : new Request(input, init)
+        const operation = request.url.endsWith("/withdraw") ? "withdraw" : "revert"
+        calls.push(operation)
+        return Response.json({ data: operation === "withdraw" ? withdrawn : { messageID: "msg_user" } })
+      },
+      { preconnect: fetch.preconnect },
+    ),
+  })
+
+  await undoMessage(client, { sessionID: "ses_test", messageID: "msg_user" })
+
+  expect(calls).toEqual([...expected])
+})
@@ -110,6 +110,8 @@ test("navigates session tabs with leader arrows", () => {
  expect(config.keybinds.get("session.tab.previous")).toMatchObject([
    { key: "ctrl+shift+tab,<leader>left,alt+shift+[" },
  ])
+  expect(config.keybinds.get("session.tab.history.back")).toMatchObject([{ key: "ctrl+o" }])
+  expect(config.keybinds.get("session.tab.history.forward")).toMatchObject([{ key: "ctrl+i" }])
  expect(config.keybinds.get("session.tab.next_unread")).toMatchObject([{ key: "<leader>down" }])
  expect(config.keybinds.get("session.tab.previous_unread")).toMatchObject([{ key: "<leader>up" }])
 })
@@ -11,7 +11,6 @@ import { DataProvider } from "../../src/context/data"
 import { RouteProvider, useRoute } from "../../src/context/route"
 import { TuiAppProvider } from "../../src/context/runtime"
 import { SessionTabsProvider, useSessionTabs } from "../../src/context/session-tabs"
-import { NEW_SESSION_TAB_TITLE } from "../../src/context/session-tabs-model"
 import { StorageProvider } from "../../src/context/storage"
 import { createApi, createEventStream, createFetch, directory } from "../fixture/tui-client"
 import { TestTuiContexts } from "../fixture/tui-environment"
@@ -143,13 +142,11 @@ test("tracks a temporary new session tab across close and creation", async () =>
    setup.route.navigate({ type: "home" })
    await wait(() => setup.tabs.newTab())
    setup.route.navigate({ type: "session", sessionID: "third" })
-    expect(setup.tabs.newTab()).toBe(true)
    await wait(
      () => setup.tabs.current() === "third" && setup.tabs.tabs().some((tab) => tab.sessionID === "third"),
    )

    expect(setup.tabs.newTab()).toBe(false)
-    expect(setup.tabs.tabs().find((tab) => tab.sessionID === "third")?.title).toBe(NEW_SESSION_TAB_TITLE)
  } finally {
    setup.destroy()
  }
@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test"
 import type { SessionMessageInfo } from "@opencode-ai/client"
-import { isDefaultTitle, lastAssistantWithUsage, sessionTitle } from "../../src/util/session"
+import { isDefaultTitle, lastAssistantWithUsage } from "../../src/util/session"

 const assistant = (id: string, input: number): SessionMessageInfo => ({
  id,
@@ -14,21 +14,11 @@ const assistant = (id: string, input: number): SessionMessageInfo => ({

 describe("util.session", () => {
  test("recognizes generated parent and child titles", () => {
-    expect(isDefaultTitle(undefined)).toBeTrue()
    expect(isDefaultTitle("New session - 2026-06-06T12:34:56.789Z")).toBeTrue()
    expect(isDefaultTitle("Child session - 2026-06-06T12:34:56.789Z")).toBeTrue()
    expect(isDefaultTitle("New session - custom")).toBeFalse()
  })

-  test("derives display-only titles for untitled sessions", () => {
-    expect(sessionTitle({ title: undefined, time: { created: 0, updated: 0 } })).toBe(
-      "New session - 1970-01-01T00:00:00.000Z",
-    )
-    expect(sessionTitle({ title: undefined, parentID: "ses_parent", time: { created: 0, updated: 0 } })).toBe(
-      "Child session - 1970-01-01T00:00:00.000Z",
-    )
-  })
-
  test("tracks usage across undo and redo boundaries", () => {
    const messages = [assistant("msg_z", 10), assistant("msg_a", 30)]
Author	SHA1	Message	Date
Kit Langton	d7ffc7fec1	refactor(session): simplify pending withdrawal	2026-07-30 16:13:18 -04:00
Kit Langton	330ab9acae	fix(tui): undo pending session input	2026-07-30 16:13:18 -04:00