fix(core): exclude deleted projects from listing

2026-07-31 15:34:02 -04:00 · 2026-07-31 11:21:05 -04:00
32 changed files with 176 additions and 405 deletions
@@ -107,7 +107,6 @@ export const bodyFields = {
  stream_options: Schema.optional(Schema.Struct({ include_usage: Schema.Boolean })),
  store: Schema.optional(Schema.Boolean),
  reasoning_effort: Schema.optional(OpenAIOptions.OpenAIReasoningEffort),
-  max_completion_tokens: Schema.optional(Schema.Number),
  max_tokens: Schema.optional(Schema.Number),
  temperature: Schema.optional(Schema.Number),
  top_p: Schema.optional(Schema.Number),
@@ -416,7 +415,6 @@ const fromRequest = Effect.fn("OpenAIChat.fromRequest")(function* (request: LLMR
    )
  const generation = request.generation
  const toolSchemaCompatibility = request.model.compatibility?.toolSchema
-  const maxTokensField = request.model.compatibility?.maxTokensField ?? "max_tokens"
  return {
    model: request.model.id,
    messages: yield* lowerMessages(request),
@@ -429,9 +427,7 @@ const fromRequest = Effect.fn("OpenAIChat.fromRequest")(function* (request: LLMR
    tool_choice: request.toolChoice ? yield* lowerToolChoice(request.toolChoice) : undefined,
    stream: true as const,
    stream_options: { include_usage: true },
-    ...(maxTokensField === "max_completion_tokens"
-      ? { max_completion_tokens: generation?.maxTokens }
-      : { max_tokens: generation?.maxTokens }),
+    max_tokens: generation?.maxTokens,
    temperature: generation?.temperature,
    top_p: generation?.topP,
    frequency_penalty: generation?.frequencyPenalty,
@@ -6,7 +6,6 @@ export interface Settings extends Readonly<Record<string, unknown>> {
  readonly body?: Readonly<Record<string, unknown>>
  readonly limits?: {
    readonly context: number
-    readonly input?: number
    readonly output: number
  }
 }
@@ -28,9 +28,57 @@ const applyQuery = (url: string, query: Record<string, string> | undefined) => {
  return next.toString()
 }

+const PROTOCOL_BODY_OVERLAY_DENYLIST = new Set([
+  "anthropic_version",
+  "content",
+  "contents",
+  "frequencyPenalty",
+  "frequency_penalty",
+  "generationConfig",
+  "inferenceConfig",
+  "input",
+  "maxTokens",
+  "max_tokens",
+  "messages",
+  "model",
+  "presencePenalty",
+  "presence_penalty",
+  "responseFormat",
+  "response_format",
+  "seed",
+  "stop",
+  "stopSequences",
+  "stop_sequences",
+  "stream",
+  "streamOptions",
+  "stream_options",
+  "system",
+  "systemInstruction",
+  "system_instruction",
+  "temperature",
+  "thinking",
+  "toolChoice",
+  "toolConfig",
+  "tool_choice",
+  "tool_config",
+  "tools",
+  "topK",
+  "topP",
+  "top_k",
+  "top_p",
+])
+
+const forbiddenBodyOverlayKeys = (body: Record<string, unknown>) =>
+  Object.keys(body).filter((key) => PROTOCOL_BODY_OVERLAY_DENYLIST.has(key))
+
 const bodyWithOverlay = <Body>(body: Body, request: LLMRequest, encodeBody: (body: Body) => string) =>
  Effect.gen(function* () {
    if (request.http?.body === undefined) return { jsonBody: body, bodyText: encodeBody(body) }
+    const forbiddenKeys = forbiddenBodyOverlayKeys(request.http.body)
+    if (forbiddenKeys.length > 0)
+      return yield* ProviderShared.invalidRequest(
+        `http.body cannot overlay protocol-owned field(s): ${forbiddenKeys.join(", ")}`,
+      )
    if (ProviderShared.isRecord(body)) {
      const overlaid = mergeJsonRecords(body, request.http.body) ?? {}
      return { jsonBody: overlaid, bodyText: ProviderShared.encodeJson(overlaid) }
@@ -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),
 }) {}

@@ -167,13 +166,9 @@ export namespace ModelDefaults {
 export const ModelToolSchemaCompatibility = Schema.Literals(["gemini", "moonshot"])
 export type ModelToolSchemaCompatibility = Schema.Schema.Type<typeof ModelToolSchemaCompatibility>

-export const ModelMaxTokensFieldCompatibility = Schema.Literals(["max_completion_tokens", "max_tokens"])
-export type ModelMaxTokensFieldCompatibility = Schema.Schema.Type<typeof ModelMaxTokensFieldCompatibility>
-
 export class ModelCompatibility extends Schema.Class<ModelCompatibility>("LLM.ModelCompatibility")({
  toolSchema: Schema.optional(ModelToolSchemaCompatibility),
  reasoningField: Schema.optional(Schema.String),
-  maxTokensField: Schema.optional(ModelMaxTokensFieldCompatibility),
 }) {}

 export namespace ModelCompatibility {
@@ -171,27 +171,24 @@ describe("request option precedence", () => {
    ),
  )

-  it.effect("applies raw body overlays after protocol lowering", () =>
-    LLMClient.generate(
-      LLM.request({
-        model: OpenAIChat.route
-          .with({ endpoint: { baseURL: "https://api.openai.test/v1/" }, auth: Auth.bearer("test") })
-          .model({ id: "gpt-4o-mini" }),
-        prompt: "Say hello.",
-        http: { body: { model: "gpt-5", messages: [], tools: [] } },
-      }),
-    ).pipe(
-      Effect.provide(
-        dynamicResponse((input) =>
-          Effect.gen(function* () {
-            expect(decodeJson(input.text)).toMatchObject({ model: "gpt-5", messages: [], tools: [] })
-            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
+        .with({ endpoint: { baseURL: "https://api.openai.test/v1/" }, auth: Auth.bearer("test") })
+        .model({ id: "gpt-4o-mini" })
+      const error = yield* compileRequest(
+        LLM.request({
+          model,
+          prompt: "Say hello.",
+          http: { body: { model: "gpt-5", messages: [], tools: [] } },
+        }),
+      ).pipe(Effect.flip)
+
+      expect(error.reason).toMatchObject({
+        _tag: "InvalidRequest",
+        message: "http.body cannot overlay protocol-owned field(s): model, messages, tools",
+      })
+    }),
  )

  it.effect("uses model output limits after route limits and before call maxTokens", () =>
@@ -181,6 +181,23 @@ describe("Google Vertex providers", () => {
    }),
  )

+  it.effect("protects the Vertex Messages API version from body overlays", () =>
+    Effect.gen(function* () {
+      const error = yield* compileRequest(
+        LLM.request({
+          model: GoogleVertexMessages.configure({
+            accessToken: "vertex-token",
+            http: { body: { anthropic_version: "wrong" } },
+            project: "vertex-project",
+          }).model("claude-sonnet-4-6"),
+          prompt: "Say hello.",
+        }),
+      ).pipe(Effect.flip)
+
+      expect(error.message).toContain("http.body cannot overlay protocol-owned field(s): anthropic_version")
+    }),
+  )
+
  it.effect("routes tuned Gemini models through their deployed endpoint", () =>
    Effect.gen(function* () {
      const response = yield* LLMClient.generate(
@@ -144,20 +144,6 @@ describe("OpenAI-compatible Chat route", () => {
    }),
  )

-  it.effect("configures the max tokens request field", () =>
-    Effect.gen(function* () {
-      const compatible = OpenAICompatibleChat.route
-        .with({ provider: "custom", endpoint: { baseURL: "https://api.custom.test/v1" } })
-        .model({ id: "custom-model", compatibility: { maxTokensField: "max_completion_tokens" } })
-      const prepared = yield* compileRequest(
-        LLM.request({ model: compatible, prompt: "Say hello.", generation: { maxTokens: 20 } }),
-      )
-
-      expect(prepared.body).toMatchObject({ max_completion_tokens: 20 })
-      expect(prepared.body).not.toHaveProperty("max_tokens")
-    }),
-  )
-
  it.effect("matches AI SDK compatible tool request body fixture", () =>
    Effect.gen(function* () {
      const prepared = yield* compileRequest(
@@ -38,19 +38,17 @@ test("reports a divergent native offset once and ignores equal offsets and unrel
    instance.scrollOffset = offset
  })

+  document.body.append(unrelated)
+  unrelated.remove()
+  await frames(2)
+  expect(calls).toEqual([])
+
  route.remove()
  document.body.append(route)
  await new Promise((resolve) => setTimeout(resolve, 0))
  await frames(3)
  expect(calls).toEqual([[0, false]])

-  instance.scrollOffset = 79_400
-  document.body.append(unrelated)
-  unrelated.remove()
-  await frames(2)
-  expect(calls).toEqual([[0, false]])
-
-  instance.scrollOffset = 0
  route.remove()
  document.body.append(route)
  await new Promise((resolve) => setTimeout(resolve, 0))
@@ -58,9 +58,8 @@ export async function collectNodeAssets(target: NodeTarget) {
        source: path.join(ptyRoot, relative),
      })),
  ]
-  const unique = [...new Map(assets.map((asset) => [asset.key, asset])).values()]
-  await Promise.all(unique.map((asset) => stat(asset.source)))
-  return unique
+  await Promise.all(assets.map((asset) => stat(asset.source)))
+  return assets
 }

 export async function hashNodeAssets(assets: readonly NodeAsset[]) {
@@ -1,17 +0,0 @@
-import { expect, test } from "bun:test"
-import { fileURLToPath } from "node:url"
-import { collectNodeAssets } from "../script/node-assets"
-import { nodeTarget, shellParserWasmAssets } from "../src/node/target"
-
-test("collects each SEA asset key once", async () => {
-  const assets = await collectNodeAssets(nodeTarget(process.platform, process.arch))
-  const keys = assets.map((asset) => asset.key)
-
-  expect(new Set(keys).size).toBe(keys.length)
-  expect(assets.filter((asset) => asset.key === shellParserWasmAssets.runtime)).toEqual([
-    {
-      key: shellParserWasmAssets.runtime,
-      source: fileURLToPath(import.meta.resolve(shellParserWasmAssets.runtime)),
-    },
-  ])
-})
@@ -118,7 +118,6 @@ export type SessionListOperation<E = never> = (input?: Endpoint5_0Input) => Effe

 export type Endpoint5_1Input = {
  readonly id?: Session.ID | undefined
-  readonly title?: string | undefined
  readonly agent?: Agent.ID | undefined
  readonly model?: Model.Ref | undefined
  readonly location?: Location.Ref | undefined
@@ -299,13 +299,7 @@ const Endpoint5_0 = (raw: RawClient["server.session"]) => (input?: Endpoint5_0In
 const Endpoint5_1 = (raw: RawClient["server.session"]) => (input?: Endpoint5_1Input) =>
  preserveEffect<Endpoint5_1Output>()(
    raw["session.create"]({
-      payload: {
-        id: input?.["id"],
-        title: input?.["title"],
-        agent: input?.["agent"],
-        model: input?.["model"],
-        location: input?.["location"],
-      },
+      payload: { id: input?.["id"], agent: input?.["agent"], model: input?.["model"], location: input?.["location"] },
    }).pipe(
      Effect.mapError(mapClientError),
      Effect.map((value) => value.data),
@@ -462,7 +462,6 @@ export function make(options: ClientOptions) {
            path: `/api/session`,
            body: {
              id: input?.["id"],
-              title: input?.["title"],
              agent: input?.["agent"],
              model: input?.["model"],
              location: input?.["location"],
@@ -2662,35 +2662,24 @@ export type SessionListOutput = SessionsResponse
 export type SessionCreateInput = {
  readonly id?: {
    readonly id?: string | null
-    readonly title?: string | null
    readonly agent?: string | null
    readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string } | null
    readonly location?: { readonly directory: string; readonly workspaceID?: string } | null
  }["id"]
-  readonly title?: {
-    readonly id?: string | null
-    readonly title?: string | null
-    readonly agent?: string | null
-    readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string } | null
-    readonly location?: { readonly directory: string; readonly workspaceID?: string } | null
-  }["title"]
  readonly agent?: {
    readonly id?: string | null
-    readonly title?: string | null
    readonly agent?: string | null
    readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string } | null
    readonly location?: { readonly directory: string; readonly workspaceID?: string } | null
  }["agent"]
  readonly model?: {
    readonly id?: string | null
-    readonly title?: string | null
    readonly agent?: string | null
    readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string } | null
    readonly location?: { readonly directory: string; readonly workspaceID?: string } | null
  }["model"]
  readonly location?: {
    readonly id?: string | null
-    readonly title?: string | null
    readonly agent?: string | null
    readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string } | null
    readonly location?: { readonly directory: string; readonly workspaceID?: string } | null
@@ -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: {
@@ -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) => {
@@ -204,7 +204,7 @@ export const fromCatalogModel = (
      ...nativeCredentialSettings(specifier, credential),
      headers: resolved.headers,
      body: resolved.body,
-      limits: { context: resolved.limit.context, input: resolved.limit.input, output: resolved.limit.output },
+      limits: { context: resolved.limit.context, output: resolved.limit.output },
    }
    return yield* Effect.try({
      try: () => {
@@ -220,8 +220,12 @@ export const OpenAIPlugin = define({
            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 }
+          if (draft.id.includes("gpt-5.5")) {
+            draft.limit = { context: 400_000, input: 272_000, output: 128_000 }
+          }
+          if (draft.id.includes("gpt-5.6")) {
+            draft.limit = { context: 500_000, input: 372_000, output: 128_000 }
+          }
        })
      }
    })
@@ -148,7 +148,7 @@ const layer = Layer.effect(
        .orderBy(desc(ProjectTable.time_updated), asc(ProjectTable.id))
        .all()
        .pipe(Effect.orDie)
-      return rows.map(fromRow)
+      return yield* Effect.filter(rows.map(fromRow), (project) => fs.existsSafe(project.canonical))
    })

    const directories = Effect.fn("Project.directories")(function* (input: DirectoriesInput) {
@@ -152,11 +152,14 @@ const settings = (documents: readonly Config.Entry[]) => {
  const configured = documents
    .filter((entry): entry is Config.Document => entry.type === "document")
    .flatMap((entry) => (entry.info.compaction ? [entry.info.compaction] : []))
-  return {
-    auto: configured.findLast((value) => value.auto !== undefined)?.auto ?? true,
-    buffer: configured.findLast((value) => value.buffer !== undefined)?.buffer ?? DEFAULT_BUFFER,
-    tokens: configured.findLast((value) => value.keep?.tokens !== undefined)?.keep?.tokens ?? DEFAULT_KEEP_TOKENS,
-  }
+  return configured.reduce<Settings>(
+    (result, current) => ({
+      auto: current.auto ?? result.auto,
+      buffer: current.buffer ?? result.buffer,
+      tokens: current.keep?.tokens ?? result.tokens,
+    }),
+    { auto: true, buffer: DEFAULT_BUFFER, tokens: DEFAULT_KEEP_TOKENS },
+  )
 }

 const select = (
@@ -347,16 +350,11 @@ const make = (dependencies: Dependencies) => {
        message.type === "assistant" && message.tokens !== undefined,
    )
    if (!last) return false
-    const limits = input.model.route.defaults.limits
-    const output = Math.min(limits?.output ?? 0, OUTPUT_TOKEN_MAX)
-    const promptCeiling = Math.min(
-      limits?.input === undefined ? Number.POSITIVE_INFINITY : limits.input - config.buffer,
-      context - Math.max(output, config.buffer),
-    )
+    const output = Math.min(input.model.route.defaults.limits?.output ?? 0, OUTPUT_TOKEN_MAX)
    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 >= promptCeiling
+    return used >= context - (output || config.buffer)
  }
  const compactManual = Effect.fn("SessionCompaction.compactManual")(function* (input: ManualInput) {
    const content = planContent(input.messages, config.tokens)
@@ -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 } } },
        },
      })
@@ -74,9 +74,6 @@ 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" } }
@@ -140,7 +137,7 @@ describe("OpenAIPlugin", () => {
      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.limit).toEqual({ context: 400_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 +145,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(gpt56.limit).toEqual({ context: 500_000, input: 372_000, output: 128_000 })
      expect(required(yield* catalog.model.get(Provider.ID.openai, Model.ID.make("gpt-4.1"))).enabled).toBe(false)
    }),
  )
@@ -15,8 +15,16 @@ import { testEffect } from "./lib/effect"
 const it = testEffect(Layer.merge(AppNodeBuilder.build(Project.node), AppNodeBuilder.build(Database.node)))

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

      expect(yield* project.list()).toEqual([
        {
          id: Project.ID.make("newer"),
-          canonical: abs("/newer"),
+          canonical: newer,
          time: { created: 2, updated: 2, initialized: 3 },
          sandboxes: [],
        },
        {
          id: Project.ID.make("older"),
-          canonical: abs("/older"),
+          canonical: older,
          vcs: "git",
          name: "Older",
          icon: { color: "#000000" },
          commands: { start: "bun dev" },
          time: { created: 1, updated: 1 },
-          sandboxes: [abs("/older/sandbox")],
+          sandboxes: [abs(path.join(older, "sandbox"))],
        },
      ])
    }),
@@ -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,52 +130,6 @@ test("compaction prompt requires the checkpoint headings in order", () => {
  expect(prompt).toContain("Keep every section, even when empty.")
 })

-it.effect("auto compaction reserves a buffer below the prompt ceiling", () =>
-  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, limits: { context: number; input?: number; output: number }) => ({
-      session,
-      model: Model.make({
-        id: "test-model",
-        provider: "test-provider",
-        route: OpenAIChat.route.with({ limits }),
-      }),
-      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 },
-        }),
-      ],
-    })
-
-    const inputLimited = { context: 400_000, input: 272_000, output: 128_000 }
-    expect(compaction.required(input(251_999, inputLimited))).toBe(false)
-    expect(compaction.required(input(252_000, inputLimited))).toBe(true)
-
-    const contextLimited = { context: 100_000, output: 10_000 }
-    expect(compaction.required(input(79_999, contextLimited))).toBe(false)
-    expect(compaction.required(input(80_000, contextLimited))).toBe(true)
-
-    const outputLimited = { context: 100_000, output: 30_000 }
-    expect(compaction.required(input(69_999, outputLimited))).toBe(false)
-    expect(compaction.required(input(70_000, outputLimited))).toBe(true)
-  }),
-)
-
 it.effect("manual compaction summarizes short context instead of no-op", () =>
  Effect.gen(function* () {
    requests = []
@@ -149,7 +149,6 @@ export const makeSessionGroup = <I extends HttpApiMiddleware.AnyId, S>(sessionLo
      HttpApiEndpoint.post("session.create", "/api/session", {
        payload: Schema.Struct({
          id: Session.ID.pipe(Schema.optional),
-          title: Schema.String.pipe(Schema.optional),
          agent: Agent.ID.pipe(Schema.optional),
          model: Model.Ref.pipe(Schema.optional),
          location: Location.Ref.pipe(Schema.optional),
@@ -77,7 +77,6 @@ export const SessionHandler = HttpApiBuilder.group(Api, "server.session", (handl
            data: yield* session
              .create({
                id: ctx.payload.id,
-                title: ctx.payload.title,
                agent: ctx.payload.agent,
                model: ctx.payload.model,
                location: ctx.payload.location ?? { directory: AbsolutePath.make(process.cwd()) },
@@ -37,8 +37,8 @@ export function DialogOpen() {
  const dimensions = useTerminalDimensions()
  const shortcuts = Keymap.useShortcuts()
  const [filter, setFilter] = createSignal("")
-  const [selectionMoved, setSelectionMoved] = createSignal(false)

+  data.project.invalidate()
  void data.project.sync().catch(() => {})

  // One background fetch fills in recent sessions from other projects; the menu renders
@@ -52,12 +52,8 @@ export function DialogOpen() {
    { initialValue: [] },
  )

-  const openTabs = createMemo(
-    () => new Set(sessionTabs.enabled() ? sessionTabs.tabs().map((tab) => tab.sessionID) : []),
-  )
-  const currentSessionID = createMemo(() =>
-    route.data.type === "session" ? data.session.root(route.data.sessionID) : undefined,
-  )
+  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()]
@@ -73,7 +69,7 @@ export function DialogOpen() {
    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 loaded tab by name still switches to it.
+    // matching a tab by name still switches to it.
    const recent = filter().trim()
      ? sessions()
      : sessions()
@@ -82,9 +78,7 @@ export function DialogOpen() {
    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.status(session.id) === "running" ||
-        data.session.family(session.id).some((id) => data.session.status(id) === "running")
+      const running = data.session.family(session.id).some((id) => data.session.status(id) === "running")
      return {
        title: withTimestampedFallback(session),
        value: { type: "session", sessionID: session.id } as OpenTarget,
@@ -104,7 +98,7 @@ export function DialogOpen() {
    const projectOptions = data.project
      .list()
      .filter((project) => {
-        if (project.canonical === "/" || seen.has(project.canonical)) return false
+        if (project.canonical === "/" || project.id === current?.id || seen.has(project.canonical)) return false
        seen.add(project.canonical)
        return true
      })
@@ -119,10 +113,6 @@ export function DialogOpen() {
          searchText: footer,
          value: { type: "project", directory: project.canonical } as OpenTarget,
          category: "Projects",
-          gutter:
-            project.canonical === current?.canonical
-              ? () => <text fg={theme.text.formfield.selected}>●</text>
-              : undefined,
        }
      })

@@ -138,8 +128,6 @@ export function DialogOpen() {
      options={options()}
      current={currentSessionID() ? ({ type: "session", sessionID: currentSessionID()! } as OpenTarget) : undefined}
      focusCurrent={false}
-      preserveSelection={selectionMoved()}
-      onMove={() => setSelectionMoved(true)}
      onFilter={setFilter}
      noMatchView={
        <box paddingLeft={4} paddingRight={4}>
@@ -89,8 +89,7 @@ export function DialogSessionList() {
  const sessions = createMemo(() => {
    const query = filter().trim()
    const local = localSessions()
-    if (query !== search().trim()) return searchResults.latest?.sessions ?? local
-    if (searchResults.loading) return searchResults.latest?.sessions ?? []
+    if (query !== search().trim() || searchResults.loading) return searchResults.latest?.sessions ?? local
    const result = searchResults()
    if (result?.query !== query || result.allProjects !== allProjects() || result.error) return local
    return result.sessions
@@ -155,13 +154,11 @@ export function DialogSessionList() {
        footer,
        bg: deleting ? theme.background.action.destructive.focused : undefined,
        fg: deleting ? theme.text.action.destructive.focused : undefined,
-        gutter:
-          data.session.status(session.id) === "running" ||
-          data.session.family(session.id).some((id) => data.session.status(id) === "running")
-            ? () => <Spinner />
-            : slot === undefined
-              ? undefined
-              : () => <text fg={theme.hue.accent[mode() === "light" ? 800 : 200]}>{slot}</text>,
+        gutter: data.session.family(session.id).some((id) => data.session.status(id) === "running")
+          ? () => <Spinner />
+          : slot === undefined
+            ? undefined
+            : () => <text fg={theme.hue.accent[mode() === "light" ? 800 : 200]}>{slot}</text>,
      }
    }

@@ -245,7 +245,7 @@ export function DialogSelect<T>(props: DialogSelectProps<T>) {
    on(
      () => props.options,
      () => {
-        if (!props.preserveSelection && (props.current === undefined || props.focusCurrent === false)) {
+        if (!props.preserveSelection && props.current === undefined) {
          const count = flat().length
          if (count === 0) return
          const next = reconcileSelection(store.selected, count)
@@ -281,11 +281,7 @@ export function DialogSelect<T>(props: DialogSelectProps<T>) {
          setStore("selected", index)
          selection = option
          if (!moved) return
-          if (
-            (!props.preserveSelection && (props.current === undefined || props.focusCurrent === false)) ||
-            store.filter.length > 0
-          )
-            return
+          if ((!props.preserveSelection && props.current === undefined) || store.filter.length > 0) return
          scrollAfterLayout(false, option.value)
          return
        }
@@ -106,18 +106,11 @@ test("does not preload session summaries into the data context", async () => {
  }
 })

-test("proactively syncs project metadata newest first", async () => {
+test("proactively syncs project metadata", async () => {
  const events = createEventStream()
  const calls = createFetch((url) => {
    if (url.pathname !== "/api/project") return
    return json([
-      {
-        id: "proj_old",
-        canonical: "/old/project",
-        name: "Old project",
-        time: { created: 1, updated: 1 },
-        sandboxes: [],
-      },
      {
        id: "proj_test",
        canonical: worktree,
@@ -156,13 +149,6 @@ test("proactively syncs project metadata newest first", async () => {
        time: { created: 1, updated: 2 },
        sandboxes: [],
      },
-      {
-        id: "proj_old",
-        canonical: "/old/project",
-        name: "Old project",
-        time: { created: 1, updated: 1 },
-        sandboxes: [],
-      },
    ])
  } finally {
    app.renderer.destroy()
@@ -18,14 +18,16 @@ import { StorageProvider } from "../../../src/context/storage"
 import { ThemeProvider } from "../../../src/context/theme"
 import { DialogProvider, useDialog } from "../../../src/ui/dialog"
 import { ToastProvider } from "../../../src/ui/toast"
-import { createApi, createEventStream, createFetch, json, type FetchHandler } from "../../fixture/tui-client"
+import { createApi, createEventStream, createFetch, json } from "../../fixture/tui-client"
 import { TestTuiContexts } from "../../fixture/tui-environment"
 import { createTuiResolvedConfig } from "../../fixture/tui-runtime"

 test("selecting an unhydrated session preserves its location", async () => {
+  const state = mkdtempSync(path.join(tmpdir(), "opencode-dialog-open-"))
+  const events = createEventStream()
  const remote = { directory: "/tmp/opencode/remote", workspaceID: "ws_remote" }
-  const fixture = await renderOpen((url) => {
-    if (url.pathname !== "/api/session") return undefined
+  const calls = createFetch((url) => {
+    if (url.pathname !== "/api/session") return
    return json({
      data: [
        {
@@ -40,129 +42,7 @@ test("selecting an unhydrated session preserves its location", async () => {
      ],
      cursor: {},
    })
-  })
-
-  try {
-    await fixture.app.waitForFrame((frame) => frame.includes("Remote session"))
-    expect(fixture.data.session.get("ses_remote")).toBeUndefined()
-
-    fixture.app.mockInput.pressEnter()
-    await fixture.app.waitFor(() => fixture.route.data.type === "session")
-
-    expect(fixture.route.data).toEqual({ type: "session", sessionID: "ses_remote" })
-    expect(fixture.location.ref).toEqual(remote)
-  } finally {
-    fixture.dispose()
-  }
-})
-
-test("shows the current project and opens its root", async () => {
-  const root = "/tmp/opencode/project"
-  const subfolder = `${root}/packages/tui`
-  const fixture = await renderOpen(
-    (url) => {
-      if (url.pathname === "/api/project")
-        return json([
-          {
-            id: "proj_current",
-            canonical: root,
-            name: "OpenCode",
-            time: { created: 1, updated: 2 },
-            sandboxes: [],
-          },
-        ])
-      if (url.pathname === "/api/location")
-        return json({
-          directory: subfolder,
-          project: { id: "proj_current", directory: root, canonical: root },
-        })
-      return undefined
-    },
-    async ({ data, location }) => {
-      await data.location.sync({ directory: subfolder })
-      location.set({ directory: subfolder })
-    },
-  )
-
-  try {
-    const frame = await fixture.app.waitForFrame((value) => value.includes("OpenCode") && value.includes("●"))
-    expect(frame).toContain(root)
-
-    fixture.app.mockInput.pressEnter()
-    await fixture.app.waitFor(() => fixture.route.data.type === "home")
-
-    expect(fixture.route.data).toEqual({ type: "home", location: { directory: root } })
-    expect(fixture.location.ref).toEqual({ directory: root })
-  } finally {
-    fixture.dispose()
-  }
-})
-
-test("preserves a moved project when sessions arrive", async () => {
-  let resolveSessions!: (response: Response) => void
-  const sessions = new Promise<Response>((resolve) => (resolveSessions = resolve))
-  const fixture = await renderOpen((url) => {
-    if (url.pathname === "/api/session") return sessions
-    if (url.pathname === "/api/project")
-      return json([
-        {
-          id: "proj_first",
-          canonical: "/tmp/opencode/first",
-          name: "First project",
-          time: { created: 1, updated: 2 },
-          sandboxes: [],
-        },
-        {
-          id: "proj_second",
-          canonical: "/tmp/opencode/second",
-          name: "Second project",
-          time: { created: 1, updated: 1 },
-          sandboxes: [],
-        },
-      ])
-    return undefined
-  })
-
-  try {
-    await fixture.app.waitForFrame((frame) => frame.includes("Second project"))
-    fixture.app.mockInput.pressArrow("down")
-
-    resolveSessions(
-      json({
-        data: [
-          {
-            id: "ses_recent",
-            projectID: "proj_first",
-            cost: 0,
-            tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
-            time: { created: 2, updated: 3 },
-            title: "Recent session",
-            location: { directory: "/tmp/opencode/first" },
-          },
-        ],
-        cursor: {},
-      }),
-    )
-    await fixture.app.waitForFrame((frame) => frame.includes("Recent session"))
-    fixture.app.mockInput.pressEnter()
-    await fixture.app.waitFor(() => fixture.route.data.type === "home")
-
-    expect(fixture.route.data).toEqual({ type: "home", location: { directory: "/tmp/opencode/second" } })
-  } finally {
-    fixture.dispose()
-  }
-})
-
-async function renderOpen(
-  handler: FetchHandler,
-  beforeOpen?: (contexts: {
-    data: ReturnType<typeof useData>
-    location: ReturnType<typeof useLocation>
-  }) => void | Promise<void>,
-) {
-  const state = mkdtempSync(path.join(tmpdir(), "opencode-dialog-open-"))
-  const events = createEventStream()
-  const calls = createFetch(handler, events)
+  }, events)
  let route!: ReturnType<typeof useRoute>
  let location!: ReturnType<typeof useLocation>
  let data!: ReturnType<typeof useData>
@@ -172,9 +52,7 @@ async function renderOpen(
    route = useRoute()
    location = useLocation()
    data = useData()
-    onMount(
-      () => void Promise.resolve(beforeOpen?.({ data, location })).then(() => dialog.replace(() => <DialogOpen />)),
-    )
+    onMount(() => dialog.replace(() => <DialogOpen />))
    return null
  }

@@ -212,20 +90,17 @@ async function renderOpen(
  )
  app.renderer.start()

-  return {
-    app,
-    get route() {
-      return route
-    },
-    get location() {
-      return location
-    },
-    get data() {
-      return data
-    },
-    dispose() {
-      app.renderer.destroy()
-      rmSync(state, { recursive: true, force: true })
-    },
+  try {
+    await app.waitForFrame((frame) => frame.includes("Remote session"))
+    expect(data.session.get("ses_remote")).toBeUndefined()
+
+    app.mockInput.pressEnter()
+    await app.waitFor(() => route.data.type === "session")
+
+    expect(route.data).toEqual({ type: "session", sessionID: "ses_remote" })
+    expect(location.ref).toEqual(remote)
+  } finally {
+    app.renderer.destroy()
+    rmSync(state, { recursive: true, force: true })
  }
-}
+})
@@ -82,12 +82,7 @@ async function renderSelect(
  return app
 }

-async function mountSelect(
-  root: string,
-  initial: DialogSelectOption<string>[],
-  current?: string,
-  focusCurrent?: boolean,
-) {
+async function mountSelect(root: string, initial: DialogSelectOption<string>[], current?: string) {
  const state = path.join(root, "state")
  await mkdir(state, { recursive: true })
  const config = createTuiResolvedConfig()
@@ -123,7 +118,6 @@ async function mountSelect(
            title="Mutable options"
            options={options()}
            current={current}
-            focusCurrent={focusCurrent}
            onMove={(option) => moved.push(option.value)}
            onSelect={(option) => selected.push(option.value)}
          />
@@ -358,24 +352,3 @@ test("keeps the current option selected when options reorder", async () => {
    select.app.renderer.destroy()
  }
 })
-
-test("keeps the first row selected when current is only a marker", async () => {
-  await using tmp = await tmpdir()
-  const project = { title: "project", value: "project" }
-  const select = await mountSelect(tmp.path, [project], "current", false)
-
-  try {
-    select.replaceOptions([
-      { title: "recent session", value: "recent" },
-      project,
-      { title: "current session", value: "current" },
-    ])
-    await select.app.waitForFrame((frame) => frame.includes("recent session"))
-    select.app.mockInput.pressEnter()
-    await select.app.waitFor(() => select.selected.length === 1)
-
-    expect(select.selected).toEqual(["recent"])
-  } finally {
-    select.app.renderer.destroy()
-  }
-})
@@ -95,7 +95,7 @@ Add `compaction` to any [OpenCode configuration file](/config):
 | `auto` | `true` | Runs the preflight context-size check. It does not disable manual compaction or one-shot provider-overflow recovery. |
 | `prune` | None | Accepted by the V2 schema, but currently has no runtime effect. V2 does not prune old tool outputs in place. |
 | `keep.tokens` | `8000` | Approximate number of tokens from the newest serialized conversation context to retain beside the summary. |
-| `buffer` | `20000` | Safety reserve below an explicit input limit. Without one, it is the minimum context reserve and the model output allowance wins when larger. |
+| `buffer` | `20000` | Token reserve used by the automatic threshold. The requested model output allowance wins when it is larger. |

 `keep.tokens` and `buffer` accept non-negative integers. Larger `keep.tokens`
 preserves more recent detail but leaves less room for future work. Larger