refactor(core): remove unused small model selection

packages/app/src/context/command.tsx

@@ -248,6 +248,11 @@ export function formatKeybind(config: string, t?: (key: KeyLabel) => string): st
   return IS_MAC ? parts.join("") : parts.join("+")
 }
 
+// KeybindV2 takes an array instead of a string
+export function formatKeybindKeys(config: string, t?: (key: KeyLabel) => string): string[] {
+  return formatKeybindParts(config, t)
+}
+
 function isEditableTarget(target: EventTarget | null) {
   if (!(target instanceof HTMLElement)) return false
   if (target.isContentEditable) return true

packages/app/src/context/file.tsx

@@ -286,6 +286,13 @@ export const { use: useFile, provider: FileProvider } = createSimpleContext({
         children: tree.children,
         expand: tree.expandDir,
         collapse: tree.collapseDir,
+        toggle(input: string) {
+          if (tree.dirState(input)?.expanded) {
+            tree.collapseDir(input)
+            return
+          }
+          tree.expandDir(input)
+        },
       },
       get,
       load,

packages/app/src/context/global-sync/utils.ts

@@ -153,6 +153,18 @@ export function normalizeProviderList(
   }
 }
 
+export function sanitizeProject(project: Project) {
+  if (!project.icon?.url && !project.icon?.override) return project
+  return {
+    ...project,
+    icon: {
+      ...project.icon,
+      url: undefined,
+      override: undefined,
+    },
+  }
+}
+
 export function normalizeProjectInfo(project: Project | CurrentProject): Project {
   return {
     ...project,

packages/app/src/context/layout.tsx

@@ -753,6 +753,9 @@ export const { use: useLayout, provider: LayoutProvider } = createSimpleContext(
       },
       mobileSidebar: {
         opened: createMemo(() => store.mobileSidebar?.opened ?? false),
+        show() {
+          setStore("mobileSidebar", "opened", true)
+        },
         hide() {
           setStore("mobileSidebar", "opened", false)
         },
@@ -958,6 +961,33 @@ export const { use: useLayout, provider: LayoutProvider } = createSimpleContext(
               if (current.reviewOpen.includes(path)) return
               setStore("sessionView", session, "reviewOpen", current.reviewOpen.length, path)
             },
+            closePath(path: string) {
+              const session = key()
+              const current = store.sessionView[session]?.reviewOpen
+              if (!current) return
+
+              const index = current.indexOf(path)
+              if (index === -1) return
+              setStore(
+                "sessionView",
+                session,
+                "reviewOpen",
+                produce((draft) => {
+                  if (!draft) return
+                  draft.splice(index, 1)
+                }),
+              )
+            },
+            togglePath(path: string) {
+              const session = key()
+              const current = store.sessionView[session]?.reviewOpen
+              if (!current || !current.includes(path)) {
+                this.openPath(path)
+                return
+              }
+
+              this.closePath(path)
+            },
           },
         }
       },

packages/app/src/pages/session/helpers.ts

@@ -22,6 +22,8 @@ type TabsInput = {
   fileBrowser?: Accessor<boolean>
 }
 
+export const getSessionKey = (dir: string | undefined, id: string | undefined) => `${dir ?? ""}${id ? `/${id}` : ""}`
+
 export function shouldShowFileTree(input: { visible: boolean; opened: boolean }) {
   return input.opened && input.visible
 }

packages/core/src/catalog.ts

@@ -52,7 +52,6 @@ export interface Interface extends State.Transformable<Draft> {
     readonly all: () => Effect.Effect<Model.Info[]>
     readonly available: () => Effect.Effect<Model.Info[]>
     readonly default: () => Effect.Effect<Model.Info | undefined>
-    readonly small: (providerID: Provider.ID) => Effect.Effect<Model.Info | undefined>
   }
 }
 
@@ -206,59 +205,6 @@ const layer = Layer.effect(
 
           return (yield* result.model.available())[0]
         }),
-
-        small: Effect.fn("Catalog.model.small")(function* (providerID) {
-          const record = state.get().providers.get(providerID)
-          if (!record) return
-          const provider = record.provider
-
-          // TODO: Remove these provider-specific assumptions once model syncing reliably reports available deployments.
-          if (providerID === Provider.ID.azure || providerID === Provider.ID.make("azure-cognitive-services")) {
-            return
-          }
-
-          if (providerID === Provider.ID.opencode) {
-            const gpt5Nano = record.models.get(Model.ID.make("gpt-5-nano"))
-            if (gpt5Nano?.enabled && gpt5Nano.status === "active") return projectModel(gpt5Nano, provider)
-          }
-
-          const candidates = pipe(
-            Array.fromIterable(record.models.values()),
-            Array.filter(
-              (model) =>
-                model.providerID === providerID &&
-                model.enabled &&
-                model.status === "active" &&
-                model.capabilities.input.some((item) => item.startsWith("text")) &&
-                model.capabilities.output.some((item) => item.startsWith("text")),
-            ),
-            Array.map((model) => ({
-              model,
-              cost: model.cost[0] ? model.cost[0].input + model.cost[0].output : 999,
-              age: (Date.now() - model.time.released) / (1000 * 60 * 60 * 24 * 30),
-              small: SMALL_MODEL_RE.test(`${model.id} ${model.family ?? ""} ${model.name}`.toLowerCase()),
-            })),
-            Array.filter((item) => item.cost > 0 && item.age <= 18),
-          )
-
-          const pick = (items: typeof candidates) => {
-            if (!Array.isReadonlyArrayNonEmpty(items)) return
-            const maxCost = Math.max(...items.map((item) => item.cost), 0.01)
-            const maxAge = Math.max(...items.map((item) => item.age), 0.01)
-            const selected = Array.min(
-              items,
-              Order.mapInput(
-                Order.Number,
-                (item: (typeof candidates)[number]) =>
-                  (item.cost / maxCost) * 0.8 + (item.age / maxAge) * 0.2,
-              ),
-            )
-            return projectModel(selected.model, provider)
-          }
-
-          const small = candidates.filter((item) => item.small)
-          return pick(small.length > 0 ? small : candidates)
-        }),
       },
     }
 
@@ -266,6 +212,4 @@ const layer = Layer.effect(
   }),
 )
 
-const SMALL_MODEL_RE = /\b(nano|flash|lite|mini|haiku|small|fast)\b/
-
 export const node = makeLocationNode({ service: Service, layer, deps: [Bus.node, Integration.node] })

packages/core/src/filesystem.ts

@@ -7,7 +7,7 @@ import { FSUtil } from "@opencode-ai/util/fs-util"
 import { Location } from "./location"
 import { PositiveInt, RelativePath } from "./schema"
 import { FileSystemSearch } from "./filesystem/search"
-import { Entry, FileSystem, FindInput } from "@opencode-ai/schema/filesystem"
+import { Entry, FileSystem, FindInput, Match } from "@opencode-ai/schema/filesystem"
 export { Entry, Match, Submatch } from "@opencode-ai/schema/filesystem"
 
 export const ReadInput = Schema.Struct({
@@ -53,6 +53,8 @@ export interface Interface {
   readonly read: (input: ReadInput) => Effect.Effect<{ readonly content: Uint8Array; readonly mime: string }>
   readonly list: (input?: ListInput) => Effect.Effect<Entry[]>
   readonly find: (input: FindInput) => Effect.Effect<Entry[]>
+  readonly glob: (input: GlobInput) => Effect.Effect<readonly Entry[]>
+  readonly grep: (input: GrepInput) => Effect.Effect<readonly Match[]>
 }
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/FileSystem") {}
@@ -74,6 +76,8 @@ const baseLayer = Layer.effect(
     })
     return Service.of({
       find: search.find,
+      glob: search.glob,
+      grep: search.grep,
       read: Effect.fn("FileSystem.read")(function* (input) {
         const target = yield* resolve(input.path)
         const info = yield* fs.stat(target.real).pipe(Effect.orDie)

packages/core/src/filesystem/fff.bun.ts

@@ -3,6 +3,9 @@ import {
   type DirItem,
   type DirSearchResult,
   type FileItem,
+  type GrepCursor,
+  type GrepMatch,
+  type GrepResult,
   type InitOptions,
   type MixedItem,
   type MixedSearchResult,
@@ -42,6 +45,19 @@ export interface MixedSearch {
 export type File = FileItem
 export type Directory = DirItem
 export type Mixed = MixedItem
+export type Cursor = GrepCursor | null
+export type Hit = GrepMatch
+
+export interface Grep {
+  items: GrepResult["items"]
+  totalMatched: number
+  totalFilesSearched: number
+  totalFiles: number
+  filteredFileCount: number
+  nextCursor: Cursor
+  regexFallbackError?: string
+}
+
 export interface Picker {
   destroy(): void
   isScanning(): boolean
@@ -55,6 +71,14 @@ export interface Picker {
       pageSize?: number
     },
   ): Result<Search>
+  glob(
+    pattern: string,
+    opts?: {
+      currentFile?: string
+      pageIndex?: number
+      pageSize?: number
+    },
+  ): Result<Search>
   directorySearch(
     query: string,
     opts?: {
@@ -71,6 +95,18 @@ export interface Picker {
       pageSize?: number
     },
   ): Result<MixedSearch>
+  grep(
+    query: string,
+    opts?: {
+      mode?: "plain" | "regex" | "fuzzy"
+      maxMatchesPerFile?: number
+      timeBudgetMs?: number
+      beforeContext?: number
+      afterContext?: number
+      cursor?: Cursor
+      pageSize?: number
+    },
+  ): Result<Grep>
   trackQuery(query: string, file: string): Result<boolean>
   getHistoricalQuery(offset: number): Result<string | null>
 }
@@ -91,8 +127,10 @@ export function create(opts: Init): Result<Picker> {
       waitForScan: (timeoutMs) => pick.waitForScan(timeoutMs),
       refreshGitStatus: () => pick.refreshGitStatus(),
       fileSearch: (query, next) => pick.fileSearch(query, next),
+      glob: (pattern, next) => pick.glob(pattern, next),
       directorySearch: (query, next) => pick.directorySearch(query, next),
       mixedSearch: (query, next) => pick.mixedSearch(query, next),
+      grep: (query, next) => pick.grep(query, next),
       trackQuery: (query, file) => pick.trackQuery(query, file),
       getHistoricalQuery: (offset) => pick.getHistoricalQuery(offset),
     },

packages/core/src/filesystem/fff.node.ts

@@ -2,6 +2,9 @@ import type {
   DirItem,
   DirSearchResult,
   FileItem,
+  GrepCursor,
+  GrepMatch,
+  GrepResult,
   InitOptions,
   MixedItem,
   MixedSearchResult,
@@ -39,6 +42,19 @@ export interface MixedSearch {
 export type File = FileItem
 export type Directory = DirItem
 export type Mixed = MixedItem
+export type Cursor = GrepCursor | null
+export type Hit = GrepMatch
+
+export interface Grep {
+  items: GrepResult["items"]
+  totalMatched: number
+  totalFilesSearched: number
+  totalFiles: number
+  filteredFileCount: number
+  nextCursor: Cursor
+  regexFallbackError?: string
+}
+
 export interface Picker {
   destroy(): void
   isScanning(): boolean
@@ -52,6 +68,14 @@ export interface Picker {
       pageSize?: number
     },
   ): Result<Search>
+  glob(
+    pattern: string,
+    opts?: {
+      currentFile?: string
+      pageIndex?: number
+      pageSize?: number
+    },
+  ): Result<Search>
   directorySearch(
     query: string,
     opts?: {
@@ -68,6 +92,18 @@ export interface Picker {
       pageSize?: number
     },
   ): Result<MixedSearch>
+  grep(
+    query: string,
+    opts?: {
+      mode?: "plain" | "regex" | "fuzzy"
+      maxMatchesPerFile?: number
+      timeBudgetMs?: number
+      beforeContext?: number
+      afterContext?: number
+      cursor?: Cursor
+      pageSize?: number
+    },
+  ): Result<Grep>
   trackQuery(query: string, file: string): Result<boolean>
   getHistoricalQuery(offset: number): Result<string | null>
 }
@@ -89,8 +125,10 @@ export function create(opts: Init): Result<Picker> {
       waitForScan: (timeoutMs) => pick.waitForScan(timeoutMs),
       refreshGitStatus: () => pick.refreshGitStatus(),
       fileSearch: (query, next) => pick.fileSearch(query, next),
+      glob: (pattern, next) => pick.glob(pattern, next),
       directorySearch: (query, next) => pick.directorySearch(query, next),
       mixedSearch: (query, next) => pick.mixedSearch(query, next),
+      grep: (query, next) => pick.grep(query, next),
       trackQuery: (query, file) => pick.trackQuery(query, file),
       getHistoricalQuery: (offset) => pick.getHistoricalQuery(offset),
     },

packages/core/src/filesystem/location-watcher.ts

@@ -3,6 +3,7 @@ export * as LocationWatcher from "./location-watcher"
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import { Context, Effect, Layer, Stream } from "effect"
 import { FileSystem } from "@opencode-ai/schema/filesystem"
+import os from "os"
 import path from "path"
 import { Config } from "../config"
 import { Bus } from "../bus"
@@ -43,7 +44,7 @@ const layer = Layer.effect(
       const config = (yield* configService.entries())
         .filter((entry): entry is Config.Document => entry.type === "document")
         .flatMap((item) => item.info.watcher?.ignore ?? [])
-      const home = Protected.isHome(location.directory)
+      const home = path.resolve(location.directory) === path.resolve(os.homedir())
 
       if (!home && location.vcs) {
         const updates = yield* watcher.subscribe({

packages/core/src/filesystem/protected.ts

@@ -3,10 +3,6 @@ import path from "path"
 
 const home = os.homedir()
 
-export function isHome(directory: string) {
-  return path.resolve(directory) === path.resolve(home)
-}
-
 const DARWIN_HOME = [
   "Music",
   "Pictures",

packages/core/src/filesystem/search.ts

@@ -6,13 +6,15 @@ import { Context, Effect, Layer, Schema, Scope } from "effect"
 import { Fff } from "#fff"
 import fuzzysort from "fuzzysort"
 import { FileSystem } from "../filesystem"
+import { FSUtil } from "@opencode-ai/util/fs-util"
 import { Location } from "../location"
 import { Ripgrep } from "../ripgrep"
 import { RelativePath } from "../schema"
-import { Protected } from "./protected"
 
 export interface Interface {
   readonly find: (input: FileSystem.FindInput) => Effect.Effect<FileSystem.Entry[]>
+  readonly glob: (input: FileSystem.GlobInput) => Effect.Effect<readonly FileSystem.Entry[]>
+  readonly grep: (input: FileSystem.GrepInput) => Effect.Effect<readonly FileSystem.Match[]>
 }
 
 export const Options = Schema.Struct({
@@ -25,18 +27,17 @@ export class Service extends Context.Service<Service, Interface>()("@opencode/Fi
 export const ripgrepLayer = Layer.effect(
   Service,
   Effect.gen(function* () {
+    const fs = yield* FSUtil.Service
     const location = yield* Location.Service
     const ripgrep = yield* Ripgrep.Service
     const scope = yield* Scope.Scope
     const files: string[] = []
     const directories = new Set<string>()
-    const home = Protected.isHome(location.directory)
     yield* ripgrep
       .find({
         cwd: location.directory,
         pattern: "*",
-        limit: location.vcs && !home ? Number.MAX_SAFE_INTEGER : 100_000,
-        exclude: home ? [...Protected.names()].map((name) => `${name}/**`) : undefined,
+        limit: location.vcs ? Number.MAX_SAFE_INTEGER : 100_000,
         onEntry: (entry) =>
           Effect.sync(() => {
             files.push(entry.path)
@@ -46,6 +47,57 @@ export const ripgrepLayer = Layer.effect(
       })
       .pipe(Effect.orDie, Effect.asVoid, Effect.forkIn(scope))
     return Service.of({
+      glob: (input) =>
+        Effect.gen(function* () {
+          const target = path.resolve(location.directory, input.path ?? ".")
+          const info = yield* fs.stat(target).pipe(Effect.orDie)
+          const cwd = info.type === "File" ? path.dirname(target) : target
+          return yield* ripgrep
+            .glob({
+              cwd,
+              pattern: input.pattern,
+              limit: input.limit ?? FileSystem.DEFAULT_SEARCH_LIMIT,
+            })
+            .pipe(
+              Effect.map((result) =>
+                result.map((entry) =>
+                  FileSystem.Entry.make({
+                    ...entry,
+                    path: RelativePath.make(path.relative(location.directory, path.resolve(cwd, entry.path))),
+                  }),
+                ),
+              ),
+              Effect.orDie,
+            )
+        }),
+      grep: (input) =>
+        Effect.gen(function* () {
+          const target = path.resolve(location.directory, input.path ?? ".")
+          const info = yield* fs.stat(target).pipe(Effect.orDie)
+          const cwd = info.type === "File" ? path.dirname(target) : target
+          return yield* ripgrep
+            .grep({
+              cwd,
+              pattern: input.pattern,
+              file: info.type === "File" ? path.basename(target) : undefined,
+              include: input.include,
+              limit: input.limit ?? FileSystem.DEFAULT_SEARCH_LIMIT,
+            })
+            .pipe(
+              Effect.map((result) =>
+                result.map((match) =>
+                  FileSystem.Match.make({
+                    ...match,
+                    entry: FileSystem.Entry.make({
+                      ...match.entry,
+                      path: RelativePath.make(path.relative(location.directory, path.resolve(cwd, match.entry.path))),
+                    }),
+                  }),
+                ),
+              ),
+              Effect.orDie,
+            )
+        }),
       find: (input) =>
         Effect.gen(function* () {
           const items =
@@ -87,10 +139,55 @@ export const fffLayer = Layer.effect(
       if (result) yield* Effect.logWarning("failed to initialize fff", { error: result.error })
       return Service.of({
         find: () => Effect.succeed([]),
+        glob: () => Effect.succeed([]),
+        grep: () => Effect.succeed([]),
       })
     }
     yield* Effect.addFinalizer(() => Effect.sync(() => result.value.destroy()).pipe(Effect.ignore))
     return Service.of({
+      glob: (input) =>
+        Effect.sync(() => {
+          const prefix = input.path?.replaceAll("\\", "/").replace(/\/$/, "")
+          const found = result.value.glob(prefix ? `${prefix}/${input.pattern}` : input.pattern, {
+            pageIndex: 0,
+            pageSize: input.limit ?? FileSystem.DEFAULT_SEARCH_LIMIT,
+          })
+          if (!found.ok) throw found.error
+          return found.value.items.map((item) =>
+            FileSystem.Entry.make({
+              path: RelativePath.make(item.relativePath.replaceAll("\\", "/")),
+              type: "file",
+            }),
+          )
+        }),
+      grep: (input) =>
+        Effect.sync(() => {
+          const prefix = input.path?.replaceAll("\\", "/").replace(/\/$/, "")
+          const found = result.value.grep(
+            [prefix ? `${prefix}/**` : undefined, input.include, input.pattern]
+              .filter((value) => value !== undefined)
+              .join(" "),
+            { mode: "regex", pageSize: input.limit ?? FileSystem.DEFAULT_SEARCH_LIMIT, timeBudgetMs: 1_500 },
+          )
+          if (!found.ok) throw found.error
+          return found.value.items.map((match) => {
+            const bytes = Buffer.from(match.lineContent)
+            return FileSystem.Match.make({
+              entry: FileSystem.Entry.make({
+                path: RelativePath.make(match.relativePath.replaceAll("\\", "/")),
+                type: "file",
+              }),
+              line: match.lineNumber,
+              offset: match.byteOffset,
+              text: match.lineContent.length > 2_000 ? match.lineContent.slice(0, 2_000) + "..." : match.lineContent,
+              submatches: match.matchRanges.map(([start, end]) => ({
+                text: bytes.subarray(start, end).toString("utf8"),
+                start,
+                end,
+              })),
+            })
+          })
+        }),
       find: (input) =>
         Effect.sync(() => {
           const options = { pageIndex: 0, pageSize: input.limit ?? 50 }
@@ -135,19 +232,18 @@ export const fffLayer = Layer.effect(
   }),
 )
 
-export const layer = (options?: Options) =>
-  Layer.unwrap(
-    Effect.gen(function* () {
-      if (options?.fff === false || (options?.fff === undefined && process.platform === "win32") || !Fff.available())
-        return ripgrepLayer
-      const location = yield* Location.Service
-      // Non-VCS locations can contain many repositories, so avoid eagerly content-indexing the entire aggregate tree.
-      return location.vcs && !Protected.isHome(location.directory) ? fffLayer : ripgrepLayer
-    }),
-  )
+export const layer = (options?: Options) => Layer.unwrap(
+  Effect.gen(function* () {
+    if (options?.fff === false || (options?.fff === undefined && process.platform === "win32") || !Fff.available())
+      return ripgrepLayer
+    const location = yield* Location.Service
+    // Non-VCS locations can contain many repositories, so avoid eagerly content-indexing the entire aggregate tree.
+    return location.vcs ? fffLayer : ripgrepLayer
+  }),
+)
 
 export function configured(options?: Options) {
-  return makeLocationNode({ service: Service, layer: layer(options), deps: [Location.node, Ripgrep.node] })
+  return makeLocationNode({ service: Service, layer: layer(options), deps: [FSUtil.node, Location.node, Ripgrep.node] })
 }
 
 export const node = configured()

packages/core/src/plugin/promise.ts

@@ -2,6 +2,7 @@ export * as PluginPromise from "./promise"
 
 import { define } from "@opencode-ai/plugin/effect/plugin"
 import type { Context, Plugin } from "@opencode-ai/plugin/promise/plugin"
+import type { SessionHooks, SessionHttp, SessionHttpMiddleware } from "@opencode-ai/plugin/promise/session"
 import type { Info } from "@opencode-ai/plugin/promise/tool"
 import { Agent } from "@opencode-ai/schema/agent"
 import { Integration } from "@opencode-ai/schema/integration"
@@ -57,6 +58,62 @@ export function fromPromise(plugin: Plugin) {
               }),
             )
 
+        function sessionHook<Name extends keyof SessionHooks>(
+          name: Name,
+          callback: (event: SessionHooks[Name]) => Promise<void> | void,
+        ): Promise<Registration>
+        function sessionHook(
+          ...registration: {
+            [Name in keyof SessionHooks]: [
+              name: Name,
+              callback: (event: SessionHooks[Name]) => Promise<void> | void,
+            ]
+          }[keyof SessionHooks]
+        ) {
+          if (registration[0] !== "http")
+            return register(
+              host.session.hook(registration[0], (event) =>
+                Effect.promise(() => Promise.resolve(registration[1](event))),
+              ),
+            )
+          return register(
+            host.session.hook("http", (event) => {
+              const middlewares: SessionHttpMiddleware[] = []
+              const output: SessionHttp = {
+                ...event,
+                use: (item) => {
+                  middlewares.push(item)
+                },
+              }
+              return Effect.promise(() => Promise.resolve(registration[1](output))).pipe(
+                Effect.flatMap(() =>
+                  Effect.forEach(
+                    middlewares,
+                    (item) =>
+                      event.use((input, next) =>
+                        Effect.tryPromise({
+                          try: (signal) => {
+                            const inputSignal = AbortSignal.any([signal, input.signal])
+                            return Promise.resolve(
+                              item(new Request(input, { signal: inputSignal }), (request) => {
+                                const requestSignal = AbortSignal.any([signal, request.signal])
+                                return Effect.runPromiseWith(
+                                  context,
+                                )(next(new Request(request, { signal: requestSignal })), { signal: requestSignal })
+                              }),
+                            )
+                          },
+                          catch: (cause) => (cause instanceof Error ? cause : new Error(String(cause))),
+                        }),
+                      ),
+                    { discard: true },
+                  ),
+                ),
+              )
+            }),
+          )
+        }
+
         const context2: Context = {
           app: host.app,
           options: host.options,
@@ -265,8 +322,7 @@ export function fromPromise(plugin: Plugin) {
               ),
           },
           session: {
-            hook: (name, callback) =>
-              register(host.session.hook(name, (event) => Effect.promise(() => Promise.resolve(callback(event))))),
+            hook: sessionHook,
             create: (input) =>
               run(
                 host.session.create(

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

@@ -225,14 +225,14 @@ export const OpenAIPlugin = define({
         })
       }
     })
-    yield* ctx.session.hook("http.request", (evt) =>
-      Effect.sync(() => {
-        if (!chatgpt || evt.model.providerID !== Provider.ID.openai) return
-        const url = new URL(evt.request.url)
-        evt.request.headers.set("originator", "opencode")
-        evt.request.headers.set("session-id", evt.sessionID)
-        if (url.origin !== "https://api.openai.com") return
-        evt.request = new Request(`${codexBaseURL}${url.pathname.replace(/^\/v1/, "")}${url.search}`, evt.request)
+    yield* ctx.session.hook("http", (evt) =>
+      evt.use((request, next) => {
+        if (!chatgpt || evt.model.providerID !== Provider.ID.openai) return next(request)
+        const url = new URL(request.url)
+        request.headers.set("originator", "opencode")
+        request.headers.set("session-id", evt.sessionID)
+        if (url.origin !== "https://api.openai.com") return next(request)
+        return next(new Request(`${codexBaseURL}${url.pathname.replace(/^\/v1/, "")}${url.search}`, request))
       }),
     )
 

packages/core/src/project.ts

@@ -59,6 +59,16 @@ export interface Interface {
   readonly list: () => Effect.Effect<ReadonlyArray<Info>>
   readonly directories: (input: DirectoriesInput) => Effect.Effect<Directories>
   readonly resolve: (input: AbsolutePath) => Effect.Effect<Resolved>
+  /**
+   * Temporary bridge method for writing the resolved project ID to the repo-local cache.
+   *
+   * This exists while the old opencode project service and this core project
+   * service work together: core resolves the ID, while the old service still owns
+   * database migration and persistence. The old service should call this after it
+   * finishes migrating from `resolve().previous` to `resolve().id`; once project
+   * persistence moves into core, this separate bridge method can go away.
+   */
+  readonly commit: (input: { store: AbsolutePath; id: ID }) => Effect.Effect<void>
 }
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/Project") {}
@@ -258,7 +268,11 @@ const layer = Layer.effect(
       return yield* persist({ id: ID.global, directory, canonical: directory, vcs: undefined })
     })
 
-    return Service.of({ list, directories, resolve })
+    const commit = Effect.fn("Project.commit")(function* (input: { store: AbsolutePath; id: ID }) {
+      yield* fs.writeFileString(path.join(input.store, "opencode"), input.id).pipe(Effect.ignore)
+    })
+
+    return Service.of({ list, directories, resolve, commit })
   }),
 )
 

packages/core/src/repository-cache.ts

@@ -31,6 +31,14 @@ export type EnsureInput = {
   readonly branch?: string
 }
 
+export class InvalidRepositoryError extends Schema.TaggedErrorClass<InvalidRepositoryError>()(
+  "RepositoryCacheInvalidRepositoryError",
+  {
+    repository: Schema.String,
+    message: Schema.String,
+  },
+) {}
+
 export class InvalidBranchError extends Schema.TaggedErrorClass<InvalidBranchError>()(
   "RepositoryCacheInvalidBranchError",
   {
@@ -78,6 +86,7 @@ export class CacheOperationError extends Schema.TaggedErrorClass<CacheOperationE
 ) {}
 
 export type Error =
+  | InvalidRepositoryError
   | InvalidBranchError
   | CloneFailedError
   | FetchFailedError
@@ -94,6 +103,7 @@ export class Service extends Context.Service<Service, Interface>()("@opencode/Re
 
 export function isError(error: unknown): error is Error {
   return (
+    error instanceof InvalidRepositoryError ||
     error instanceof InvalidBranchError ||
     error instanceof CloneFailedError ||
     error instanceof FetchFailedError ||
@@ -104,6 +114,13 @@ export function isError(error: unknown): error is Error {
   )
 }
 
+export const parseRemote = Effect.fn("RepositoryCache.parseRemote")(function* (repository: string) {
+  return yield* Effect.try({
+    try: () => Repository.parseRemote(repository),
+    catch: (error) => new InvalidRepositoryError({ repository, message: errorMessage(error) }),
+  })
+})
+
 export const validateBranch = Effect.fn("RepositoryCache.validateBranch")(function* (branch: string) {
   return yield* Effect.try({
     try: () => Repository.validateBranch(branch),

packages/core/src/repository.ts

@@ -44,6 +44,16 @@ export class InvalidBranchError extends Schema.TaggedErrorClass<InvalidBranchErr
   message: Schema.String,
 }) {}
 
+export type Error = InvalidReferenceError | UnsupportedLocalRepositoryError | InvalidBranchError
+
+export function isError(error: unknown): error is Error {
+  return (
+    error instanceof InvalidReferenceError ||
+    error instanceof UnsupportedLocalRepositoryError ||
+    error instanceof InvalidBranchError
+  )
+}
+
 export function parse(input: string): Reference | undefined {
   const cleaned = normalizeInput(input)
   if (!cleaned) return

packages/core/src/ripgrep.ts

@@ -52,7 +52,6 @@ export interface FindInput {
   readonly cwd: string
   readonly pattern: string
   readonly limit: number
-  readonly exclude?: readonly string[]
   readonly hidden?: boolean
   readonly follow?: boolean
   readonly signal?: AbortSignal
@@ -196,7 +195,6 @@ const layer = Layer.effect(
             ...(input.hidden ? ["--hidden"] : []),
             ...(input.follow ? ["--follow"] : []),
             ...(input.pattern === "*" ? [] : [`--glob=${input.pattern}`]),
-            ...(input.exclude ?? []).map((pattern) => `--glob=!${pattern}`),
             "--glob=!**/.git/**",
             ".",
           ],

packages/core/src/session/message-updater.ts

@@ -1,8 +1,12 @@
 import { castDraft, produce, type WritableDraft } from "immer"
-import { DateTime, Effect, Match, pipe } from "effect"
+import { DateTime, Effect } from "effect"
 import { SessionEvent } from "./event"
 import { SessionMessage } from "./message"
 
+export type MemoryState = {
+  messages: SessionMessage.Info[]
+}
+
 export interface Adapter {
   readonly getModel: () => Effect.Effect<SessionMessage.ModelSelected["model"] | undefined, never, never>
   readonly getCurrentAssistant: () => Effect.Effect<SessionMessage.Assistant | undefined, never, never>
@@ -19,7 +23,89 @@ export interface Adapter {
   readonly appendMessage: (message: SessionMessage.Info) => Effect.Effect<void, never, never>
 }
 
-export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
+export function memory(state: MemoryState): Adapter {
+  const assistantIndex = (messageID: SessionMessage.ID) =>
+    state.messages.findLastIndex((message) => message.id === messageID)
+  const shellIndex = (messageID: SessionMessage.ID) =>
+    state.messages.findLastIndex((message) => message.id === messageID)
+  const compactionIndex = () =>
+    state.messages.findLastIndex((message) => message.type === "compaction" && message.status === "running")
+  // A newer step supersedes stale incomplete rows; never resume an older assistant projection.
+  const latestAssistantIndex = () => state.messages.findLastIndex((message) => message.type === "assistant")
+
+  return {
+    getModel() {
+      return Effect.sync(
+        () =>
+          state.messages.findLast(
+            (message): message is SessionMessage.ModelSelected | SessionMessage.Assistant =>
+              message.type === "model-switched" || message.type === "assistant",
+          )?.model,
+      )
+    },
+    getCurrentAssistant() {
+      return Effect.sync(() => {
+        const index = latestAssistantIndex()
+        if (index < 0) return
+        const assistant = state.messages[index]
+        return assistant?.type === "assistant" && !assistant.time.completed ? assistant : undefined
+      })
+    },
+    getAssistant(messageID) {
+      return Effect.sync(() => {
+        const index = assistantIndex(messageID)
+        if (index < 0) return
+        const assistant = state.messages[index]
+        return assistant?.type === "assistant" ? assistant : undefined
+      })
+    },
+    getShell(shellID) {
+      return Effect.sync(() => {
+        return state.messages.find((message): message is SessionMessage.Shell => {
+          return message.type === "shell" && message.shellID === shellID
+        })
+      })
+    },
+    getCompaction() {
+      return Effect.sync(() => {
+        const index = compactionIndex()
+        const message = state.messages[index]
+        return message?.type === "compaction" ? message : undefined
+      })
+    },
+    updateAssistant(assistant) {
+      return Effect.sync(() => {
+        const index = assistantIndex(assistant.id)
+        if (index < 0) return
+        const current = state.messages[index]
+        if (current?.type !== "assistant") return
+        state.messages[index] = assistant
+      })
+    },
+    updateShell(shell) {
+      return Effect.sync(() => {
+        const index = shellIndex(shell.id)
+        if (index < 0) return
+        const current = state.messages[index]
+        if (current?.type !== "shell") return
+        state.messages[index] = shell
+      })
+    },
+    updateCompaction(compaction) {
+      return Effect.sync(() => {
+        const index = state.messages.findLastIndex((message) => message.id === compaction.id)
+        if (index >= 0) state.messages[index] = compaction
+      })
+    },
+    appendMessage(message) {
+      return Effect.sync(() => {
+        state.messages.push(message)
+      })
+    },
+  }
+}
+
+export function update(adapter: Adapter, event: SessionEvent.Event) {
   type DraftAssistant = WritableDraft<SessionMessage.Assistant>
   type DraftTool = WritableDraft<SessionMessage.AssistantTool>
   type DraftText = WritableDraft<SessionMessage.AssistantText>
@@ -53,9 +139,9 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
     }
   })
 
-  const project = pipe(
-    Match.type<SessionEvent.DurableEvent>(),
-    Match.discriminatorsExhaustive("type")({
+  return Effect.gen(function* () {
+    yield* SessionEvent.All.match(event, {
+      "session.usage.updated": () => Effect.void,
       "session.usage.recorded": () => Effect.void,
       "session.agent.selected": (event) => {
         return adapter.appendMessage(
@@ -235,6 +321,12 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
           draft.content.push(castDraft(SessionMessage.AssistantText.make({ type: "text", text: "" })))
         })
       },
+      "session.text.delta": (event) => {
+        return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+          const match = latestText(draft)
+          if (match) match.text += event.data.delta
+        })
+      },
       "session.text.ended": (event) => {
         return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
           const match = latestText(draft)
@@ -259,6 +351,7 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
           )
         })
       },
+      "session.tool.input.delta": () => Effect.void,
       "session.tool.input.ended": (event) => {
         return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
           const match = latestTool(draft, event.data.id)
@@ -282,6 +375,14 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
           }
         })
       },
+      "session.tool.progress": (event) => {
+        return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+          const match = latestTool(draft, event.data.id)
+          if (match && match.state.status === "running") {
+            match.state.metadata = event.data.metadata
+          }
+        })
+      },
       // Terminal tool events are self-contained; projection is a direct copy and
       // never reaches into ephemeral progress history.
       "session.tool.success": (event) => {
@@ -335,6 +436,12 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
           )
         })
       },
+      "session.reasoning.delta": (event) => {
+        return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+          const match = latestReasoning(draft)
+          if (match) match.text += event.data.delta
+        })
+      },
       "session.reasoning.ended": (event) => {
         return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
           const match = latestReasoning(draft)
@@ -368,6 +475,12 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
             time: { created: event.created },
           }),
         ),
+      "session.compaction.delta": (event) =>
+        Effect.gen(function* () {
+          const current = yield* adapter.getCompaction()
+          if (current?.status !== "running") return
+          yield* adapter.updateCompaction({ ...current, summary: current.summary + event.data.text })
+        }),
       "session.compaction.ended": (event) => {
         return Effect.gen(function* () {
           const current = yield* adapter.getCompaction()
@@ -413,9 +526,8 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
       "session.revert.staged": () => Effect.void,
       "session.revert.cleared": () => Effect.void,
       "session.revert.committed": () => Effect.void,
-    }),
-  )
-  return project(event)
+    })
+  })
 }
 
 export * as SessionMessageUpdater from "./message-updater"

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

@@ -2,6 +2,7 @@ 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 { SessionHttpHandler, SessionHttpMiddleware } from "@opencode-ai/plugin/effect/session"
 import type { Content } from "@opencode-ai/schema/tool"
 import { SessionError } from "@opencode-ai/schema/session-error"
 import { Cause, Config, Context, Effect, Layer, Result, Stream } from "effect"
@@ -229,31 +230,44 @@ export const layer = Layer.effect(
       const options: StreamOptions = {
         http: (request, handler) =>
           Effect.gen(function* () {
-            const before = yield* hooks.trigger("session", "http.request", {
+            let latest = request
+            const origins = new WeakMap<Response, HttpClientRequest.HttpClientRequest>()
+            const middlewares: SessionHttpMiddleware[] = []
+            const web = yield* HttpClientRequest.toWeb(request)
+            yield* hooks.trigger("session", "http", {
               sessionID: session.id,
               agent: agent.id,
               model: resolved.ref,
-              request: yield* HttpClientRequest.toWeb(request),
+              use: (item) =>
+                Effect.sync(() => {
+                  middlewares.push(item)
+                }),
             })
-            let sent = HttpClientRequest.fromWeb(before.request)
-            if (before.request.body)
-              sent = HttpClientRequest.bodyUint8Array(
-                sent,
-                new Uint8Array(yield* Effect.promise(() => before.request.clone().arrayBuffer())),
-                before.request.headers.get("content-type") ?? undefined,
-              )
-            const response = yield* handler(sent)
-            const after = yield* hooks.trigger("session", "http.response", {
-              sessionID: session.id,
-              agent: agent.id,
-              model: resolved.ref,
-              request: before.request,
-              response: new Response(
-                [204, 205, 304].includes(response.status) ? null : yield* Stream.toReadableStreamEffect(response.stream),
-                { status: response.status, headers: response.headers },
-              ),
-            })
-            return HttpClientResponse.fromWeb(sent, after.response)
+            const send = (input: Request) =>
+              Effect.gen(function* () {
+                let sent = HttpClientRequest.fromWeb(input)
+                if (input.body)
+                  sent = HttpClientRequest.bodyUint8Array(
+                    sent,
+                    new Uint8Array(yield* Effect.promise(() => input.clone().arrayBuffer())),
+                    input.headers.get("content-type") ?? undefined,
+                  )
+                latest = sent
+                const response = yield* handler(sent)
+                const body = [204, 205, 304].includes(response.status)
+                  ? null
+                  : yield* Stream.toReadableStreamEffect(response.stream)
+                const output = new Response(body, { status: response.status, headers: response.headers })
+                origins.set(output, sent)
+                return output
+              })
+            const dispatch = middlewares.reduce<SessionHttpHandler>(
+              (next, item) => (input: Request) => item(input, next),
+              send,
+            )
+            const response = yield* dispatch(web)
+            const origin = origins.get(response) ?? latest
+            return HttpClientResponse.fromWeb(origin, response)
           }).pipe(Effect.mapError((cause) => (cause instanceof Error ? cause : new Error(String(cause))))),
       }
       if (promptCacheSnapshots) {

packages/core/test/catalog.test.ts

@@ -1,5 +1,4 @@
 import { describe, expect } from "bun:test"
-import { Money } from "@opencode-ai/schema/money"
 import { Effect, Fiber, Layer, Stream } from "effect"
 import { TestClock } from "effect/testing"
 import { Catalog } from "@opencode-ai/core/catalog"
@@ -292,46 +291,4 @@ describe("Catalog", () => {
       })
     }),
   )
-
-  it.effect("small model prefers small keyword candidates before cost scoring", () =>
-    Effect.gen(function* () {
-      const catalog = yield* Catalog.Service
-      const providerID = Provider.ID.make("test")
-      yield* catalog.transform((catalog) => {
-        catalog.provider.update(providerID, () => {})
-        catalog.model.update(providerID, Model.ID.make("cheap-large"), (model) => {
-          model.capabilities.input = ["text"]
-          model.capabilities.output = ["text"]
-          model.cost = [
-            {
-              input: Money.USDPerMillionTokens.make(1),
-              output: Money.USDPerMillionTokens.make(1),
-              cache: {
-                read: Money.USDPerMillionTokens.zero,
-                write: Money.USDPerMillionTokens.zero,
-              },
-            },
-          ]
-          model.time.released = Date.now()
-        })
-        catalog.model.update(providerID, Model.ID.make("expensive-mini"), (model) => {
-          model.capabilities.input = ["text"]
-          model.capabilities.output = ["text"]
-          model.cost = [
-            {
-              input: Money.USDPerMillionTokens.make(10),
-              output: Money.USDPerMillionTokens.make(10),
-              cache: {
-                read: Money.USDPerMillionTokens.zero,
-                write: Money.USDPerMillionTokens.zero,
-              },
-            },
-          ]
-          model.time.released = Date.now()
-        })
-      })
-
-      expect((yield* catalog.model.small(providerID))?.id).toMatch("expensive-mini")
-    }),
-  )
 })

packages/core/test/effect/layer-node/node-build.test.ts

@@ -80,6 +80,7 @@ describe("node build", () => {
           list: () => Effect.succeed([]),
           directories: () => Effect.succeed([]),
           resolve: (directory) => Effect.succeed({ id: Project.ID.global, directory, canonical: directory }),
+          commit: () => Effect.void,
         })
       }),
     )

packages/core/test/filesystem/search.test.ts

@@ -1,59 +1,44 @@
-import { describe, expect, test } from "bun:test"
-import os from "os"
+import { describe, expect } from "bun:test"
+import fs from "fs/promises"
 import path from "path"
-import { Effect, Layer } from "effect"
-import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
-import { FileSystem } from "@opencode-ai/core/filesystem"
-import { Protected } from "@opencode-ai/core/filesystem/protected"
-import { FileSystemSearch } from "@opencode-ai/core/filesystem/search"
-import { Location } from "@opencode-ai/core/location"
+import { Effect } from "effect"
+import { LayerNode } from "@opencode-ai/util/effect/layer-node"
 import { Ripgrep } from "@opencode-ai/core/ripgrep"
 import { AbsolutePath, RelativePath } from "@opencode-ai/core/schema"
-import { location } from "../fixture/location"
+import { tmpdir } from "../fixture/tmpdir"
+import { testEffect } from "../lib/effect"
 
-describe("FileSystemSearch", () => {
-  test("bounds a home scan even when home is detected as a repository", async () => {
-    let observed: Ripgrep.FindInput | undefined
-    const home = AbsolutePath.make(os.homedir())
-    const layer = AppNodeBuilder.build(FileSystemSearch.node, [
-      [
-        Location.node,
-        Layer.succeed(
-          Location.Service,
-          Location.Service.of(
-            location({ directory: home }, { vcs: { type: "git", store: AbsolutePath.make(path.join(home, ".git")) } }),
-          ),
-        ),
-      ],
-      [
-        Ripgrep.node,
-        Layer.succeed(
-          Ripgrep.Service,
-          Ripgrep.Service.of({
-            find: (input) =>
-              Effect.gen(function* () {
-                observed = input
-                if (input.onEntry)
-                  yield* input.onEntry(FileSystem.Entry.make({ path: RelativePath.make("src/index.ts"), type: "file" }))
-                return []
-              }),
-            glob: () => Effect.succeed([]),
-            grep: () => Effect.succeed([]),
-          }),
-        ),
-      ],
-    ])
+const it = testEffect(LayerNode.compile(Ripgrep.node))
 
-    await Effect.runPromise(
+const withTmp = <A, E, R>(f: (directory: AbsolutePath) => Effect.Effect<A, E, R>) =>
+  Effect.acquireRelease(
+    Effect.promise(() => tmpdir()),
+    (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
+  ).pipe(Effect.flatMap((tmp) => f(AbsolutePath.make(tmp.path))))
+
+describe("Ripgrep", () => {
+  it.live("globs files as an array", () =>
+    withTmp((cwd) =>
       Effect.gen(function* () {
-        const search = yield* FileSystemSearch.Service
-        yield* Effect.sleep("10 millis")
-        expect(observed?.limit).toBe(100_000)
-        expect(observed?.exclude).toEqual([...Protected.names()].map((name) => `${name}/**`))
-        expect((yield* search.find({ query: "src", type: "directory" }))[0]?.path).toBe(
-          RelativePath.make(`src${path.sep}`),
-        )
-      }).pipe(Effect.provide(layer), Effect.scoped),
-    )
-  })
+        yield* Effect.promise(() => fs.mkdir(path.join(cwd, "src")))
+        yield* Effect.promise(() => fs.writeFile(path.join(cwd, "src", "match.ts"), "needle\n"))
+        const result = yield* (yield* Ripgrep.Service).glob({ cwd, pattern: "**/*.ts", limit: 10 })
+        expect(result.map((item) => item.path)).toEqual([RelativePath.make("src/match.ts")])
+      }),
+    ),
+  )
+
+  it.live("greps files with include filtering", () =>
+    withTmp((cwd) =>
+      Effect.gen(function* () {
+        yield* Effect.promise(() => fs.mkdir(path.join(cwd, "src")))
+        yield* Effect.promise(() => fs.writeFile(path.join(cwd, "src", "match.ts"), "needle\n"))
+        yield* Effect.promise(() => fs.writeFile(path.join(cwd, "src", "skip.txt"), "needle\n"))
+        const result = yield* (yield* Ripgrep.Service).grep({ cwd, pattern: "needle", include: "*.ts", limit: 10 })
+        expect(result).toHaveLength(1)
+        expect(result[0]?.entry.path).toBe(RelativePath.make("src/match.ts"))
+        expect(result[0]?.submatches[0]?.text).toBe("needle")
+      }),
+    ),
+  )
 })

packages/core/test/generate.test.ts

@@ -30,7 +30,6 @@ const catalog = Layer.mock(Catalog.Service, {
     all: () => Effect.die("unused"),
     available: () => Effect.die("unused"),
     default: () => Effect.die("unused"),
-    small: () => Effect.die("unused"),
   },
 })
 const integrations = Layer.mock(Integration.Service, {

packages/core/test/location.test.ts

@@ -21,6 +21,7 @@ const projectLayer = Layer.succeed(
         canonical: AbsolutePath.make("/main/repo"),
         vcs: { type: "git", store: AbsolutePath.make("/repo/.git") },
       }),
+    commit: () => Effect.void,
   }),
 )
 const it = testEffect(AppNodeBuilder.build(Location.boundNode(ref), [[Project.node, projectLayer]]))

packages/core/test/plugin/promise.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect } from "bun:test"
 import { Message, SystemPart } from "@opencode-ai/ai"
-import { DateTime, Effect, Schema } from "effect"
+import { DateTime, Deferred, Effect, Fiber, Schema } from "effect"
 import { Agent } from "@opencode-ai/core/agent"
 import { Catalog } from "@opencode-ai/core/catalog"
 import { Model } from "@opencode-ai/core/model"
@@ -15,7 +15,7 @@ import { SessionPending } from "@opencode-ai/core/session/pending"
 import { Tool } from "@opencode-ai/core/tool"
 import { Provider } from "@opencode-ai/core/provider"
 import { define } from "@opencode-ai/plugin/promise/plugin"
-import type { SessionHooks } from "@opencode-ai/plugin/effect/session"
+import type { SessionHooks, SessionHttpHandler } from "@opencode-ai/plugin/effect/session"
 import { testEffect } from "../lib/effect"
 import { PluginTestLayer } from "./fixture"
 import { host as testHost } from "./host"
@@ -223,45 +223,102 @@ describe("fromPromise", () => {
     }),
   )
 
-  it.effect("adapts promise session HTTP request and response hooks", () =>
+  it.effect("adapts promise session HTTP hooks", () =>
+    Effect.gen(function* () {
+      const plugin = yield* Plugin.Service
+      const hooks = yield* PluginHooks.Service
+      const host = yield* PluginHost.make(plugin)
+      const bodies: string[] = []
+      yield* PluginPromise.fromPromise(
+        define({
+          id: "promise-session-http",
+          setup: async (ctx) => {
+            await ctx.session.hook("http", (event) => {
+              event.use(async (request, next) => {
+                request.headers.set("x-hook", "promise")
+                await next(request)
+                const response = await next(request)
+                return new Response(`${await response.text()}-response`)
+              })
+            })
+            await ctx.session.hook("http", (event) => {
+              event.use(async (request, next) => {
+                const response = await next(request)
+                return new Response(`${await response.text()}-outer`)
+              })
+            })
+          },
+        }),
+      ).effect(host)
+      const middlewares: Parameters<PluginHooks.Domains["session"]["http"]["use"]>[0][] = []
+      const event: PluginHooks.Domains["session"]["http"] = {
+        sessionID: Session.ID.make("ses_promise_session_http"),
+        agent: Agent.ID.make("build"),
+        model: Model.Ref.make({ providerID: Provider.ID.make("test"), id: Model.ID.make("model") }),
+        use: (item) =>
+          Effect.sync(() => {
+            middlewares.push(item)
+          }),
+      }
+
+      yield* hooks.trigger("session", "http", event)
+      const request = middlewares.reduce<SessionHttpHandler>(
+        (next, item) => (input: Request) => item(input, next),
+        (input: Request) =>
+          Effect.promise(() => input.text()).pipe(
+            Effect.tap((body) => Effect.sync(() => bodies.push(body))),
+            Effect.as(new Response(input.headers.get("x-hook") ?? "missing")),
+          ),
+      )
+      const response = yield* request(new Request("https://provider.test", { method: "POST", body: "payload" }))
+
+      expect(bodies).toEqual(["payload", "payload"])
+      expect(yield* Effect.promise(() => response.text())).toBe("promise-response-outer")
+    }),
+  )
+
+  it.effect("interrupts the Effect request through a promise session HTTP hook", () =>
     Effect.gen(function* () {
       const plugin = yield* Plugin.Service
       const hooks = yield* PluginHooks.Service
       const host = yield* PluginHost.make(plugin)
       yield* PluginPromise.fromPromise(
         define({
-          id: "promise-session-http",
+          id: "promise-session-http-interrupt",
           setup: async (ctx) => {
-            await ctx.session.hook("http.request", (event) => {
-              event.request = new Request("https://provider.test/changed", event.request)
-              event.request.headers.set("x-hook", "promise")
-            })
-            await ctx.session.hook("http.response", async (event) => {
-              event.response = new Response(`${await event.response.text()}-response`, {
-                status: event.response.status,
-              })
+            await ctx.session.hook("http", (event) => {
+              event.use((request, next) => next(request))
             })
           },
         }),
       ).effect(host)
-      const context = {
-        sessionID: Session.ID.make("ses_promise_session_http"),
+      const started = yield* Deferred.make<void>()
+      const interrupted = yield* Deferred.make<void>()
+      const middlewares: Parameters<PluginHooks.Domains["session"]["http"]["use"]>[0][] = []
+      const event: PluginHooks.Domains["session"]["http"] = {
+        sessionID: Session.ID.make("ses_promise_session_http_interrupt"),
         agent: Agent.ID.make("build"),
         model: Model.Ref.make({ providerID: Provider.ID.make("test"), id: Model.ID.make("model") }),
+        use: (item) =>
+          Effect.sync(() => {
+            middlewares.push(item)
+          }),
       }
 
-      const request = yield* hooks.trigger("session", "http.request", {
-        ...context,
-        request: new Request("https://provider.test", { method: "POST", body: "payload" }),
-      })
-      const response = yield* hooks.trigger("session", "http.response", {
-        ...context,
-        request: request.request,
-        response: new Response(request.request.headers.get("x-hook") ?? "missing"),
-      })
+      yield* hooks.trigger("session", "http", event)
+      const request = middlewares.reduce<SessionHttpHandler>(
+        (next, item) => (input: Request) => item(input, next),
+        () =>
+          Deferred.succeed(started, undefined).pipe(
+            Effect.andThen(Effect.never),
+            Effect.onInterrupt(() => Deferred.succeed(interrupted, undefined)),
+          ),
+      )
+      const fiber = yield* request(new Request("https://provider.test")).pipe(Effect.forkChild)
+      yield* Deferred.await(started)
+      yield* Fiber.interrupt(fiber)
 
-      expect(request.request.url).toBe("https://provider.test/changed")
-      expect(yield* Effect.promise(() => response.response.text())).toBe("promise-response")
+      expect(yield* Deferred.isDone(interrupted)).toBeTrue()
     }),
   )
 

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

@@ -12,6 +12,7 @@ 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 type { SessionHttpHandler } from "@opencode-ai/plugin/effect/session"
 import { testEffect } from "../lib/effect"
 import { PluginTestLayer } from "./fixture"
 
@@ -30,13 +31,26 @@ function required<T>(value: T | undefined): T {
 }
 
 const http = Effect.fn(function* (providerID: Provider.ID, url: string) {
-  const event = yield* (yield* PluginHooks.Service).trigger("session", "http.request", {
+  const middlewares: Parameters<PluginHooks.Domains["session"]["http"]["use"]>[0][] = []
+  yield* (yield* PluginHooks.Service).trigger("session", "http", {
     sessionID: Session.ID.make("ses_test"),
     agent: Agent.ID.make("build"),
     model: Model.Ref.make({ providerID, id: Model.ID.make("gpt-5.5") }),
-    request: new Request(url, { method: "POST", body: "{}" }),
+    use: (item) =>
+      Effect.sync(() => {
+        middlewares.push(item)
+      }),
   })
-  return { url: event.request.url, headers: Object.fromEntries(event.request.headers.entries()) }
+  const request = middlewares.reduce<SessionHttpHandler>(
+    (next, item) => (input: Request) => item(input, next),
+    (input: Request) => {
+      const headers = new Headers(input.headers)
+      headers.set("x-seen-url", input.url)
+      return Effect.succeed(new Response(null, { headers }))
+    },
+  )
+  const response = yield* request(new Request(url, { method: "POST", body: "{}" }))
+  return { url: response.headers.get("x-seen-url"), headers: Object.fromEntries(response.headers.entries()) }
 })
 
 describe("OpenAIPlugin", () => {

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

@@ -484,31 +484,4 @@ describe("OpencodePlugin", () => {
       }),
     ),
   )
-
-  it.effect("prefers gpt-5-nano as the opencode small model", () =>
-    Effect.gen(function* () {
-      const catalog = yield* Catalog.Service
-      const providerID = Provider.ID.opencode
-
-      yield* catalog.transform((catalog) => {
-        catalog.provider.update(providerID, () => {})
-        catalog.model.update(providerID, Model.ID.make("cheap-mini"), (model) => {
-          model.capabilities.input = ["text"]
-          model.capabilities.output = ["text"]
-          model.cost = [...cost(1, 1)]
-          model.time.released = Date.now()
-        })
-        catalog.model.update(providerID, Model.ID.make("gpt-5-nano"), (model) => {
-          model.capabilities.input = ["text"]
-          model.capabilities.output = ["text"]
-          model.cost = [...cost(10, 10)]
-          model.time.released = Date.now()
-        })
-      })
-
-      const selected = yield* catalog.model.small(providerID)
-
-      expect(selected?.id).toBe(Model.ID.make("gpt-5-nano"))
-    }),
-  )
 })

packages/core/test/repository-cache.test.ts

@@ -101,10 +101,13 @@ describe("RepositoryCache", () => {
     ),
   )
 
-  it.live("returns typed branch validation and clone failures", () =>
+  it.live("returns typed validation and clone failures", () =>
     withRemote((fixture) =>
       Effect.gen(function* () {
         const cache = yield* RepositoryCache.Service
+        const invalidRepository = yield* Effect.flip(RepositoryCache.parseRemote("not-a-repo"))
+        expect(invalidRepository).toBeInstanceOf(RepositoryCache.InvalidRepositoryError)
+
         const invalidBranch = yield* Effect.flip(cache.ensure({ reference: fixture.reference, branch: "../unsafe" }))
         expect(invalidBranch).toBeInstanceOf(RepositoryCache.InvalidBranchError)
 

packages/core/test/ripgrep.test.ts

@@ -11,44 +11,6 @@ import { testEffect } from "./lib/effect"
 const it = testEffect(LayerNode.compile(Ripgrep.node))
 
 describe("Ripgrep", () => {
-  it.live("globs files as an array", () =>
-    Effect.acquireUseRelease(
-      Effect.promise(() => tmpdir()),
-      (tmp) =>
-        Effect.gen(function* () {
-          yield* Effect.promise(() => fs.mkdir(path.join(tmp.path, "src")))
-          yield* Effect.promise(() => fs.writeFile(path.join(tmp.path, "src", "match.ts"), "needle\n"))
-
-          const result = yield* (yield* Ripgrep.Service).glob({ cwd: tmp.path, pattern: "**/*.ts", limit: 10 })
-          expect(result.map((item) => item.path)).toEqual([RelativePath.make("src/match.ts")])
-        }),
-      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-    ),
-  )
-
-  it.live("greps files with include filtering", () =>
-    Effect.acquireUseRelease(
-      Effect.promise(() => tmpdir()),
-      (tmp) =>
-        Effect.gen(function* () {
-          yield* Effect.promise(() => fs.mkdir(path.join(tmp.path, "src")))
-          yield* Effect.promise(() => fs.writeFile(path.join(tmp.path, "src", "match.ts"), "needle\n"))
-          yield* Effect.promise(() => fs.writeFile(path.join(tmp.path, "src", "skip.txt"), "needle\n"))
-
-          const result = yield* (yield* Ripgrep.Service).grep({
-            cwd: tmp.path,
-            pattern: "needle",
-            include: "*.ts",
-            limit: 10,
-          })
-          expect(result).toHaveLength(1)
-          expect(result[0]?.entry.path).toBe(RelativePath.make("src/match.ts"))
-          expect(result[0]?.submatches[0]?.text).toBe("needle")
-        }),
-      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-    ),
-  )
-
   it.live("keeps ignored files out of catch-all find results", () =>
     Effect.acquireUseRelease(
       Effect.promise(() => tmpdir()),
@@ -101,29 +63,6 @@ describe("Ripgrep", () => {
     ),
   )
 
-  it.live("excludes protected directory trees from catch-all find results", () =>
-    Effect.acquireUseRelease(
-      Effect.promise(() => tmpdir()),
-      (tmp) =>
-        Effect.gen(function* () {
-          yield* Effect.promise(() => fs.mkdir(path.join(tmp.path, "Pictures")))
-          yield* Effect.promise(() => fs.writeFile(path.join(tmp.path, "Pictures", "private.jpg"), "private\n"))
-          yield* Effect.promise(() => fs.writeFile(path.join(tmp.path, "visible.txt"), "visible\n"))
-
-          const files = yield* (yield* Ripgrep.Service).find({
-            cwd: tmp.path,
-            pattern: "*",
-            limit: 10,
-            exclude: ["Pictures/**"],
-          })
-
-          expect(files.map((item) => item.path)).toContain(RelativePath.make("visible.txt"))
-          expect(files.map((item) => item.path)).not.toContain(RelativePath.make("Pictures/private.jpg"))
-        }),
-      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-    ),
-  )
-
   it.live("returns a bounded preview for matches on oversized lines", () =>
     Effect.acquireUseRelease(
       Effect.promise(() => tmpdir()),

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

@@ -36,6 +36,7 @@ const projects = Layer.succeed(
     list: () => Effect.succeed([]),
     resolve: (directory) => Effect.succeed({ id: Project.ID.global, directory, canonical: directory }),
     directories: () => Effect.succeed([]),
+    commit: () => Effect.void,
   }),
 )
 let requests: LLMRequest[] = []

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

@@ -34,6 +34,7 @@ const projects = Layer.succeed(
     list: () => Effect.succeed([]),
     resolve: (directory) => Effect.succeed({ id: Project.ID.global, directory, canonical: directory }),
     directories: () => Effect.succeed([]),
+    commit: () => Effect.void,
   }),
 )
 const it = testEffect(

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

@@ -56,6 +56,7 @@ const projects = Layer.succeed(
     list: () => Effect.succeed([]),
     resolve: (directory) => Effect.succeed({ id: Project.ID.global, directory, canonical: directory }),
     directories: () => Effect.succeed([]),
+    commit: () => Effect.void,
   }),
 )
 const permission = Layer.succeed(

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

@@ -23,6 +23,7 @@ const projects = Layer.succeed(
     list: () => Effect.succeed([]),
     resolve: (directory) => Effect.succeed({ id: Project.ID.global, directory, canonical: directory }),
     directories: () => Effect.succeed([]),
+    commit: () => Effect.void,
   }),
 )
 const it = testEffect(

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

@@ -17,6 +17,7 @@ import { Session } from "@opencode-ai/core/session"
 import { SessionEvent } from "@opencode-ai/core/session/event"
 import { SessionMessage } from "@opencode-ai/core/session/message"
 import { Money } from "@opencode-ai/schema/money"
+import { SessionMessageUpdater } from "@opencode-ai/core/session/message-updater"
 import { SessionProjector } from "@opencode-ai/core/session/projector"
 import { SessionExecution } from "@opencode-ai/core/session/execution"
 import { fromRow } from "@opencode-ai/core/session/info"
@@ -125,6 +126,34 @@ describe("SessionProjector", () => {
     }),
   )
 
+  it.effect("folds live compaction deltas into running memory state", () =>
+    Effect.gen(function* () {
+      const state = {
+        messages: [
+          SessionMessage.CompactionRunning.make({
+            id: SessionMessage.ID.make("msg_compaction"),
+            type: "compaction",
+            status: "running",
+            reason: "manual",
+            summary: "partial ",
+            recent: "recent",
+            time: { created },
+          }),
+        ],
+      }
+      yield* SessionMessageUpdater.update(
+        SessionMessageUpdater.memory(state),
+        SessionEvent.Compaction.Delta.make({
+          id: Event.ID.make("evt_delta"),
+          type: "session.compaction.delta",
+          created,
+          data: { sessionID, text: "summary" },
+        }),
+      )
+      expect(state.messages[0]).toMatchObject({ status: "running", summary: "partial summary", recent: "recent" })
+    }),
+  )
+
   it.effect("projects staged, cleared, and committed reverts", () =>
     Effect.gen(function* () {
       const db = (yield* Database.Service).db
@@ -521,6 +550,31 @@ describe("SessionProjector", () => {
     }),
   )
 
+  it.effect("does not revive a stale incomplete in-memory assistant projection", () =>
+    Effect.gen(function* () {
+      const stale = SessionMessage.Assistant.make({
+        id: SessionMessage.ID.make("msg_assistant_stale"),
+        type: "assistant",
+        agent: build,
+        model,
+        content: [],
+        time: { created },
+      })
+      const completed = SessionMessage.Assistant.make({
+        id: SessionMessage.ID.make("msg_assistant_completed"),
+        type: "assistant",
+        agent: build,
+        model,
+        content: [],
+        time: { created: DateTime.makeUnsafe(1), completed: DateTime.makeUnsafe(2) },
+      })
+
+      expect(
+        yield* SessionMessageUpdater.memory({ messages: [stale, completed] }).getCurrentAssistant(),
+      ).toBeUndefined()
+    }),
+  )
+
   it.effect("projects retry state and clears it at the next step or execution terminal", () =>
     Effect.gen(function* () {
       const { db } = yield* Database.Service

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

@@ -19,6 +19,7 @@ const projects = Layer.succeed(
     list: () => Effect.succeed([]),
     resolve: (directory) => Effect.succeed({ id: Project.ID.global, directory, canonical: directory }),
     directories: () => Effect.succeed([]),
+    commit: () => Effect.void,
   }),
 )
 const it = testEffect(

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

@@ -102,7 +102,6 @@ const promptCatalog = Layer.mock(Catalog.Service, {
     all: () => Effect.succeed([]),
     available: () => Effect.succeed([]),
     default: () => Effect.succeed(undefined),
-    small: () => Effect.succeed(undefined),
   },
 })
 const runnerLayer = (llmClient: Layer.Layer<typeof LLMClient.Service>) =>
@@ -254,7 +253,6 @@ describe("SessionRunnerLLM recorded", () => {
 describe("SessionModelRequest HTTP bridge", () => {
   const bodies: Uint8Array[] = []
   const methods: string[] = []
-  const headers: Array<string | undefined> = []
   const response = [
     'data: {"id":"chatcmpl_test","object":"chat.completion.chunk","created":0,"model":"gpt-4o-mini","choices":[{"index":0,"delta":{"role":"assistant","content":"Hello!"},"finish_reason":null}]}',
     'data: {"id":"chatcmpl_test","object":"chat.completion.chunk","created":0,"model":"gpt-4o-mini","choices":[{"index":0,"delta":{},"finish_reason":"stop"}]}',
@@ -268,7 +266,6 @@ describe("SessionModelRequest HTTP bridge", () => {
         if (request.body._tag !== "Uint8Array") throw new Error(`Unexpected request body: ${request.body._tag}`)
         methods.push(request.method)
         bodies.push(request.body.body.slice())
-        headers.push(request.headers["x-hook"])
         return HttpClientResponse.fromWeb(
           request,
           new Response(response, { headers: { "content-type": "text/event-stream" } }),
@@ -276,16 +273,14 @@ describe("SessionModelRequest HTTP bridge", () => {
       }),
     ),
   )
-  const httpIt = testEffect(
+  const retryIt = testEffect(
     testLayer(LLMClient.layer.pipe(Layer.provide(RequestExecutor.layer.pipe(Layer.provide(transport))))),
   )
 
-  httpIt.effect("runs Effect HTTP request and response hooks around one provider request", () =>
+  retryIt.effect("lets an Effect plugin send the same POST Request twice", () =>
     Effect.gen(function* () {
       bodies.length = 0
       methods.length = 0
-      headers.length = 0
-      const seen: string[] = []
       const agents = yield* Agent.Service
       const catalog = yield* Catalog.Service
       const hooks = yield* PluginHooks.Service
@@ -300,20 +295,13 @@ describe("SessionModelRequest HTTP bridge", () => {
         catalog: catalogHost(catalog),
         session: { hook: (name, callback) => hooks.register("session", name, callback) },
       })
-      yield* pluginHost.session.hook("http.request", (event) =>
-        Effect.sync(() => {
-          seen.push("request")
-          event.request.headers.set("x-hook", "effect")
-        }),
-      )
-      yield* pluginHost.session.hook("http.response", (event) =>
-        Effect.gen(function* () {
-          seen.push(`response:${event.response.status}:${event.request.headers.get("x-hook")}`)
-          event.response = new Response(
-            (yield* Effect.promise(() => event.response.text())).replace("Hello!", "Hooked!"),
-            event.response,
-          )
-        }),
+      yield* pluginHost.session.hook("http", (event) =>
+        event.use((request, next) =>
+          Effect.gen(function* () {
+            yield* next(request).pipe(Effect.flatMap((response) => Effect.promise(() => response.text())))
+            return yield* next(request)
+          }),
+        ),
       )
       yield* Effect.forEach(SystemPromptPlugin.Plugins, (plugin) => plugin.effect(pluginHost), { discard: true })
       const { db } = yield* Database.Service
@@ -341,15 +329,10 @@ describe("SessionModelRequest HTTP bridge", () => {
 
       yield* session.resume(retrySessionID)
 
-      expect(methods).toEqual(["POST"])
-      expect(headers).toEqual(["effect"])
-      expect(seen).toEqual(["request", "response:200:effect"])
-      expect(bodies).toHaveLength(1)
+      expect(methods).toEqual(["POST", "POST"])
+      expect(bodies).toHaveLength(2)
       expect(bodies[0]?.byteLength).toBeGreaterThan(0)
-      expect((yield* session.context(retrySessionID))[1]).toMatchObject({
-        type: "assistant",
-        content: [{ type: "text", text: "Hooked!" }],
-      })
+      expect(bodies[1]).toEqual(bodies[0])
     }),
   )
 })

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

@@ -362,7 +362,6 @@ const promptCatalog = Layer.mock(Catalog.Service, {
     all: () => Effect.succeed([]),
     available: () => Effect.succeed([]),
     default: () => Effect.succeed(undefined),
-    small: () => Effect.succeed(undefined),
   },
 })
 const runnerLayer = AppNodeBuilder.build(SessionRunnerLLM.node, [

packages/plugin/src/effect/session.ts

@@ -3,7 +3,7 @@ import type { Message, SystemPart } from "@opencode-ai/ai"
 import type { Agent } from "@opencode-ai/schema/agent"
 import type { Model } from "@opencode-ai/schema/model"
 import type { Session } from "@opencode-ai/schema/session"
-import type { JsonSchema } from "effect"
+import type { Effect, JsonSchema } from "effect"
 import type { Hooks } from "./registration.js"
 
 export interface SessionContext {
@@ -15,25 +15,23 @@ export interface SessionContext {
   tools: Record<string, { description: string; input: JsonSchema.JsonSchema }>
 }
 
-export interface SessionHttpRequest {
+export interface SessionHttp {
   readonly sessionID: Session.ID
   readonly agent: Agent.ID
   readonly model: Model.Ref
-  request: Request
+  readonly use: (middleware: SessionHttpMiddleware) => Effect.Effect<void>
 }
 
-export interface SessionHttpResponse {
-  readonly sessionID: Session.ID
-  readonly agent: Agent.ID
-  readonly model: Model.Ref
-  readonly request: Request
-  response: Response
-}
+export type SessionHttpHandler = (request: Request) => Effect.Effect<Response, Error>
+
+export type SessionHttpMiddleware = (
+  request: Request,
+  next: SessionHttpHandler,
+) => Effect.Effect<Response, Error>
 
 export interface SessionHooks {
   readonly context: SessionContext
-  readonly "http.request": SessionHttpRequest
-  readonly "http.response": SessionHttpResponse
+  readonly http: SessionHttp
 }
 
 export type SessionDomain = Pick<

packages/plugin/src/promise/session.ts

@@ -15,25 +15,23 @@ export interface SessionContext {
   tools: Record<string, { description: string; input: JsonSchema.JsonSchema }>
 }
 
-export interface SessionHttpRequest {
+export interface SessionHttp {
   readonly sessionID: Session.ID
   readonly agent: Agent.ID
   readonly model: Model.Ref
-  request: Request
+  readonly use: (middleware: SessionHttpMiddleware) => void
 }
 
-export interface SessionHttpResponse {
-  readonly sessionID: Session.ID
-  readonly agent: Agent.ID
-  readonly model: Model.Ref
-  readonly request: Request
-  response: Response
-}
+export type SessionHttpHandler = (request: Request) => Promise<Response>
+
+export type SessionHttpMiddleware = (
+  request: Request,
+  next: SessionHttpHandler,
+) => Promise<Response> | Response
 
 export interface SessionHooks {
   readonly context: SessionContext
-  readonly "http.request": SessionHttpRequest
-  readonly "http.response": SessionHttpResponse
+  readonly http: SessionHttp
 }
 
 export type SessionDomain = Pick<

packages/session-ui/src/components/line-comment-styles.ts

@@ -36,6 +36,10 @@ export const lineCommentStyles = `
   border: none;
 }
 
+[data-component="line-comment"][data-variant="add"] [data-slot="line-comment-button"] {
+  background: var(--syntax-diff-add);
+}
+
 [data-component="line-comment"] [data-component="icon"] {
   color: var(--white);
 }

packages/session-ui/src/components/line-comment.tsx

@@ -9,7 +9,7 @@ import { useI18n } from "@opencode-ai/ui/context/i18n"
 
 installLineCommentStyles()
 
-export type LineCommentVariant = "default" | "editor"
+export type LineCommentVariant = "default" | "editor" | "add"
 
 function InlineGlyph(props: { icon: "comment" | "plus" }) {
   return (
@@ -156,6 +156,25 @@ export const LineComment = (props: LineCommentProps) => {
   )
 }
 
+export type LineCommentAddProps = Omit<LineCommentAnchorProps, "children" | "variant" | "open" | "icon"> & {
+  label?: string
+}
+
+export const LineCommentAdd = (props: LineCommentAddProps) => {
+  const [split, rest] = splitProps(props, ["label"])
+  const i18n = useI18n()
+
+  return (
+    <LineCommentAnchor
+      {...rest}
+      open={false}
+      variant="add"
+      icon="plus"
+      buttonLabel={split.label ?? i18n.t("ui.lineComment.submit")}
+    />
+  )
+}
+
 export type LineCommentEditorProps = Omit<LineCommentAnchorProps, "children" | "open" | "variant" | "onClick"> & {
   value: string
   selection: JSX.Element

packages/session-ui/src/components/message-part.tsx

@@ -948,6 +948,10 @@ function ExaOutput(props: { output?: string }) {
   )
 }
 
+export function registerPartComponent(type: string, component: PartComponent) {
+  PART_MAPPING[type] = component
+}
+
 export function Message(props: MessageProps) {
   return (
     <Switch>

packages/www/content/docs/build/plugins.mdx

@@ -246,27 +246,19 @@ Runtime hooks intercept live operations:
 | `ctx.aisdk.hook("sdk", callback)`           | `sdk`, after inspecting `model`, `package`, and `options`                      |
 | `ctx.aisdk.hook("language", callback)`      | `language`, after inspecting `model`, `sdk`, and `options`                     |
 | `ctx.session.hook("context", callback)`     | `system`, `messages`, and the `tools` record immediately before model dispatch |
-| `ctx.session.hook("http.request", callback)` | `request`, immediately before provider dispatch                                |
-| `ctx.session.hook("http.response", callback)` | `response`, immediately after the provider responds                            |
+| `ctx.session.hook("http", callback)`       | `use`, registering request and response handling                               |
 | `ctx.tool.hook("execute.before", callback)` | `input`, before the selected tool executes                                     |
 | `ctx.tool.hook("execute.after", callback)`  | Terminal `result` on success or `error` on failure                             |
 
-HTTP hooks can modify requests and responses. They apply to native models; AI
-SDK models do not currently pass through these hooks. Request and response
-bodies are one-shot streams. Use `clone()` when you intentionally need a
-separate reader, but be aware that its slower branch may buffer data. To inspect
-or modify chunks while preserving streaming, replace the body with one piped
-through a `TransformStream`.
+HTTP hooks can modify requests, inspect responses, retry, or return a
+response without calling the provider. It applies to native models; AI SDK
+models do not currently pass through this hook.
 
 ```ts
-await ctx.session.hook("http.request", (event) => {
-  event.request.headers.set("x-session-id", event.sessionID)
-})
-
-await ctx.session.hook("http.response", (event) => {
-  event.response = new Response(event.response.body, {
-    status: event.response.status,
-    headers: { ...Object.fromEntries(event.response.headers), "x-plugin": "enabled" },
+await ctx.session.hook("http", (event) => {
+  event.use((request, next) => {
+    request.headers.set("x-session-id", event.sessionID)
+    return next(request)
   })
 })
 ```