fix(app): more startup perf

This reverts commit 898456a25c.

.github/workflows/close-issues.yml

@@ -0,0 +1,24 @@
+name: close-issues
+
+on:
+  schedule:
+    - cron: "0 2 * * *" # Daily at 2:00 AM
+  workflow_dispatch:
+
+jobs:
+  close:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      issues: write
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+
+      - name: Close stale issues
+        env:
+          GITHUB_TOKEN: ${{ github.token }}
+        run: bun script/github/close-issues.ts

.github/workflows/stale-issues.yml

@@ -1,33 +0,0 @@
-name: stale-issues
-
-on:
-  schedule:
-    - cron: "30 1 * * *" # Daily at 1:30 AM
-  workflow_dispatch:
-
-env:
-  DAYS_BEFORE_STALE: 90
-  DAYS_BEFORE_CLOSE: 7
-
-jobs:
-  stale:
-    runs-on: ubuntu-latest
-    permissions:
-      issues: write
-    steps:
-      - uses: actions/stale@v10
-        with:
-          days-before-stale: ${{ env.DAYS_BEFORE_STALE }}
-          days-before-close: ${{ env.DAYS_BEFORE_CLOSE }}
-          stale-issue-label: "stale"
-          close-issue-message: |
-            [automated] Closing due to ${{ env.DAYS_BEFORE_STALE }}+ days of inactivity.
-
-            Feel free to reopen if you still need this!
-          stale-issue-message: |
-            [automated] This issue has had no activity for ${{ env.DAYS_BEFORE_STALE }} days.
-
-            It will be closed in ${{ env.DAYS_BEFORE_CLOSE }} days if there's no new activity.
-          remove-stale-when-updated: true
-          exempt-issue-labels: "pinned,security,feature-request,on-hold"
-          start-date: "2025-12-27"

packages/app/src/app.tsx

@@ -133,7 +133,7 @@ function RouterRoot(props: ParentProps<{ appChildren?: JSX.Element }>) {
 export function AppBaseProviders(props: ParentProps<{ locale?: Locale }>) {
   return (
     <MetaProvider>
-      <Font />
+      <Font preloadMono={false} />
       <ThemeProvider
         onThemeApplied={(_, mode) => {
           void window.api?.setTitlebar?.({ mode })

packages/app/src/components/file-tree.tsx

@@ -17,6 +17,7 @@ import {
   type JSXElement,
   type ParentProps,
 } from "solid-js"
+import { createStore, type SetStoreFunction } from "solid-js/store"
 import { Dynamic } from "solid-js/web"
 import type { FileNode } from "@opencode-ai/sdk/v2"
 
@@ -201,6 +202,7 @@ export default function FileTree(props: {
   modified?: readonly string[]
   kinds?: ReadonlyMap<string, Kind>
   draggable?: boolean
+  synthetic?: boolean
   onFileClick?: (file: FileNode) => void
 
   _filter?: Filter
@@ -208,10 +210,15 @@ export default function FileTree(props: {
   _deeps?: Map<string, number>
   _kinds?: ReadonlyMap<string, Kind>
   _chain?: readonly string[]
+  _open?: Record<string, boolean>
+  _setOpen?: SetStoreFunction<Record<string, boolean>>
 }) {
   const file = useFile()
   const level = props.level ?? 0
   const draggable = () => props.draggable ?? true
+  const local = createStore<Record<string, boolean>>({})
+  const open = props._open ?? local[0]
+  const setOpen = props._setOpen ?? local[1]
 
   const key = (p: string) =>
     file
@@ -258,6 +265,7 @@ export default function FileTree(props: {
 
   const deeps = createMemo(() => {
     if (props._deeps) return props._deeps
+    if (props.synthetic) return new Map<string, number>()
 
     const out = new Map<string, number>()
 
@@ -304,6 +312,7 @@ export default function FileTree(props: {
   })
 
   createEffect(() => {
+    if (props.synthetic) return
     const current = filter()
     const dirs = dirsToExpand({
       level,
@@ -317,6 +326,7 @@ export default function FileTree(props: {
     on(
       () => props.path,
       (path) => {
+        if (props.synthetic) return
         const dir = untrack(() => file.tree.state(path))
         if (!shouldListRoot({ level, dir })) return
         void file.tree.list(path)
@@ -388,7 +398,8 @@ export default function FileTree(props: {
     <div data-component="filetree" class={`flex flex-col gap-0.5 ${props.class ?? ""}`}>
       <For each={nodes()}>
         {(node) => {
-          const expanded = () => file.tree.state(node.path)?.expanded ?? false
+          const expanded = () =>
+            props.synthetic ? (open[node.path] ?? true) : (file.tree.state(node.path)?.expanded ?? false)
           const deep = () => deeps().get(node.path) ?? -1
           const kind = () => visibleKind(node, kinds(), marks())
           const active = () => !!kind() && !node.ignored
@@ -402,7 +413,13 @@ export default function FileTree(props: {
                   data-scope="filetree"
                   forceMount={false}
                   open={expanded()}
-                  onOpenChange={(open) => (open ? file.tree.expand(node.path) : file.tree.collapse(node.path))}
+                  onOpenChange={(open) => {
+                    if (props.synthetic) {
+                      setOpen(node.path, open)
+                      return
+                    }
+                    open ? file.tree.expand(node.path) : file.tree.collapse(node.path)
+                  }}
                 >
                   <Collapsible.Trigger>
                     <FileTreeNode
@@ -435,6 +452,7 @@ export default function FileTree(props: {
                       <FileTree
                         path={node.path}
                         level={level + 1}
+                        synthetic={props.synthetic}
                         allowed={props.allowed}
                         modified={props.modified}
                         kinds={props.kinds}
@@ -446,6 +464,8 @@ export default function FileTree(props: {
                         _deeps={deeps()}
                         _kinds={kinds()}
                         _chain={chain}
+                        _open={open}
+                        _setOpen={setOpen}
                       />
                     </Show>
                   </Collapsible.Content>

packages/app/src/components/prompt-input.tsx

@@ -27,7 +27,6 @@ import { IconButton } from "@opencode-ai/ui/icon-button"
 import { Select } from "@opencode-ai/ui/select"
 import { useDialog } from "@opencode-ai/ui/context/dialog"
 import { ModelSelectorPopover } from "@/components/dialog-select-model"
-import { DialogSelectModelUnpaid } from "@/components/dialog-select-model-unpaid"
 import { useProviders } from "@/hooks/use-providers"
 import { useCommand } from "@/context/command"
 import { Persist, persisted } from "@/utils/persist"
@@ -1494,7 +1493,11 @@ export const PromptInput: Component<PromptInputProps> = (props) => {
                           size="normal"
                           class="min-w-0 max-w-[320px] text-13-regular text-text-base group"
                           style={control()}
-                          onClick={() => dialog.show(() => <DialogSelectModelUnpaid model={local.model} />)}
+                          onClick={() => {
+                            void import("@/components/dialog-select-model-unpaid").then((x) =>
+                              dialog.show(() => <x.DialogSelectModelUnpaid model={local.model} />),
+                            )
+                          }}
                         >
                           <Show when={local.model.current()?.provider?.id}>
                             <ProviderIcon

packages/app/src/context/command-keybind.test.ts

@@ -32,6 +32,25 @@ describe("command keybind helpers", () => {
     expect(matchKeybind(keybinds, new KeyboardEvent("keydown", { key: ",", ctrlKey: true, altKey: true }))).toBe(false)
   })
 
+  test("matchKeybind supports bracket keys", () => {
+    const keybinds = parseKeybind("mod+alt+[, mod+alt+]")
+    const prev = keybinds[0]
+    const next = keybinds[1]
+
+    expect(
+      matchKeybind(
+        keybinds,
+        new KeyboardEvent("keydown", { key: "[", ctrlKey: prev?.ctrl, metaKey: prev?.meta, altKey: true }),
+      ),
+    ).toBe(true)
+    expect(
+      matchKeybind(
+        keybinds,
+        new KeyboardEvent("keydown", { key: "]", ctrlKey: next?.ctrl, metaKey: next?.meta, altKey: true }),
+      ),
+    ).toBe(true)
+  })
+
   test("formatKeybind returns human readable output", () => {
     const display = formatKeybind("ctrl+alt+arrowup")
 

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

@@ -243,12 +243,6 @@ export async function bootstrapDirectory(input: {
   ]
 
   const slow = [
-    () =>
-      retry(() =>
-        input.sdk.provider.list().then((x) => {
-          input.setStore("provider", normalizeProviderList(x.data!))
-        }),
-      ),
     () => Promise.resolve(input.loadSessions(input.directory)),
     () => retry(() => input.sdk.mcp.status().then((x) => input.setStore("mcp", x.data!))),
     () => retry(() => input.sdk.lsp.status().then((x) => input.setStore("lsp", x.data!))),

packages/app/src/context/global-sync/event-reducer.ts

@@ -56,6 +56,22 @@ function cleanupSessionCaches(
   )
 }
 
+function keep(next: Session, prev?: Session) {
+  const diffs = prev?.summary?.diffs
+  const files = prev?.summary?.files
+  if (!diffs?.length) return next
+  if (!next.summary || next.summary.diffs?.length) return next
+  if (next.summary.files <= 0) return next
+  if (next.summary.files !== files) return next
+  return {
+    ...next,
+    summary: {
+      ...next.summary,
+      diffs,
+    },
+  }
+}
+
 export function cleanupDroppedSessionCaches(
   store: Store<State>,
   setStore: SetStoreFunction<State>,
@@ -105,7 +121,7 @@ export function applyDirectoryEvent(input: {
       const info = (event.properties as { info: Session }).info
       const result = Binary.search(input.store.session, info.id, (s) => s.id)
       if (result.found) {
-        input.setStore("session", result.index, reconcile(info))
+        input.setStore("session", result.index, reconcile(keep(info, input.store.session[result.index])))
         break
       }
       const next = input.store.session.slice()
@@ -134,7 +150,7 @@ export function applyDirectoryEvent(input: {
         break
       }
       if (result.found) {
-        input.setStore("session", result.index, reconcile(info))
+        input.setStore("session", result.index, reconcile(keep(info, input.store.session[result.index])))
         break
       }
       const next = input.store.session.slice()

packages/app/src/context/settings.tsx

@@ -1,5 +1,5 @@
 import { createStore, reconcile } from "solid-js/store"
-import { createEffect, createMemo } from "solid-js"
+import { createEffect, createMemo, onCleanup } from "solid-js"
 import { createSimpleContext } from "@opencode-ai/ui/context"
 import { persisted } from "@/utils/persist"
 
@@ -120,7 +120,16 @@ export const { use: useSettings, provider: SettingsProvider } = createSimpleCont
       if (typeof document === "undefined") return
       const id = store.appearance?.font ?? defaultSettings.appearance.font
       if (id !== defaultSettings.appearance.font) {
-        void loadFont().then((x) => x.ensureMonoFont(id))
+        const run = () => {
+          void loadFont().then((x) => x.ensureMonoFont(id))
+        }
+        if (typeof requestIdleCallback === "function") {
+          const idle = requestIdleCallback(run, { timeout: 2000 })
+          onCleanup(() => cancelIdleCallback(idle))
+        } else {
+          const timeout = window.setTimeout(run, 2000)
+          onCleanup(() => window.clearTimeout(timeout))
+        }
       }
       document.documentElement.style.setProperty("--font-family-mono", monoFontFamily(id))
     })

packages/app/src/context/sync.tsx

@@ -180,8 +180,8 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
       return globalSync.child(directory)
     }
     const absolute = (path: string) => (current()[0].path.directory + "/" + path).replace("//", "/")
-    const initialMessagePageSize = 80
-    const historyMessagePageSize = 200
+    const initialMessagePageSize = 40
+    const historyMessagePageSize = 80
     const inflight = new Map<string, Promise<void>>()
     const inflightDiff = new Map<string, Promise<void>>()
     const inflightTodo = new Map<string, Promise<void>>()
@@ -460,13 +460,16 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
               }
             }
 
-            const hasSession = Binary.search(store.session, sessionID, (s) => s.id).found
+            const hit = Binary.search(store.session, sessionID, (s) => s.id)
+            const session = hit.found ? store.session[hit.index] : undefined
+            const hasSession = hit.found
             const cached = store.message[sessionID] !== undefined && meta.limit[key] !== undefined
-            if (cached && hasSession && !opts?.force) return
+            const needs = !!session?.summary?.files && !session.summary?.diffs
+            if (cached && hasSession && !opts?.force && !needs) return
 
             const limit = meta.limit[key] ?? initialMessagePageSize
             const sessionReq =
-              hasSession && !opts?.force
+              hasSession && !opts?.force && !needs
                 ? Promise.resolve()
                 : retry(() => client.session.get({ sessionID })).then((session) => {
                     if (!tracked(directory, sessionID)) return

packages/app/src/entry.tsx

@@ -97,15 +97,10 @@ if (!(root instanceof HTMLElement) && import.meta.env.DEV) {
   throw new Error(getRootNotFoundError())
 }
 
-const localUrl = () =>
-  `http://${import.meta.env.VITE_OPENCODE_SERVER_HOST ?? "localhost"}:${import.meta.env.VITE_OPENCODE_SERVER_PORT ?? "4096"}`
-
-const isLocalHost = () => ["localhost", "127.0.0.1", "0.0.0.0"].includes(location.hostname)
-
 const getCurrentUrl = () => {
-  if (location.hostname.includes("opencode.ai")) return localUrl()
-  if (import.meta.env.DEV) return localUrl()
-  if (isLocalHost()) return localUrl()
+  if (location.hostname.includes("opencode.ai")) return "http://localhost:4096"
+  if (import.meta.env.DEV)
+    return `http://${import.meta.env.VITE_OPENCODE_SERVER_HOST ?? "localhost"}:${import.meta.env.VITE_OPENCODE_SERVER_PORT ?? "4096"}`
   return location.origin
 }
 

packages/app/src/hooks/use-providers.ts

@@ -21,7 +21,7 @@ export function useProviders() {
   const dir = createMemo(() => decode64(params.dir) ?? "")
   const providers = () => {
     if (dir()) {
-      const [projectStore] = globalSync.child(dir())
+      const [projectStore] = globalSync.peek(dir(), { bootstrap: false })
       if (projectStore.provider.all.length > 0) return projectStore.provider
     }
     return globalSync.data.provider

packages/app/src/pages/layout.tsx

@@ -965,6 +965,8 @@ export default function Layout(props: ParentProps) {
         : projects[(index + offset + projects.length) % projects.length]
     if (!target) return
 
+    // warm up child store to prevent flicker
+    globalSync.child(target.worktree)
     openProject(target.worktree)
   }
 

packages/app/src/pages/session.tsx

@@ -158,6 +158,13 @@ function createSessionHistoryWindow(input: SessionHistoryWindowInput) {
     preserveScroll(() => setTurnStart(nextStart))
   }
 
+  const reveal = () => {
+    const start = turnStart()
+    if (start <= 0) return false
+    backfillTurns()
+    return true
+  }
+
   /** Button path: reveal all cached turns, fetch older history, reveal one batch. */
   const loadAndReveal = async () => {
     const id = input.sessionID()
@@ -303,6 +310,7 @@ function createSessionHistoryWindow(input: SessionHistoryWindowInput) {
   return {
     turnStart,
     setTurnStart,
+    reveal,
     renderedUserMessages,
     loadAndReveal,
     onScrollerScroll,
@@ -877,6 +885,7 @@ export default function Page() {
   }
 
   const mobileChanges = createMemo(() => !isDesktop() && store.mobileTab === "changes")
+  const wantsDiff = createMemo(() => (isDesktop() ? desktopReviewOpen() && activeTab() === "review" : mobileChanges()))
 
   const fileTreeTab = () => layout.fileTree.tab()
   const setFileTreeTab = (value: "changes" | "all") => layout.fileTree.setTab(value)
@@ -1074,6 +1083,7 @@ export default function Page() {
   }
 
   const focusReviewDiff = (path: string) => {
+    void tabs().open("review")
     openReviewPanel()
     view().review.openPath(path)
     setTree({ activeDiff: path, pendingDiff: path })
@@ -1124,10 +1134,7 @@ export default function Page() {
     const id = params.id
     if (!id) return
 
-    const wants = isDesktop()
-      ? desktopFileTreeOpen() || (desktopReviewOpen() && activeTab() === "review")
-      : store.mobileTab === "changes"
-    if (!wants) return
+    if (!wantsDiff()) return
     if (sync.data.session_diff[id] !== undefined) return
     if (sync.status === "loading") return
 
@@ -1136,13 +1143,7 @@ export default function Page() {
 
   createEffect(
     on(
-      () =>
-        [
-          sessionKey(),
-          isDesktop()
-            ? desktopFileTreeOpen() || (desktopReviewOpen() && activeTab() === "review")
-            : store.mobileTab === "changes",
-        ] as const,
+      () => [sessionKey(), wantsDiff()] as const,
       ([key, wants]) => {
         if (diffFrame !== undefined) cancelAnimationFrame(diffFrame)
         if (diffTimer !== undefined) window.clearTimeout(diffTimer)
@@ -1167,19 +1168,6 @@ export default function Page() {
     ),
   )
 
-  let treeDir: string | undefined
-  createEffect(() => {
-    const dir = sdk.directory
-    if (!isDesktop()) return
-    if (!layout.fileTree.opened()) return
-    if (sync.status === "loading") return
-
-    fileTreeTab()
-    const refresh = treeDir !== dir
-    treeDir = dir
-    void (refresh ? file.tree.refresh("") : file.tree.list(""))
-  })
-
   createEffect(
     on(
       () => sdk.directory,
@@ -1296,9 +1284,9 @@ export default function Page() {
       const el = scroller
       if (!el) return
       if (el.scrollHeight > el.clientHeight + 1) return
-      if (historyWindow.turnStart() <= 0 && !historyMore()) return
+      if (historyWindow.turnStart() <= 0) return
 
-      void historyWindow.loadAndReveal()
+      historyWindow.reveal()
     })
   }
 
@@ -1309,14 +1297,13 @@ export default function Page() {
           params.id,
           messagesReady(),
           historyWindow.turnStart(),
-          historyMore(),
           historyLoading(),
           autoScroll.userScrolled(),
           visibleUserMessages().length,
         ] as const,
-      ([id, ready, start, more, loading, scrolled]) => {
+      ([id, ready, start, loading, scrolled]) => {
         if (!id || !ready || loading || scrolled) return
-        if (start <= 0 && !more) return
+        if (start <= 0) return
         fill()
       },
       { defer: true },

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

@@ -49,7 +49,6 @@ export const createSessionTabs = (input: TabsInput) => {
     const first = openedTabs()[0]
     if (first) return first
     if (contextOpen()) return "context"
-    if (review() && hasReview()) return "review"
     return "empty"
   })
   const activeFileTab = createMemo(() => {

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

@@ -896,7 +896,8 @@ export function MessageTimeline(props: {
             </Show>
             <div
               role="log"
-              class="flex flex-col gap-12 items-start justify-start pb-16 transition-[margin]"
+              data-slot="session-turn-list"
+              class="flex flex-col items-start justify-start pb-16 transition-[margin]"
               classList={{
                 "w-full": true,
                 "md:max-w-200 md:mx-auto 2xl:max-w-[1000px]": props.centered,

packages/app/src/pages/session/session-side-panel.tsx

@@ -13,7 +13,6 @@ import { useDialog } from "@opencode-ai/ui/context/dialog"
 
 import FileTree from "@/components/file-tree"
 import { SessionContextUsage } from "@/components/session-context-usage"
-import { DialogSelectFile } from "@/components/dialog-select-file"
 import { SessionContextTab, SortableTab, FileVisual } from "@/components/session"
 import { useCommand } from "@/context/command"
 import { useFile, type SelectedLineRange } from "@/context/file"
@@ -56,14 +55,15 @@ export function SessionSidePanel(props: {
 
   const info = createMemo(() => (params.id ? sync.session.get(params.id) : undefined))
   const diffs = createMemo(() => (params.id ? (sync.data.session_diff[params.id] ?? []) : []))
+  const changes = createMemo(() => {
+    const id = params.id
+    if (!id) return []
+    const full = sync.data.session_diff[id]
+    if (full !== undefined) return full
+    return info()?.summary?.diffs ?? []
+  })
   const reviewCount = createMemo(() => Math.max(info()?.summary?.files ?? 0, diffs().length))
   const hasReview = createMemo(() => reviewCount() > 0)
-  const diffsReady = createMemo(() => {
-    const id = params.id
-    if (!id) return true
-    if (!hasReview()) return true
-    return sync.data.session_diff[id] !== undefined
-  })
 
   const reviewEmptyKey = createMemo(() => {
     if (sync.project && !sync.project.vcs) return "session.review.noVcs"
@@ -71,7 +71,7 @@ export function SessionSidePanel(props: {
     return "session.review.noChanges"
   })
 
-  const diffFiles = createMemo(() => diffs().map((d) => d.file))
+  const diffFiles = createMemo(() => changes().map((d) => d.file))
   const kinds = createMemo(() => {
     const merge = (a: "add" | "del" | "mix" | undefined, b: "add" | "del" | "mix") => {
       if (!a) return b
@@ -82,7 +82,7 @@ export function SessionSidePanel(props: {
     const normalize = (p: string) => p.replaceAll("\\\\", "/").replace(/\/+$/, "")
 
     const out = new Map<string, "add" | "del" | "mix">()
-    for (const diff of diffs()) {
+    for (const diff of changes()) {
       const file = normalize(diff.file)
       const kind = diff.status === "added" ? "add" : diff.status === "deleted" ? "del" : "mix"
 
@@ -293,9 +293,11 @@ export function SessionSidePanel(props: {
                             variant="ghost"
                             iconSize="large"
                             class="!rounded-md"
-                            onClick={() =>
-                              dialog.show(() => <DialogSelectFile mode="files" onOpenFile={showAllFiles} />)
-                            }
+                            onClick={() => {
+                              void import("@/components/dialog-select-file").then((x) =>
+                                dialog.show(() => <x.DialogSelectFile mode="files" onOpenFile={showAllFiles} />),
+                              )
+                            }}
                             aria-label={language.t("command.file.open")}
                           />
                         </TooltipKeybind>
@@ -386,26 +388,17 @@ export function SessionSidePanel(props: {
                 </Tabs.List>
                 <Tabs.Content value="changes" class="bg-background-stronger px-3 py-0">
                   <Switch>
-                    <Match when={hasReview()}>
-                      <Show
-                        when={diffsReady()}
-                        fallback={
-                          <div class="px-2 py-2 text-12-regular text-text-weak">
-                            {language.t("common.loading")}
-                            {language.t("common.loading.ellipsis")}
-                          </div>
-                        }
-                      >
-                        <FileTree
-                          path=""
-                          class="pt-3"
-                          allowed={diffFiles()}
-                          kinds={kinds()}
-                          draggable={false}
-                          active={props.activeDiff}
-                          onFileClick={(node) => props.focusReviewDiff(node.path)}
-                        />
-                      </Show>
+                    <Match when={hasReview() && diffFiles().length > 0}>
+                      <FileTree
+                        synthetic
+                        path=""
+                        class="pt-3"
+                        allowed={diffFiles()}
+                        kinds={kinds()}
+                        draggable={false}
+                        active={props.activeDiff}
+                        onFileClick={(node) => props.focusReviewDiff(node.path)}
+                      />
                     </Match>
                     <Match when={true}>
                       {empty(

packages/app/src/pages/session/use-session-commands.tsx

@@ -11,10 +11,6 @@ import { usePrompt } from "@/context/prompt"
 import { useSDK } from "@/context/sdk"
 import { useSync } from "@/context/sync"
 import { useTerminal } from "@/context/terminal"
-import { DialogSelectFile } from "@/components/dialog-select-file"
-import { DialogSelectModel } from "@/components/dialog-select-model"
-import { DialogSelectMcp } from "@/components/dialog-select-mcp"
-import { DialogFork } from "@/components/dialog-fork"
 import { showToast } from "@opencode-ai/ui/toast"
 import { findLast } from "@opencode-ai/util/array"
 import { createSessionTabs } from "@/pages/session/helpers"
@@ -257,7 +253,11 @@ export const useSessionCommands = (actions: SessionCommandContext) => {
         description: language.t("palette.search.placeholder"),
         keybind: "mod+k,mod+p",
         slash: "open",
-        onSelect: () => dialog.show(() => <DialogSelectFile onOpenFile={showAllFiles} />),
+        onSelect: () => {
+          void import("@/components/dialog-select-file").then((x) =>
+            dialog.show(() => <x.DialogSelectFile onOpenFile={showAllFiles} />),
+          )
+        },
       }),
       fileCommand({
         id: "tab.close",
@@ -333,7 +333,7 @@ export const useSessionCommands = (actions: SessionCommandContext) => {
         id: "message.previous",
         title: language.t("command.message.previous"),
         description: language.t("command.message.previous.description"),
-        keybind: "mod+arrowup",
+        keybind: "mod+alt+[",
         disabled: !params.id,
         onSelect: () => navigateMessageByOffset(-1),
       }),
@@ -341,7 +341,7 @@ export const useSessionCommands = (actions: SessionCommandContext) => {
         id: "message.next",
         title: language.t("command.message.next"),
         description: language.t("command.message.next.description"),
-        keybind: "mod+arrowdown",
+        keybind: "mod+alt+]",
         disabled: !params.id,
         onSelect: () => navigateMessageByOffset(1),
       }),
@@ -351,7 +351,11 @@ export const useSessionCommands = (actions: SessionCommandContext) => {
         description: language.t("command.model.choose.description"),
         keybind: "mod+'",
         slash: "model",
-        onSelect: () => dialog.show(() => <DialogSelectModel model={local.model} />),
+        onSelect: () => {
+          void import("@/components/dialog-select-model").then((x) =>
+            dialog.show(() => <x.DialogSelectModel model={local.model} />),
+          )
+        },
       }),
       mcpCommand({
         id: "mcp.toggle",
@@ -359,7 +363,9 @@ export const useSessionCommands = (actions: SessionCommandContext) => {
         description: language.t("command.mcp.toggle.description"),
         keybind: "mod+;",
         slash: "mcp",
-        onSelect: () => dialog.show(() => <DialogSelectMcp />),
+        onSelect: () => {
+          void import("@/components/dialog-select-mcp").then((x) => dialog.show(() => <x.DialogSelectMcp />))
+        },
       }),
       agentCommand({
         id: "agent.cycle",
@@ -487,7 +493,9 @@ export const useSessionCommands = (actions: SessionCommandContext) => {
         description: language.t("command.session.fork.description"),
         slash: "fork",
         disabled: !params.id || visibleUserMessages().length === 0,
-        onSelect: () => dialog.show(() => <DialogFork />),
+        onSelect: () => {
+          void import("@/components/dialog-fork").then((x) => dialog.show(() => <x.DialogFork />))
+        },
       }),
       ...share,
     ]

packages/desktop-electron/src/main/ipc.ts

@@ -88,7 +88,7 @@ export function registerIpcHandlers(deps: Deps) {
     "open-directory-picker",
     async (_event: IpcMainInvokeEvent, opts?: { multiple?: boolean; title?: string; defaultPath?: string }) => {
       const result = await dialog.showOpenDialog({
-        properties: ["openDirectory", ...(opts?.multiple ? ["multiSelections" as const] : [])],
+        properties: ["openDirectory", ...(opts?.multiple ? ["multiSelections" as const] : []), "createDirectory"],
         title: opts?.title ?? "Choose a folder",
         defaultPath: opts?.defaultPath,
       })

packages/desktop-electron/src/main/store.ts

@@ -7,7 +7,7 @@ const cache = new Map<string, Store>()
 export function getStore(name = SETTINGS_STORE) {
   const cached = cache.get(name)
   if (cached) return cached
-  const next = new Store({ name })
+  const next = new Store({ name, fileExtension: "" })
   cache.set(name, next)
   return next
 }

packages/opencode/script/build.ts

@@ -21,10 +21,14 @@ const modelsData = process.env.MODELS_DEV_API_JSON
   ? await Bun.file(process.env.MODELS_DEV_API_JSON).text()
   : await fetch(`${modelsUrl}/api.json`).then((x) => x.text())
 await Bun.write(
-  path.join(dir, "src/provider/models-snapshot.ts"),
-  `// Auto-generated by build.ts - do not edit\nexport const snapshot = ${modelsData} as const\n`,
+  path.join(dir, "src/provider/models-snapshot.js"),
+  `// @ts-nocheck\n// Auto-generated by build.ts - do not edit\nexport const snapshot = ${modelsData}\n`,
 )
-console.log("Generated models-snapshot.ts")
+await Bun.write(
+  path.join(dir, "src/provider/models-snapshot.d.ts"),
+  `// Auto-generated by build.ts - do not edit\nexport declare const snapshot: Record<string, unknown>\n`,
+)
+console.log("Generated models-snapshot.js")
 
 // Load migrations from migration directories
 const migrationDirs = (

packages/opencode/specs/effect-migration.md

@@ -164,7 +164,7 @@ Still open and likely worth migrating:
 - [x] `Plugin`
 - [x] `ToolRegistry`
 - [ ] `Pty`
-- [ ] `Worktree`
+- [x] `Worktree`
 - [ ] `Bus`
 - [x] `Command`
 - [ ] `Config`

packages/opencode/src/control-plane/adaptors/worktree.ts

@@ -22,12 +22,11 @@ export const WorktreeAdaptor: Adaptor = {
   },
   async create(info) {
     const config = Config.parse(info)
-    const bootstrap = await Worktree.createFromInfo({
+    await Worktree.createFromInfo({
       name: config.name,
       directory: config.directory,
       branch: config.branch,
     })
-    return bootstrap()
   },
   async remove(info) {
     const config = Config.parse(info)

packages/opencode/src/lsp/index.ts

@@ -177,6 +177,12 @@ export namespace LSP {
 
   async function getClients(file: string) {
     const s = await state()
+
+    // Only spawn LSP clients for files within the instance directory
+    if (!Instance.containsPath(file)) {
+      return []
+    }
+
     const extension = path.parse(file).ext || file
     const result: LSPClient.Info[] = []
 

packages/opencode/src/provider/models.ts

@@ -89,7 +89,7 @@ export namespace ModelsDev {
     const result = await Filesystem.readJson(Flag.OPENCODE_MODELS_PATH ?? filepath).catch(() => {})
     if (result) return result
     // @ts-ignore
-    const snapshot = await import("./models-snapshot")
+    const snapshot = await import("./models-snapshot.js")
       .then((m) => m.snapshot as Record<string, unknown>)
       .catch(() => undefined)
     if (snapshot) return snapshot

packages/opencode/src/server/routes/experimental.ts

@@ -108,7 +108,7 @@ export const ExperimentalRoutes = lazy(() =>
           ...errors(400),
         },
       }),
-      validator("json", Worktree.create.schema),
+      validator("json", Worktree.CreateInput.optional()),
       async (c) => {
         const body = c.req.valid("json")
         const worktree = await Worktree.create(body)
@@ -155,7 +155,7 @@ export const ExperimentalRoutes = lazy(() =>
           ...errors(400),
         },
       }),
-      validator("json", Worktree.remove.schema),
+      validator("json", Worktree.RemoveInput),
       async (c) => {
         const body = c.req.valid("json")
         await Worktree.remove(body)
@@ -181,7 +181,7 @@ export const ExperimentalRoutes = lazy(() =>
           ...errors(400),
         },
       }),
-      validator("json", Worktree.reset.schema),
+      validator("json", Worktree.ResetInput),
       async (c) => {
         const body = c.req.valid("json")
         await Worktree.reset(body)

packages/opencode/src/server/routes/session.ts

@@ -123,6 +123,15 @@ export const SessionRoutes = lazy(() =>
         const sessionID = c.req.valid("param").sessionID
         log.info("SEARCH", { url: c.req.url })
         const session = await Session.get(sessionID)
+        if (session.summary?.files) {
+          const diffs = await SessionSummary.list(sessionID)
+          if (diffs.length > 0) {
+            session.summary = {
+              ...session.summary,
+              diffs,
+            }
+          }
+        }
         return c.json(session)
       },
     )

packages/opencode/src/server/server.ts

@@ -1,3 +1,4 @@
+import { createHash } from "node:crypto"
 import { Log } from "../util/log"
 import { describeRoute, generateSpecs, validator, resolver, openAPIRouteHandler } from "hono-openapi"
 import { Hono } from "hono"
@@ -47,6 +48,61 @@ import { lazy } from "@/util/lazy"
 // @ts-ignore This global is needed to prevent ai-sdk from logging warnings to stdout https://github.com/vercel/ai/blob/2dc67e0ef538307f21368db32d5a12345d98831b/packages/ai/src/logger/log-warnings.ts#L85
 globalThis.AI_SDK_LOG_WARNINGS = false
 
+const csp = (hash = "") =>
+  `default-src 'self'; script-src 'self' 'wasm-unsafe-eval'${hash ? ` 'sha256-${hash}'` : ""}; style-src 'self' 'unsafe-inline'; img-src 'self' data: https:; font-src 'self' data:; media-src 'self' data:; connect-src 'self' data:`
+
+const api = (path: string) =>
+  path === "/agent" ||
+  path === "/command" ||
+  path === "/formatter" ||
+  path === "/log" ||
+  path === "/lsp" ||
+  path === "/path" ||
+  path === "/skill" ||
+  path === "/vcs" ||
+  path.startsWith("/auth/") ||
+  path.startsWith("/config") ||
+  path.startsWith("/experimental") ||
+  path.startsWith("/global") ||
+  path.startsWith("/mcp") ||
+  path.startsWith("/permission") ||
+  path.startsWith("/project") ||
+  path.startsWith("/provider") ||
+  path.startsWith("/question") ||
+  path.startsWith("/session")
+
+const json = (value: string | null) => {
+  const type = value?.split(";")[0]?.trim()
+  return type === "application/json" || type?.endsWith("+json")
+}
+
+const gzip = (value?: string) => {
+  if (!value) return false
+
+  let star = false
+  for (const item of value.split(",")) {
+    const [name, ...params] = item.trim().toLowerCase().split(";")
+    const q = params.find((part) => part.trim().startsWith("q="))
+    const score = q ? Number(q.trim().slice(2)) : 1
+    const ok = !Number.isNaN(score) && score > 0
+
+    if (name === "gzip") return ok
+    if (name === "*") star = ok
+  }
+
+  return star
+}
+
+const vary = (headers: Headers, value: string) => {
+  const current = headers.get("Vary")
+  if (!current) {
+    headers.set("Vary", value)
+    return
+  }
+  if (current.split(",").some((item) => item.trim().toLowerCase() === value.toLowerCase())) return
+  headers.set("Vary", `${current}, ${value}`)
+}
+
 export namespace Server {
   const log = Log.create({ service: "server" })
 
@@ -100,6 +156,26 @@ export namespace Server {
           timer.stop()
         }
       })
+      .use(async (c, next) => {
+        await next()
+
+        if (!api(c.req.path)) return
+        if (c.req.method === "HEAD") return
+        if (c.res.headers.has("Content-Encoding")) return
+        if (c.res.headers.has("Transfer-Encoding")) return
+        if (!json(c.res.headers.get("Content-Type"))) return
+
+        if (!gzip(c.req.header("Accept-Encoding"))) return
+
+        const size = Number(c.res.headers.get("Content-Length") ?? "")
+        if (Number.isFinite(size) && size > 0 && size < 1024) return
+        if (!c.res.body) return
+
+        c.res = new Response(c.res.body.pipeThrough(new CompressionStream("gzip")), c.res)
+        c.res.headers.delete("Content-Length")
+        c.res.headers.set("Content-Encoding", "gzip")
+        vary(c.res.headers, "Accept-Encoding")
+      })
       .use(
         cors({
           origin(input) {
@@ -506,10 +582,13 @@ export namespace Server {
             host: "app.opencode.ai",
           },
         })
-        response.headers.set(
-          "Content-Security-Policy",
-          "default-src 'self'; script-src 'self' 'wasm-unsafe-eval'; style-src 'self' 'unsafe-inline'; img-src 'self' data: https:; font-src 'self' data:; media-src 'self' data:; connect-src 'self' data:",
-        )
+        const match = response.headers.get("content-type")?.includes("text/html")
+          ? (await response.clone().text()).match(
+              /<script\b(?![^>]*\bsrc\s*=)[^>]*\bid=(['"])oc-theme-preload-script\1[^>]*>([\s\S]*?)<\/script>/i,
+            )
+          : undefined
+        const hash = match ? createHash("sha256").update(match[2]).digest("base64") : ""
+        response.headers.set("Content-Security-Policy", csp(hash))
         return response
       })
   }

packages/opencode/src/session/summary.ts

@@ -12,6 +12,14 @@ import { Bus } from "@/bus"
 import { NotFoundError } from "@/storage/db"
 
 export namespace SessionSummary {
+  function shape(diffs: Snapshot.FileDiff[]) {
+    return diffs.map((item) => ({
+      ...item,
+      before: "",
+      after: "",
+    }))
+  }
+
   function unquoteGitPath(input: string) {
     if (!input.startsWith('"')) return input
     if (!input.endsWith('"')) return input
@@ -141,6 +149,8 @@ export namespace SessionSummary {
     },
   )
 
+  export const list = fn(SessionID.zod, async (sessionID) => shape(await diff({ sessionID })))
+
   export async function computeDiff(input: { messages: MessageV2.WithParts[] }) {
     let from: string | undefined
     let to: string | undefined

packages/opencode/src/snapshot/index.ts

@@ -34,6 +34,7 @@ export namespace Snapshot {
 
   const log = Log.create({ service: "snapshot" })
   const prune = "7.days"
+  const limit = 2 * 1024 * 1024
   const core = ["-c", "core.longpaths=true", "-c", "core.symlinks=true"]
   const cfg = ["-c", "core.autocrlf=false", ...core]
   const quote = [...cfg, "-c", "core.quotepath=false"]
@@ -123,20 +124,69 @@ export namespace Snapshot {
               return file
             })
 
-            const sync = Effect.fnUntraced(function* () {
+            const sync = Effect.fnUntraced(function* (list: string[] = []) {
               const file = yield* excludes()
               const target = path.join(state.gitdir, "info", "exclude")
+              const text = [
+                file ? (yield* read(file)).trimEnd() : "",
+                ...list.map((item) => `/${item.replaceAll("\\", "/")}`),
+              ]
+                .filter(Boolean)
+                .join("\n")
               yield* fs.ensureDir(path.join(state.gitdir, "info")).pipe(Effect.orDie)
-              if (!file) {
-                yield* fs.writeFileString(target, "").pipe(Effect.orDie)
-                return
-              }
-              yield* fs.writeFileString(target, yield* read(file)).pipe(Effect.orDie)
+              yield* fs.writeFileString(target, text ? `${text}\n` : "").pipe(Effect.orDie)
             })
 
             const add = Effect.fnUntraced(function* () {
               yield* sync()
-              yield* git([...cfg, ...args(["add", "."])], { cwd: state.directory })
+              const [diff, other] = yield* Effect.all(
+                [
+                  git([...quote, ...args(["diff-files", "--name-only", "-z", "--", "."])], {
+                    cwd: state.directory,
+                  }),
+                  git([...quote, ...args(["ls-files", "--others", "--exclude-standard", "-z", "--", "."])], {
+                    cwd: state.directory,
+                  }),
+                ],
+                { concurrency: 2 },
+              )
+              if (diff.code !== 0 || other.code !== 0) {
+                log.warn("failed to list snapshot files", {
+                  diffCode: diff.code,
+                  diffStderr: diff.stderr,
+                  otherCode: other.code,
+                  otherStderr: other.stderr,
+                })
+                return
+              }
+
+              const tracked = diff.text.split("\0").filter(Boolean)
+              const all = Array.from(new Set([...tracked, ...other.text.split("\0").filter(Boolean)]))
+              if (!all.length) return
+
+              const large = (yield* Effect.all(
+                all.map((item) =>
+                  fs
+                    .stat(path.join(state.directory, item))
+                    .pipe(Effect.catch(() => Effect.void))
+                    .pipe(
+                      Effect.map((stat) => {
+                        if (!stat || stat.type !== "File") return
+                        const size = typeof stat.size === "bigint" ? Number(stat.size) : stat.size
+                        return size > limit ? item : undefined
+                      }),
+                    ),
+                ),
+                { concurrency: 8 },
+              )).filter((item): item is string => Boolean(item))
+              yield* sync(large)
+              const result = yield* git([...cfg, ...args(["add", "--sparse", "."])], { cwd: state.directory })
+              if (result.code !== 0) {
+                log.warn("failed to add snapshot files", {
+                  exitCode: result.code,
+                  stderr: result.stderr,
+                })
+              }
             })
 
             const cleanup = Effect.fnUntraced(function* () {
@@ -177,7 +227,7 @@ export namespace Snapshot {
             const patch = Effect.fnUntraced(function* (hash: string) {
               yield* add()
               const result = yield* git(
-                [...quote, ...args(["diff", "--no-ext-diff", "--name-only", hash, "--", "."])],
+                [...quote, ...args(["diff", "--cached", "--no-ext-diff", "--name-only", hash, "--", "."])],
                 {
                   cwd: state.directory,
                 },
@@ -245,7 +295,7 @@ export namespace Snapshot {
 
             const diff = Effect.fnUntraced(function* (hash: string) {
               yield* add()
-              const result = yield* git([...quote, ...args(["diff", "--no-ext-diff", hash, "--", "."])], {
+              const result = yield* git([...quote, ...args(["diff", "--cached", "--no-ext-diff", hash, "--", "."])], {
                 cwd: state.worktree,
               })
               if (result.code !== 0) {

packages/opencode/src/worktree/index.ts

@@ -1,5 +1,3 @@
-import fs from "fs/promises"
-import path from "path"
 import z from "zod"
 import { NamedError } from "@opencode-ai/util/error"
 import { Global } from "../global"
@@ -9,12 +7,15 @@ import { Project } from "../project/project"
 import { Database, eq } from "../storage/db"
 import { ProjectTable } from "../project/project.sql"
 import type { ProjectID } from "../project/schema"
-import { fn } from "../util/fn"
 import { Log } from "../util/log"
-import { Process } from "../util/process"
-import { git } from "../util/git"
+import { Slug } from "@opencode-ai/util/slug"
 import { BusEvent } from "@/bus/bus-event"
 import { GlobalBus } from "@/bus/global"
+import { Effect, FileSystem, Layer, Path, Scope, ServiceMap, Stream } from "effect"
+import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process"
+import { NodeFileSystem, NodePath } from "@effect/platform-node"
+import { makeRunPromise } from "@/effect/run-service"
+import * as CrossSpawnSpawner from "@/effect/cross-spawn-spawner"
 
 export namespace Worktree {
   const log = Log.create({ service: "worktree" })
@@ -123,77 +124,7 @@ export namespace Worktree {
     }),
   )
 
-  const ADJECTIVES = [
-    "brave",
-    "calm",
-    "clever",
-    "cosmic",
-    "crisp",
-    "curious",
-    "eager",
-    "gentle",
-    "glowing",
-    "happy",
-    "hidden",
-    "jolly",
-    "kind",
-    "lucky",
-    "mighty",
-    "misty",
-    "neon",
-    "nimble",
-    "playful",
-    "proud",
-    "quick",
-    "quiet",
-    "shiny",
-    "silent",
-    "stellar",
-    "sunny",
-    "swift",
-    "tidy",
-    "witty",
-  ] as const
-
-  const NOUNS = [
-    "cabin",
-    "cactus",
-    "canyon",
-    "circuit",
-    "comet",
-    "eagle",
-    "engine",
-    "falcon",
-    "forest",
-    "garden",
-    "harbor",
-    "island",
-    "knight",
-    "lagoon",
-    "meadow",
-    "moon",
-    "mountain",
-    "nebula",
-    "orchid",
-    "otter",
-    "panda",
-    "pixel",
-    "planet",
-    "river",
-    "rocket",
-    "sailor",
-    "squid",
-    "star",
-    "tiger",
-    "wizard",
-    "wolf",
-  ] as const
-
-  function pick<const T extends readonly string[]>(list: T) {
-    return list[Math.floor(Math.random() * list.length)]
-  }
-
-  function slug(input: string) {
+  function slugify(input: string) {
     return input
       .trim()
       .toLowerCase()
@@ -202,28 +133,8 @@ export namespace Worktree {
       .replace(/-+$/, "")
   }
 
-  function randomName() {
-    return `${pick(ADJECTIVES)}-${pick(NOUNS)}`
-  }
-
-  async function exists(target: string) {
-    return fs
-      .stat(target)
-      .then(() => true)
-      .catch(() => false)
-  }
-
-  function outputText(input: Uint8Array | undefined) {
-    if (!input?.length) return ""
-    return new TextDecoder().decode(input).trim()
-  }
-
-  function errorText(result: { stdout?: Uint8Array; stderr?: Uint8Array }) {
-    return [outputText(result.stderr), outputText(result.stdout)].filter(Boolean).join("\n")
-  }
-
-  function failed(result: { stdout?: Uint8Array; stderr?: Uint8Array }) {
-    return [outputText(result.stderr), outputText(result.stdout)].filter(Boolean).flatMap((chunk) =>
+  function failedRemoves(...chunks: string[]) {
+    return chunks.filter(Boolean).flatMap((chunk) =>
       chunk
         .split("\n")
         .map((line) => line.trim())
@@ -237,436 +148,484 @@ export namespace Worktree {
     )
   }
 
-  async function prune(root: string, entries: string[]) {
-    const base = await canonical(root)
-    await Promise.all(
-      entries.map(async (entry) => {
-        const target = await canonical(path.resolve(root, entry))
-        if (target === base) return
-        if (!target.startsWith(`${base}${path.sep}`)) return
-        await fs.rm(target, { recursive: true, force: true }).catch(() => undefined)
-      }),
-    )
+  // ---------------------------------------------------------------------------
+  // Effect service
+  // ---------------------------------------------------------------------------
+
+  export interface Interface {
+    readonly makeWorktreeInfo: (name?: string) => Effect.Effect<Info>
+    readonly createFromInfo: (info: Info, startCommand?: string) => Effect.Effect<void>
+    readonly create: (input?: CreateInput) => Effect.Effect<Info>
+    readonly remove: (input: RemoveInput) => Effect.Effect<boolean>
+    readonly reset: (input: ResetInput) => Effect.Effect<boolean>
   }
 
-  async function sweep(root: string) {
-    const first = await git(["clean", "-ffdx"], { cwd: root })
-    if (first.exitCode === 0) return first
+  export class Service extends ServiceMap.Service<Service, Interface>()("@opencode/Worktree") {}
 
-    const entries = failed(first)
-    if (!entries.length) return first
+  type GitResult = { code: number; text: string; stderr: string }
 
-    await prune(root, entries)
-    return git(["clean", "-ffdx"], { cwd: root })
-  }
+  export const layer: Layer.Layer<
+    Service,
+    never,
+    FileSystem.FileSystem | Path.Path | ChildProcessSpawner.ChildProcessSpawner
+  > = Layer.effect(
+    Service,
+    Effect.gen(function* () {
+      const scope = yield* Scope.Scope
+      const fsys = yield* FileSystem.FileSystem
+      const pathSvc = yield* Path.Path
+      const spawner = yield* ChildProcessSpawner.ChildProcessSpawner
 
-  async function canonical(input: string) {
-    const abs = path.resolve(input)
-    const real = await fs.realpath(abs).catch(() => abs)
-    const normalized = path.normalize(real)
-    return process.platform === "win32" ? normalized.toLowerCase() : normalized
-  }
+      const git = Effect.fnUntraced(
+        function* (args: string[], opts?: { cwd?: string }) {
+          const handle = yield* spawner.spawn(
+            ChildProcess.make("git", args, { cwd: opts?.cwd, extendEnv: true, stdin: "ignore" }),
+          )
+          const [text, stderr] = yield* Effect.all(
+            [Stream.mkString(Stream.decodeText(handle.stdout)), Stream.mkString(Stream.decodeText(handle.stderr))],
+            { concurrency: 2 },
+          )
+          const code = yield* handle.exitCode
+          return { code, text, stderr } satisfies GitResult
+        },
+        Effect.scoped,
+        Effect.catch((e) =>
+          Effect.succeed({ code: 1, text: "", stderr: e instanceof Error ? e.message : String(e) } satisfies GitResult),
+        ),
+      )
 
-  async function candidate(root: string, base?: string) {
-    for (const attempt of Array.from({ length: 26 }, (_, i) => i)) {
-      const name = base ? (attempt === 0 ? base : `${base}-${randomName()}`) : randomName()
-      const branch = `opencode/${name}`
-      const directory = path.join(root, name)
+      const MAX_NAME_ATTEMPTS = 26
+      const candidate = Effect.fn("Worktree.candidate")(function* (root: string, base?: string) {
+        for (const attempt of Array.from({ length: MAX_NAME_ATTEMPTS }, (_, i) => i)) {
+          const name = base ? (attempt === 0 ? base : `${base}-${Slug.create()}`) : Slug.create()
+          const branch = `opencode/${name}`
+          const directory = pathSvc.join(root, name)
 
-      if (await exists(directory)) continue
+          if (yield* fsys.exists(directory).pipe(Effect.orDie)) continue
 
-      const ref = `refs/heads/${branch}`
-      const branchCheck = await git(["show-ref", "--verify", "--quiet", ref], {
-        cwd: Instance.worktree,
+          const ref = `refs/heads/${branch}`
+          const branchCheck = yield* git(["show-ref", "--verify", "--quiet", ref], { cwd: Instance.worktree })
+          if (branchCheck.code === 0) continue
+
+          return Info.parse({ name, branch, directory })
+        }
+        throw new NameGenerationFailedError({ message: "Failed to generate a unique worktree name" })
       })
-      if (branchCheck.exitCode === 0) continue
 
-      return Info.parse({ name, branch, directory })
-    }
+      const makeWorktreeInfo = Effect.fn("Worktree.makeWorktreeInfo")(function* (name?: string) {
+        if (Instance.project.vcs !== "git") {
+          throw new NotGitError({ message: "Worktrees are only supported for git projects" })
+        }
 
-    throw new NameGenerationFailedError({ message: "Failed to generate a unique worktree name" })
-  }
+        const root = pathSvc.join(Global.Path.data, "worktree", Instance.project.id)
+        yield* fsys.makeDirectory(root, { recursive: true }).pipe(Effect.orDie)
 
-  async function runStartCommand(directory: string, cmd: string) {
-    if (process.platform === "win32") {
-      return Process.run(["cmd", "/c", cmd], { cwd: directory, nothrow: true })
-    }
-    return Process.run(["bash", "-lc", cmd], { cwd: directory, nothrow: true })
-  }
-
-  type StartKind = "project" | "worktree"
-
-  async function runStartScript(directory: string, cmd: string, kind: StartKind) {
-    const text = cmd.trim()
-    if (!text) return true
-
-    const ran = await runStartCommand(directory, text)
-    if (ran.code === 0) return true
-
-    log.error("worktree start command failed", {
-      kind,
-      directory,
-      message: errorText(ran),
-    })
-    return false
-  }
-
-  async function runStartScripts(directory: string, input: { projectID: ProjectID; extra?: string }) {
-    const row = Database.use((db) => db.select().from(ProjectTable).where(eq(ProjectTable.id, input.projectID)).get())
-    const project = row ? Project.fromRow(row) : undefined
-    const startup = project?.commands?.start?.trim() ?? ""
-    const ok = await runStartScript(directory, startup, "project")
-    if (!ok) return false
-
-    const extra = input.extra ?? ""
-    await runStartScript(directory, extra, "worktree")
-    return true
-  }
-
-  function queueStartScripts(directory: string, input: { projectID: ProjectID; extra?: string }) {
-    setTimeout(() => {
-      const start = async () => {
-        await runStartScripts(directory, input)
-      }
-
-      void start().catch((error) => {
-        log.error("worktree start task failed", { directory, error })
+        const base = name ? slugify(name) : ""
+        return yield* candidate(root, base || undefined)
       })
-    }, 0)
-  }
 
-  export async function makeWorktreeInfo(name?: string): Promise<Info> {
-    if (Instance.project.vcs !== "git") {
-      throw new NotGitError({ message: "Worktrees are only supported for git projects" })
-    }
+      const setup = Effect.fnUntraced(function* (info: Info) {
+        const created = yield* git(["worktree", "add", "--no-checkout", "-b", info.branch, info.directory], {
+          cwd: Instance.worktree,
+        })
+        if (created.code !== 0) {
+          throw new CreateFailedError({ message: created.stderr || created.text || "Failed to create git worktree" })
+        }
 
-    const root = path.join(Global.Path.data, "worktree", Instance.project.id)
-    await fs.mkdir(root, { recursive: true })
+        yield* Effect.promise(() => Project.addSandbox(Instance.project.id, info.directory).catch(() => undefined))
+      })
 
-    const base = name ? slug(name) : ""
-    return candidate(root, base || undefined)
-  }
+      const boot = Effect.fnUntraced(function* (info: Info, startCommand?: string) {
+        const projectID = Instance.project.id
+        const extra = startCommand?.trim()
 
-  export async function createFromInfo(info: Info, startCommand?: string) {
-    const created = await git(["worktree", "add", "--no-checkout", "-b", info.branch, info.directory], {
-      cwd: Instance.worktree,
-    })
-    if (created.exitCode !== 0) {
-      throw new CreateFailedError({ message: errorText(created) || "Failed to create git worktree" })
-    }
-
-    await Project.addSandbox(Instance.project.id, info.directory).catch(() => undefined)
-
-    const projectID = Instance.project.id
-    const extra = startCommand?.trim()
-
-    return () => {
-      const start = async () => {
-        const populated = await git(["reset", "--hard"], { cwd: info.directory })
-        if (populated.exitCode !== 0) {
-          const message = errorText(populated) || "Failed to populate worktree"
+        const populated = yield* git(["reset", "--hard"], { cwd: info.directory })
+        if (populated.code !== 0) {
+          const message = populated.stderr || populated.text || "Failed to populate worktree"
           log.error("worktree checkout failed", { directory: info.directory, message })
           GlobalBus.emit("event", {
             directory: info.directory,
-            payload: {
-              type: Event.Failed.type,
-              properties: {
-                message,
-              },
-            },
+            payload: { type: Event.Failed.type, properties: { message } },
           })
           return
         }
 
-        const booted = await Instance.provide({
-          directory: info.directory,
-          init: InstanceBootstrap,
-          fn: () => undefined,
-        })
-          .then(() => true)
-          .catch((error) => {
-            const message = error instanceof Error ? error.message : String(error)
-            log.error("worktree bootstrap failed", { directory: info.directory, message })
-            GlobalBus.emit("event", {
-              directory: info.directory,
-              payload: {
-                type: Event.Failed.type,
-                properties: {
-                  message,
-                },
-              },
-            })
-            return false
+        const booted = yield* Effect.promise(() =>
+          Instance.provide({
+            directory: info.directory,
+            init: InstanceBootstrap,
+            fn: () => undefined,
           })
+            .then(() => true)
+            .catch((error) => {
+              const message = error instanceof Error ? error.message : String(error)
+              log.error("worktree bootstrap failed", { directory: info.directory, message })
+              GlobalBus.emit("event", {
+                directory: info.directory,
+                payload: { type: Event.Failed.type, properties: { message } },
+              })
+              return false
+            }),
+        )
         if (!booted) return
 
         GlobalBus.emit("event", {
           directory: info.directory,
           payload: {
             type: Event.Ready.type,
-            properties: {
-              name: info.name,
-              branch: info.branch,
-            },
+            properties: { name: info.name, branch: info.branch },
           },
         })
 
-        await runStartScripts(info.directory, { projectID, extra })
+        yield* runStartScripts(info.directory, { projectID, extra })
+      })
+
+      const createFromInfo = Effect.fn("Worktree.createFromInfo")(function* (info: Info, startCommand?: string) {
+        yield* setup(info)
+        yield* boot(info, startCommand)
+      })
+
+      const create = Effect.fn("Worktree.create")(function* (input?: CreateInput) {
+        const info = yield* makeWorktreeInfo(input?.name)
+        yield* setup(info)
+        yield* boot(info, input?.startCommand).pipe(
+          Effect.catchCause((cause) => Effect.sync(() => log.error("worktree bootstrap failed", { cause }))),
+          Effect.forkIn(scope),
+        )
+        return info
+      })
+
+      const canonical = Effect.fnUntraced(function* (input: string) {
+        const abs = pathSvc.resolve(input)
+        const real = yield* fsys.realPath(abs).pipe(Effect.catch(() => Effect.succeed(abs)))
+        const normalized = pathSvc.normalize(real)
+        return process.platform === "win32" ? normalized.toLowerCase() : normalized
+      })
+
+      function parseWorktreeList(text: string) {
+        return text
+          .split("\n")
+          .map((line) => line.trim())
+          .reduce<{ path?: string; branch?: string }[]>((acc, line) => {
+            if (!line) return acc
+            if (line.startsWith("worktree ")) {
+              acc.push({ path: line.slice("worktree ".length).trim() })
+              return acc
+            }
+            const current = acc[acc.length - 1]
+            if (!current) return acc
+            if (line.startsWith("branch ")) {
+              current.branch = line.slice("branch ".length).trim()
+            }
+            return acc
+          }, [])
       }
 
-      return start().catch((error) => {
-        log.error("worktree start task failed", { directory: info.directory, error })
-      })
-    }
-  }
-
-  export const create = fn(CreateInput.optional(), async (input) => {
-    const info = await makeWorktreeInfo(input?.name)
-    const bootstrap = await createFromInfo(info, input?.startCommand)
-    // This is needed due to how worktrees currently work in the
-    // desktop app
-    setTimeout(() => {
-      bootstrap()
-    }, 0)
-    return info
-  })
-
-  export const remove = fn(RemoveInput, async (input) => {
-    if (Instance.project.vcs !== "git") {
-      throw new NotGitError({ message: "Worktrees are only supported for git projects" })
-    }
-
-    const directory = await canonical(input.directory)
-    const locate = async (stdout: Uint8Array | undefined) => {
-      const lines = outputText(stdout)
-        .split("\n")
-        .map((line) => line.trim())
-      const entries = lines.reduce<{ path?: string; branch?: string }[]>((acc, line) => {
-        if (!line) return acc
-        if (line.startsWith("worktree ")) {
-          acc.push({ path: line.slice("worktree ".length).trim() })
-          return acc
-        }
-        const current = acc[acc.length - 1]
-        if (!current) return acc
-        if (line.startsWith("branch ")) {
-          current.branch = line.slice("branch ".length).trim()
-        }
-        return acc
-      }, [])
-
-      return (async () => {
+      const locateWorktree = Effect.fnUntraced(function* (
+        entries: { path?: string; branch?: string }[],
+        directory: string,
+      ) {
         for (const item of entries) {
           if (!item.path) continue
-          const key = await canonical(item.path)
+          const key = yield* canonical(item.path)
           if (key === directory) return item
         }
-      })()
-    }
+        return undefined
+      })
 
-    const clean = (target: string) =>
-      fs
-        .rm(target, {
-          recursive: true,
-          force: true,
-          maxRetries: 5,
-          retryDelay: 100,
-        })
-        .catch((error) => {
-          const message = error instanceof Error ? error.message : String(error)
-          throw new RemoveFailedError({ message: message || "Failed to remove git worktree directory" })
-        })
-
-    const stop = async (target: string) => {
-      if (!(await exists(target))) return
-      await git(["fsmonitor--daemon", "stop"], { cwd: target })
-    }
-
-    const list = await git(["worktree", "list", "--porcelain"], { cwd: Instance.worktree })
-    if (list.exitCode !== 0) {
-      throw new RemoveFailedError({ message: errorText(list) || "Failed to read git worktrees" })
-    }
-
-    const entry = await locate(list.stdout)
-
-    if (!entry?.path) {
-      const directoryExists = await exists(directory)
-      if (directoryExists) {
-        await stop(directory)
-        await clean(directory)
-      }
-      return true
-    }
-
-    await stop(entry.path)
-    const removed = await git(["worktree", "remove", "--force", entry.path], {
-      cwd: Instance.worktree,
-    })
-    if (removed.exitCode !== 0) {
-      const next = await git(["worktree", "list", "--porcelain"], { cwd: Instance.worktree })
-      if (next.exitCode !== 0) {
-        throw new RemoveFailedError({
-          message: errorText(removed) || errorText(next) || "Failed to remove git worktree",
-        })
+      function stopFsmonitor(target: string) {
+        return fsys.exists(target).pipe(
+          Effect.orDie,
+          Effect.flatMap((exists) => (exists ? git(["fsmonitor--daemon", "stop"], { cwd: target }) : Effect.void)),
+        )
       }
 
-      const stale = await locate(next.stdout)
-      if (stale?.path) {
-        throw new RemoveFailedError({ message: errorText(removed) || "Failed to remove git worktree" })
+      function cleanDirectory(target: string) {
+        return Effect.promise(() =>
+          import("fs/promises").then((fsp) =>
+            fsp.rm(target, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 }),
+          ),
+        )
       }
-    }
 
-    await clean(entry.path)
+      const remove = Effect.fn("Worktree.remove")(function* (input: RemoveInput) {
+        if (Instance.project.vcs !== "git") {
+          throw new NotGitError({ message: "Worktrees are only supported for git projects" })
+        }
 
-    const branch = entry.branch?.replace(/^refs\/heads\//, "")
-    if (branch) {
-      const deleted = await git(["branch", "-D", branch], { cwd: Instance.worktree })
-      if (deleted.exitCode !== 0) {
-        throw new RemoveFailedError({ message: errorText(deleted) || "Failed to delete worktree branch" })
-      }
-    }
+        const directory = yield* canonical(input.directory)
 
-    return true
-  })
+        const list = yield* git(["worktree", "list", "--porcelain"], { cwd: Instance.worktree })
+        if (list.code !== 0) {
+          throw new RemoveFailedError({ message: list.stderr || list.text || "Failed to read git worktrees" })
+        }
 
-  export const reset = fn(ResetInput, async (input) => {
-    if (Instance.project.vcs !== "git") {
-      throw new NotGitError({ message: "Worktrees are only supported for git projects" })
-    }
+        const entries = parseWorktreeList(list.text)
+        const entry = yield* locateWorktree(entries, directory)
 
-    const directory = await canonical(input.directory)
-    const primary = await canonical(Instance.worktree)
-    if (directory === primary) {
-      throw new ResetFailedError({ message: "Cannot reset the primary workspace" })
-    }
+        if (!entry?.path) {
+          const directoryExists = yield* fsys.exists(directory).pipe(Effect.orDie)
+          if (directoryExists) {
+            yield* stopFsmonitor(directory)
+            yield* cleanDirectory(directory)
+          }
+          return true
+        }
 
-    const list = await git(["worktree", "list", "--porcelain"], { cwd: Instance.worktree })
-    if (list.exitCode !== 0) {
-      throw new ResetFailedError({ message: errorText(list) || "Failed to read git worktrees" })
-    }
+        yield* stopFsmonitor(entry.path)
+        const removed = yield* git(["worktree", "remove", "--force", entry.path], { cwd: Instance.worktree })
+        if (removed.code !== 0) {
+          const next = yield* git(["worktree", "list", "--porcelain"], { cwd: Instance.worktree })
+          if (next.code !== 0) {
+            throw new RemoveFailedError({
+              message: removed.stderr || removed.text || next.stderr || next.text || "Failed to remove git worktree",
+            })
+          }
 
-    const lines = outputText(list.stdout)
-      .split("\n")
-      .map((line) => line.trim())
-    const entries = lines.reduce<{ path?: string; branch?: string }[]>((acc, line) => {
-      if (!line) return acc
-      if (line.startsWith("worktree ")) {
-        acc.push({ path: line.slice("worktree ".length).trim() })
-        return acc
-      }
-      const current = acc[acc.length - 1]
-      if (!current) return acc
-      if (line.startsWith("branch ")) {
-        current.branch = line.slice("branch ".length).trim()
-      }
-      return acc
-    }, [])
+          const stale = yield* locateWorktree(parseWorktreeList(next.text), directory)
+          if (stale?.path) {
+            throw new RemoveFailedError({ message: removed.stderr || removed.text || "Failed to remove git worktree" })
+          }
+        }
 
-    const entry = await (async () => {
-      for (const item of entries) {
-        if (!item.path) continue
-        const key = await canonical(item.path)
-        if (key === directory) return item
-      }
-    })()
-    if (!entry?.path) {
-      throw new ResetFailedError({ message: "Worktree not found" })
-    }
+        yield* cleanDirectory(entry.path)
 
-    const remoteList = await git(["remote"], { cwd: Instance.worktree })
-    if (remoteList.exitCode !== 0) {
-      throw new ResetFailedError({ message: errorText(remoteList) || "Failed to list git remotes" })
-    }
+        const branch = entry.branch?.replace(/^refs\/heads\//, "")
+        if (branch) {
+          const deleted = yield* git(["branch", "-D", branch], { cwd: Instance.worktree })
+          if (deleted.code !== 0) {
+            throw new RemoveFailedError({
+              message: deleted.stderr || deleted.text || "Failed to delete worktree branch",
+            })
+          }
+        }
 
-    const remotes = outputText(remoteList.stdout)
-      .split("\n")
-      .map((line) => line.trim())
-      .filter(Boolean)
+        return true
+      })
 
-    const remote = remotes.includes("origin")
-      ? "origin"
-      : remotes.length === 1
-        ? remotes[0]
-        : remotes.includes("upstream")
-          ? "upstream"
-          : ""
+      const gitExpect = Effect.fnUntraced(function* (
+        args: string[],
+        opts: { cwd: string },
+        error: (r: GitResult) => Error,
+      ) {
+        const result = yield* git(args, opts)
+        if (result.code !== 0) throw error(result)
+        return result
+      })
 
-    const remoteHead = remote
-      ? await git(["symbolic-ref", `refs/remotes/${remote}/HEAD`], { cwd: Instance.worktree })
-      : { exitCode: 1, stdout: undefined, stderr: undefined }
+      const runStartCommand = Effect.fnUntraced(
+        function* (directory: string, cmd: string) {
+          const [shell, args] = process.platform === "win32" ? ["cmd", ["/c", cmd]] : ["bash", ["-lc", cmd]]
+          const handle = yield* spawner.spawn(
+            ChildProcess.make(shell, args, { cwd: directory, extendEnv: true, stdin: "ignore" }),
+          )
+          // Drain stdout, capture stderr for error reporting
+          const [, stderr] = yield* Effect.all(
+            [Stream.runDrain(handle.stdout), Stream.mkString(Stream.decodeText(handle.stderr))],
+            { concurrency: 2 },
+          ).pipe(Effect.orDie)
+          const code = yield* handle.exitCode
+          return { code, stderr }
+        },
+        Effect.scoped,
+        Effect.catch(() => Effect.succeed({ code: 1, stderr: "" })),
+      )
 
-    const remoteRef = remoteHead.exitCode === 0 ? outputText(remoteHead.stdout) : ""
-    const remoteTarget = remoteRef ? remoteRef.replace(/^refs\/remotes\//, "") : ""
-    const remoteBranch = remote && remoteTarget.startsWith(`${remote}/`) ? remoteTarget.slice(`${remote}/`.length) : ""
+      const runStartScript = Effect.fnUntraced(function* (directory: string, cmd: string, kind: string) {
+        const text = cmd.trim()
+        if (!text) return true
+        const result = yield* runStartCommand(directory, text)
+        if (result.code === 0) return true
+        log.error("worktree start command failed", { kind, directory, message: result.stderr })
+        return false
+      })
 
-    const mainCheck = await git(["show-ref", "--verify", "--quiet", "refs/heads/main"], {
-      cwd: Instance.worktree,
-    })
-    const masterCheck = await git(["show-ref", "--verify", "--quiet", "refs/heads/master"], {
-      cwd: Instance.worktree,
-    })
-    const localBranch = mainCheck.exitCode === 0 ? "main" : masterCheck.exitCode === 0 ? "master" : ""
+      const runStartScripts = Effect.fnUntraced(function* (
+        directory: string,
+        input: { projectID: ProjectID; extra?: string },
+      ) {
+        const row = yield* Effect.sync(() =>
+          Database.use((db) => db.select().from(ProjectTable).where(eq(ProjectTable.id, input.projectID)).get()),
+        )
+        const project = row ? Project.fromRow(row) : undefined
+        const startup = project?.commands?.start?.trim() ?? ""
+        const ok = yield* runStartScript(directory, startup, "project")
+        if (!ok) return false
+        yield* runStartScript(directory, input.extra ?? "", "worktree")
+        return true
+      })
 
-    const target = remoteBranch ? `${remote}/${remoteBranch}` : localBranch
-    if (!target) {
-      throw new ResetFailedError({ message: "Default branch not found" })
-    }
+      const prune = Effect.fnUntraced(function* (root: string, entries: string[]) {
+        const base = yield* canonical(root)
+        yield* Effect.forEach(
+          entries,
+          (entry) =>
+            Effect.gen(function* () {
+              const target = yield* canonical(pathSvc.resolve(root, entry))
+              if (target === base) return
+              if (!target.startsWith(`${base}${pathSvc.sep}`)) return
+              yield* fsys.remove(target, { recursive: true }).pipe(Effect.ignore)
+            }),
+          { concurrency: "unbounded" },
+        )
+      })
 
-    if (remoteBranch) {
-      const fetch = await git(["fetch", remote, remoteBranch], { cwd: Instance.worktree })
-      if (fetch.exitCode !== 0) {
-        throw new ResetFailedError({ message: errorText(fetch) || `Failed to fetch ${target}` })
-      }
-    }
+      const sweep = Effect.fnUntraced(function* (root: string) {
+        const first = yield* git(["clean", "-ffdx"], { cwd: root })
+        if (first.code === 0) return first
 
-    if (!entry.path) {
-      throw new ResetFailedError({ message: "Worktree path not found" })
-    }
+        const entries = failedRemoves(first.stderr, first.text)
+        if (!entries.length) return first
 
-    const worktreePath = entry.path
+        yield* prune(root, entries)
+        return yield* git(["clean", "-ffdx"], { cwd: root })
+      })
 
-    const resetToTarget = await git(["reset", "--hard", target], { cwd: worktreePath })
-    if (resetToTarget.exitCode !== 0) {
-      throw new ResetFailedError({ message: errorText(resetToTarget) || "Failed to reset worktree to target" })
-    }
+      const reset = Effect.fn("Worktree.reset")(function* (input: ResetInput) {
+        if (Instance.project.vcs !== "git") {
+          throw new NotGitError({ message: "Worktrees are only supported for git projects" })
+        }
 
-    const clean = await sweep(worktreePath)
-    if (clean.exitCode !== 0) {
-      throw new ResetFailedError({ message: errorText(clean) || "Failed to clean worktree" })
-    }
+        const directory = yield* canonical(input.directory)
+        const primary = yield* canonical(Instance.worktree)
+        if (directory === primary) {
+          throw new ResetFailedError({ message: "Cannot reset the primary workspace" })
+        }
 
-    const update = await git(["submodule", "update", "--init", "--recursive", "--force"], { cwd: worktreePath })
-    if (update.exitCode !== 0) {
-      throw new ResetFailedError({ message: errorText(update) || "Failed to update submodules" })
-    }
+        const list = yield* git(["worktree", "list", "--porcelain"], { cwd: Instance.worktree })
+        if (list.code !== 0) {
+          throw new ResetFailedError({ message: list.stderr || list.text || "Failed to read git worktrees" })
+        }
 
-    const subReset = await git(["submodule", "foreach", "--recursive", "git", "reset", "--hard"], {
-      cwd: worktreePath,
-    })
-    if (subReset.exitCode !== 0) {
-      throw new ResetFailedError({ message: errorText(subReset) || "Failed to reset submodules" })
-    }
+        const entry = yield* locateWorktree(parseWorktreeList(list.text), directory)
+        if (!entry?.path) {
+          throw new ResetFailedError({ message: "Worktree not found" })
+        }
 
-    const subClean = await git(["submodule", "foreach", "--recursive", "git", "clean", "-fdx"], {
-      cwd: worktreePath,
-    })
-    if (subClean.exitCode !== 0) {
-      throw new ResetFailedError({ message: errorText(subClean) || "Failed to clean submodules" })
-    }
+        const worktreePath = entry.path
 
-    const status = await git(["-c", "core.fsmonitor=false", "status", "--porcelain=v1"], { cwd: worktreePath })
-    if (status.exitCode !== 0) {
-      throw new ResetFailedError({ message: errorText(status) || "Failed to read git status" })
-    }
+        const remoteList = yield* git(["remote"], { cwd: Instance.worktree })
+        if (remoteList.code !== 0) {
+          throw new ResetFailedError({ message: remoteList.stderr || remoteList.text || "Failed to list git remotes" })
+        }
 
-    const dirty = outputText(status.stdout)
-    if (dirty) {
-      throw new ResetFailedError({ message: `Worktree reset left local changes:\n${dirty}` })
-    }
+        const remotes = remoteList.text
+          .split("\n")
+          .map((l) => l.trim())
+          .filter(Boolean)
+        const remote = remotes.includes("origin")
+          ? "origin"
+          : remotes.length === 1
+            ? remotes[0]
+            : remotes.includes("upstream")
+              ? "upstream"
+              : ""
 
-    const projectID = Instance.project.id
-    queueStartScripts(worktreePath, { projectID })
+        const remoteHead = remote
+          ? yield* git(["symbolic-ref", `refs/remotes/${remote}/HEAD`], { cwd: Instance.worktree })
+          : { code: 1, text: "", stderr: "" }
 
-    return true
-  })
+        const remoteRef = remoteHead.code === 0 ? remoteHead.text.trim() : ""
+        const remoteTarget = remoteRef ? remoteRef.replace(/^refs\/remotes\//, "") : ""
+        const remoteBranch =
+          remote && remoteTarget.startsWith(`${remote}/`) ? remoteTarget.slice(`${remote}/`.length) : ""
+
+        const [mainCheck, masterCheck] = yield* Effect.all(
+          [
+            git(["show-ref", "--verify", "--quiet", "refs/heads/main"], { cwd: Instance.worktree }),
+            git(["show-ref", "--verify", "--quiet", "refs/heads/master"], { cwd: Instance.worktree }),
+          ],
+          { concurrency: 2 },
+        )
+        const localBranch = mainCheck.code === 0 ? "main" : masterCheck.code === 0 ? "master" : ""
+
+        const target = remoteBranch ? `${remote}/${remoteBranch}` : localBranch
+        if (!target) {
+          throw new ResetFailedError({ message: "Default branch not found" })
+        }
+
+        if (remoteBranch) {
+          yield* gitExpect(
+            ["fetch", remote, remoteBranch],
+            { cwd: Instance.worktree },
+            (r) => new ResetFailedError({ message: r.stderr || r.text || `Failed to fetch ${target}` }),
+          )
+        }
+
+        yield* gitExpect(
+          ["reset", "--hard", target],
+          { cwd: worktreePath },
+          (r) => new ResetFailedError({ message: r.stderr || r.text || "Failed to reset worktree to target" }),
+        )
+
+        const cleanResult = yield* sweep(worktreePath)
+        if (cleanResult.code !== 0) {
+          throw new ResetFailedError({ message: cleanResult.stderr || cleanResult.text || "Failed to clean worktree" })
+        }
+
+        yield* gitExpect(
+          ["submodule", "update", "--init", "--recursive", "--force"],
+          { cwd: worktreePath },
+          (r) => new ResetFailedError({ message: r.stderr || r.text || "Failed to update submodules" }),
+        )
+
+        yield* gitExpect(
+          ["submodule", "foreach", "--recursive", "git", "reset", "--hard"],
+          { cwd: worktreePath },
+          (r) => new ResetFailedError({ message: r.stderr || r.text || "Failed to reset submodules" }),
+        )
+
+        yield* gitExpect(
+          ["submodule", "foreach", "--recursive", "git", "clean", "-fdx"],
+          { cwd: worktreePath },
+          (r) => new ResetFailedError({ message: r.stderr || r.text || "Failed to clean submodules" }),
+        )
+
+        const status = yield* git(["-c", "core.fsmonitor=false", "status", "--porcelain=v1"], { cwd: worktreePath })
+        if (status.code !== 0) {
+          throw new ResetFailedError({ message: status.stderr || status.text || "Failed to read git status" })
+        }
+
+        if (status.text.trim()) {
+          throw new ResetFailedError({ message: `Worktree reset left local changes:\n${status.text.trim()}` })
+        }
+
+        yield* runStartScripts(worktreePath, { projectID: Instance.project.id }).pipe(
+          Effect.catchCause((cause) => Effect.sync(() => log.error("worktree start task failed", { cause }))),
+          Effect.forkIn(scope),
+        )
+
+        return true
+      })
+
+      return Service.of({ makeWorktreeInfo, createFromInfo, create, remove, reset })
+    }),
+  )
+
+  const defaultLayer = layer.pipe(
+    Layer.provide(CrossSpawnSpawner.layer),
+    Layer.provide(NodeFileSystem.layer),
+    Layer.provide(NodePath.layer),
+  )
+  const runPromise = makeRunPromise(Service, defaultLayer)
+
+  export async function makeWorktreeInfo(name?: string) {
+    return runPromise((svc) => svc.makeWorktreeInfo(name))
+  }
+
+  export async function createFromInfo(info: Info, startCommand?: string) {
+    return runPromise((svc) => svc.createFromInfo(info, startCommand))
+  }
+
+  export async function create(input?: CreateInput) {
+    return runPromise((svc) => svc.create(input))
+  }
+
+  export async function remove(input: RemoveInput) {
+    return runPromise((svc) => svc.remove(input))
+  }
+
+  export async function reset(input: ResetInput) {
+    return runPromise((svc) => svc.reset(input))
+  }
 }

packages/opencode/test/lsp/index.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect, spyOn, test } from "bun:test"
+import path from "path"
+import * as Lsp from "../../src/lsp/index"
+import { LSPServer } from "../../src/lsp/server"
+import { Instance } from "../../src/project/instance"
+import { tmpdir } from "../fixture/fixture"
+
+describe("lsp.spawn", () => {
+  test("does not spawn builtin LSP for files outside instance", async () => {
+    await using tmp = await tmpdir()
+    const spy = spyOn(LSPServer.Typescript, "spawn").mockResolvedValue(undefined)
+
+    try {
+      await Instance.provide({
+        directory: tmp.path,
+        fn: async () => {
+          await Lsp.LSP.touchFile(path.join(tmp.path, "..", "outside.ts"))
+          await Lsp.LSP.hover({
+            file: path.join(tmp.path, "..", "hover.ts"),
+            line: 0,
+            character: 0,
+          })
+        },
+      })
+
+      expect(spy).toHaveBeenCalledTimes(0)
+    } finally {
+      spy.mockRestore()
+      await Instance.disposeAll()
+    }
+  })
+
+  test("would spawn builtin LSP for files inside instance", async () => {
+    await using tmp = await tmpdir()
+    const spy = spyOn(LSPServer.Typescript, "spawn").mockResolvedValue(undefined)
+
+    try {
+      await Instance.provide({
+        directory: tmp.path,
+        fn: async () => {
+          await Lsp.LSP.hover({
+            file: path.join(tmp.path, "src", "inside.ts"),
+            line: 0,
+            character: 0,
+          })
+        },
+      })
+
+      expect(spy).toHaveBeenCalledTimes(1)
+    } finally {
+      spy.mockRestore()
+      await Instance.disposeAll()
+    }
+  })
+})

packages/opencode/test/project/worktree.test.ts

@@ -0,0 +1,173 @@
+import { $ } from "bun"
+import { afterEach, describe, expect, test } from "bun:test"
+
+const wintest = process.platform !== "win32" ? test : test.skip
+import fs from "fs/promises"
+import path from "path"
+import { Instance } from "../../src/project/instance"
+import { Worktree } from "../../src/worktree"
+import { tmpdir } from "../fixture/fixture"
+
+function withInstance(directory: string, fn: () => Promise<any>) {
+  return Instance.provide({ directory, fn })
+}
+
+function normalize(input: string) {
+  return input.replace(/\\/g, "/").toLowerCase()
+}
+
+async function waitReady() {
+  const { GlobalBus } = await import("../../src/bus/global")
+
+  return await new Promise<{ name: string; branch: string }>((resolve, reject) => {
+    const timer = setTimeout(() => {
+      GlobalBus.off("event", on)
+      reject(new Error("timed out waiting for worktree.ready"))
+    }, 10_000)
+
+    function on(evt: { directory?: string; payload: { type: string; properties: { name: string; branch: string } } }) {
+      if (evt.payload.type !== Worktree.Event.Ready.type) return
+      clearTimeout(timer)
+      GlobalBus.off("event", on)
+      resolve(evt.payload.properties)
+    }
+
+    GlobalBus.on("event", on)
+  })
+}
+
+describe("Worktree", () => {
+  afterEach(() => Instance.disposeAll())
+
+  describe("makeWorktreeInfo", () => {
+    test("returns info with name, branch, and directory", async () => {
+      await using tmp = await tmpdir({ git: true })
+
+      const info = await withInstance(tmp.path, () => Worktree.makeWorktreeInfo())
+
+      expect(info.name).toBeDefined()
+      expect(typeof info.name).toBe("string")
+      expect(info.branch).toBe(`opencode/${info.name}`)
+      expect(info.directory).toContain(info.name)
+    })
+
+    test("uses provided name as base", async () => {
+      await using tmp = await tmpdir({ git: true })
+
+      const info = await withInstance(tmp.path, () => Worktree.makeWorktreeInfo("my-feature"))
+
+      expect(info.name).toBe("my-feature")
+      expect(info.branch).toBe("opencode/my-feature")
+    })
+
+    test("slugifies the provided name", async () => {
+      await using tmp = await tmpdir({ git: true })
+
+      const info = await withInstance(tmp.path, () => Worktree.makeWorktreeInfo("My Feature Branch!"))
+
+      expect(info.name).toBe("my-feature-branch")
+    })
+
+    test("throws NotGitError for non-git directories", async () => {
+      await using tmp = await tmpdir()
+
+      await expect(withInstance(tmp.path, () => Worktree.makeWorktreeInfo())).rejects.toThrow("WorktreeNotGitError")
+    })
+  })
+
+  describe("create + remove lifecycle", () => {
+    test("create returns worktree info and remove cleans up", async () => {
+      await using tmp = await tmpdir({ git: true })
+
+      const info = await withInstance(tmp.path, () => Worktree.create())
+
+      expect(info.name).toBeDefined()
+      expect(info.branch).toStartWith("opencode/")
+      expect(info.directory).toBeDefined()
+
+      // Wait for bootstrap to complete
+      await Bun.sleep(1000)
+
+      const ok = await withInstance(tmp.path, () => Worktree.remove({ directory: info.directory }))
+      expect(ok).toBe(true)
+    })
+
+    test("create returns after setup and fires Event.Ready after bootstrap", async () => {
+      await using tmp = await tmpdir({ git: true })
+      const ready = waitReady()
+
+      const info = await withInstance(tmp.path, () => Worktree.create())
+
+      // create returns before bootstrap completes, but the worktree already exists
+      expect(info.name).toBeDefined()
+      expect(info.branch).toStartWith("opencode/")
+
+      const text = await $`git worktree list --porcelain`.cwd(tmp.path).quiet().text()
+      const dir = await fs.realpath(info.directory).catch(() => info.directory)
+      expect(normalize(text)).toContain(normalize(dir))
+
+      // Event.Ready fires after bootstrap finishes in the background
+      const props = await ready
+      expect(props.name).toBe(info.name)
+      expect(props.branch).toBe(info.branch)
+
+      // Cleanup
+      await withInstance(info.directory, () => Instance.dispose())
+      await Bun.sleep(100)
+      await withInstance(tmp.path, () => Worktree.remove({ directory: info.directory }))
+    })
+
+    test("create with custom name", async () => {
+      await using tmp = await tmpdir({ git: true })
+      const ready = waitReady()
+
+      const info = await withInstance(tmp.path, () => Worktree.create({ name: "test-workspace" }))
+
+      expect(info.name).toBe("test-workspace")
+      expect(info.branch).toBe("opencode/test-workspace")
+
+      // Cleanup
+      await ready
+      await withInstance(info.directory, () => Instance.dispose())
+      await Bun.sleep(100)
+      await withInstance(tmp.path, () => Worktree.remove({ directory: info.directory }))
+    })
+  })
+
+  describe("createFromInfo", () => {
+    wintest("creates and bootstraps git worktree", async () => {
+      await using tmp = await tmpdir({ git: true })
+
+      const info = await withInstance(tmp.path, () => Worktree.makeWorktreeInfo("from-info-test"))
+      await withInstance(tmp.path, () => Worktree.createFromInfo(info))
+
+      // Worktree should exist in git (normalize slashes for Windows)
+      const list = await $`git worktree list --porcelain`.cwd(tmp.path).quiet().text()
+      const normalizedList = list.replace(/\\/g, "/")
+      const normalizedDir = info.directory.replace(/\\/g, "/")
+      expect(normalizedList).toContain(normalizedDir)
+
+      // Cleanup
+      await withInstance(tmp.path, () => Worktree.remove({ directory: info.directory }))
+    })
+  })
+
+  describe("remove edge cases", () => {
+    test("remove non-existent directory succeeds silently", async () => {
+      await using tmp = await tmpdir({ git: true })
+
+      const ok = await withInstance(tmp.path, () =>
+        Worktree.remove({ directory: path.join(tmp.path, "does-not-exist") }),
+      )
+      expect(ok).toBe(true)
+    })
+
+    test("throws NotGitError for non-git directories", async () => {
+      await using tmp = await tmpdir()
+
+      await expect(withInstance(tmp.path, () => Worktree.remove({ directory: "/tmp/fake" }))).rejects.toThrow(
+        "WorktreeNotGitError",
+      )
+    })
+  })
+})

packages/opencode/test/snapshot/snapshot.test.ts

@@ -181,7 +181,7 @@ test("symlink handling", async () => {
   })
 })
 
-test("large file handling", async () => {
+test("file under size limit handling", async () => {
   await using tmp = await bootstrap()
   await Instance.provide({
     directory: tmp.path,
@@ -196,6 +196,23 @@ test("large file handling", async () => {
   })
 })
 
+test("large added files are skipped", async () => {
+  await using tmp = await bootstrap()
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      const before = await Snapshot.track()
+      expect(before).toBeTruthy()
+
+      await Filesystem.write(`${tmp.path}/huge.txt`, new Uint8Array(2 * 1024 * 1024 + 1))
+
+      expect((await Snapshot.patch(before!)).files).toEqual([])
+      expect(await Snapshot.diff(before!)).toBe("")
+      expect(await Snapshot.track()).toBe(before)
+    },
+  })
+})
+
 test("nested directory revert", async () => {
   await using tmp = await bootstrap()
   await Instance.provide({

packages/sdk/js/src/client.ts

@@ -5,6 +5,31 @@ import { type Config } from "./gen/client/types.gen.js"
 import { OpencodeClient } from "./gen/sdk.gen.js"
 export { type Config as OpencodeClientConfig, OpencodeClient }
 
+const keys = [
+  ["x-opencode-directory", "directory"],
+  ["x-opencode-workspace", "workspace"],
+] as const
+
+function move(req: Request) {
+  if (req.method !== "GET" && req.method !== "HEAD") return req
+
+  let url: URL | undefined
+
+  for (const [header, key] of keys) {
+    const value = req.headers.get(header)
+    if (!value) continue
+    url ??= new URL(req.url)
+    if (!url.searchParams.has(key)) url.searchParams.set(key, value)
+  }
+
+  if (!url) return req
+  const next = new Request(url, req)
+  for (const [header] of keys) {
+    next.headers.delete(header)
+  }
+  return next
+}
+
 export function createOpencodeClient(config?: Config & { directory?: string }) {
   if (!config?.fetch) {
     const customFetch: any = (req: any) => {
@@ -26,5 +51,8 @@ export function createOpencodeClient(config?: Config & { directory?: string }) {
   }
 
   const client = createClient(config)
+  if (typeof window === "object" && typeof document === "object") {
+    client.interceptors.request.use(move)
+  }
   return new OpencodeClient({ client })
 }

packages/sdk/js/src/v2/client.ts

@@ -5,6 +5,31 @@ import { type Config } from "./gen/client/types.gen.js"
 import { OpencodeClient } from "./gen/sdk.gen.js"
 export { type Config as OpencodeClientConfig, OpencodeClient }
 
+const keys = [
+  ["x-opencode-directory", "directory"],
+  ["x-opencode-workspace", "workspace"],
+] as const
+
+function move(req: Request) {
+  if (req.method !== "GET" && req.method !== "HEAD") return req
+
+  let url: URL | undefined
+
+  for (const [header, key] of keys) {
+    const value = req.headers.get(header)
+    if (!value) continue
+    url ??= new URL(req.url)
+    if (!url.searchParams.has(key)) url.searchParams.set(key, value)
+  }
+
+  if (!url) return req
+  const next = new Request(url, req)
+  for (const [header] of keys) {
+    next.headers.delete(header)
+  }
+  return next
+}
+
 export function createOpencodeClient(config?: Config & { directory?: string; experimental_workspaceID?: string }) {
   if (!config?.fetch) {
     const customFetch: any = (req: any) => {
@@ -35,5 +60,8 @@ export function createOpencodeClient(config?: Config & { directory?: string; exp
   }
 
   const client = createClient(config)
+  if (typeof window === "object" && typeof document === "object") {
+    client.interceptors.request.use(move)
+  }
   return new OpencodeClient({ client })
 }

packages/storybook/.storybook/main.ts

@@ -2,6 +2,7 @@ import { defineMain } from "storybook-solidjs-vite"
 import path from "node:path"
 import { fileURLToPath } from "node:url"
 import tailwindcss from "@tailwindcss/vite"
+import { playgroundCss } from "./playground-css-plugin"
 
 const here = path.dirname(fileURLToPath(import.meta.url))
 const ui = path.resolve(here, "../../ui")
@@ -24,7 +25,7 @@ export default defineMain({
   async viteFinal(config) {
     const { mergeConfig, searchForWorkspaceRoot } = await import("vite")
     return mergeConfig(config, {
-      plugins: [tailwindcss()],
+      plugins: [tailwindcss(), playgroundCss()],
       resolve: {
         dedupe: ["solid-js", "solid-js/web", "@solidjs/meta"],
         alias: [

packages/storybook/.storybook/playground-css-plugin.ts

@@ -0,0 +1,136 @@
+/**
+ * Vite plugin that exposes a POST endpoint for the timeline playground
+ * to write CSS changes back to source files on disk.
+ *
+ * POST /__playground/apply-css
+ * Body: { edits: Array<{ file: string; anchor: string; prop: string; value: string }> }
+ *
+ * For each edit the plugin finds `anchor` in the file, then locates the
+ * next `prop: <anything>;` after it and replaces the value portion.
+ * `file` is a basename resolved relative to packages/ui/src/components/.
+ */
+import type { Plugin } from "vite"
+import type { IncomingMessage, ServerResponse } from "node:http"
+import fs from "node:fs"
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+
+const here = path.dirname(fileURLToPath(import.meta.url))
+const root = path.resolve(here, "../../ui/src/components")
+
+const ENDPOINT = "/__playground/apply-css"
+
+type Edit = { file: string; anchor: string; prop: string; value: string }
+type Result = { file: string; prop: string; ok: boolean; error?: string }
+
+function applyEdits(content: string, edits: Edit[]): { content: string; results: Result[] } {
+  const results: Result[] = []
+  let out = content
+
+  for (const edit of edits) {
+    const name = edit.file
+    const idx = out.indexOf(edit.anchor)
+    if (idx === -1) {
+      results.push({ file: name, prop: edit.prop, ok: false, error: `Anchor not found: ${edit.anchor.slice(0, 50)}` })
+      continue
+    }
+
+    // From the anchor position, find the next occurrence of `prop: <value>`
+    // We match `prop:` followed by any value up to `;`
+    const after = out.slice(idx)
+    const re = new RegExp(`(${escapeRegex(edit.prop)}\\s*:\\s*)([^;]+)(;)`)
+    const match = re.exec(after)
+    if (!match) {
+      results.push({ file: name, prop: edit.prop, ok: false, error: `Property "${edit.prop}" not found after anchor` })
+      continue
+    }
+
+    const start = idx + match.index + match[1].length
+    const end = start + match[2].length
+    out = out.slice(0, start) + edit.value + out.slice(end)
+    results.push({ file: name, prop: edit.prop, ok: true })
+  }
+
+  return { content: out, results }
+}
+
+function escapeRegex(s: string) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+}
+
+export function playgroundCss(): Plugin {
+  return {
+    name: "playground-css",
+    configureServer(server) {
+      server.middlewares.use((req: IncomingMessage, res: ServerResponse, next: () => void) => {
+        if (req.url !== ENDPOINT) return next()
+        if (req.method !== "POST") {
+          res.statusCode = 405
+          res.setHeader("Content-Type", "application/json")
+          res.end(JSON.stringify({ error: "Method not allowed" }))
+          return
+        }
+
+        let data = ""
+        req.on("data", (chunk: Buffer) => {
+          data += chunk.toString()
+        })
+        req.on("end", () => {
+          let payload: { edits: Edit[] }
+          try {
+            payload = JSON.parse(data)
+          } catch {
+            res.statusCode = 400
+            res.setHeader("Content-Type", "application/json")
+            res.end(JSON.stringify({ error: "Invalid JSON" }))
+            return
+          }
+
+          if (!Array.isArray(payload.edits)) {
+            res.statusCode = 400
+            res.setHeader("Content-Type", "application/json")
+            res.end(JSON.stringify({ error: "Missing edits array" }))
+            return
+          }
+
+          // Group by file
+          const grouped = new Map<string, Edit[]>()
+          for (const edit of payload.edits) {
+            if (!edit.file || !edit.anchor || !edit.prop || edit.value === undefined) continue
+            const abs = path.resolve(root, edit.file)
+            if (!abs.startsWith(root)) continue
+            const key = abs
+            if (!grouped.has(key)) grouped.set(key, [])
+            grouped.get(key)!.push(edit)
+          }
+
+          const results: Result[] = []
+
+          for (const [abs, edits] of grouped) {
+            const name = path.basename(abs)
+            if (!fs.existsSync(abs)) {
+              for (const e of edits) results.push({ file: name, prop: e.prop, ok: false, error: "File not found" })
+              continue
+            }
+
+            try {
+              const content = fs.readFileSync(abs, "utf-8")
+              const applied = applyEdits(content, edits)
+              results.push(...applied.results)
+
+              if (applied.results.some((r) => r.ok)) {
+                fs.writeFileSync(abs, applied.content, "utf-8")
+              }
+            } catch (err) {
+              for (const e of edits) results.push({ file: name, prop: e.prop, ok: false, error: String(err) })
+            }
+          }
+
+          res.statusCode = 200
+          res.setHeader("Content-Type", "application/json")
+          res.end(JSON.stringify({ results }))
+        })
+      })
+    },
+  }
+}

packages/ui/src/components/font.tsx

@@ -5,7 +5,7 @@ import ibmPlexMonoBold from "../assets/fonts/ibm-plex-mono-bold.woff2"
 import ibmPlexMonoMedium from "../assets/fonts/ibm-plex-mono-medium.woff2"
 import ibmPlexMonoRegular from "../assets/fonts/ibm-plex-mono.woff2"
 
-export const Font = () => {
+export const Font = (props: { preloadMono?: boolean }) => {
   return (
     <>
       <Style>{`
@@ -56,7 +56,9 @@ export const Font = () => {
       `}</Style>
       <Show when={typeof location === "undefined" || location.protocol !== "file:"}>
         <Link rel="preload" href={inter} as="font" type="font/woff2" crossorigin="anonymous" />
-        <Link rel="preload" href={ibmPlexMonoRegular} as="font" type="font/woff2" crossorigin="anonymous" />
+        <Show when={props.preloadMono !== false}>
+          <Link rel="preload" href={ibmPlexMonoRegular} as="font" type="font/woff2" crossorigin="anonymous" />
+        </Show>
       </Show>
     </>
   )

packages/ui/src/components/message-part.css

@@ -248,11 +248,6 @@
     opacity: 1;
     pointer-events: auto;
   }
-
-  [data-component="markdown"] {
-    margin-top: 0;
-    font-size: var(--font-size-base);
-  }
 }
 
 [data-component="compaction-part"] {

packages/ui/src/components/session-turn.css

@@ -85,10 +85,6 @@
     flex-direction: column;
     align-self: stretch;
     gap: 12px;
-
-    > :first-child > [data-component="markdown"]:first-child {
-      margin-top: 0;
-    }
   }
 
   [data-slot="session-turn-diffs"] {
@@ -230,3 +226,7 @@
     display: none;
   }
 }
+
+[data-slot="session-turn-list"] {
+  gap: 48px;
+}

script/beta.ts

@@ -1,6 +1,9 @@
 #!/usr/bin/env bun
 
 import { $ } from "bun"
+import fs from "fs/promises"
+
+const model = "opencode/gpt-5.3-codex"
 
 interface PR {
   number: number
@@ -50,17 +53,76 @@ async function cleanup() {
   } catch {}
 }
 
-async function fix(pr: PR, files: string[]) {
+function lines(prs: PR[]) {
+  return prs.map((x) => `- #${x.number}: ${x.title}`).join("\n") || "(none)"
+}
+
+async function typecheck() {
+  console.log("  Running typecheck...")
+
+  try {
+    await $`bun typecheck`.cwd("packages/opencode")
+    return true
+  } catch (err) {
+    console.log(`Typecheck failed: ${err}`)
+    return false
+  }
+}
+
+async function build() {
+  console.log("  Running final build smoke check...")
+
+  try {
+    await $`./script/build.ts --single`.cwd("packages/opencode")
+    return true
+  } catch (err) {
+    console.log(`Build failed: ${err}`)
+    return false
+  }
+}
+
+async function install() {
+  console.log("  Regenerating bun.lock...")
+
+  try {
+    await fs.rm("bun.lock", { force: true })
+    await $`bun install`
+    await $`git add bun.lock`
+    return true
+  } catch (err) {
+    console.log(`Install failed: ${err}`)
+    return false
+  }
+}
+
+async function fix(pr: PR, files: string[], prs: PR[], applied: number[], idx: number) {
   console.log(`  Trying to auto-resolve ${files.length} conflict(s) with opencode...`)
+
+  const done = lines(prs.filter((x) => applied.includes(x.number)))
+  const next = lines(prs.slice(idx + 1))
+
   const prompt = [
     `Resolve the current git merge conflicts while merging PR #${pr.number} into the beta branch.`,
-    `Only touch these files: ${files.join(", ")}.`,
+    `PR #${pr.number}: ${pr.title}`,
+    `Start with these conflicted files: ${files.join(", ")}.`,
+    `Merged PRs on HEAD:\n${done}`,
+    `Pending PRs after this one (context only):\n${next}`,
+    "IMPORTANT: The conflict resolution must be consistent with already-merged PRs.",
+    "Pending PRs are context only; do not introduce their changes unless they are already present on HEAD.",
+    "Prefer already-merged PRs over the base branch when resolving stacked conflicts.",
+    "If bun.lock is conflicted, do not hand-merge it. Delete bun.lock and run bun install after the code conflicts are resolved.",
+    "If a PR already deleted a file/directory, do not re-add it, instead apply changes in the new semantic location.",
+    "If a PR already changed an import, keep that change.",
+    "After resolving the conflicts, run `bun typecheck` in `packages/opencode`.",
+    "If typecheck fails, you may also update any files reported by typecheck.",
+    "Keep any non-conflict edits narrowly scoped to restoring a valid merged state for the current PR batch.",
+    "Fix any merge-caused typecheck errors before finishing.",
     "Keep the merge in progress, do not abort the merge, and do not create a commit.",
-    "When done, leave the working tree with no unmerged files.",
+    "When done, leave the working tree with no unmerged files and a passing typecheck.",
   ].join("\n")
 
   try {
-    await $`opencode run -m opencode/gpt-5.3-codex ${prompt}`
+    await $`opencode run -m ${model} ${prompt}`
   } catch (err) {
     console.log(`  opencode failed: ${err}`)
     return false
@@ -72,10 +134,68 @@ async function fix(pr: PR, files: string[]) {
     return false
   }
 
+  if (files.includes("bun.lock") && !(await install())) return false
+
+  if (!(await typecheck())) return false
+
   console.log("  Conflicts resolved with opencode")
   return true
 }
 
+async function smoke(prs: PR[], applied: number[]) {
+  console.log("\nRunning final smoke check with opencode...")
+
+  const done = lines(prs.filter((x) => applied.includes(x.number)))
+  const prompt = [
+    "The beta merge batch is complete.",
+    `Merged PRs on HEAD:\n${done}`,
+    "Run `bun typecheck` in `packages/opencode`.",
+    "Run `./script/build.ts --single` in `packages/opencode`.",
+    "Fix any merge-caused issues until both commands pass.",
+    "Do not create a commit.",
+  ].join("\n")
+
+  try {
+    await $`opencode run -m ${model} ${prompt}`
+  } catch (err) {
+    console.log(`Smoke fix failed: ${err}`)
+    return false
+  }
+
+  if (!(await typecheck())) {
+    return false
+  }
+
+  if (!(await build())) {
+    return false
+  }
+
+  const out = await $`git status --porcelain`.text()
+  if (!out.trim()) {
+    console.log("Smoke check passed")
+    return true
+  }
+
+  try {
+    await $`git add -A`
+    await $`git commit -m "Fix beta integration"`
+  } catch (err) {
+    console.log(`Failed to commit smoke fixes: ${err}`)
+    return false
+  }
+
+  if (!(await typecheck())) {
+    return false
+  }
+
+  if (!(await build())) {
+    return false
+  }
+
+  console.log("Smoke check passed")
+  return true
+}
+
 async function main() {
   console.log("Fetching open PRs with beta label...")
 
@@ -99,8 +219,8 @@ async function main() {
   const applied: number[] = []
   const failed: FailedPR[] = []
 
-  for (const pr of prs) {
-    console.log(`\nProcessing PR #${pr.number}: ${pr.title}`)
+  for (const [idx, pr] of prs.entries()) {
+    console.log(`\nProcessing PR ${idx + 1}/${prs.length} #${pr.number}: ${pr.title}`)
 
     console.log("  Fetching PR head...")
     try {
@@ -119,7 +239,7 @@ async function main() {
       const files = await conflicts()
       if (files.length > 0) {
         console.log("  Failed to merge (conflicts)")
-        if (!(await fix(pr, files))) {
+        if (!(await fix(pr, files, prs, applied, idx))) {
           await cleanup()
           failed.push({ number: pr.number, title: pr.title, reason: "Merge conflicts" })
           await commentOnPR(pr.number, "Merge conflicts with dev branch")
@@ -174,6 +294,13 @@ async function main() {
     throw new Error(`${failed.length} PR(s) failed to merge`)
   }
 
+  if (applied.length > 0) {
+    const ok = await smoke(prs, applied)
+    if (!ok) {
+      throw new Error("Final smoke check failed")
+    }
+  }
+
   console.log("\nChecking if beta branch has changes...")
   await $`git fetch origin beta`
 

script/github/close-issues.ts

@@ -0,0 +1,97 @@
+#!/usr/bin/env bun
+
+const repo = "anomalyco/opencode"
+const days = 60
+const msg =
+  "To stay organized issues are automatically closed after 90 days of no activity. If the issue is still relevant please open a new one."
+
+const token = process.env.GITHUB_TOKEN
+if (!token) {
+  console.error("GITHUB_TOKEN environment variable is required")
+  process.exit(1)
+}
+
+const cutoff = new Date(Date.now() - days * 24 * 60 * 60 * 1000)
+
+type Issue = {
+  number: number
+  updated_at: string
+}
+
+const headers = {
+  Authorization: `Bearer ${token}`,
+  "Content-Type": "application/json",
+  Accept: "application/vnd.github+json",
+  "X-GitHub-Api-Version": "2022-11-28",
+}
+
+async function close(num: number) {
+  const base = `https://api.github.com/repos/${repo}/issues/${num}`
+
+  const comment = await fetch(`${base}/comments`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ body: msg }),
+  })
+  if (!comment.ok) throw new Error(`Failed to comment #${num}: ${comment.status} ${comment.statusText}`)
+
+  const patch = await fetch(base, {
+    method: "PATCH",
+    headers,
+    body: JSON.stringify({ state: "closed", state_reason: "completed" }),
+  })
+  if (!patch.ok) throw new Error(`Failed to close #${num}: ${patch.status} ${patch.statusText}`)
+
+  console.log(`Closed https://github.com/${repo}/issues/${num}`)
+}
+
+async function main() {
+  let page = 1
+  let closed = 0
+
+  while (true) {
+    const res = await fetch(
+      `https://api.github.com/repos/${repo}/issues?state=open&sort=updated&direction=asc&per_page=100&page=${page}`,
+      { headers },
+    )
+    if (!res.ok) throw new Error(res.statusText)
+
+    const all = (await res.json()) as Issue[]
+    if (all.length === 0) break
+    console.log(`Fetched page ${page} ${all.length} issues`)
+
+    const stale: number[] = []
+    for (const i of all) {
+      const updated = new Date(i.updated_at)
+      if (updated < cutoff) {
+        stale.push(i.number)
+      } else {
+        console.log(`\nFound fresh issue #${i.number}, stopping`)
+        if (stale.length > 0) {
+          for (const num of stale) {
+            await close(num)
+            closed++
+          }
+        }
+        console.log(`Closed ${closed} issues total`)
+        return
+      }
+    }
+
+    if (stale.length > 0) {
+      for (const num of stale) {
+        await close(num)
+        closed++
+      }
+    }
+
+    page++
+  }
+
+  console.log(`Closed ${closed} issues total`)
+}
+
+main().catch((err) => {
+  console.error("Error:", err)
+  process.exit(1)
+})