fix(tui): harden highlight cache lifecycle

bun.lock

@@ -489,6 +489,18 @@
         "@typescript/native-preview": "catalog:",
       },
     },
+    "packages/effect-sqlite-node": {
+      "name": "@opencode-ai/effect-sqlite-node",
+      "version": "1.18.8",
+      "dependencies": {
+        "effect": "catalog:",
+      },
+      "devDependencies": {
+        "@tsconfig/bun": "catalog:",
+        "@types/node": "catalog:",
+        "@typescript/native-preview": "catalog:",
+      },
+    },
     "packages/enterprise": {
       "name": "@opencode-ai/enterprise",
       "version": "1.18.8",
@@ -2055,6 +2067,8 @@
 
     "@opencode-ai/effect-drizzle-sqlite": ["@opencode-ai/effect-drizzle-sqlite@workspace:packages/effect-drizzle-sqlite"],
 
+    "@opencode-ai/effect-sqlite-node": ["@opencode-ai/effect-sqlite-node@workspace:packages/effect-sqlite-node"],
+
     "@opencode-ai/enterprise": ["@opencode-ai/enterprise@workspace:packages/enterprise"],
 
     "@opencode-ai/function": ["@opencode-ai/function@workspace:packages/function"],

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/codemode/src/stdlib/collections.ts

@@ -58,3 +58,13 @@ export const setMethods = new Set([
   "isSupersetOf",
   "isDisjointFrom",
 ])
+
+export const spreadItems = (value: unknown): Array<unknown> | undefined => {
+  if (Array.isArray(value)) return value
+  if (typeof value === "string") return Array.from(value)
+  if (value instanceof CodeModeMap) return Array.from(value.map.entries(), ([key, item]) => [key, item])
+  if (value instanceof CodeModeSet) return Array.from(value.set.values())
+  if (value instanceof CodeModeURLSearchParams) return Array.from(value.params.entries(), ([key, item]) => [key, item])
+  return undefined
+}
+import { CodeModeMap, CodeModeSet, CodeModeURLSearchParams } from "../values.js"

packages/console/app/src/component/desktop-promo.css

@@ -0,0 +1,103 @@
+[data-component="desktop-promo"] {
+  --promo-background: hsl(0, 20%, 99%);
+  --promo-background-weak: hsl(0, 8%, 97%);
+  --promo-text: hsl(0, 1%, 39%);
+  --promo-text-strong: hsl(0, 5%, 12%);
+  --promo-border: hsla(0, 100%, 3%, 0.12);
+
+  position: fixed;
+  z-index: 20;
+  right: 1.5rem;
+  bottom: 1.5rem;
+  width: min(28rem, calc(100vw - 2rem));
+  padding: 4px;
+  overflow: hidden;
+  color: var(--promo-text);
+  border: 1px solid var(--promo-border);
+  border-radius: 8px;
+  background: var(--promo-background);
+  box-shadow: 0 0.75rem 2rem rgb(0 0 0 / 15%);
+  font-family: var(--font-mono);
+
+  @media (prefers-color-scheme: dark) {
+    --promo-background: hsl(0, 9%, 7%);
+    --promo-background-weak: hsl(0, 6%, 10%);
+    --promo-text: hsl(0, 4%, 71%);
+    --promo-text-strong: hsl(0, 15%, 94%);
+    --promo-border: hsl(0, 4%, 23%);
+  }
+
+  @media (max-width: 40rem) {
+    right: 1rem;
+    bottom: 1rem;
+  }
+
+  [data-slot="desktop-promo-link"] {
+    display: block;
+    color: var(--promo-text);
+    text-decoration: none;
+  }
+
+  [data-slot="desktop-promo-link"]:focus-visible {
+    outline: 2px solid var(--promo-text-strong);
+    outline-offset: -3px;
+  }
+
+  video {
+    display: block;
+    width: 100%;
+    aspect-ratio: 16 / 9;
+    object-fit: cover;
+    border-radius: 4px;
+    background: var(--promo-background-weak);
+  }
+
+  [data-slot="desktop-promo-copy"] {
+    display: flex;
+    flex-direction: column;
+    gap: 0.35rem;
+    padding: 1rem;
+    font-size: 0.875rem;
+    line-height: 1.4;
+  }
+
+  [data-slot="desktop-promo-copy"] strong {
+    color: var(--promo-text-strong);
+    font-weight: 500;
+  }
+
+  [data-slot="desktop-promo-close"] {
+    position: absolute;
+    top: 0.5rem;
+    right: 0.5rem;
+    display: grid;
+    width: 2rem;
+    height: 2rem;
+    padding: 0;
+    place-items: center;
+    cursor: pointer;
+    color: white;
+    border: none;
+    border-radius: 0.25rem;
+    background: rgb(0 0 0 / 70%);
+    opacity: 0;
+    transition:
+      opacity 150ms ease,
+      background 150ms ease;
+  }
+
+  &:hover [data-slot="desktop-promo-close"],
+  [data-slot="desktop-promo-close"]:focus-visible {
+    opacity: 1;
+  }
+
+  [data-slot="desktop-promo-close"]:hover {
+    background: rgb(0 0 0 / 90%);
+  }
+
+  @media (hover: none) {
+    [data-slot="desktop-promo-close"] {
+      opacity: 1;
+    }
+  }
+}

packages/console/app/src/component/desktop-promo.tsx

@@ -0,0 +1,60 @@
+import "./desktop-promo.css"
+import { A, useLocation } from "@solidjs/router"
+import { createSignal, Show } from "solid-js"
+import { getRequestEvent } from "solid-js/web"
+import desktopPromoVideo from "~/asset/lander/desktop-tabs-landscape.mp4"
+import { useI18n } from "~/context/i18n"
+import { useLanguage } from "~/context/language"
+import { strip } from "~/lib/language"
+
+const DISMISSED_COOKIE = "desktop_promo_dismissed"
+
+export function DesktopPromo() {
+  const i18n = useI18n()
+  const language = useLanguage()
+  const location = useLocation()
+  const request = getRequestEvent()?.request
+  const cookie = request?.headers.get("cookie") ?? (typeof document === "object" ? document.cookie : "")
+  const [visible, setVisible] = createSignal(
+    !cookie.split(";").some((value) => value.trim() === `${DISMISSED_COOKIE}=1`),
+  )
+  const hostname = request ? new URL(request.url).hostname : typeof window === "object" ? window.location.hostname : ""
+  const primaryHost =
+    hostname === "opencode.ai" || hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1"
+
+  return (
+    <Show
+      when={
+        visible() &&
+        primaryHost &&
+        strip(location.pathname) !== "/download" &&
+        !strip(location.pathname).startsWith("/download/")
+      }
+    >
+      <aside data-component="desktop-promo">
+        <A href={language.route("/download")} data-slot="desktop-promo-link">
+          <video src={desktopPromoVideo} autoplay playsinline loop muted preload="metadata" aria-hidden="true" />
+          <span data-slot="desktop-promo-copy">
+            <strong>{i18n.t("home.promo.title")}</strong>
+            <span>
+              {i18n.t("home.promo.body")} {i18n.t("home.promo.cta")}
+            </span>
+          </span>
+        </A>
+        <button
+          type="button"
+          data-slot="desktop-promo-close"
+          onClick={() => {
+            document.cookie = `${DISMISSED_COOKIE}=1; Path=/; Max-Age=31536000; SameSite=Lax`
+            setVisible(false)
+          }}
+        >
+          <span class="sr-only">{i18n.t("home.promo.close")}</span>
+          <svg width="20" height="20" viewBox="0 0 20 20" fill="none" aria-hidden="true">
+            <path d="M5 5L15 15M15 5L5 15" stroke="currentColor" stroke-width="1.5" />
+          </svg>
+        </button>
+      </aside>
+    </Show>
+  )
+}

packages/console/mail/emails/components.tsx

@@ -19,6 +19,10 @@ export function Span({ children, ...props }: SpanProps) {
   return React.createElement("span", props, children)
 }
 
+export function Wbr({ children, ...props }: WbrProps) {
+  return React.createElement("wbr", props, children)
+}
+
 export function Fonts({ assetsUrl }: { assetsUrl: string }) {
   return (
     <>
@@ -55,3 +59,14 @@ export function Fonts({ assetsUrl }: { assetsUrl: string }) {
     </>
   )
 }
+
+export function SplitString({ text, split }: { text: string; split: number }) {
+  const segments: JSX.Element[] = []
+  for (let i = 0; i < text.length; i += split) {
+    segments.push(<>{text.slice(i, i + split)}</>)
+    if (i + split < text.length) {
+      segments.push(<Wbr key={`${i}wbr`} />)
+    }
+  }
+  return <>{segments}</>
+}

packages/core/src/agent.ts

@@ -44,6 +44,7 @@ export type Draft = {
 
 export interface Interface extends State.Transformable<Draft> {
   readonly get: (id: ID) => Effect.Effect<Info | undefined>
+  readonly default: () => Effect.Effect<Info | undefined>
   readonly resolve: (id?: ID | string) => Effect.Effect<Info | undefined>
   readonly select: (id?: ID | string) => Effect.Effect<Selection>
   readonly list: () => Effect.Effect<Info[]>
@@ -109,6 +110,9 @@ const layer = Layer.effect(
       get: Effect.fn("Agent.get")(function* (id) {
         return state.get().agents.get(id)
       }),
+      default: Effect.fn("Agent.default")(function* () {
+        return selectedDefault()
+      }),
       resolve: Effect.fn("Agent.resolve")(function* (id) {
         if (id !== undefined) return state.get().agents.get(ID.make(id))
         return selectedDefault()

packages/core/src/bus.ts

@@ -152,19 +152,16 @@ export interface Interface {
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/Bus") {}
 
-interface Options {
+export interface LayerOptions {
   readonly beforeAggregateRead?: (aggregateID: string) => Effect.Effect<void>
   /** Maximum durable rows read per page while replaying or tailing an aggregate log. */
   readonly logReadPageSize?: number
-  /** Retain durable event payloads for historical log reads and replay. */
-  readonly persist?: boolean
 }
 
-export function configured(options?: Options) {
-  return makeGlobalNode({
-    service: Service,
-    deps: [Database.node],
-    layer: Layer.effect(Service, Effect.gen(function* () {
+export const layerWith = (options?: LayerOptions) =>
+  Layer.effect(
+    Service,
+    Effect.gen(function* () {
       const pubsub = {
         live: yield* PubSub.unbounded<Event.Payload>(),
         durable: new Map<string, Set<PubSub.PubSub<void>>>(),
@@ -174,7 +171,6 @@ export function configured(options?: Options) {
       const listeners = new Array<Subscriber>()
       const { db } = yield* Database.Service
       const logReadPageSize = options?.logReadPageSize ?? 512
-      const persist = options?.persist ?? false
 
       const getOrCreate = (definition: Event.Definition) =>
         Effect.gen(function* () {
@@ -255,7 +251,6 @@ export function configured(options?: Options) {
                             )
                           }
                           if (input && input.seq <= latest) {
-                            if (!persist) return
                             const stored = yield* db
                               .select()
                               .from(EventTable)
@@ -297,21 +292,19 @@ export function configured(options?: Options) {
                               }),
                             )
                           }
-                          if (persist) {
-                            const stored = yield* db
-                              .select({ aggregateID: EventTable.aggregate_id, seq: EventTable.seq })
-                              .from(EventTable)
-                              .where(eq(EventTable.id, event.id))
-                              .get()
-                              .pipe(Effect.orDie)
-                            if (stored)
-                              yield* Effect.die(
-                                new InvalidDurableEventError({
-                                  type: event.type,
-                                  message: `Event ${event.id} already exists at aggregate ${stored.aggregateID} sequence ${stored.seq}`,
-                                }),
-                              )
-                          }
+                          const stored = yield* db
+                            .select({ aggregateID: EventTable.aggregate_id, seq: EventTable.seq })
+                            .from(EventTable)
+                            .where(eq(EventTable.id, event.id))
+                            .get()
+                            .pipe(Effect.orDie)
+                          if (stored)
+                            yield* Effect.die(
+                              new InvalidDurableEventError({
+                                type: event.type,
+                                message: `Event ${event.id} already exists at aggregate ${stored.aggregateID} sequence ${stored.seq}`,
+                              }),
+                            )
                           const committed = {
                             ...event,
                             durable: { aggregateID, seq, version: durable.version },
@@ -332,21 +325,20 @@ export function configured(options?: Options) {
                             })
                             .run()
                             .pipe(Effect.orDie)
-                          if (persist)
-                            yield* db
-                              .insert(EventTable)
-                              .values([
-                                {
-                                  id: event.id,
-                                  aggregate_id: aggregateID,
-                                  seq,
-                                  created: DateTime.toEpochMillis(event.created ?? DateTime.makeUnsafe(0)),
-                                  type: versionedType(definition.type, durable.version),
-                                  data: encoded,
-                                },
-                              ])
-                              .run()
-                              .pipe(Effect.orDie)
+                          yield* db
+                            .insert(EventTable)
+                            .values([
+                              {
+                                id: event.id,
+                                aggregate_id: aggregateID,
+                                seq,
+                                created: DateTime.toEpochMillis(event.created ?? DateTime.makeUnsafe(0)),
+                                type: versionedType(definition.type, durable.version),
+                                data: encoded,
+                              },
+                            ])
+                            .run()
+                            .pipe(Effect.orDie)
                           return { aggregateID, seq }
                         }),
                       { behavior: "immediate" },
@@ -691,8 +683,8 @@ export function configured(options?: Options) {
         remove,
         claim,
       })
-    })),
-  })
-}
+    }),
+  )
 
-export const node = configured()
+export const layer = layerWith()
+export const node = makeGlobalNode({ service: Service, layer: layer, deps: [Database.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/ignore.ts

@@ -1,3 +1,5 @@
+import { Glob } from "@opencode-ai/util/glob"
+
 const FOLDERS = new Set([
   "node_modules",
   "bower_components",
@@ -45,4 +47,21 @@ const FILES = [
 
 export const PATTERNS = [...FILES, ...FOLDERS, `**/{${Array.from(FOLDERS).join(",")}}/**`]
 
+export function match(filepath: string, opts?: { extra?: string[]; whitelist?: string[] }) {
+  for (const pattern of opts?.whitelist || []) {
+    if (Glob.match(pattern, filepath)) return false
+  }
+
+  const parts = filepath.split(/[/\\]/)
+  for (const part of parts) {
+    if (FOLDERS.has(part)) return true
+  }
+
+  for (const pattern of [...FILES, ...(opts?.extra || [])]) {
+    if (Glob.match(pattern, filepath)) return true
+  }
+
+  return false
+}
+
 export * as Ignore from "./ignore"

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/instructions/builtins.ts

@@ -28,7 +28,7 @@ const layer = Layer.effect(
               read: Effect.sync(() =>
                 [
                   "<env>",
-                  `  Current conversation session ID: ${sessionID}`,
+                  `  Session ID: ${sessionID}`,
                   `  Working directory: ${location.directory}`,
                   `  Workspace root folder: ${location.project.directory}`,
                   `  Is directory a git repo: ${location.vcs?.type === "git" ? "yes" : "no"}`,

packages/core/src/mcp/index.ts

@@ -12,6 +12,7 @@ import { Credential } from "../credential"
 import { Bus } from "../bus"
 import { Form } from "../form"
 import { Integration } from "../integration"
+import { IntegrationConnection } from "../integration/connection"
 import { KeyedMutex } from "../effect/keyed-mutex"
 import { Location } from "../location"
 import { waitForAbort } from "@opencode-ai/util/process"
@@ -30,6 +31,7 @@ export class ServerInfo extends Schema.Class<ServerInfo>("MCP.ServerInfo")({
   name: ServerName,
   status: Status,
   integrationID: Integration.ID.pipe(Schema.optional),
+  connection: IntegrationConnection.Info.pipe(Schema.optional),
 }) {}
 
 export class ServerInstructions extends Schema.Class<ServerInstructions>("MCP.ServerInstructions")({
@@ -245,6 +247,14 @@ export const layer = (options?: Options) => Layer.effect(
       return { name, entry }
     })
 
+    const info = (name: ServerName, entry: ServerEntry, connection: IntegrationConnection.Info | undefined) =>
+      new ServerInfo({
+        name,
+        status: entry.status,
+        integrationID: entry.integrationID,
+        connection,
+      })
+
     // Builds the connect-time auth provider for a remote OAuth-integration server. The SDK presents and
     // refreshes stored tokens, persisting refreshes back to the same credential row. The provider never
     // opens a browser, so an auth-gated connect ends in UnauthorizedError -> needs_auth rather than a redirect.
@@ -593,12 +603,15 @@ export const layer = (options?: Options) => Layer.effect(
     )
     return Service.of({
       servers: Effect.fn("MCP.servers")(function* () {
-        return Array.from(runtime)
-          .toSorted(([a], [b]) => a.localeCompare(b))
-          .map(
-            ([name, entry]) =>
-              new ServerInfo({ name, status: entry.status, integrationID: entry.integrationID }),
-          )
+        const entries = Array.from(runtime).toSorted(([a], [b]) => a.localeCompare(b))
+        return yield* Effect.forEach(entries, ([name, entry]) =>
+          Effect.gen(function* () {
+            const connection = entry.integrationID
+              ? yield* integration.connection.active(entry.integrationID)
+              : undefined
+            return info(name, entry, connection)
+          }),
+        )
       }),
       add: Effect.fn("MCP.add")(function* (server, config) {
         const name = ServerName.make(server)

packages/core/src/plugin/provider/github-copilot.ts

@@ -1,5 +1,4 @@
 import type { IntegrationOAuthMethodRegistration } from "@opencode-ai/plugin/effect/integration"
-import { shouldUseResponsesApi } from "@opencode-ai/ai/providers/github-copilot"
 import { Effect, Option, Schema, Semaphore, Stream } from "effect"
 import { Catalog } from "../../catalog"
 import { Credential } from "../../credential"
@@ -141,6 +140,14 @@ const oauth = (app: App.Info) => ({
     }),
 }) satisfies IntegrationOAuthMethodRegistration
 
+function shouldUseResponses(modelID: string) {
+  // Copilot supports Responses for GPT-5 class models, except mini variants
+  // which still need the chat-completions endpoint.
+  const match = /^gpt-(\d+)/.exec(modelID)
+  if (!match) return false
+  return Number(match[1]) >= 5 && !modelID.startsWith("gpt-5-mini")
+}
+
 export const GithubCopilotPlugin = define({
   id: "opencode.provider.github-copilot",
   effect: Effect.fn(function* (ctx) {
@@ -262,7 +269,7 @@ export const GithubCopilotPlugin = define({
           return
         }
         const id = evt.model.modelID ?? evt.model.id
-        evt.language = shouldUseResponsesApi(id) ? evt.sdk.responses(id) : evt.sdk.chat(id)
+        evt.language = shouldUseResponses(id) ? evt.sdk.responses(id) : evt.sdk.chat(id)
       }),
     )
   }),

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/project/copy.ts

@@ -70,6 +70,11 @@ export class StrategyUnavailableError extends Schema.TaggedErrorClass<StrategyUn
   { strategy: StrategyID },
 ) {}
 
+export class DuplicateStrategyError extends Schema.TaggedErrorClass<DuplicateStrategyError>()(
+  "ProjectCopy.DuplicateStrategyError",
+  { strategy: StrategyID },
+) {}
+
 export type Error =
   | SourceDirectoryNotFoundError
   | DestinationExistsError
@@ -94,6 +99,7 @@ export interface Strategy {
 export { Event }
 
 export interface Interface {
+  readonly register: (strategy: Strategy) => Effect.Effect<void, DuplicateStrategyError>
   readonly create: (input: CreateInput) => Effect.Effect<Copy, Error>
   readonly remove: (input: RemoveInput) => Effect.Effect<void, Error>
   readonly refresh: (input: RefreshInput) => Effect.Effect<RefreshResult, Error>
@@ -138,18 +144,29 @@ const layer = Layer.effect(
       return resolved
     })
 
-    const strategy = makeGitWorktreeStrategy({ git, canonical })
+    const registry = new Map<StrategyID, Strategy>()
+
+    const register = Effect.fn("ProjectCopy.register")(function* (strategy: Strategy) {
+      if (registry.has(strategy.id)) return yield* new DuplicateStrategyError({ strategy: strategy.id })
+      registry.set(strategy.id, strategy)
+    })
+
+    // Register default strategies
+    yield* register(makeGitWorktreeStrategy({ git, canonical })).pipe(Effect.orDie)
+
+    const strategies = () => Array.from(registry.values())
 
     const source = Effect.fnUntraced(function* (input: AbsolutePath, projectID: Project.ID) {
       const sourceDirectory = yield* canonical(input)
-      if ((yield* directories.get({ projectID, directory: sourceDirectory })) === undefined)
+      if (!(yield* directories.contains({ projectID, directory: sourceDirectory })))
         return yield* new SourceDirectoryNotFoundError({ directory: sourceDirectory })
       return sourceDirectory
     })
 
     const getStrategy = Effect.fnUntraced(function* (id: StrategyID) {
-      if (id !== strategy.id) return yield* new StrategyUnavailableError({ strategy: id })
-      return strategy
+      const found = registry.get(id)
+      if (!found) return yield* new StrategyUnavailableError({ strategy: id })
+      return found
     })
 
     const create = Effect.fn("ProjectCopy.create")(function* (input: CreateInput) {
@@ -209,18 +226,20 @@ const layer = Layer.effect(
       const discovered = yield* Effect.forEach(
         sourceDirectories,
         (sourceDirectory) =>
-          strategy.list(sourceDirectory).pipe(
-            Effect.catchTag("ProjectCopy.DirectoryUnavailableError", () => Effect.succeed([])),
-            Effect.map((items) =>
-              items.map((item) => ({
-                directory: item.directory,
-                strategy: item.type === "copy" ? strategy.id : undefined,
-              })),
+          Effect.forEach(strategies(), (strategy) =>
+            strategy.list(sourceDirectory).pipe(
+              Effect.catchTag("ProjectCopy.DirectoryUnavailableError", () => Effect.succeed([])),
+              Effect.map((items) =>
+                items.map((item) => ({
+                  directory: item.directory,
+                  strategy: item.type === "copy" ? strategy.id : undefined,
+                })),
+              ),
             ),
           ),
         { concurrency: "unbounded" },
       ).pipe(
-        Effect.map((sets) => new Map(sets.flat().map((item) => [item.directory, item] as const)).values().toArray()),
+        Effect.map((sets) => new Map(sets.flat(2).map((item) => [item.directory, item] as const)).values().toArray()),
       )
       const removed = checked.filter((item) => !item.exists).map((item) => item.directory)
       const result = yield* db
@@ -252,6 +271,7 @@ const layer = Layer.effect(
     })
 
     return Service.of({
+      register,
       create,
       remove,
       refresh,

packages/core/src/project/directories.ts

@@ -41,6 +41,7 @@ export interface Interface {
     projectID: ProjectSchema.ID
     directory: AbsolutePath
   }) => Effect.Effect<Directory | undefined>
+  readonly contains: (input: { projectID: ProjectSchema.ID; directory: AbsolutePath }) => Effect.Effect<boolean>
   readonly create: (input: CreateInput, tx?: Transaction) => Effect.Effect<boolean>
   readonly remove: (input: RemoveInput, tx?: Transaction) => Effect.Effect<boolean>
 }
@@ -98,6 +99,25 @@ const layer = Layer.effect(
       return rows.map((row) => ({ directory: row.directory, strategy: row.strategy ?? undefined }))
     })
 
+    const contains = Effect.fn("ProjectDirectories.contains")(function* (input: {
+      projectID: ProjectSchema.ID
+      directory: AbsolutePath
+    }) {
+      return (
+        (yield* db
+          .select({ directory: ProjectDirectoryTable.directory })
+          .from(ProjectDirectoryTable)
+          .where(
+            and(
+              eq(ProjectDirectoryTable.project_id, input.projectID),
+              eq(ProjectDirectoryTable.directory, input.directory),
+            ),
+          )
+          .get()
+          .pipe(Effect.orDie)) !== undefined
+      )
+    })
+
     const get = Effect.fn("ProjectDirectories.get")(function* (input: {
       projectID: ProjectSchema.ID
       directory: AbsolutePath
@@ -119,6 +139,7 @@ const layer = Layer.effect(
     return Service.of({
       list,
       get,
+      contains,
       create,
       remove,
     })

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.ts

@@ -52,6 +52,9 @@ import { Shell as ShellSchema } from "@opencode-ai/schema/shell"
 import { KeyedMutex } from "./effect/keyed-mutex"
 import { fileURLToPath } from "url"
 
+export const RevertState = Session.Revert
+export type RevertState = Session.Revert
+
 // get project -> project.locations
 //
 // get all sessions
@@ -107,6 +110,13 @@ type ForkInput = {
   boundary: Session.ForkRequestBoundary
 }
 
+export class OperationUnavailableError extends Schema.TaggedErrorClass<OperationUnavailableError>()(
+  "Session.OperationUnavailableError",
+  {
+    operation: Schema.Literals(["move", "skill", "switchAgent", "compact"]),
+  },
+) {}
+
 export { MessageDecodeError, NotFoundError }
 
 export class PromptConflictError extends Schema.TaggedErrorClass<PromptConflictError>()("Session.PromptConflictError", {
@@ -150,6 +160,23 @@ export class DestinationNotDirectoryError extends Schema.TaggedErrorClass<Destin
 export const MessageNotFoundError = SessionRevert.MessageNotFoundError
 export type MessageNotFoundError = SessionRevert.MessageNotFoundError
 
+export type Error =
+  | NotFoundError
+  | MessageDecodeError
+  | OperationUnavailableError
+  | PromptConflictError
+  | SyntheticConflictError
+  | AttachmentError
+  | CompactionConflictError
+  | BusyError
+  | SkillNotFoundError
+  | DestinationNotFoundError
+  | DestinationNotDirectoryError
+  | Command.NotFoundError
+  | Command.EvaluationError
+  | MessageNotFoundError
+  | SessionGenerate.Error
+
 export interface Interface {
   readonly list: (input?: ListInput) => Effect.Effect<{
     readonly data: SessionSchema.Info[]

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/shell/select.ts

@@ -7,16 +7,16 @@ import { Schema } from "effect"
 import { FSUtil } from "@opencode-ai/util/fs-util"
 import { which } from "../util/which"
 
-const META: Record<string, { deny?: boolean; login?: boolean; ps?: boolean }> = {
-  bash: { login: true },
-  dash: { login: true },
+const META: Record<string, { deny?: boolean; login?: boolean; posix?: boolean; ps?: boolean }> = {
+  bash: { login: true, posix: true },
+  dash: { login: true, posix: true },
   fish: { deny: true, login: true },
-  ksh: { login: true },
+  ksh: { login: true, posix: true },
   nu: { deny: true },
   powershell: { ps: true },
   pwsh: { ps: true },
-  sh: { login: true },
-  zsh: { login: true },
+  sh: { login: true, posix: true },
+  zsh: { login: true, posix: true },
 }
 
 export type Item = {
@@ -116,6 +116,10 @@ export function login(file: string) {
   return meta(file)?.login === true
 }
 
+export function posix(file: string) {
+  return meta(file)?.posix === true
+}
+
 export function ps(file: string) {
   return meta(file)?.ps === true
 }

packages/core/test/bus.test.ts

@@ -100,19 +100,9 @@ const tail = (bus: Bus.Interface, input: { aggregateID: string; after?: number }
   bus.log({ ...input, follow: true }).pipe(Stream.filter((item): item is Event.Payload => !Bus.isSynced(item)))
 
 const it = testEffect(
-  AppNodeBuilder.build(LayerNode.group([Database.node, Bus.node, Location.node]), [
-    [Location.node, locationLayer],
-    [Bus.node, Bus.configured({ persist: true })],
-  ]),
-)
-const itWithoutLocation = testEffect(
-  AppNodeBuilder.build(LayerNode.group([Database.node, Bus.node]), [
-    [Bus.node, Bus.configured({ persist: true })],
-  ]),
-)
-const itWithoutPersistence = testEffect(
-  AppNodeBuilder.build(LayerNode.group([Database.node, Bus.node])),
+  AppNodeBuilder.build(LayerNode.group([Database.node, Bus.node, Location.node]), [[Location.node, locationLayer]]),
 )
+const itWithoutLocation = testEffect(AppNodeBuilder.build(LayerNode.group([Database.node, Bus.node])))
 
 describe("Bus", () => {
   it.effect("subscribes to multiple event definitions with a discriminated payload union", () =>
@@ -264,27 +254,6 @@ describe("Bus", () => {
     }),
   )
 
-  itWithoutPersistence.effect("projects durable events without retaining their payloads", () =>
-    Effect.gen(function* () {
-      const bus = yield* Bus.Service
-      const { db } = yield* Database.Service
-      const aggregateID = Event.ID.create()
-      yield* db.run("CREATE TABLE IF NOT EXISTS event_commit_probe (value text NOT NULL)")
-      yield* bus.project(SyncMessage, () =>
-        db.run("INSERT INTO event_commit_probe (value) VALUES ('projected')").pipe(Effect.orDie, Effect.asVoid),
-      )
-
-      const event = yield* bus.publish(SyncMessage, { id: aggregateID, text: "hello" })
-
-      expect(event.durable?.seq).toBe(Event.Seq.make(0))
-      expect(yield* db.all("SELECT value FROM event_commit_probe")).toEqual([{ value: "projected" }])
-      expect(yield* db.select().from(EventTable).where(eq(EventTable.aggregate_id, aggregateID)).all()).toEqual([])
-      expect(
-        yield* db.select().from(EventSequenceTable).where(eq(EventSequenceTable.aggregate_id, aggregateID)).all(),
-      ).toEqual([{ aggregate_id: aggregateID, seq: 0, owner_id: null }])
-    }),
-  )
-
   it.effect("rejects local commit hooks on live-only events", () =>
     Effect.gen(function* () {
       const bus = yield* Bus.Service
@@ -503,18 +472,12 @@ describe("Bus", () => {
       const readStarted = yield* Deferred.make<void>()
       const continueRead = yield* Deferred.make<void>()
       let pause = true
-      const eventLayer = AppNodeBuilder.build(LayerNode.group([Database.node, Bus.node]), [
-        [
-          Bus.node,
-          Bus.configured({
-            persist: true,
-            beforeAggregateRead: () =>
-              pause
-                ? Deferred.succeed(readStarted, undefined).pipe(Effect.andThen(Deferred.await(continueRead)))
-                : Effect.void,
-          }),
-        ],
-      ])
+      const eventLayer = Bus.layerWith({
+        beforeAggregateRead: () =>
+          pause
+            ? Deferred.succeed(readStarted, undefined).pipe(Effect.andThen(Deferred.await(continueRead)))
+            : Effect.void,
+      }).pipe(Layer.provide(LayerNode.compile(Database.node)))
 
       yield* Effect.gen(function* () {
         const bus = yield* Bus.Service
@@ -529,7 +492,7 @@ describe("Bus", () => {
         expect(Array.from(yield* Fiber.join(fiber)).map((event) => [event.durable?.seq, event.data])).toEqual([
           [0, durableData(aggregateID, "during handoff")],
         ])
-      }).pipe(Effect.provide(eventLayer))
+      }).pipe(Effect.provide(Layer.merge(LayerNode.compile(Database.node), eventLayer)))
     }),
   )
 
@@ -1272,9 +1235,7 @@ describe("Bus", () => {
 
   it.effect("log replays across configured read pages", () =>
     Effect.gen(function* () {
-      const eventLayer = AppNodeBuilder.build(LayerNode.group([Database.node, Bus.node]), [
-        [Bus.node, Bus.configured({ persist: true, logReadPageSize: 2 })],
-      ])
+      const eventLayer = Bus.layerWith({ logReadPageSize: 2 }).pipe(Layer.provide(LayerNode.compile(Database.node)))
 
       yield* Effect.gen(function* () {
         const bus = yield* Bus.Service
@@ -1296,7 +1257,7 @@ describe("Bus", () => {
           "log.synced",
         ])
         expect(items.at(-1)).toEqual({ type: "log.synced", aggregateID, seq: Event.Seq.make(4) })
-      }).pipe(Effect.provide(eventLayer))
+      }).pipe(Effect.provide(Layer.merge(LayerNode.compile(Database.node), eventLayer)))
     }),
   )
 
@@ -1305,21 +1266,15 @@ describe("Bus", () => {
       const readStarted = yield* Deferred.make<void>()
       const releaseRead = yield* Deferred.make<void>()
       const firstRead = yield* Ref.make(true)
-      const eventLayer = AppNodeBuilder.build(LayerNode.group([Database.node, Bus.node]), [
-        [
-          Bus.node,
-          Bus.configured({
-            persist: true,
-            beforeAggregateRead: () =>
-              Ref.getAndSet(firstRead, false).pipe(
-                Effect.flatMap((shouldBlock) => {
-                  if (!shouldBlock) return Effect.void
-                  return Deferred.succeed(readStarted, undefined).pipe(Effect.andThen(Deferred.await(releaseRead)))
-                }),
-              ),
-          }),
-        ],
-      ])
+      const eventLayer = Bus.layerWith({
+        beforeAggregateRead: () =>
+          Ref.getAndSet(firstRead, false).pipe(
+            Effect.flatMap((shouldBlock) => {
+              if (!shouldBlock) return Effect.void
+              return Deferred.succeed(readStarted, undefined).pipe(Effect.andThen(Deferred.await(releaseRead)))
+            }),
+          ),
+      }).pipe(Layer.provide(LayerNode.compile(Database.node)))
 
       yield* Effect.gen(function* () {
         const bus = yield* Bus.Service
@@ -1339,7 +1294,7 @@ describe("Bus", () => {
           { type: "log.synced", aggregateID, seq: Event.Seq.make(0) },
           Event.Seq.make(1),
         ])
-      }).pipe(Effect.provide(eventLayer))
+      }).pipe(Effect.provide(Layer.merge(LayerNode.compile(Database.node), eventLayer)))
     }),
   )
 

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/ignore.test.ts

@@ -3,6 +3,14 @@ import { Ignore } from "@opencode-ai/core/filesystem/ignore"
 // @ts-ignore
 import { createWrapper } from "@parcel/watcher/wrapper"
 
+test("match nested and non-nested", () => {
+  expect(Ignore.match("node_modules/index.js")).toBe(true)
+  expect(Ignore.match("node_modules")).toBe(true)
+  expect(Ignore.match("node_modules/")).toBe(true)
+  expect(Ignore.match("node_modules/bar")).toBe(true)
+  expect(Ignore.match("node_modules/bar/")).toBe(true)
+})
+
 test("parcel patterns ignore built-in folders at any depth", async () => {
   let ignoreGlobs: string[] = []
   const watcher = createWrapper({

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/instruction-state.test.ts

@@ -17,11 +17,7 @@ import { SessionSchema } from "@opencode-ai/core/session/schema"
 import { InstructionBlobTable, InstructionStateTable, SessionMessageTable, SessionTable } from "@opencode-ai/core/session/sql"
 import { testEffect } from "./lib/effect"
 
-const it = testEffect(
-  AppNodeBuilder.build(LayerNode.group([Database.node, Bus.node, SessionProjector.node]), [
-    [Bus.node, Bus.configured({ persist: true })],
-  ]),
-)
+const it = testEffect(AppNodeBuilder.build(LayerNode.group([Database.node, Bus.node, SessionProjector.node])))
 
 const source = (name: string, read: Effect.Effect<string | Instructions.Unavailable | Instructions.Removed>) =>
   Instructions.make({

packages/core/test/instructions/builtins.test.ts

@@ -44,7 +44,7 @@ describe("InstructionBuiltIns", () => {
         [
           "Here is some useful information about the environment you are running in:",
           "<env>",
-          `  Current conversation session ID: ${sessionID}`,
+          `  Session ID: ${sessionID}`,
           `  Working directory: ${directory}`,
           `  Workspace root folder: ${projectDirectory}`,
           "  Is directory a git repo: yes",

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/project-copy.test.ts

@@ -83,10 +83,20 @@ describe("ProjectCopy", () => {
     }),
   )
 
-  it.effect("reports unavailable strategy ids", () =>
+  it.effect("rejects duplicate strategies and reports unavailable ids", () =>
     Effect.gen(function* () {
       const input = yield* setup()
       const copy = yield* ProjectCopy.Service
+      const strategy: ProjectCopy.Strategy = {
+        id: ProjectCopy.StrategyID.make("test/duplicate"),
+        create: () => Effect.die("unused"),
+        remove: () => Effect.die("unused"),
+        list: () => Effect.succeed([]),
+      }
+
+      yield* copy.register(strategy)
+      expect(yield* copy.register(strategy).pipe(Effect.flip)).toBeInstanceOf(ProjectCopy.DuplicateStrategyError)
+
       const unavailable = ProjectCopy.StrategyID.make("acme/missing")
       const error = yield* copy
         .create({

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-compaction.test.ts

@@ -81,7 +81,6 @@ const it = testEffect(
   AppNodeBuilder.build(
     LayerNode.group([Database.node, Bus.node, SessionProjector.node, SessionStore.node, SessionCompaction.node]),
     [
-      [Bus.node, Bus.configured({ persist: true })],
       [llmClient, client],
       [Config.node, config],
       [SessionRunnerModel.node, models],

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

@@ -34,13 +34,13 @@ 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(
   AppNodeBuilder.build(
     LayerNode.group([Database.node, Bus.node, SessionProjector.node, SessionStore.node, Session.node]),
     [
-      [Bus.node, Bus.configured({ persist: true })],
       [Project.node, projects],
       [SessionExecution.node, SessionExecution.noopLayer],
     ],
@@ -563,10 +563,7 @@ describe("Session.create", () => {
       const targetDatabase = Database.layer({ path: path.join(tmp.path, "target.sqlite") })
       const targetLayer = AppNodeBuilder.build(
         LayerNode.group([Database.node, Bus.node, SessionProjector.node, SessionStore.node]),
-        [
-          [Database.node, targetDatabase],
-          [Bus.node, Bus.configured({ persist: true })],
-        ],
+        [[Database.node, targetDatabase]],
       )
 
       yield* Effect.gen(function* () {

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

@@ -133,7 +133,6 @@ const it = testEffect(
       SessionGenerateNode.node,
     ]),
     [
-      [Bus.node, Bus.configured({ persist: true })],
       [llmClient, client],
       [SessionRunnerModel.node, models],
       [InstructionBuiltIns.node, builtins],

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,13 +23,13 @@ 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(
   AppNodeBuilder.build(
     LayerNode.group([Database.node, Bus.node, SessionProjector.node, SessionStore.node, Session.node]),
     [
-      [Bus.node, Bus.configured({ persist: true })],
       [Project.node, projects],
       [SessionExecution.node, SessionExecution.noopLayer],
     ],
@@ -46,7 +46,9 @@ describe("Session.log", () => {
 
       const items = Array.from(yield* Stream.runCollect(session.log({ sessionID: created.id })))
 
-      expect(items.map((item) => item.type)).toEqual(["session.created", "session.renamed", "log.synced"])
+      // Session creation commits a non-public durable event, so the marker's
+      // seq covers more of the aggregate than the public events emitted.
+      expect(items.map((item) => item.type)).toEqual(["session.renamed", "log.synced"])
       expect(items.at(-1)).toEqual({ type: "log.synced", aggregateID: created.id, seq: Event.Seq.make(1) })
     }),
   )
@@ -56,7 +58,7 @@ describe("Session.log", () => {
       const session = yield* Session.Service
       const created = yield* session.create({ location })
       const fiber = yield* session
-        .log({ sessionID: created.id, after: Event.Seq.make(0), follow: true })
+        .log({ sessionID: created.id, follow: true })
         .pipe(Stream.take(2), Stream.runCollect, Effect.forkScoped)
       yield* Effect.yieldNow
 

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"
@@ -31,11 +32,7 @@ import {
 import { testEffect } from "./lib/effect"
 import { Snapshot } from "@opencode-ai/core/snapshot"
 
-const it = testEffect(
-  AppNodeBuilder.build(LayerNode.group([Database.node, Bus.node, SessionProjector.node]), [
-    [Bus.node, Bus.configured({ persist: true })],
-  ]),
-)
+const it = testEffect(AppNodeBuilder.build(LayerNode.group([Database.node, Bus.node, SessionProjector.node])))
 const sessionsLayer = AppNodeBuilder.build(Session.node, [[SessionExecution.node, SessionExecution.noopLayer]])
 const sessionID = Session.ID.make("ses_projector_test")
 const created = DateTime.makeUnsafe(0)
@@ -129,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
@@ -525,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-prompt.test.ts

@@ -68,7 +68,6 @@ const it = testEffect(
   AppNodeBuilder.build(
     LayerNode.group([Database.node, Bus.node, SessionProjector.node, SessionStore.node, Session.node]),
     [
-      [Bus.node, Bus.configured({ persist: true })],
       [SessionExecution.node, execution],
       [LocationServiceMap.node, locations],
     ],

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

@@ -159,7 +159,6 @@ const testLayer = (llmClient: Layer.Layer<typeof LLMClient.Service>) =>
       Session.node,
     ]),
     [
-      [Bus.node, Bus.configured({ persist: true })],
       [LayerNodePlatform.llmClient, llmClient],
       [Permission.node, permission],
       [Catalog.node, promptCatalog],

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

@@ -423,7 +423,6 @@ const it = testEffect(
       Session.node,
     ]),
     [
-      [Bus.node, Bus.configured({ persist: true })],
       [LayerNodePlatform.llmClient, client],
       [Permission.node, permission],
       [Catalog.node, promptCatalog],

packages/core/test/session-tool-progress.test.ts

@@ -2,7 +2,6 @@ import { describe, expect } from "bun:test"
 import { asc, eq } from "drizzle-orm"
 import { DateTime, Effect, Schema } from "effect"
 import { Database } from "@opencode-ai/core/database/database"
-import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
 import { Bus } from "@opencode-ai/core/bus"
 import { Agent } from "@opencode-ai/core/agent"
@@ -19,11 +18,7 @@ import { SessionProjector } from "@opencode-ai/core/session/projector"
 import { SessionTable, SessionMessageTable } from "@opencode-ai/core/session/sql"
 import { testEffect } from "./lib/effect"
 
-const it = testEffect(
-  AppNodeBuilder.build(LayerNode.group([Database.node, Bus.node, SessionProjector.node]), [
-    [Bus.node, Bus.configured({ persist: true })],
-  ]),
-)
+const it = testEffect(LayerNode.compile(LayerNode.group([Database.node, Bus.node, SessionProjector.node])))
 const timestamp = DateTime.makeUnsafe(1)
 const model = { id: Model.ID.make("model"), providerID: Provider.ID.make("provider") }
 

packages/core/test/shell.test.ts

@@ -34,6 +34,12 @@ describe("shell", () => {
     expect(ShellSelect.login("C:/tools/pwsh.exe")).toBe(false)
   })
 
+  test("detects posix shells", () => {
+    expect(ShellSelect.posix("/bin/bash")).toBe(true)
+    expect(ShellSelect.posix("/bin/fish")).toBe(false)
+    expect(ShellSelect.posix("C:/tools/pwsh.exe")).toBe(false)
+  })
+
   test("falls back when configured shell cannot be resolved", async () => {
     await withShell(undefined, async () => {
       const preferred = ShellSelect.preferred()

packages/desktop/src/main/env.d.ts

@@ -5,3 +5,15 @@ interface ImportMetaEnv {
 interface ImportMeta {
   readonly env: ImportMetaEnv
 }
+
+declare module "virtual:opencode-server" {
+  export namespace Server {
+    export const listen: typeof import("../../../opencode/dist/types/src/node").Server.listen
+    export type Listener = import("../../../opencode/dist/types/src/node").Server.Listener
+  }
+  export namespace Config {
+    export const get: typeof import("../../../opencode/dist/types/src/node").Config.get
+    export type Info = import("../../../opencode/dist/types/src/node").Config.Info
+  }
+  export const bootstrap: typeof import("../../../opencode/dist/types/src/node").bootstrap
+}

packages/desktop/src/main/server.ts

@@ -1,8 +1,32 @@
+import { dirname, join } from "node:path"
+import { fileURLToPath } from "node:url"
+import { app, utilityProcess } from "electron"
+import type { Details } from "electron"
 import { getLogger } from "./logging"
 import { getUserShell, loadShellEnv } from "./shell-env"
 import { getStore } from "./store"
 import { DEFAULT_SERVER_URL_KEY } from "./store-keys"
 
+export type HealthCheck = { wait: Promise<void> }
+
+type SidecarMessage =
+  | { type: "ready" }
+  | { type: "stopped" }
+  | { type: "error"; error: { message: string; stack?: string } }
+
+export type SidecarListener = { stop: () => Promise<void> }
+
+const SIDECAR_SERVICE_NAME = "opencode server"
+const SIDECAR_START_STALL_TIMEOUT = 60_000
+const SIDECAR_STOP_TIMEOUT = 6_000
+
+type SpawnLocalServerOptions = {
+  userDataPath: string
+  onStdout?: (message: string) => void
+  onStderr?: (message: string) => void
+  onExit?: (code: number) => void
+}
+
 export function getDefaultServerUrl(): string | null {
   const value = getStore().get(DEFAULT_SERVER_URL_KEY)
   return typeof value === "string" ? value : null
@@ -30,6 +54,135 @@ export function preferAppEnv(userDataPath: string) {
   return shellEnv
 }
 
+export async function spawnLocalServer(
+  hostname: string,
+  port: number,
+  password: string,
+  options: SpawnLocalServerOptions,
+) {
+  const sidecar = join(dirname(fileURLToPath(import.meta.url)), "sidecar.js")
+  const child = utilityProcess.fork(sidecar, [], {
+    cwd: process.cwd(),
+    env: createSidecarEnv(),
+    serviceName: SIDECAR_SERVICE_NAME,
+    stdio: "pipe",
+  })
+  let exited = false
+  const exit = defer<number>()
+
+  const onProcessGone = (_event: unknown, details: Details) => {
+    if (details.type !== "Utility" || details.name !== SIDECAR_SERVICE_NAME) return
+    options.onStderr?.(`utility process gone reason=${details.reason} exitCode=${details.exitCode}`)
+  }
+
+  app.on("child-process-gone", onProcessGone)
+  child.once("exit", (code) => {
+    exited = true
+    app.off("child-process-gone", onProcessGone)
+    options.onExit?.(code)
+    exit.resolve(code)
+  })
+  child.on("error", (error) => options.onStderr?.(`utility process error: ${serializeError(error).message}`))
+
+  child.stdout?.on("data", (chunk: Buffer) => options.onStdout?.(chunk.toString("utf8").trimEnd()))
+  child.stderr?.on("data", (chunk: Buffer) => options.onStderr?.(chunk.toString("utf8").trimEnd()))
+
+  await new Promise<void>((resolve, reject) => {
+    let done = false
+    let timeout: NodeJS.Timeout
+
+    const fail = (error: Error) => {
+      if (done) return
+      done = true
+      cleanup()
+      reject(error)
+    }
+
+    const refreshTimeout = () => {
+      clearTimeout(timeout)
+      timeout = setTimeout(() => {
+        fail(new Error(`Sidecar did not become ready within ${SIDECAR_START_STALL_TIMEOUT}ms: ${sidecar}`))
+      }, SIDECAR_START_STALL_TIMEOUT)
+    }
+
+    const onMessage = (message: SidecarMessage) => {
+      if (message.type === "ready") {
+        if (done) return
+        done = true
+        cleanup()
+        resolve()
+        return
+      }
+      if (message.type === "error") {
+        fail(Object.assign(new Error(message.error.message), { stack: message.error.stack }))
+      }
+    }
+    const onExit = (code: number) => {
+      fail(new Error(`Sidecar exited before ready with code ${code}`))
+    }
+    const cleanup = () => {
+      clearTimeout(timeout)
+      child.off("message", onMessage)
+      child.off("exit", onExit)
+    }
+
+    child.on("message", onMessage)
+    child.on("exit", onExit)
+    refreshTimeout()
+    child.postMessage({
+      type: "start",
+      hostname,
+      port,
+      password,
+      userDataPath: options.userDataPath,
+    })
+  }).catch((error) => {
+    if (!exited) child.kill()
+    throw error
+  })
+
+  const wait = (async () => {
+    const url = `http://${hostname}:${port}`
+    let healthy = false
+    const gone = exit.promise.then((code) => {
+      if (healthy) return
+      throw new Error(`Sidecar exited before health check passed with code ${code}`)
+    })
+
+    const ready = async () => {
+      while (true) {
+        await new Promise((resolve) => setTimeout(resolve, 100))
+        if (await checkHealth(url, password)) {
+          healthy = true
+          return
+        }
+      }
+    }
+
+    await Promise.race([ready(), gone])
+  })()
+
+  let stopping: Promise<void> | undefined
+
+  return {
+    listener: {
+      stop: () => {
+        if (stopping) return stopping
+        if (exited) return Promise.resolve()
+        child.postMessage({ type: "stop" })
+        stopping = Promise.race([
+          exit.promise.then(() => undefined),
+          delay(SIDECAR_STOP_TIMEOUT).then(() => {
+            if (!exited) child.kill()
+          }),
+        ])
+        return stopping
+      },
+    },
+    health: { wait },
+  }
+}
+
 export async function checkHealth(url: string, password?: string | null): Promise<boolean> {
   let healthUrls: URL[]
   try {
@@ -56,3 +209,31 @@ export async function checkHealth(url: string, password?: string | null): Promis
   }
   return false
 }
+
+function createSidecarEnv(): Record<string, string> {
+  const env = Object.fromEntries(
+    Object.entries(process.env).flatMap(([key, value]) => (value === undefined ? [] : [[key, String(value)]])),
+  )
+  delete env.DEBUG
+  if (process.platform === "linux") delete env.LD_PRELOAD
+  return env
+}
+
+function delay(ms: number) {
+  return new Promise<void>((resolve) => setTimeout(resolve, ms))
+}
+
+function serializeError(error: unknown) {
+  if (error instanceof Error) return { message: error.message, stack: error.stack }
+  return { message: String(error) }
+}
+
+function defer<T>() {
+  let resolve!: (value: T) => void
+  let reject!: (error: Error) => void
+  const promise = new Promise<T>((res, rej) => {
+    resolve = res
+    reject = rej
+  })
+  return { promise, resolve, reject }
+}

packages/desktop/src/main/sidecar.ts

@@ -0,0 +1,157 @@
+import * as http from "node:http"
+import * as tls from "node:tls"
+
+type NodeHttpWithEnvProxy = typeof http & {
+  setGlobalProxyFromEnv: () => void
+}
+
+type NodeTlsWithSystemCertificates = typeof tls & {
+  getCACertificates: (type: "default" | "system") => string[]
+  setDefaultCACertificates: (certificates: string[]) => void
+}
+
+type StartCommand = {
+  type: "start"
+  hostname: string
+  port: number
+  password: string
+  userDataPath: string
+}
+
+type StopCommand = { type: "stop" }
+type SidecarCommand = StartCommand | StopCommand
+
+type SidecarMessage =
+  | { type: "ready" }
+  | { type: "stopped" }
+  | { type: "error"; error: { message: string; stack?: string } }
+
+type ParentPort = {
+  postMessage(message: SidecarMessage): void
+  on(event: "message", listener: (event: { data: unknown }) => void): void
+}
+
+type Listener = {
+  stop(close?: boolean): void | Promise<void>
+}
+
+const parentPort = getParentPort()
+let listener: Listener | undefined
+
+parentPort.on("message", (event) => {
+  const command = parseCommand(event.data)
+  if (!command) return
+  if (command.type === "stop") {
+    void stop()
+    return
+  }
+  void start(command)
+})
+
+async function start(command: StartCommand) {
+  try {
+    prepareSidecarEnv(command.password, command.userDataPath)
+    ensureLoopbackNoProxy()
+    useSystemCertificates()
+    useEnvProxy()
+    const { Server } = await import("virtual:opencode-server")
+
+    listener = await Server.listen({
+      port: command.port,
+      hostname: command.hostname,
+      username: "opencode",
+      password: command.password,
+      cors: ["oc://renderer"],
+    })
+    parentPort.postMessage({ type: "ready" })
+  } catch (error) {
+    parentPort.postMessage({ type: "error", error: serializeError(error) })
+    setImmediate(() => process.exit(1))
+  }
+}
+
+async function stop() {
+  try {
+    await listener?.stop()
+  } finally {
+    listener = undefined
+    parentPort.postMessage({ type: "stopped" })
+    setImmediate(() => process.exit(0))
+  }
+}
+
+function prepareSidecarEnv(password: string, userDataPath: string) {
+  Object.assign(process.env, {
+    OPENCODE_SERVER_USERNAME: "opencode",
+    OPENCODE_SERVER_PASSWORD: password,
+    XDG_STATE_HOME: process.env.XDG_STATE_HOME ?? userDataPath,
+  })
+}
+
+function ensureLoopbackNoProxy() {
+  const loopback = ["127.0.0.1", "localhost", "::1"]
+  const upsert = (key: string) => {
+    const items = (process.env[key] ?? "")
+      .split(",")
+      .map((value: string) => value.trim())
+      .filter((value: string) => Boolean(value))
+
+    for (const host of loopback) {
+      if (items.some((value: string) => value.toLowerCase() === host)) continue
+      items.push(host)
+    }
+
+    process.env[key] = items.join(",")
+  }
+
+  upsert("NO_PROXY")
+  upsert("no_proxy")
+}
+
+function useSystemCertificates() {
+  try {
+    const nodeTls = tls as NodeTlsWithSystemCertificates
+    nodeTls.setDefaultCACertificates([
+      ...new Set([...nodeTls.getCACertificates("default"), ...nodeTls.getCACertificates("system")]),
+    ])
+  } catch (error) {
+    console.warn("failed to load system certificates", error)
+  }
+}
+
+function useEnvProxy() {
+  try {
+    ;(http as NodeHttpWithEnvProxy).setGlobalProxyFromEnv()
+  } catch (error) {
+    console.warn("failed to load proxy environment", error)
+  }
+}
+
+function parseCommand(value: unknown): SidecarCommand | undefined {
+  if (!value || typeof value !== "object") return
+  const command = value as Partial<StartCommand | StopCommand>
+  if (command.type === "stop") return { type: "stop" }
+  if (command.type !== "start") return
+  if (typeof command.hostname !== "string") return
+  if (typeof command.port !== "number") return
+  if (typeof command.password !== "string") return
+  if (typeof command.userDataPath !== "string") return
+  return {
+    type: "start",
+    hostname: command.hostname,
+    port: command.port,
+    password: command.password,
+    userDataPath: command.userDataPath,
+  }
+}
+
+function serializeError(error: unknown) {
+  if (error instanceof Error) return { message: error.message, stack: error.stack }
+  return { message: String(error) }
+}
+
+function getParentPort() {
+  const port = process.parentPort as ParentPort | undefined
+  if (!port) throw new Error("Sidecar parent port unavailable")
+  return port
+}

packages/desktop/src/preload/index.ts

@@ -12,6 +12,7 @@ const updaterHandler = (_: unknown, state: UpdaterState) => {
 
 const api: ElectronAPI = {
   killSidecar: () => ipcRenderer.invoke("kill-sidecar"),
+  installCli: () => ipcRenderer.invoke("install-cli"),
   awaitInitialization: () => ipcRenderer.invoke("await-initialization"),
   wslServers: {
     getState: () => ipcRenderer.invoke("wsl-servers-get-state"),

packages/desktop/src/preload/types.ts

@@ -43,6 +43,7 @@ export type FatalRendererError = {
 
 export type ElectronAPI = {
   killSidecar: () => Promise<void>
+  installCli: () => Promise<string>
   awaitInitialization: () => Promise<ServerReadyData>
   wslServers: WslServersAPI
   updater: UpdaterAPI

packages/desktop/src/renderer/cli.ts

@@ -0,0 +1,12 @@
+import { initI18n, t } from "./i18n"
+
+export async function installCli(): Promise<void> {
+  await initI18n()
+
+  try {
+    const path = await window.api.installCli()
+    window.alert(t("desktop.cli.installed.message", { path }))
+  } catch (e) {
+    window.alert(t("desktop.cli.failed.message", { error: String(e) }))
+  }
+}

packages/desktop/src/renderer/i18n/ar.ts

@@ -1,5 +1,6 @@
 export const dict = {
   "desktop.menu.checkForUpdates": "التحقق من وجود تحديثات...",
+  "desktop.menu.installCli": "تثبيت CLI...",
   "desktop.menu.reloadWebview": "إعادة تحميل Webview",
   "desktop.menu.restart": "إعادة تشغيل",
 
@@ -17,4 +18,9 @@ export const dict = {
   "desktop.updater.downloaded.prompt": "تم تنزيل إصدار {{version}} من OpenCode، هل ترغب في تثبيته وإعادة تشغيله؟",
   "desktop.updater.installFailed.title": "فشل التحديث",
   "desktop.updater.installFailed.message": "فشل تثبيت التحديث",
+
+  "desktop.cli.installed.title": "تم تثبيت CLI",
+  "desktop.cli.installed.message": "تم تثبيت CLI في {{path}}\n\nأعد تشغيل الطرفية لاستخدام الأمر 'opencode'.",
+  "desktop.cli.failed.title": "فشل التثبيت",
+  "desktop.cli.failed.message": "فشل تثبيت CLI: {{error}}",
 }

packages/desktop/src/renderer/i18n/br.ts

@@ -1,5 +1,6 @@
 export const dict = {
   "desktop.menu.checkForUpdates": "Verificar atualizações...",
+  "desktop.menu.installCli": "Instalar CLI...",
   "desktop.menu.reloadWebview": "Recarregar Webview",
   "desktop.menu.restart": "Reiniciar",
 
@@ -18,4 +19,9 @@ export const dict = {
     "A versão {{version}} do OpenCode foi baixada. Você gostaria de instalá-la e reiniciar?",
   "desktop.updater.installFailed.title": "Falha na atualização",
   "desktop.updater.installFailed.message": "Falha ao instalar a atualização",
+
+  "desktop.cli.installed.title": "CLI instalada",
+  "desktop.cli.installed.message": "CLI instalada em {{path}}\n\nReinicie seu terminal para usar o comando 'opencode'.",
+  "desktop.cli.failed.title": "Falha na instalação",
+  "desktop.cli.failed.message": "Falha ao instalar a CLI: {{error}}",
 }

packages/desktop/src/renderer/i18n/bs.ts

@@ -1,5 +1,6 @@
 export const dict = {
   "desktop.menu.checkForUpdates": "Provjeri ažuriranja...",
+  "desktop.menu.installCli": "Instaliraj CLI...",
   "desktop.menu.reloadWebview": "Ponovo učitavanje webview-a",
   "desktop.menu.restart": "Restartuj",
 
@@ -18,4 +19,10 @@ export const dict = {
     "Verzija {{version}} OpenCode-a je preuzeta. Želiš li da je instaliraš i ponovo pokreneš aplikaciju?",
   "desktop.updater.installFailed.title": "Ažuriranje nije uspjelo",
   "desktop.updater.installFailed.message": "Neuspjela instalacija ažuriranja",
+
+  "desktop.cli.installed.title": "CLI instaliran",
+  "desktop.cli.installed.message":
+    "CLI je instaliran u {{path}}\n\nRestartuj terminal da bi koristio komandu 'opencode'.",
+  "desktop.cli.failed.title": "Instalacija nije uspjela",
+  "desktop.cli.failed.message": "Neuspjela instalacija CLI-a: {{error}}",
 }

packages/desktop/src/renderer/i18n/da.ts

@@ -1,5 +1,6 @@
 export const dict = {
   "desktop.menu.checkForUpdates": "Tjek for opdateringer...",
+  "desktop.menu.installCli": "Installer CLI...",
   "desktop.menu.reloadWebview": "Genindlæs Webview",
   "desktop.menu.restart": "Genstart",
 
@@ -18,4 +19,10 @@ export const dict = {
     "Version {{version}} af OpenCode er blevet downloadet. Vil du installere den og genstarte?",
   "desktop.updater.installFailed.title": "Opdatering mislykkedes",
   "desktop.updater.installFailed.message": "Kunne ikke installere opdateringen",
+
+  "desktop.cli.installed.title": "CLI installeret",
+  "desktop.cli.installed.message":
+    "CLI installeret i {{path}}\n\nGenstart din terminal for at bruge 'opencode'-kommandoen.",
+  "desktop.cli.failed.title": "Installation mislykkedes",
+  "desktop.cli.failed.message": "Kunne ikke installere CLI: {{error}}",
 }

packages/desktop/src/renderer/i18n/de.ts

@@ -1,5 +1,6 @@
 export const dict = {
   "desktop.menu.checkForUpdates": "Nach Updates suchen...",
+  "desktop.menu.installCli": "CLI installieren...",
   "desktop.menu.reloadWebview": "Webview neu laden",
   "desktop.menu.restart": "Neustart",
 
@@ -18,4 +19,10 @@ export const dict = {
     "Version {{version}} von OpenCode wurde heruntergeladen. Möchten Sie sie installieren und neu starten?",
   "desktop.updater.installFailed.title": "Update fehlgeschlagen",
   "desktop.updater.installFailed.message": "Update konnte nicht installiert werden",
+
+  "desktop.cli.installed.title": "CLI installiert",
+  "desktop.cli.installed.message":
+    "CLI wurde in {{path}} installiert\n\nStarten Sie Ihr Terminal neu, um den Befehl 'opencode' zu verwenden.",
+  "desktop.cli.failed.title": "Installation fehlgeschlagen",
+  "desktop.cli.failed.message": "CLI konnte nicht installiert werden: {{error}}",
 }

packages/desktop/src/renderer/i18n/en.ts

@@ -1,5 +1,6 @@
 export const dict = {
   "desktop.menu.checkForUpdates": "Check for Updates...",
+  "desktop.menu.installCli": "Install CLI...",
   "desktop.menu.reloadWebview": "Reload Webview",
   "desktop.menu.restart": "Restart",
 
@@ -18,4 +19,9 @@ export const dict = {
     "Version {{version}} of OpenCode has been downloaded, would you like to install it and relaunch?",
   "desktop.updater.installFailed.title": "Update Failed",
   "desktop.updater.installFailed.message": "Failed to install update",
+
+  "desktop.cli.installed.title": "CLI Installed",
+  "desktop.cli.installed.message": "CLI installed to {{path}}\n\nRestart your terminal to use the 'opencode' command.",
+  "desktop.cli.failed.title": "Installation Failed",
+  "desktop.cli.failed.message": "Failed to install CLI: {{error}}",
 }

packages/desktop/src/renderer/i18n/es.ts

@@ -1,5 +1,6 @@
 export const dict = {
   "desktop.menu.checkForUpdates": "Buscar actualizaciones...",
+  "desktop.menu.installCli": "Instalar CLI...",
   "desktop.menu.reloadWebview": "Recargar Webview",
   "desktop.menu.restart": "Reiniciar",
 
@@ -18,4 +19,9 @@ export const dict = {
     "Se ha descargado la versión {{version}} de OpenCode. ¿Quieres instalarla y reiniciar?",
   "desktop.updater.installFailed.title": "Actualización fallida",
   "desktop.updater.installFailed.message": "No se pudo instalar la actualización",
+
+  "desktop.cli.installed.title": "CLI instalada",
+  "desktop.cli.installed.message": "CLI instalada en {{path}}\n\nReinicia tu terminal para usar el comando 'opencode'.",
+  "desktop.cli.failed.title": "Instalación fallida",
+  "desktop.cli.failed.message": "No se pudo instalar la CLI: {{error}}",
 }

packages/desktop/src/renderer/i18n/fr.ts

@@ -1,5 +1,6 @@
 export const dict = {
   "desktop.menu.checkForUpdates": "Vérifier les mises à jour...",
+  "desktop.menu.installCli": "Installer la CLI...",
   "desktop.menu.reloadWebview": "Recharger la Webview",
   "desktop.menu.restart": "Redémarrer",
 
@@ -18,4 +19,10 @@ export const dict = {
     "La version {{version}} d'OpenCode a été téléchargée. Voulez-vous l'installer et redémarrer ?",
   "desktop.updater.installFailed.title": "Échec de la mise à jour",
   "desktop.updater.installFailed.message": "Impossible d'installer la mise à jour",
+
+  "desktop.cli.installed.title": "CLI installée",
+  "desktop.cli.installed.message":
+    "CLI installée dans {{path}}\n\nRedémarrez votre terminal pour utiliser la commande 'opencode'.",
+  "desktop.cli.failed.title": "Échec de l'installation",
+  "desktop.cli.failed.message": "Impossible d'installer la CLI : {{error}}",
 }

packages/desktop/src/renderer/i18n/ja.ts

@@ -1,5 +1,6 @@
 export const dict = {
   "desktop.menu.checkForUpdates": "アップデートを確認...",
+  "desktop.menu.installCli": "CLI をインストール...",
   "desktop.menu.reloadWebview": "Webview を再読み込み",
   "desktop.menu.restart": "再起動",
 
@@ -18,4 +19,10 @@ export const dict = {
     "OpenCode のバージョン {{version}} がダウンロードされました。インストールして再起動しますか？",
   "desktop.updater.installFailed.title": "アップデートに失敗しました",
   "desktop.updater.installFailed.message": "アップデートをインストールできませんでした",
+
+  "desktop.cli.installed.title": "CLI をインストールしました",
+  "desktop.cli.installed.message":
+    "CLI を {{path}} にインストールしました\n\nターミナルを再起動して 'opencode' コマンドを使用してください。",
+  "desktop.cli.failed.title": "インストールに失敗しました",
+  "desktop.cli.failed.message": "CLI のインストールに失敗しました: {{error}}",
 }

packages/desktop/src/renderer/i18n/ko.ts

@@ -1,5 +1,6 @@
 export const dict = {
   "desktop.menu.checkForUpdates": "업데이트 확인...",
+  "desktop.menu.installCli": "CLI 설치...",
   "desktop.menu.reloadWebview": "Webview 새로고침",
   "desktop.menu.restart": "다시 시작",
 
@@ -17,4 +18,10 @@ export const dict = {
   "desktop.updater.downloaded.prompt": "OpenCode {{version}} 버전을 다운로드했습니다. 설치하고 다시 실행할까요?",
   "desktop.updater.installFailed.title": "업데이트 실패",
   "desktop.updater.installFailed.message": "업데이트를 설치하지 못했습니다",
+
+  "desktop.cli.installed.title": "CLI 설치됨",
+  "desktop.cli.installed.message":
+    "CLI가 {{path}}에 설치되었습니다\n\n터미널을 다시 시작하여 'opencode' 명령을 사용하세요.",
+  "desktop.cli.failed.title": "설치 실패",
+  "desktop.cli.failed.message": "CLI 설치 실패: {{error}}",
 }

packages/desktop/src/renderer/i18n/no.ts

@@ -1,5 +1,6 @@
 export const dict = {
   "desktop.menu.checkForUpdates": "Se etter oppdateringer...",
+  "desktop.menu.installCli": "Installer CLI...",
   "desktop.menu.reloadWebview": "Last inn Webview på nytt",
   "desktop.menu.restart": "Start på nytt",
 
@@ -18,4 +19,10 @@ export const dict = {
     "Versjon {{version}} av OpenCode er lastet ned. Vil du installere den og starte på nytt?",
   "desktop.updater.installFailed.title": "Oppdatering mislyktes",
   "desktop.updater.installFailed.message": "Kunne ikke installere oppdateringen",
+
+  "desktop.cli.installed.title": "CLI installert",
+  "desktop.cli.installed.message":
+    "CLI installert til {{path}}\n\nStart terminalen på nytt for å bruke 'opencode'-kommandoen.",
+  "desktop.cli.failed.title": "Installasjon mislyktes",
+  "desktop.cli.failed.message": "Kunne ikke installere CLI: {{error}}",
 }

packages/desktop/src/renderer/i18n/pl.ts

@@ -1,5 +1,6 @@
 export const dict = {
   "desktop.menu.checkForUpdates": "Sprawdź aktualizacje...",
+  "desktop.menu.installCli": "Zainstaluj CLI...",
   "desktop.menu.reloadWebview": "Przeładuj Webview",
   "desktop.menu.restart": "Restartuj",
 
@@ -18,4 +19,10 @@ export const dict = {
     "Pobrano wersję {{version}} OpenCode. Czy chcesz ją zainstalować i uruchomić ponownie?",
   "desktop.updater.installFailed.title": "Aktualizacja nie powiodła się",
   "desktop.updater.installFailed.message": "Nie udało się zainstalować aktualizacji",
+
+  "desktop.cli.installed.title": "CLI zainstalowane",
+  "desktop.cli.installed.message":
+    "CLI zainstalowane w {{path}}\n\nUruchom ponownie terminal, aby użyć polecenia 'opencode'.",
+  "desktop.cli.failed.title": "Instalacja nie powiodła się",
+  "desktop.cli.failed.message": "Nie udało się zainstalować CLI: {{error}}",
 }

packages/desktop/src/renderer/i18n/ru.ts

@@ -1,5 +1,6 @@
 export const dict = {
   "desktop.menu.checkForUpdates": "Проверить обновления...",
+  "desktop.menu.installCli": "Установить CLI...",
   "desktop.menu.reloadWebview": "Перезагрузить Webview",
   "desktop.menu.restart": "Перезапустить",
 
@@ -17,4 +18,10 @@ export const dict = {
   "desktop.updater.downloaded.prompt": "Версия OpenCode {{version}} загружена. Хотите установить и перезапустить?",
   "desktop.updater.installFailed.title": "Обновление не удалось",
   "desktop.updater.installFailed.message": "Не удалось установить обновление",
+
+  "desktop.cli.installed.title": "CLI установлен",
+  "desktop.cli.installed.message":
+    "CLI установлен в {{path}}\n\nПерезапустите терминал, чтобы использовать команду 'opencode'.",
+  "desktop.cli.failed.title": "Ошибка установки",
+  "desktop.cli.failed.message": "Не удалось установить CLI: {{error}}",
 }

packages/desktop/src/renderer/i18n/uk.ts

@@ -1,5 +1,6 @@
 export const dict = {
   "desktop.menu.checkForUpdates": "Перевірити оновлення...",
+  "desktop.menu.installCli": "Встановити CLI...",
   "desktop.menu.reloadWebview": "Перезавантажити Webview",
   "desktop.menu.restart": "Перезапустити",
 
@@ -18,4 +19,10 @@ export const dict = {
     "Версію {{version}} OpenCode завантажено. Бажаєте встановити її та перезапустити?",
   "desktop.updater.installFailed.title": "Помилка оновлення",
   "desktop.updater.installFailed.message": "Не вдалося встановити оновлення",
+
+  "desktop.cli.installed.title": "CLI встановлено",
+  "desktop.cli.installed.message":
+    "CLI встановлено до {{path}}\n\nПерезапустіть термінал, щоб використовувати команду 'opencode'.",
+  "desktop.cli.failed.title": "Не вдалося встановити",
+  "desktop.cli.failed.message": "Не вдалося встановити CLI: {{error}}",
 }

packages/desktop/src/renderer/i18n/zh.ts

@@ -1,5 +1,6 @@
 export const dict = {
   "desktop.menu.checkForUpdates": "检查更新...",
+  "desktop.menu.installCli": "安装 CLI...",
   "desktop.menu.reloadWebview": "重新加载 Webview",
   "desktop.menu.restart": "重启",
 
@@ -17,4 +18,9 @@ export const dict = {
   "desktop.updater.downloaded.prompt": "已下载 OpenCode {{version}} 版本，是否安装并重启？",
   "desktop.updater.installFailed.title": "更新失败",
   "desktop.updater.installFailed.message": "无法安装更新",
+
+  "desktop.cli.installed.title": "CLI 已安装",
+  "desktop.cli.installed.message": "CLI 已安装到 {{path}}\n\n重启终端以使用 'opencode' 命令。",
+  "desktop.cli.failed.title": "安装失败",
+  "desktop.cli.failed.message": "无法安装 CLI: {{error}}",
 }

packages/desktop/src/renderer/i18n/zht.ts

@@ -1,5 +1,6 @@
 export const dict = {
   "desktop.menu.checkForUpdates": "檢查更新...",
+  "desktop.menu.installCli": "安裝 CLI...",
   "desktop.menu.reloadWebview": "重新載入 Webview",
   "desktop.menu.restart": "重新啟動",
 
@@ -17,4 +18,9 @@ export const dict = {
   "desktop.updater.downloaded.prompt": "已下載 OpenCode {{version}} 版本，是否安裝並重新啟動？",
   "desktop.updater.installFailed.title": "更新失敗",
   "desktop.updater.installFailed.message": "無法安裝更新",
+
+  "desktop.cli.installed.title": "CLI 已安裝",
+  "desktop.cli.installed.message": "CLI 已安裝到 {{path}}\n\n重新啟動終端機以使用 'opencode' 命令。",
+  "desktop.cli.failed.title": "安裝失敗",
+  "desktop.cli.failed.message": "無法安裝 CLI: {{error}}",
 }

packages/effect-sqlite-node/package.json

@@ -0,0 +1,22 @@
+{
+  "$schema": "https://json.schemastore.org/package.json",
+  "version": "1.18.8",
+  "name": "@opencode-ai/effect-sqlite-node",
+  "type": "module",
+  "license": "MIT",
+  "private": true,
+  "scripts": {
+    "typecheck": "tsgo --noEmit"
+  },
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "devDependencies": {
+    "@tsconfig/bun": "catalog:",
+    "@types/node": "catalog:",
+    "@typescript/native-preview": "catalog:"
+  },
+  "dependencies": {
+    "effect": "catalog:"
+  }
+}

packages/effect-sqlite-node/src/index.ts

@@ -0,0 +1,171 @@
+export * as NodeSqliteClient from "./index"
+
+import { DatabaseSync, type SQLInputValue } from "node:sqlite"
+import { identity } from "effect/Function"
+import * as Context from "effect/Context"
+import * as Effect from "effect/Effect"
+import * as Fiber from "effect/Fiber"
+import * as Layer from "effect/Layer"
+import * as Scope from "effect/Scope"
+import * as Semaphore from "effect/Semaphore"
+import * as Stream from "effect/Stream"
+import * as Reactivity from "effect/unstable/reactivity/Reactivity"
+import * as Client from "effect/unstable/sql/SqlClient"
+import type { Connection } from "effect/unstable/sql/SqlConnection"
+import { classifySqliteError, SqlError } from "effect/unstable/sql/SqlError"
+import * as Statement from "effect/unstable/sql/Statement"
+
+const ATTR_DB_SYSTEM_NAME = "db.system.name"
+
+export const TypeId: TypeId = "~@opencode-ai/effect-sqlite-node/NodeSqliteClient"
+export type TypeId = "~@opencode-ai/effect-sqlite-node/NodeSqliteClient"
+
+export interface SqliteClient extends Client.SqlClient {
+  readonly [TypeId]: TypeId
+  readonly config: SqliteClientConfig
+  readonly loadExtension: (path: string) => Effect.Effect<void, SqlError>
+  readonly updateValues: never
+}
+
+export const SqliteClient = Context.Service<SqliteClient>("@opencode-ai/effect-sqlite-node/NodeSqliteClient")
+
+export interface SqliteClientConfig {
+  readonly filename: string
+  readonly readonly?: boolean | undefined
+  readonly create?: boolean | undefined
+  readonly readwrite?: boolean | undefined
+  readonly disableWAL?: boolean | undefined
+  readonly timeout?: number | undefined
+  readonly allowExtension?: boolean | undefined
+  readonly spanAttributes?: Record<string, unknown> | undefined
+  readonly transformResultNames?: ((str: string) => string) | undefined
+  readonly transformQueryNames?: ((str: string) => string) | undefined
+}
+
+interface SqliteConnection extends Connection {
+  readonly loadExtension: (path: string) => Effect.Effect<void, SqlError>
+}
+
+export const make = (
+  options: SqliteClientConfig,
+): Effect.Effect<SqliteClient, never, Scope.Scope | Reactivity.Reactivity> =>
+  Effect.gen(function* () {
+    const compiler = Statement.makeCompilerSqlite(options.transformQueryNames)
+    const transformRows = options.transformResultNames
+      ? Statement.defaultTransforms(options.transformResultNames).array
+      : undefined
+
+    const makeConnection = Effect.gen(function* () {
+      const db = new DatabaseSync(options.filename, {
+        readOnly: options.readonly,
+        timeout: options.timeout,
+        allowExtension: options.allowExtension,
+        enableForeignKeyConstraints: true,
+        open: true,
+      })
+      yield* Effect.addFinalizer(() => Effect.sync(() => db.close()))
+
+      if (options.disableWAL !== true && options.readonly !== true) {
+        db.exec("PRAGMA journal_mode = WAL;")
+      }
+
+      const run = (sql: string, params: ReadonlyArray<unknown> = []) =>
+        Effect.withFiber<Array<Record<string, unknown>>, SqlError>((fiber) => {
+          const statement = db.prepare(sql)
+          statement.setReadBigInts(Context.get(fiber.context, Client.SafeIntegers))
+          try {
+            return Effect.succeed(statement.all(...(params as SQLInputValue[])) as Array<Record<string, unknown>>)
+          } catch (cause) {
+            return Effect.fail(
+              new SqlError({
+                reason: classifySqliteError(cause, { message: "Failed to execute statement", operation: "execute" }),
+              }),
+            )
+          }
+        })
+
+      const runValues = (sql: string, params: ReadonlyArray<unknown> = []) =>
+        Effect.withFiber<ReadonlyArray<ReadonlyArray<unknown>>, SqlError>((fiber) => {
+          const statement = db.prepare(sql)
+          statement.setReadBigInts(Context.get(fiber.context, Client.SafeIntegers))
+          statement.setReturnArrays(true)
+          try {
+            return Effect.succeed(
+              statement.all(...(params as SQLInputValue[])) as unknown as ReadonlyArray<ReadonlyArray<unknown>>,
+            )
+          } catch (cause) {
+            return Effect.fail(
+              new SqlError({
+                reason: classifySqliteError(cause, { message: "Failed to execute statement", operation: "execute" }),
+              }),
+            )
+          }
+        })
+
+      return identity<SqliteConnection>({
+        execute(sql, params, transformRows) {
+          return transformRows ? Effect.map(run(sql, params), transformRows) : run(sql, params)
+        },
+        executeRaw(sql, params) {
+          return run(sql, params)
+        },
+        executeValues(sql, params) {
+          return runValues(sql, params)
+        },
+        executeValuesUnprepared(sql, params) {
+          return runValues(sql, params)
+        },
+        executeUnprepared(sql, params, transformRows) {
+          return this.execute(sql, params, transformRows)
+        },
+        executeStream() {
+          return Stream.die("executeStream not implemented")
+        },
+        loadExtension: (path) =>
+          Effect.try({
+            try: () => db.loadExtension(path),
+            catch: (cause) =>
+              new SqlError({
+                reason: classifySqliteError(cause, { message: "Failed to load extension", operation: "loadExtension" }),
+              }),
+          }),
+      })
+    })
+
+    const semaphore = yield* Semaphore.make(1)
+    const connection = yield* makeConnection
+    const acquirer = semaphore.withPermits(1)(Effect.succeed(connection))
+    const transactionAcquirer = Effect.uninterruptibleMask((restore) => {
+      const fiber = Fiber.getCurrent()!
+      const scope = Context.getUnsafe(fiber.context, Scope.Scope)
+      return Effect.as(
+        Effect.tap(restore(semaphore.take(1)), () => Scope.addFinalizer(scope, semaphore.release(1))),
+        connection,
+      )
+    })
+
+    return Object.assign(
+      (yield* Client.make({
+        acquirer,
+        compiler,
+        transactionAcquirer,
+        spanAttributes: [
+          ...(options.spanAttributes ? Object.entries(options.spanAttributes) : []),
+          [ATTR_DB_SYSTEM_NAME, "sqlite"],
+        ],
+        transformRows,
+      })) as SqliteClient,
+      {
+        [TypeId]: TypeId as TypeId,
+        config: options,
+        loadExtension: (path: string) => Effect.flatMap(acquirer, (_) => _.loadExtension(path)),
+      },
+    )
+  })
+
+export const layer = (config: SqliteClientConfig): Layer.Layer<SqliteClient | Client.SqlClient> =>
+  Layer.effectContext(
+    Effect.map(make(config), (client) =>
+      Context.make(SqliteClient, client).pipe(Context.add(Client.SqlClient, client)),
+    ),
+  ).pipe(Layer.provide(Reactivity.layer))

packages/effect-sqlite-node/sst-env.d.ts

@@ -0,0 +1,10 @@
+/* This file is auto-generated by SST. Do not edit. */
+/* tslint:disable */
+/* eslint-disable */
+/* deno-fmt-ignore-file */
+/* biome-ignore-all lint: auto-generated */
+
+/// <reference path="../../sst-env.d.ts" />
+
+import "sst"
+export {}

packages/effect-sqlite-node/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "extends": "@tsconfig/bun/tsconfig.json",
+  "compilerOptions": {
+    "lib": ["ESNext", "DOM", "DOM.Iterable"],
+    "noUncheckedIndexedAccess": false,
+    "plugins": [
+      {
+        "name": "@effect/language-service",
+        "transform": "@effect/language-service/transform",
+        "namespaceImportPackages": ["effect", "@effect/*"]
+      }
+    ]
+  }
+}

packages/sdk-next/test/embedded.test.ts

@@ -207,7 +207,7 @@ it.live(
   () =>
     withEmbedded("opencode-embedded-", (fixture) =>
       Effect.gen(function* () {
-        const opencode = yield* fixture.sdk.OpenCode.create({ events: { persist: true } })
+        const opencode = yield* fixture.sdk.OpenCode.create()
         const id = sessionID(fixture)
         const model = fixture.sdk.Model.Ref.make({
           id: fixture.sdk.Model.ID.make("embedded"),
@@ -266,7 +266,7 @@ it.live(
         const wakeContext = yield* opencode.sessions.context({ sessionID: id })
         const pendingAfterPromote = yield* opencode.sessions.pending.list({ sessionID: id })
         const event = yield* opencode.sessions.log({ sessionID: id }).pipe(
-          Stream.filter((item) => item.type === "session.model.selected"),
+          Stream.filter((item) => item.type !== "log.synced"),
           Stream.take(1),
           Stream.runHead,
           Effect.map(Option.getOrUndefined),

packages/server/src/options.ts

@@ -18,11 +18,6 @@ export const ServerOptions = Schema.Struct({
   password: Schema.optional(Schema.String),
   simulation: Schema.optional(Schema.Boolean),
   database: Schema.optional(Database.Options),
-  events: Schema.optional(
-    Schema.Struct({
-      persist: Schema.optional(Schema.Boolean),
-    }),
-  ),
   models: Schema.optional(ModelsDev.Options),
   observability: Schema.optional(Observability.Options),
   config: Schema.optional(

packages/server/src/routes.ts

@@ -83,7 +83,6 @@ function makeRoutes<AuthError, AuthServices>(
   const pluginRuntimeCell = PluginRuntime.makeCell()
   const replacements: LayerNode.Replacements = [
     [Database.node, Database.configured(options.database)],
-    [Bus.node, Bus.configured({ persist: options.events?.persist })],
     [App.node, App.configured(options.app)],
     [ModelsDev.node, ModelsDev.configured(options.models)],
     [Watcher.node, Watcher.configured({ enabled: options.fs?.filewatcher })],

packages/server/test/options.test.ts

@@ -18,7 +18,3 @@ test("accepts optional app metadata", () => {
     Option.getOrThrow(decode({ app: { name: "sdk", version: "1.2.3", channel: "beta" } })).app,
   ).toEqual({ name: "sdk", version: "1.2.3", channel: "beta" })
 })
-
-test("accepts durable event persistence configuration", () => {
-  expect(Option.getOrThrow(decode({ events: { persist: true } })).events).toEqual({ persist: true })
-})

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/session-ui/src/v2/components/session-file-panel-v2.tsx

@@ -34,6 +34,10 @@ export function SessionFilePanelV2(props: {
   )
 }
 
+export function SessionFilePanelV2Title(props: ParentProps) {
+  return <div data-slot="session-review-v2-toolbar-title">{props.children}</div>
+}
+
 export function SessionFilePanelV2Empty(props: ParentProps) {
   return <div data-slot="session-review-v2-empty">{props.children}</div>
 }

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

@@ -7,14 +7,12 @@ import { DialogVariant } from "./dialog-variant"
 import * as fuzzysort from "fuzzysort"
 import { useConnected } from "./use-connected"
 import { useData } from "../context/data"
-import { modelPreferenceKey } from "../model-preference"
 
 export function DialogModel(props: { providerID?: string }) {
   const local = useLocal()
   const data = useData()
   const dialog = useDialog()
   const [query, setQuery] = createSignal("")
-  const favoritePriority = new Set(local.model.favorite().map(modelPreferenceKey))
 
   const connected = useConnected()
   const providers = createMemo(() => new Map((data.location.provider.list() ?? []).map((item) => [item.id, item])))
@@ -65,14 +63,14 @@ export function DialogModel(props: { providerID?: string }) {
         .filter((model) => (props.providerID ? model.providerID === props.providerID : true))
         .map((model) => {
           const provider = providers().get(model.providerID)
-          const key = modelPreferenceKey({ providerID: model.providerID, modelID: model.id })
-          const favorite = favorites.some((item) => modelPreferenceKey(item) === key)
+          const favorite = favorites.some((item) => item.providerID === model.providerID && item.modelID === model.id)
           return {
             value: { providerID: model.providerID, modelID: model.id },
             providerID: model.providerID,
             providerName: provider?.name ?? model.providerID,
             title: model.name,
             releaseDate: model.time.released,
+            favorite,
             description: favorite ? "(Favorite)" : undefined,
             category: connected() ? (provider?.name ?? model.providerID) : undefined,
             footer: free(model) ? "Free" : undefined,
@@ -100,7 +98,6 @@ export function DialogModel(props: { providerID?: string }) {
     if (needle) {
       return prioritizeFavorites(
         fuzzysort.go(needle, modelOptions, { keys: ["title", "category"] }).map((item) => item.obj),
-        favoritePriority,
       )
     }
 
@@ -165,13 +162,8 @@ export function DialogModel(props: { providerID?: string }) {
   )
 }
 
-export function prioritizeFavorites<T extends { value: { providerID: string; modelID: string } }>(
-  options: T[],
-  favorites: Set<string>,
-) {
-  return options.toSorted(
-    (a, b) => Number(favorites.has(modelPreferenceKey(b.value))) - Number(favorites.has(modelPreferenceKey(a.value))),
-  )
+export function prioritizeFavorites<T extends { favorite: boolean }>(options: T[]) {
+  return options.toSorted((a, b) => Number(b.favorite) - Number(a.favorite))
 }
 
 export function sortModelOptions<

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

@@ -157,9 +157,13 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
       })
     })
 
-    // Load lightweight session metadata concurrently so persisted tabs can resolve their project
-    // labels immediately. Delay the heavier per-tab data so the visible session keeps the first
-    // connection slots and switches still render from a warm cache.
+    // Warm open tabs' session data so first switches render from cache instead of fetching inside
+    // the switch gesture. Uses only existing sync methods (each dedupes internally), so reruns on
+    // tab-set or connection changes are no-ops for already-warm sessions, and reconnects double as
+    // a cache refresh after an SSE gap. The delay lets the current session's own mount syncs get
+    // the first connection slots. The effect tracks only the id set: reorders, tab switches, and
+    // title updates neither restart the timer nor an in-flight warm pass; the timer callback
+    // itself runs untracked, where the current session is skipped.
     const openTabSessions = createMemo(() =>
       state()
         .tabs.map((tab) => tab.sessionID)
@@ -169,9 +173,7 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
     createEffect(() => {
       if (!enabled()) return
       if (client.connection.status() !== "connected") return
-      const sessionIDs = openTabSessions()
-      if (sessionIDs === "") return
-      void Promise.allSettled(sessionIDs.split("\n").map((sessionID) => data.session.sync(sessionID)))
+      if (openTabSessions() === "") return
       let stale = false
       const timer = setTimeout(async () => {
         const sessions = state()
@@ -180,6 +182,7 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
         for (const sessionID of sessions) {
           if (stale) return
           await Promise.allSettled([
+            data.session.sync(sessionID),
             data.session.message.sync(sessionID),
             data.session.pending.sync(sessionID),
             data.session.permission.sync(sessionID),