fix(core): preserve provider session failures

Co-authored-by: Test <test@opencode.test>

AGENTS.md

@@ -28,6 +28,7 @@ Examples: `fix(tui): simplify thinking toggle styling`, `docs: update contributi
 - Rely on type inference when possible; avoid explicit type annotations or interfaces unless necessary for exports or clarity
 - Prefer functional array methods (flatMap, filter, map) over for loops; use type guards on filter to maintain type inference downstream
 - In `src/config`, follow the existing self-export pattern at the top of the file (for example `export * as ConfigAgent from "./agent"`) when adding a new config module.
+- In Effect generators, bind services to named variables before calling methods. Do not use nested service yields such as `yield* (yield* Foo.Service).bar()`.
 
 Reduce total variable count by inlining when a value is only used once.
 

bun.lock

@@ -539,6 +539,7 @@
         "@openauthjs/openauth": "catalog:",
         "@opencode-ai/llm": "workspace:*",
         "@opencode-ai/plugin": "workspace:*",
+        "@opencode-ai/protocol": "workspace:*",
         "@opencode-ai/schema": "workspace:*",
         "@opencode-ai/script": "workspace:*",
         "@opencode-ai/sdk": "workspace:*",
@@ -656,6 +657,18 @@
         "@opentui/solid",
       ],
     },
+    "packages/protocol": {
+      "name": "@opencode-ai/protocol",
+      "dependencies": {
+        "@opencode-ai/schema": "workspace:*",
+        "effect": "catalog:",
+      },
+      "devDependencies": {
+        "@tsconfig/bun": "catalog:",
+        "@types/bun": "catalog:",
+        "@typescript/native-preview": "catalog:",
+      },
+    },
     "packages/schema": {
       "name": "@opencode-ai/schema",
       "dependencies": {
@@ -697,6 +710,7 @@
       "version": "1.17.10",
       "dependencies": {
         "@opencode-ai/core": "workspace:*",
+        "@opencode-ai/protocol": "workspace:*",
         "drizzle-orm": "catalog:",
         "effect": "catalog:",
       },
@@ -1863,6 +1877,8 @@
 
     "@opencode-ai/plugin": ["@opencode-ai/plugin@workspace:packages/plugin"],
 
+    "@opencode-ai/protocol": ["@opencode-ai/protocol@workspace:packages/protocol"],
+
     "@opencode-ai/schema": ["@opencode-ai/schema@workspace:packages/schema"],
 
     "@opencode-ai/script": ["@opencode-ai/script@workspace:packages/script"],

nix/hashes.json

@@ -1,8 +1,8 @@
 {
   "nodeModules": {
-    "x86_64-linux": "sha256-gV5PVd9+MB5tM3pPH+S6YhGPRPXqHv5Ayw+8gngNlqY=",
-    "aarch64-linux": "sha256-1pxoseGyRwAawiPblo8FeaaAAdl0mkKRs6BS8qxxoh0=",
-    "aarch64-darwin": "sha256-81D/v2Ka7mtFHp4iM9eB9kjFcumSTvR07ABb1ahRLS0=",
-    "x86_64-darwin": "sha256-nolxEbc/1ItbmuHPUjaSu3DHwBV/0/Si2xuM6wpiq0k="
+    "x86_64-linux": "sha256-Q0CW2wMhVtRM3uILV1kvKAzpQJqBxTp4MLsGlsSoT1s=",
+    "aarch64-linux": "sha256-UHpoDqqV+umG47LENB7DLxbCqvwjTCDjHWIFiv6Vmk8=",
+    "aarch64-darwin": "sha256-rqlFositEiB1wzx6Jcp5yVQlp8LLYBW+79KXmRpXh2Q=",
+    "x86_64-darwin": "sha256-BKr4YQio3eP0VLZ0z+oyaM93H8dAbSwmlzxT8PH6W8M="
   }
 }

packages/app/e2e/performance/timeline/session-timeline-benchmark.fixture.ts

@@ -119,7 +119,6 @@ export async function setupTimelineBenchmark(page: Page, options: { historyTurns
           editToolPartsExpanded: true,
           shellToolPartsExpanded: true,
           showReasoningSummaries: true,
-          showSessionProgressBar: true,
         },
       }),
     )

packages/app/e2e/performance/timeline/timeline-test-helpers.ts

@@ -13,7 +13,6 @@ export async function installTimelineSettings(page: Page) {
           editToolPartsExpanded: true,
           shellToolPartsExpanded: true,
           showReasoningSummaries: true,
-          showSessionProgressBar: true,
         },
       }),
     )

packages/app/e2e/regression/session-timeline-collapse-state.spec.ts

@@ -261,7 +261,6 @@ async function configurePage(page: Page) {
           editToolPartsExpanded: true,
           shellToolPartsExpanded: true,
           showReasoningSummaries: true,
-          showSessionProgressBar: true,
         },
       }),
     )

packages/app/e2e/regression/session-timeline-context-resize.spec.ts

@@ -47,7 +47,6 @@ async function configurePage(page: Page) {
           editToolPartsExpanded: true,
           shellToolPartsExpanded: true,
           showReasoningSummaries: true,
-          showSessionProgressBar: true,
         },
       }),
     )

packages/app/e2e/smoke/session-timeline.spec.ts

@@ -362,7 +362,6 @@ async function configureSmokePage(page: Page, directory: string) {
           editToolPartsExpanded: true,
           shellToolPartsExpanded: true,
           showReasoningSummaries: true,
-          showSessionProgressBar: true,
         },
       }),
     )

packages/app/src/app.tsx

@@ -31,8 +31,8 @@ import { CommandProvider } from "@/context/command"
 import { CommentsProvider } from "@/context/comments"
 import { FileProvider } from "@/context/file"
 import { ServerSDKProvider, useServerSDK } from "@/context/server-sdk"
-import { ServerSyncProvider } from "@/context/server-sync"
-import { GlobalProvider, useGlobal } from "@/context/global"
+import { ServerSyncProvider, useServerSync } from "@/context/server-sync"
+import { GlobalProvider } from "@/context/global"
 import { HighlightsProvider } from "@/context/highlights"
 import { LanguageProvider, type Locale, useLanguage } from "@/context/language"
 import { LayoutProvider } from "@/context/layout"
@@ -51,7 +51,7 @@ import LegacyLayout from "@/pages/layout"
 import NewLayout from "@/pages/layout-new"
 import { ErrorPage } from "./pages/error"
 import { useCheckServerHealth } from "./utils/server-health"
-import { legacySessionHref, requireServerKey, rootSession, sessionHref } from "./utils/session-route"
+import { legacySessionHref, requireServerKey, sessionHref } from "./utils/session-route"
 
 import Session from "@/pages/session"
 import { NewHome, LegacyHome } from "@/pages/home"
@@ -109,37 +109,26 @@ function ResolvedTargetSessionRoute() {
   const params = useParams<{ serverKey: string; id: string }>()
   const settings = useSettings()
   const tabs = useTabs()
-  const global = useGlobal()
-  const serverSDK = useServerSDK()
+  const sync = useServerSync()
   const serverKey = createMemo(() => requireServerKey(params.serverKey))
-  const placement = createMemo(() => global.sessionPlacement.get(serverKey(), params.id))
+  const cached = createMemo(() => sync().session.lineage.peek(params.id))
   const [resolved] = createResource(
     () => {
-      if (placement()) return
-      return { id: params.id, sdk: serverSDK() }
-    },
-    async ({ id, sdk }) => {
-      const session = (await sdk.client.session.get({ sessionID: id })).data!
-      const root = await rootSession(session, (sessionID) =>
-        sdk.client.session.get({ sessionID }).then((result) => result.data!),
-      )
-      return global.sessionPlacement.set({
-        server: serverKey(),
-        leafID: session.id,
-        rootID: root.id,
-        directory: session.directory,
-      })
+      if (cached()) return
+      return { id: params.id, sync: sync() }
     },
+    ({ id, sync }) => sync.session.lineage.resolve(id),
   )
-  const directory = createMemo(() => placement()?.directory ?? resolved()?.directory)
+  const current = createMemo(() => cached() ?? resolved())
+  const directory = createMemo(() => current()?.session.directory)
   const targetDirectory = () => directory()!
 
   createEffect(() => {
-    const current = placement() ?? resolved()
-    if (!current) return
+    const session = current()
+    if (!session) return
     tabs.addSessionTab({
       server: serverKey(),
-      sessionId: current.rootID,
+      sessionId: session.root.id,
     })
   })
 

packages/app/src/components/prompt-input/submit.test.ts

@@ -185,6 +185,10 @@ beforeAll(async () => {
 
   mock.module("@/context/server-sync", () => ({
     useServerSync: () => () => ({
+      session: {
+        remember: () => undefined,
+        set: () => undefined,
+      },
       child: (directory: string) => {
         syncedDirectories.push(directory)
         storedSessions[directory] ??= []

packages/app/src/components/prompt-input/submit.ts

@@ -56,16 +56,14 @@ const draftImages = (prompt: Prompt) => prompt.filter((part): part is ImageAttac
 export async function sendFollowupDraft(input: FollowupSendInput) {
   const text = draftText(input.draft.prompt)
   const images = draftImages(input.draft.prompt)
-  const [, setStore] = input.serverSync.child(input.draft.sessionDirectory)
-
   const setBusy = () => {
     if (!input.optimisticBusy) return
-    setStore("session_status", input.draft.sessionID, { type: "busy" })
+    input.serverSync.session.set("session_status", input.draft.sessionID, { type: "busy" })
   }
 
   const setIdle = () => {
     if (!input.optimisticBusy) return
-    setStore("session_status", input.draft.sessionID, { type: "idle" })
+    input.serverSync.session.set("session_status", input.draft.sessionID, { type: "idle" })
   }
 
   const wait = async () => {
@@ -234,9 +232,7 @@ export function createPromptSubmit(input: PromptSubmitInput) {
     const sessionID = params.id
     if (!sessionID) return Promise.resolve()
 
-    serverSync().todo.set(sessionID, [])
-    const [, setStore] = serverSync().child(sdk().directory)
-    setStore("todo", sessionID, [])
+    serverSync().session.set("todo", sessionID, [])
 
     input.onAbort?.()
 
@@ -282,6 +278,7 @@ export function createPromptSubmit(input: PromptSubmitInput) {
   }
 
   const seed = (dir: string, info: Session) => {
+    serverSync().session.remember(info)
     const [, setStore] = serverSync().child(dir)
     setStore("session", (list: Session[]) => {
       const result = Binary.search(list, info.id, (item) => item.id)

packages/app/src/components/settings-general.tsx

@@ -335,18 +335,6 @@ export const SettingsGeneral: Component = () => {
           </div>
         </SettingsRow>
 
-        <SettingsRow
-          title={language.t("settings.general.row.showSessionProgressBar.title")}
-          description={language.t("settings.general.row.showSessionProgressBar.description")}
-        >
-          <div data-action="settings-show-session-progress-bar">
-            <Switch
-              checked={settings.general.showSessionProgressBar()}
-              onChange={(checked) => settings.general.setShowSessionProgressBar(checked)}
-            />
-          </div>
-        </SettingsRow>
-
         <SettingsRow
           title={language.t("settings.general.row.newLayoutDesigns.title")}
           description={language.t("settings.general.row.newLayoutDesigns.description")}

packages/app/src/components/settings-v2/general.tsx

@@ -318,18 +318,6 @@ export const SettingsGeneralV2: Component = () => {
           </div>
         </SettingsRowV2>
 
-        <SettingsRowV2
-          title={language.t("settings.general.row.showSessionProgressBar.title")}
-          description={language.t("settings.general.row.showSessionProgressBar.description")}
-        >
-          <div data-action="settings-show-session-progress-bar">
-            <Switch
-              checked={settings.general.showSessionProgressBar()}
-              onChange={(checked) => settings.general.setShowSessionProgressBar(checked)}
-            />
-          </div>
-        </SettingsRowV2>
-
         <SettingsRowV2
           title={language.t("settings.general.row.newLayoutDesigns.title")}
           description={language.t("settings.general.row.newLayoutDesigns.description")}

packages/app/src/components/titlebar.tsx

@@ -512,38 +512,15 @@ export function Titlebar(props: { update?: TitlebarUpdate }) {
                             return conn ? global.ensureServerCtx(conn) : undefined
                           })
                           const sdk = createMemo(() => serverCtx()?.sdk ?? null)
-                          const cachedSession = createMemo(() => {
-                            const placement = global.sessionPlacement.get(tab.server, tab.sessionId)
-                            const ctx = serverCtx()
-                            if (!placement || !ctx) return
-                            return ctx.sync
-                              .child(placement.directory, { bootstrap: false })[0]
-                              .session.find((session) => session.id === tab.sessionId)
-                          })
+                          const cachedSession = createMemo(() => serverCtx()?.sync.session.peek(tab.sessionId))
 
                           const [loadedSession] = createResource(
                             () => {
-                              if (cachedSession()) return null
                               const id = tab.sessionId
                               const ctx = serverCtx()
                               return ctx ? { id, ctx } : null
                             },
-                            ({ id, ctx }) =>
-                              ctx.sdk.client.session
-                                .get({ sessionID: id })
-                                .then((x) => {
-                                  const session = x.data
-                                  if (!session) return
-                                  if (!session.parentID)
-                                    global.sessionPlacement.set({
-                                      server: tab.server,
-                                      leafID: session.id,
-                                      rootID: session.id,
-                                      directory: session.directory,
-                                    })
-                                  return session
-                                })
-                                .catch(() => undefined),
+                            ({ id, ctx }) => ctx.sync.session.resolve(id).catch(() => undefined),
                           )
                           const session = createMemo(() => cachedSession() ?? loadedSession())
                           let prefetched = false

packages/app/src/context/directory-sync.ts

@@ -1,175 +1,23 @@
-import { batch, createMemo } from "solid-js"
-import { createStore, produce, reconcile } from "solid-js/store"
 import { Binary } from "@opencode-ai/core/util/binary"
-import { retry } from "@opencode-ai/core/util/retry"
-import {
-  clearSessionPrefetch,
-  getSessionPrefetch,
-  getSessionPrefetchPromise,
-  setSessionPrefetch,
-} from "./global-sync/session-prefetch"
 import type { Message, Part } from "@opencode-ai/sdk/v2/client"
-import { SESSION_CACHE_LIMIT, dropSessionCaches, pickSessionCacheEvictions } from "./global-sync/session-cache"
-import { diffs as list, message as clean } from "@/utils/diffs"
-import { type createServerSdkContext } from "./server-sdk"
-import { type createServerSyncContextInner } from "./server-sync"
-
-const SKIP_PARTS = new Set(["patch", "step-start", "step-finish"])
-
-function sortParts(parts: Part[]) {
-  return parts.filter((part) => !!part?.id).sort((a, b) => cmp(a.id, b.id))
-}
-
-function runInflight(map: Map<string, Promise<void>>, key: string, task: () => Promise<void>) {
-  const pending = map.get(key)
-  if (pending) return pending
-  const promise = task().finally(() => {
-    map.delete(key)
-  })
-  map.set(key, promise)
-  return promise
-}
-
-const keyFor = (directory: string, id: string) => `${directory}\n${id}`
+import { createMemo } from "solid-js"
+import { produce, reconcile, type SetStoreFunction } from "solid-js/store"
+import type { createServerSdkContext } from "./server-sdk"
+import type { createServerSyncContextInner } from "./server-sync"
+import type { State } from "./global-sync/types"
 
 const cmp = (a: string, b: string) => (a < b ? -1 : a > b ? 1 : 0)
-
-const isNotFound = (error: unknown) =>
-  error instanceof Error &&
-  typeof error.cause === "object" &&
-  error.cause !== null &&
-  (error.cause as { status?: unknown }).status === 404
-
-function merge<T extends { id: string }>(a: readonly T[], b: readonly T[]) {
-  const map = new Map(a.map((item) => [item.id, item] as const))
-  for (const item of b) map.set(item.id, item)
-  return [...map.values()].sort((x, y) => cmp(x.id, y.id))
-}
-
-type OptimisticStore = {
-  message: Record<string, Message[] | undefined>
-  part: Record<string, Part[] | undefined>
-}
-
-type OptimisticAddInput = {
-  sessionID: string
-  message: Message
-  parts: Part[]
-}
-
-type OptimisticRemoveInput = {
-  sessionID: string
-  messageID: string
-}
-
-type OptimisticItem = {
-  message: Message
-  parts: Part[]
-}
-
-type MessagePage = {
-  session: Message[]
-  part: { id: string; part: Part[] }[]
-  cursor?: string
-  complete: boolean
-}
-
-const hasParts = (parts: Part[] | undefined, want: Part[]) => {
-  if (!parts) return want.length === 0
-  return want.every((part) => Binary.search(parts, part.id, (item) => item.id).found)
-}
-
-const mergeParts = (parts: Part[] | undefined, want: Part[]) => {
-  if (!parts) return sortParts(want)
-  const next = [...parts]
-  let changed = false
-  for (const part of want) {
-    const result = Binary.search(next, part.id, (item) => item.id)
-    if (result.found) continue
-    next.splice(result.index, 0, part)
-    changed = true
-  }
-  if (!changed) return parts
-  return next
-}
-
-export function mergeOptimisticPage(page: MessagePage, items: OptimisticItem[]) {
-  if (items.length === 0) return { ...page, confirmed: [] as string[] }
-
-  const session = [...page.session]
-  const part = new Map(page.part.map((item) => [item.id, sortParts(item.part)]))
-  const confirmed: string[] = []
-
-  for (const item of items) {
-    const result = Binary.search(session, item.message.id, (message) => message.id)
-    const found = result.found
-    if (!found) session.splice(result.index, 0, item.message)
-
-    const current = part.get(item.message.id)
-    if (found && hasParts(current, item.parts)) {
-      confirmed.push(item.message.id)
-      continue
-    }
-
-    part.set(item.message.id, mergeParts(current, item.parts))
-  }
-
-  return {
-    cursor: page.cursor,
-    complete: page.complete,
-    session,
-    part: [...part.entries()].sort((a, b) => cmp(a[0], b[0])).map(([id, part]) => ({ id, part })),
-    confirmed,
-  }
-}
-
-export function applyOptimisticAdd(draft: OptimisticStore, input: OptimisticAddInput) {
-  const messages = draft.message[input.sessionID]
-  if (messages) {
-    const result = Binary.search(messages, input.message.id, (m) => m.id)
-    messages.splice(result.index, 0, input.message)
-  } else {
-    draft.message[input.sessionID] = [input.message]
-  }
-  draft.part[input.message.id] = sortParts(input.parts)
-}
-
-export function applyOptimisticRemove(draft: OptimisticStore, input: OptimisticRemoveInput) {
-  const messages = draft.message[input.sessionID]
-  if (messages) {
-    const result = Binary.search(messages, input.messageID, (m) => m.id)
-    if (result.found) messages.splice(result.index, 1)
-  }
-  delete draft.part[input.messageID]
-}
-
-function setOptimisticAdd(setStore: (...args: unknown[]) => void, input: OptimisticAddInput) {
-  setStore("message", input.sessionID, (messages: Message[] | undefined) => {
-    if (!messages) return [input.message]
-    const result = Binary.search(messages, input.message.id, (m) => m.id)
-    const next = [...messages]
-    next.splice(result.index, 0, input.message)
-    return next
-  })
-  setStore("part", input.message.id, sortParts(input.parts))
-}
-
-function setOptimisticRemove(setStore: (...args: unknown[]) => void, input: OptimisticRemoveInput) {
-  setStore("message", input.sessionID, (messages: Message[] | undefined) => {
-    if (!messages) return messages
-    const result = Binary.search(messages, input.messageID, (m) => m.id)
-    if (!result.found) return messages
-    const next = [...messages]
-    next.splice(result.index, 1)
-    return next
-  })
-  setStore("part", (part: Record<string, Part[] | undefined>) => {
-    if (!(input.messageID in part)) return part
-    const next = { ...part }
-    delete next[input.messageID]
-    return next
-  })
-}
+const sessionFields = new Set([
+  "session_status",
+  "session_working",
+  "session_diff",
+  "todo",
+  "permission",
+  "question",
+  "message",
+  "part",
+  "part_text_accum_delta",
+])
 
 export const createDirSyncContext = (
   directory: string,
@@ -177,210 +25,42 @@ export const createDirSyncContext = (
   serverSDK: ReturnType<typeof createServerSdkContext>,
 ) => {
   const client = serverSDK.createClient({ directory, throwOnError: true })
-
-  type Child = ReturnType<(typeof serverSync)["child"]>
-  type Setter = Child[1]
-
   const current = createMemo(() => serverSync.child(directory, { mcp: true }))
-  const target = (directory?: string) => {
-    if (!directory || directory === directory) return current()
-    return serverSync.child(directory)
-  }
   const absolute = (path: string) => (current()[0].path.directory + "/" + path).replace("//", "/")
-  const initialMessagePageSize = 2
-  const historyMessagePageSize = 200
-  const inflight = new Map<string, Promise<void>>()
-  const inflightDiff = new Map<string, Promise<void>>()
-  const inflightTodo = new Map<string, Promise<void>>()
-  const optimistic = new Map<string, Map<string, OptimisticItem>>()
-  const maxDirs = 30
-  const seen = new Map<string, Set<string>>()
-  const [meta, setMeta] = createStore({
-    limit: {} as Record<string, number>,
-    cursor: {} as Record<string, string | undefined>,
-    complete: {} as Record<string, boolean>,
-    loading: {} as Record<string, boolean>,
+  const data = new Proxy({} as State, {
+    get(_, property: keyof State) {
+      if (property === "session_working") return serverSync.session.data.session_working.bind(serverSync.session.data)
+      if (sessionFields.has(property)) return serverSync.session.data[property as keyof typeof serverSync.session.data]
+      return current()[0][property]
+    },
   })
+  const set = ((...input: unknown[]) => {
+    if (typeof input[0] === "string" && sessionFields.has(input[0])) {
+      return (serverSync.session.set as (...args: unknown[]) => unknown)(...input)
+    }
+    const result = (current()[1] as (...args: unknown[]) => unknown)(...input)
+    if (input[0] === "session") current()[0].session.forEach(serverSync.session.remember)
+    return result
+  }) as SetStoreFunction<State>
 
-  const getSession = (sessionID: string) => {
-    const store = current()[0]
-    const match = Binary.search(store.session, sessionID, (s) => s.id)
-    if (match.found) return store.session[match.index]
-    return undefined
-  }
-
-  const setOptimistic = (directory: string, sessionID: string, item: OptimisticItem) => {
-    const key = keyFor(directory, sessionID)
-    const list = optimistic.get(key)
-    if (list) {
-      list.set(item.message.id, { message: item.message, parts: sortParts(item.parts) })
+  const index = (sessionID: string) => {
+    const session = serverSync.session.get(sessionID)
+    if (!session || session.directory !== directory) return
+    const [store, setStore] = current()
+    const result = Binary.search(store.session, session.id, (item) => item.id)
+    if (result.found) {
+      setStore("session", result.index, reconcile(session))
       return
     }
-    optimistic.set(key, new Map([[item.message.id, { message: item.message, parts: sortParts(item.parts) }]]))
-  }
-
-  const clearOptimistic = (directory: string, sessionID: string, messageID?: string) => {
-    const key = keyFor(directory, sessionID)
-    if (!messageID) {
-      optimistic.delete(key)
-      return
-    }
-
-    const list = optimistic.get(key)
-    if (!list) return
-    list.delete(messageID)
-    if (list.size === 0) optimistic.delete(key)
-  }
-
-  const getOptimistic = (directory: string, sessionID: string) => [
-    ...(optimistic.get(keyFor(directory, sessionID))?.values() ?? []),
-  ]
-
-  const seenFor = (directory: string) => {
-    const existing = seen.get(directory)
-    if (existing) {
-      seen.delete(directory)
-      seen.set(directory, existing)
-      return existing
-    }
-    const created = new Set<string>()
-    seen.set(directory, created)
-    while (seen.size > maxDirs) {
-      const first = seen.keys().next().value
-      if (!first) break
-      const stale = [...(seen.get(first) ?? [])]
-      seen.delete(first)
-      const [, setStore] = serverSync.child(first, { bootstrap: false })
-      evict(first, setStore, stale)
-    }
-    return created
-  }
-
-  const clearMeta = (directory: string, sessionIDs: string[]) => {
-    if (sessionIDs.length === 0) return
-    for (const sessionID of sessionIDs) {
-      clearOptimistic(directory, sessionID)
-    }
-    setMeta(
-      produce((draft) => {
-        for (const sessionID of sessionIDs) {
-          const key = keyFor(directory, sessionID)
-          delete draft.limit[key]
-          delete draft.cursor[key]
-          delete draft.complete[key]
-          delete draft.loading[key]
-        }
-      }),
-    )
-  }
-
-  const evict = (directory: string, setStore: Setter, sessionIDs: string[]) => {
-    if (sessionIDs.length === 0) return
-    clearSessionPrefetch(serverSDK.scope, directory, sessionIDs)
-    for (const sessionID of sessionIDs) {
-      serverSync.todo.set(sessionID, undefined)
-    }
     setStore(
-      produce((draft) => {
-        dropSessionCaches(draft, sessionIDs)
-      }),
+      "session",
+      produce((draft) => void draft.splice(result.index, 0, session)),
     )
-    clearMeta(directory, sessionIDs)
-  }
-
-  const touch = (directory: string, setStore: Setter, sessionID: string) => {
-    const stale = pickSessionCacheEvictions({
-      seen: seenFor(directory),
-      keep: sessionID,
-      limit: SESSION_CACHE_LIMIT,
-    })
-    evict(directory, setStore, stale)
-  }
-
-  const fetchMessages = async (input: { client: typeof client; sessionID: string; limit: number; before?: string }) => {
-    const messages = await retry(() =>
-      input.client.session.messages({ sessionID: input.sessionID, limit: input.limit, before: input.before }),
-    )
-    const items = (messages.data ?? []).filter((x) => !!x?.info?.id)
-    const session = items.map((x) => clean(x.info)).sort((a, b) => cmp(a.id, b.id))
-    const part = items.map((message) => ({ id: message.info.id, part: sortParts(message.parts) }))
-    const cursor = messages.response.headers.get("x-next-cursor") ?? undefined
-    return {
-      session,
-      part,
-      cursor,
-      complete: !cursor,
-    }
-  }
-
-  const tracked = (directory: string, sessionID: string) => seen.get(directory)?.has(sessionID) ?? false
-
-  const loadMessages = async (input: {
-    directory: string
-    client: typeof client
-    setStore: Setter
-    sessionID: string
-    limit: number
-    before?: string
-    mode?: "replace" | "prepend"
-  }) => {
-    const key = keyFor(input.directory, input.sessionID)
-    if (meta.loading[key]) return
-
-    setMeta("loading", key, true)
-    await fetchMessages(input)
-      .then((page) => {
-        if (!tracked(input.directory, input.sessionID)) return
-        const next = mergeOptimisticPage(page, getOptimistic(input.directory, input.sessionID))
-        for (const messageID of next.confirmed) {
-          clearOptimistic(input.directory, input.sessionID, messageID)
-        }
-        const [store] = serverSync.child(input.directory, { bootstrap: false })
-        const cached = input.mode === "prepend" ? (store.message[input.sessionID] ?? []) : []
-        const message = input.mode === "prepend" ? merge(cached, next.session) : next.session
-        batch(() => {
-          input.setStore("message", input.sessionID, reconcile(message, { key: "id" }))
-          for (const p of next.part) {
-            const filtered = p.part.filter((x) => !SKIP_PARTS.has(x.type))
-            if (filtered.length) input.setStore("part", p.id, filtered)
-          }
-          setMeta("limit", key, message.length)
-          setMeta("cursor", key, next.cursor)
-          setMeta("complete", key, next.complete)
-          setSessionPrefetch({
-            scope: serverSDK.scope,
-            directory: input.directory,
-            sessionID: input.sessionID,
-            limit: message.length,
-            cursor: next.cursor,
-            complete: next.complete,
-          })
-        })
-      })
-      .catch((error) => {
-        if (isNotFound(error) && !tracked(input.directory, input.sessionID)) return
-        throw error
-      })
-      .finally(() => {
-        setMeta(
-          produce((draft) => {
-            if (!tracked(input.directory, input.sessionID)) {
-              delete draft.loading[key]
-              return
-            }
-            draft.loading[key] = false
-          }),
-        )
-      })
   }
 
   return {
-    get data() {
-      return current()[0]
-    },
-    get set(): Setter {
-      return current()[1]
-    },
+    data,
+    set,
     get status() {
       return current()[0].status
     },
@@ -389,24 +69,20 @@ export const createDirSyncContext = (
     },
     get project() {
       const store = current()[0]
-      const match = Binary.search(serverSync.data.project, store.project, (p) => p.id)
+      const match = Binary.search(serverSync.data.project, store.project, (project) => project.id)
       if (match.found) return serverSync.data.project[match.index]
-      return undefined
     },
     session: {
-      get: getSession,
+      get(sessionID: string) {
+        const session = serverSync.session.get(sessionID)
+        if (session?.directory === directory) return session
+      },
       optimistic: {
         add(input: { directory?: string; sessionID: string; message: Message; parts: Part[] }) {
-          const _directory = input.directory ?? directory
-          const [, setStore] = target(input.directory)
-          setOptimistic(_directory, input.sessionID, { message: input.message, parts: input.parts })
-          setOptimisticAdd(setStore as (...args: unknown[]) => void, input)
+          serverSync.session.optimistic.add(input)
         },
         remove(input: { directory?: string; sessionID: string; messageID: string }) {
-          const _directory = input.directory ?? directory
-          const [, setStore] = target(input.directory)
-          clearOptimistic(_directory, input.sessionID, input.messageID)
-          setOptimisticRemove(setStore as (...args: unknown[]) => void, input)
+          serverSync.session.optimistic.remove(input)
         },
       },
       addOptimisticMessage(input: {
@@ -417,194 +93,48 @@ export const createDirSyncContext = (
         model: { providerID: string; modelID: string }
         variant?: string
       }) {
-        const message: Message = {
-          id: input.messageID,
+        serverSync.session.optimistic.add({
           sessionID: input.sessionID,
-          role: "user",
-          time: { created: Date.now() },
-          agent: input.agent,
-          model: { ...input.model, variant: input.variant },
-        }
-        const [, setStore] = target()
-        setOptimistic(directory, input.sessionID, { message, parts: input.parts })
-        setOptimisticAdd(setStore as (...args: unknown[]) => void, {
-          sessionID: input.sessionID,
-          message,
+          message: {
+            id: input.messageID,
+            sessionID: input.sessionID,
+            role: "user",
+            time: { created: Date.now() },
+            agent: input.agent,
+            model: { ...input.model, variant: input.variant },
+          },
           parts: input.parts,
         })
       },
-      async sync(sessionID: string, opts?: { force?: boolean }) {
-        const [store, setStore] = serverSync.child(directory)
-        const key = keyFor(directory, sessionID)
-
-        touch(directory, setStore, sessionID)
-
-        const seeded = getSessionPrefetch(serverSDK.scope, directory, sessionID)
-        if (seeded && store.message[sessionID] !== undefined && meta.limit[key] === undefined) {
-          batch(() => {
-            setMeta("limit", key, seeded.limit)
-            setMeta("cursor", key, seeded.cursor)
-            setMeta("complete", key, seeded.complete)
-            setMeta("loading", key, false)
-          })
-        }
-
-        return runInflight(inflight, key, async () => {
-          const pending = getSessionPrefetchPromise(serverSDK.scope, directory, sessionID)
-          if (pending) {
-            await pending
-            const seeded = getSessionPrefetch(serverSDK.scope, directory, sessionID)
-            if (seeded && store.message[sessionID] !== undefined && meta.limit[key] === undefined) {
-              batch(() => {
-                setMeta("limit", key, seeded.limit)
-                setMeta("cursor", key, seeded.cursor)
-                setMeta("complete", key, seeded.complete)
-                setMeta("loading", key, false)
-              })
-            }
-          }
-
-          const hasSession = Binary.search(store.session, sessionID, (s) => s.id).found
-          const cached = store.message[sessionID] !== undefined && meta.limit[key] !== undefined
-          if (cached && hasSession && !opts?.force) return
-
-          const limit = meta.limit[key] ?? initialMessagePageSize
-          const sessionReq =
-            hasSession && !opts?.force
-              ? Promise.resolve()
-              : retry(() => client.session.get({ sessionID }))
-                  .then((session) => {
-                    if (!tracked(directory, sessionID)) return
-                    const data = session.data
-                    if (!data) return
-                    setStore(
-                      "session",
-                      produce((draft) => {
-                        const match = Binary.search(draft, sessionID, (s) => s.id)
-                        if (match.found) {
-                          draft[match.index] = data
-                          return
-                        }
-                        draft.splice(match.index, 0, data)
-                      }),
-                    )
-                  })
-                  .catch((error) => {
-                    if (isNotFound(error) && !tracked(directory, sessionID)) return
-                    throw error
-                  })
-
-          const messagesReq =
-            cached && !opts?.force
-              ? Promise.resolve()
-              : loadMessages({
-                  directory,
-                  client,
-                  setStore,
-                  sessionID,
-                  limit,
-                })
-
-          await Promise.all([sessionReq, messagesReq])
-        })
+      async sync(sessionID: string, options?: { force?: boolean }) {
+        await serverSync.session.sync(sessionID, options)
+        index(sessionID)
       },
-      async diff(sessionID: string, opts?: { force?: boolean }) {
-        const [store, setStore] = serverSync.child(directory)
-        touch(directory, setStore, sessionID)
-        if (store.session_diff[sessionID] !== undefined && !opts?.force) return
-
-        const key = keyFor(directory, sessionID)
-        return runInflight(inflightDiff, key, () =>
-          retry(() => client.session.diff({ sessionID })).then((diff) => {
-            if (!tracked(directory, sessionID)) return
-            setStore("session_diff", sessionID, reconcile(list(diff.data), { key: "file" }))
-          }),
-        )
-      },
-      async todo(sessionID: string, opts?: { force?: boolean }) {
-        const [store, setStore] = serverSync.child(directory)
-        touch(directory, setStore, sessionID)
-        const existing = store.todo[sessionID]
-        const cached = serverSync.data.session_todo[sessionID]
-        if (existing !== undefined) {
-          if (cached === undefined) {
-            serverSync.todo.set(sessionID, existing)
-          }
-          if (!opts?.force) return
-        }
-
-        if (cached !== undefined) {
-          setStore("todo", sessionID, reconcile(cached, { key: "id" }))
-        }
-
-        const key = keyFor(directory, sessionID)
-        return runInflight(inflightTodo, key, () =>
-          retry(() => client.session.todo({ sessionID })).then((todo) => {
-            if (!tracked(directory, sessionID)) return
-            const list = todo.data ?? []
-            setStore("todo", sessionID, reconcile(list, { key: "id" }))
-            serverSync.todo.set(sessionID, list)
-          }),
-        )
-      },
-      history: {
-        more(sessionID: string) {
-          const store = current()[0]
-          const key = keyFor(directory, sessionID)
-          if (store.message[sessionID] === undefined) return false
-          if (meta.limit[key] === undefined) return false
-          if (meta.complete[key]) return false
-          return !!meta.cursor[key]
-        },
-        loading(sessionID: string) {
-          const key = keyFor(directory, sessionID)
-          return meta.loading[key] ?? false
-        },
-        async loadMore(sessionID: string, count?: number) {
-          const [, setStore] = serverSync.child(directory)
-          touch(directory, setStore, sessionID)
-          const key = keyFor(directory, sessionID)
-          const step = count ?? historyMessagePageSize
-          if (meta.loading[key]) return
-          if (meta.complete[key]) return
-          const before = meta.cursor[key]
-          if (!before) return
-
-          await loadMessages({
-            directory,
-            client,
-            setStore,
-            sessionID,
-            limit: step,
-            before,
-            mode: "prepend",
-          })
-        },
-      },
-      evict(sessionID: string, _directory = directory) {
-        const [, setStore] = serverSync.child(_directory)
-        seenFor(_directory).delete(sessionID)
-        evict(_directory, setStore, [sessionID])
+      diff: serverSync.session.diff,
+      todo: serverSync.session.todo,
+      history: serverSync.session.history,
+      evict(sessionID: string) {
+        serverSync.session.evict(sessionID)
       },
       fetch: async (count = 10) => {
-        const [store, setStore] = serverSync.child(directory)
-        setStore("limit", (x) => x + count)
-        await client.session.list().then((x) => {
-          const sessions = (x.data ?? [])
-            .filter((s) => !!s?.id)
-            .sort((a, b) => cmp(a.id, b.id))
-            .slice(0, store.limit)
-          setStore("session", reconcile(sessions, { key: "id" }))
-        })
+        const [store, setStore] = current()
+        setStore("limit", (value) => value + count)
+        const response = await client.session.list()
+        const sessions = (response.data ?? [])
+          .filter((session) => !!session?.id)
+          .sort((a, b) => cmp(a.id, b.id))
+          .slice(0, store.limit)
+        sessions.forEach(serverSync.session.remember)
+        setStore("session", reconcile(sessions, { key: "id" }))
       },
       more: createMemo(() => current()[0].session.length >= current()[0].limit),
       archive: async (sessionID: string) => {
-        const [, setStore] = serverSync.child(directory)
-        await client.session.update({ sessionID, time: { archived: Date.now() } })
-        setStore(
+        await serverSDK.client.session.update({ sessionID, time: { archived: Date.now() } })
+        current()[1](
+          "session",
           produce((draft) => {
-            const match = Binary.search(draft.session, sessionID, (s) => s.id)
-            if (match.found) draft.session.splice(match.index, 1)
+            const match = Binary.search(draft, sessionID, (session) => session.id)
+            if (match.found) draft.splice(match.index, 1)
           }),
         )
       },

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

@@ -7,14 +7,14 @@ import type {
   ProviderAuthResponse,
   QuestionRequest,
   Session,
-  Todo,
 } from "@opencode-ai/sdk/v2/client"
 import { showToast } from "@/utils/toast"
 import { getFilename } from "@opencode-ai/core/util/path"
 import { retry } from "@opencode-ai/core/util/retry"
 import { batch } from "solid-js"
-import { reconcile, type SetStoreFunction, type Store } from "solid-js/store"
+import { produce, reconcile, type SetStoreFunction, type Store } from "solid-js/store"
 import type { State, VcsCache } from "./types"
+import type { ServerSession } from "../server-session"
 import { cmp, normalizeAgentList, normalizeProviderList } from "./utils"
 import { formatServerError } from "@/utils/server-errors"
 import { QueryClient, queryOptions } from "@tanstack/solid-query"
@@ -26,9 +26,6 @@ type GlobalStore = {
   ready: boolean
   path: Path
   project: Project[]
-  session_todo: {
-    [sessionID: string]: Todo[]
-  }
   provider: NormalizedProviderListResponse
   provider_auth: ProviderAuthResponse
   config: Config
@@ -215,6 +212,7 @@ export async function bootstrapDirectory(input: {
     provider: NormalizedProviderListResponse
   }
   queryClient: QueryClient
+  session?: ServerSession
 }) {
   const loading = input.store.status !== "complete"
   const seededProject = projectID(input.directory, input.global.project)
@@ -238,7 +236,30 @@ export async function bootstrapDirectory(input: {
           .then((data) => input.setStore("agent", data)),
       () =>
         retry(() => input.sdk.config.get().then((x) => input.setStore("config", reconcile(x.data!, { merge: false })))),
-      () => retry(() => input.sdk.session.status().then((x) => input.setStore("session_status", x.data!))),
+      () =>
+        retry(() =>
+          input.sdk.session.status().then(async (x) => {
+            if (input.session) {
+              const statuses = x.data ?? {}
+              await Promise.all(
+                Object.keys(statuses).map((sessionID) => input.session!.resolve(sessionID).catch(() => undefined)),
+              )
+              input.session.set(
+                "session_status",
+                produce((draft) => {
+                  for (const sessionID of Object.keys(draft)) {
+                    if (statuses[sessionID]) continue
+                    if (input.session?.get(sessionID)?.directory === input.directory) delete draft[sessionID]
+                  }
+                }),
+              )
+              for (const [sessionID, status] of Object.entries(statuses)) {
+                input.session.set("session_status", sessionID, reconcile(status))
+              }
+            }
+            if (!input.session) input.setStore("session_status", x.data!)
+          }),
+        ),
       !seededProject &&
         (() => retry(() => input.sdk.project.current()).then((x) => input.setStore("project", x.data!.id))),
       !seededPath &&
@@ -263,21 +284,25 @@ export async function bootstrapDirectory(input: {
             const grouped = groupBySession(
               (x.data ?? []).filter((perm): perm is PermissionRequest => !!perm?.id && !!perm.sessionID),
             )
-            return warmSessions({ ids, store: input.store, setStore: input.setStore, sdk: input.sdk }).then(() =>
+            const warm = input.session
+              ? Promise.all(ids.map((sessionID) => input.session!.resolve(sessionID))).then(() => undefined)
+              : warmSessions({ ids, store: input.store, setStore: input.setStore, sdk: input.sdk })
+            return warm.then(() =>
               batch(() => {
-                for (const sessionID of Object.keys(input.store.permission)) {
+                const current = input.session?.data.permission ?? input.store.permission
+                for (const sessionID of Object.keys(current)) {
                   if (grouped[sessionID]) continue
-                  input.setStore("permission", sessionID, [])
+                  if (input.session?.get(sessionID)?.directory !== input.directory) continue
+                  if (input.session) input.session.set("permission", sessionID, [])
+                  if (!input.session) input.setStore("permission", sessionID, [])
                 }
                 for (const [sessionID, permissions] of Object.entries(grouped)) {
-                  input.setStore(
-                    "permission",
-                    sessionID,
-                    reconcile(
-                      permissions.filter((p) => !!p?.id).sort((a, b) => cmp(a.id, b.id)),
-                      { key: "id" },
-                    ),
+                  const value = reconcile(
+                    permissions.filter((p) => !!p?.id).sort((a, b) => cmp(a.id, b.id)),
+                    { key: "id" },
                   )
+                  if (input.session) input.session.set("permission", sessionID, value)
+                  if (!input.session) input.setStore("permission", sessionID, value)
                 }
               }),
             )
@@ -288,21 +313,25 @@ export async function bootstrapDirectory(input: {
           input.sdk.question.list().then((x) => {
             const ids = (x.data ?? []).map((question) => question?.sessionID).filter((id): id is string => !!id)
             const grouped = groupBySession((x.data ?? []).filter((q): q is QuestionRequest => !!q?.id && !!q.sessionID))
-            return warmSessions({ ids, store: input.store, setStore: input.setStore, sdk: input.sdk }).then(() =>
+            const warm = input.session
+              ? Promise.all(ids.map((sessionID) => input.session!.resolve(sessionID))).then(() => undefined)
+              : warmSessions({ ids, store: input.store, setStore: input.setStore, sdk: input.sdk })
+            return warm.then(() =>
               batch(() => {
-                for (const sessionID of Object.keys(input.store.question)) {
+                const current = input.session?.data.question ?? input.store.question
+                for (const sessionID of Object.keys(current)) {
                   if (grouped[sessionID]) continue
-                  input.setStore("question", sessionID, [])
+                  if (input.session?.get(sessionID)?.directory !== input.directory) continue
+                  if (input.session) input.session.set("question", sessionID, [])
+                  if (!input.session) input.setStore("question", sessionID, [])
                 }
                 for (const [sessionID, questions] of Object.entries(grouped)) {
-                  input.setStore(
-                    "question",
-                    sessionID,
-                    reconcile(
-                      questions.filter((q) => !!q?.id).sort((a, b) => cmp(a.id, b.id)),
-                      { key: "id" },
-                    ),
+                  const value = reconcile(
+                    questions.filter((q) => !!q?.id).sort((a, b) => cmp(a.id, b.id)),
+                    { key: "id" },
                   )
+                  if (input.session) input.session.set("question", sessionID, value)
+                  if (!input.session) input.setStore("question", sessionID, value)
                 }
               }),
             )

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

@@ -17,6 +17,21 @@ import { dropSessionCaches } from "./session-cache"
 import { diffs as list, message as clean } from "@/utils/diffs"
 
 const SKIP_PARTS = new Set(["patch", "step-start", "step-finish"])
+const SESSION_CONTENT_EVENTS = new Set([
+  "session.diff",
+  "todo.updated",
+  "session.status",
+  "message.updated",
+  "message.removed",
+  "message.part.updated",
+  "message.part.removed",
+  "message.part.delta",
+  "permission.asked",
+  "permission.replied",
+  "question.asked",
+  "question.replied",
+  "question.rejected",
+])
 
 export function applyGlobalEvent(input: {
   event: { type: string; properties?: unknown }
@@ -100,8 +115,11 @@ export function applyDirectoryEvent(input: {
   vcsCache?: VcsCache
   setSessionTodo?: (sessionID: string, todos: Todo[] | undefined) => void
   retainedLimit?: number
+  sessionContent?: boolean
+  permission?: State["permission"]
 }) {
   const event = input.event
+  if (input.sessionContent === false && SESSION_CONTENT_EVENTS.has(event.type)) return
   const limit = Math.max(input.store.limit, input.retainedLimit ?? 0)
   switch (event.type) {
     case "server.instance.disposed": {
@@ -117,7 +135,7 @@ export function applyDirectoryEvent(input: {
       }
       const next = input.store.session.slice()
       next.splice(result.index, 0, info)
-      const trimmed = trimSessions(next, { limit, permission: input.store.permission })
+      const trimmed = trimSessions(next, { limit, permission: input.permission ?? input.store.permission })
       input.setStore("session", reconcile(trimmed, { key: "id" }))
       cleanupDroppedSessionCaches(input.store, input.setStore, trimmed, input.setSessionTodo)
       if (!info.parentID) input.setStore("sessionTotal", (value) => value + 1)
@@ -147,7 +165,7 @@ export function applyDirectoryEvent(input: {
       }
       const next = input.store.session.slice()
       next.splice(result.index, 0, info)
-      const trimmed = trimSessions(next, { limit, permission: input.store.permission })
+      const trimmed = trimSessions(next, { limit, permission: input.permission ?? input.store.permission })
       input.setStore("session", reconcile(trimmed, { key: "id" }))
       cleanupDroppedSessionCaches(input.store, input.setStore, trimmed, input.setSessionTodo)
       break

packages/app/src/context/global-sync/session-prefetch.test.ts

@@ -1,139 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import {
-  clearSessionPrefetch,
-  clearSessionPrefetchDirectory,
-  getSessionPrefetch,
-  runSessionPrefetch,
-  setSessionPrefetch,
-  shouldSkipSessionPrefetch,
-} from "./session-prefetch"
-import { ServerScope } from "@/utils/server-scope"
-
-const scope = ServerScope.local
-
-describe("session prefetch", () => {
-  test("stores and clears message metadata by directory", () => {
-    clearSessionPrefetch(scope, "/tmp/a", ["ses_1"])
-    clearSessionPrefetch(scope, "/tmp/b", ["ses_1"])
-
-    setSessionPrefetch({
-      directory: "/tmp/a",
-      scope,
-      sessionID: "ses_1",
-      limit: 200,
-      cursor: "abc",
-      complete: false,
-      at: 123,
-    })
-
-    expect(getSessionPrefetch(scope, "/tmp/a", "ses_1")).toEqual({
-      limit: 200,
-      cursor: "abc",
-      complete: false,
-      at: 123,
-    })
-    expect(getSessionPrefetch(scope, "/tmp/b", "ses_1")).toBeUndefined()
-
-    clearSessionPrefetch(scope, "/tmp/a", ["ses_1"])
-
-    expect(getSessionPrefetch(scope, "/tmp/a", "ses_1")).toBeUndefined()
-  })
-
-  test("dedupes inflight work", async () => {
-    clearSessionPrefetch(scope, "/tmp/c", ["ses_2"])
-
-    let calls = 0
-    const run = () =>
-      runSessionPrefetch({
-        directory: "/tmp/c",
-        scope,
-        sessionID: "ses_2",
-        task: async () => {
-          calls += 1
-          return { limit: 100, cursor: "next", complete: true, at: 456 }
-        },
-      })
-
-    const [a, b] = await Promise.all([run(), run()])
-
-    expect(calls).toBe(1)
-    expect(a).toEqual({ limit: 100, cursor: "next", complete: true, at: 456 })
-    expect(b).toEqual({ limit: 100, cursor: "next", complete: true, at: 456 })
-  })
-
-  test("clears a whole directory", () => {
-    setSessionPrefetch({
-      scope,
-      directory: "/tmp/d",
-      sessionID: "ses_1",
-      limit: 10,
-      cursor: "a",
-      complete: true,
-      at: 1,
-    })
-    setSessionPrefetch({
-      scope,
-      directory: "/tmp/d",
-      sessionID: "ses_2",
-      limit: 20,
-      cursor: "b",
-      complete: false,
-      at: 2,
-    })
-    setSessionPrefetch({
-      scope,
-      directory: "/tmp/e",
-      sessionID: "ses_1",
-      limit: 30,
-      cursor: "c",
-      complete: true,
-      at: 3,
-    })
-
-    clearSessionPrefetchDirectory(scope, "/tmp/d")
-
-    expect(getSessionPrefetch(scope, "/tmp/d", "ses_1")).toBeUndefined()
-    expect(getSessionPrefetch(scope, "/tmp/d", "ses_2")).toBeUndefined()
-    expect(getSessionPrefetch(scope, "/tmp/e", "ses_1")).toEqual({ limit: 30, cursor: "c", complete: true, at: 3 })
-  })
-
-  test("isolates identical directories and sessions by server scope", () => {
-    const remote = "https://debian.example" as ServerScope
-    setSessionPrefetch({ scope, directory: "/repo", sessionID: "ses_1", limit: 10, complete: true, at: 1 })
-    setSessionPrefetch({ scope: remote, directory: "/repo", sessionID: "ses_1", limit: 20, complete: true, at: 2 })
-
-    expect(getSessionPrefetch(scope, "/repo", "ses_1")?.limit).toBe(10)
-    expect(getSessionPrefetch(remote, "/repo", "ses_1")?.limit).toBe(20)
-  })
-
-  test("refreshes stale first-page prefetched history", () => {
-    expect(
-      shouldSkipSessionPrefetch({
-        message: true,
-        info: { limit: 200, cursor: "x", complete: false, at: 1 },
-        chunk: 200,
-        now: 1 + 15_001,
-      }),
-    ).toBe(false)
-  })
-
-  test("keeps deeper or complete history cached", () => {
-    expect(
-      shouldSkipSessionPrefetch({
-        message: true,
-        info: { limit: 400, cursor: "x", complete: false, at: 1 },
-        chunk: 200,
-        now: 1 + 15_001,
-      }),
-    ).toBe(true)
-
-    expect(
-      shouldSkipSessionPrefetch({
-        message: true,
-        info: { limit: 120, complete: true, at: 1 },
-        chunk: 200,
-        now: 1 + 15_001,
-      }),
-    ).toBe(true)
-  })
-})

packages/app/src/context/global-sync/session-prefetch.ts

@@ -1,107 +0,0 @@
-import { ScopedKey, type ServerScope } from "@/utils/server-scope"
-
-const key = (scope: ServerScope, directory: string, sessionID: string) => ScopedKey.from(scope, directory, sessionID)
-
-export const SESSION_PREFETCH_TTL = 15_000
-
-type Meta = {
-  limit: number
-  cursor?: string
-  complete: boolean
-  at: number
-}
-
-export function shouldSkipSessionPrefetch(input: { message: boolean; info?: Meta; chunk: number; now?: number }) {
-  if (input.message) {
-    if (!input.info) return true
-    if (input.info.complete) return true
-    if (input.info.limit > input.chunk) return true
-  } else {
-    if (!input.info) return false
-  }
-
-  return (input.now ?? Date.now()) - input.info.at < SESSION_PREFETCH_TTL
-}
-
-const cache = new Map<string, Meta>()
-const inflight = new Map<string, Promise<Meta | undefined>>()
-const rev = new Map<string, number>()
-
-const version = (id: string) => rev.get(id) ?? 0
-
-export function getSessionPrefetch(scope: ServerScope, directory: string, sessionID: string) {
-  return cache.get(key(scope, directory, sessionID))
-}
-
-export function getSessionPrefetchPromise(scope: ServerScope, directory: string, sessionID: string) {
-  return inflight.get(key(scope, directory, sessionID))
-}
-
-export function clearSessionPrefetchInflight(scope: ServerScope) {
-  const prefix = ScopedKey.prefix(scope)
-  for (const id of inflight.keys()) {
-    if (id.startsWith(prefix)) inflight.delete(id)
-  }
-}
-
-export function isSessionPrefetchCurrent(scope: ServerScope, directory: string, sessionID: string, value: number) {
-  return version(key(scope, directory, sessionID)) === value
-}
-
-export function runSessionPrefetch(input: {
-  directory: string
-  scope: ServerScope
-  sessionID: string
-  task: (value: number) => Promise<Meta | undefined>
-}) {
-  const id = key(input.scope, input.directory, input.sessionID)
-  const pending = inflight.get(id)
-  if (pending) return pending
-
-  const value = version(id)
-
-  const promise = input.task(value).finally(() => {
-    if (inflight.get(id) === promise) inflight.delete(id)
-  })
-
-  inflight.set(id, promise)
-  return promise
-}
-
-export function setSessionPrefetch(input: {
-  directory: string
-  scope: ServerScope
-  sessionID: string
-  limit: number
-  cursor?: string
-  complete: boolean
-  at?: number
-}) {
-  cache.set(key(input.scope, input.directory, input.sessionID), {
-    limit: input.limit,
-    cursor: input.cursor,
-    complete: input.complete,
-    at: input.at ?? Date.now(),
-  })
-}
-
-export function clearSessionPrefetch(scope: ServerScope, directory: string, sessionIDs: Iterable<string>) {
-  for (const sessionID of sessionIDs) {
-    if (!sessionID) continue
-    const id = key(scope, directory, sessionID)
-    rev.set(id, version(id) + 1)
-    cache.delete(id)
-    inflight.delete(id)
-  }
-}
-
-export function clearSessionPrefetchDirectory(scope: ServerScope, directory: string) {
-  const prefix = ScopedKey.prefix(scope, directory)
-  const keys = new Set([...cache.keys(), ...inflight.keys()])
-  for (const id of keys) {
-    if (!id.startsWith(prefix)) continue
-    rev.set(id, version(id) + 1)
-    cache.delete(id)
-    inflight.delete(id)
-  }
-}

packages/app/src/context/global.tsx

@@ -8,13 +8,11 @@ import { createServerSyncContext } from "./server-sync"
 import { getOwner } from "solid-js/web"
 import { QueryClient } from "@tanstack/solid-query"
 import type { ServerScope } from "@/utils/server-scope"
-import { createSessionPlacementStore } from "@/utils/session-placement"
 
 export const { use: useGlobal, provider: GlobalProvider } = createSimpleContext({
   name: "Global",
   init: () => {
     const server = useServer()
-    const sessionPlacement = createSessionPlacementStore()
     const serverHealth = useServerHealth(
       () => server.list,
       () => true,
@@ -87,7 +85,6 @@ export const { use: useGlobal, provider: GlobalProvider } = createSimpleContext(
           },
         },
       },
-      sessionPlacement,
       ensureServerCtx(conn: ServerConnection.Any) {
         return ensureServerCtx(conn)
       },

packages/app/src/context/server-session.test.ts

@@ -0,0 +1,98 @@
+import { describe, expect, test } from "bun:test"
+import type { OpencodeClient, Session } from "@opencode-ai/sdk/v2/client"
+import { createServerSession } from "./server-session"
+
+const session = (id: string, parentID?: string): Session => ({
+  id,
+  slug: id,
+  projectID: "project",
+  directory: "/repo",
+  title: id,
+  version: "1",
+  parentID,
+  time: { created: 1, updated: 1 },
+})
+
+function setup(sessions: Record<string, Session>) {
+  const get: unknown[] = []
+  const messages: unknown[] = []
+  const client = {
+    session: {
+      get: async (input: unknown) => {
+        get.push(input)
+        const id = (input as { sessionID: string }).sessionID
+        return { data: sessions[id] }
+      },
+      messages: async (input: unknown) => {
+        messages.push(input)
+        return { data: [], response: { headers: new Headers() } }
+      },
+      diff: async () => ({ data: [] }),
+      todo: async () => ({ data: [] }),
+    },
+  } as unknown as OpencodeClient
+  return { get, messages, store: createServerSession(client) }
+}
+
+describe("server session", () => {
+  test("resolves lineage by session ID without directory", async () => {
+    const ctx = setup({ child: session("child", "root"), root: session("root") })
+
+    const result = await ctx.store.lineage.resolve("child")
+
+    expect(result.root.id).toBe("root")
+    expect(ctx.get).toEqual([{ sessionID: "child" }, { sessionID: "root" }])
+    expect(ctx.store.lineage.peek("child")).toEqual(result)
+  })
+
+  test("loads session content through the server client", async () => {
+    const ctx = setup({ root: session("root") })
+
+    await ctx.store.sync("root")
+
+    expect(ctx.get).toEqual([{ sessionID: "root" }])
+    expect(ctx.messages).toEqual([{ sessionID: "root", limit: 2, before: undefined }])
+    expect(ctx.store.data.message.root).toEqual([])
+  })
+
+  test("applies events without a directory store", () => {
+    const ctx = setup({})
+    ctx.store.apply({ type: "session.created", properties: { info: session("root") } })
+    ctx.store.apply({ type: "session.status", properties: { sessionID: "root", status: { type: "busy" } } })
+
+    expect(ctx.store.get("root")?.directory).toBe("/repo")
+    expect(ctx.store.data.session_working("root")).toBe(true)
+  })
+
+  test("preserves pinned session content under server-wide cache pressure", () => {
+    const ctx = setup({})
+    ctx.store.pin("active")
+    ctx.store.optimistic.add({
+      sessionID: "active",
+      message: {
+        id: "message",
+        sessionID: "active",
+        role: "assistant",
+        time: { created: 1 },
+        parentID: "parent",
+        modelID: "model",
+        providerID: "provider",
+        mode: "build",
+        agent: "agent",
+        path: { cwd: "/repo", root: "/repo" },
+        cost: 0,
+        tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+      },
+      parts: [],
+    })
+
+    for (let index = 0; index < 50; index++) {
+      ctx.store.apply({
+        type: "session.status",
+        properties: { sessionID: `session-${index}`, status: { type: "busy" } },
+      })
+    }
+
+    expect(ctx.store.data.message.active?.map((message) => message.id)).toEqual(["message"])
+  })
+})

packages/app/src/context/server-session.ts

@@ -0,0 +1,626 @@
+import { Binary } from "@opencode-ai/core/util/binary"
+import { retry } from "@opencode-ai/core/util/retry"
+import type {
+  Message,
+  OpencodeClient,
+  Part,
+  PermissionRequest,
+  QuestionRequest,
+  Session,
+  SessionStatus,
+  SnapshotFileDiff,
+  Todo,
+} from "@opencode-ai/sdk/v2/client"
+import { batch } from "solid-js"
+import { createStore, produce, reconcile } from "solid-js/store"
+import { diffs as cleanDiffs, message as cleanMessage } from "@/utils/diffs"
+import { rootSession } from "@/utils/session-route"
+import { dropSessionCaches, pickSessionCacheEvictions, SESSION_CACHE_LIMIT } from "./global-sync/session-cache"
+
+const cmp = (a: string, b: string) => (a < b ? -1 : a > b ? 1 : 0)
+const SKIP_PARTS = new Set(["patch", "step-start", "step-finish"])
+const initialMessagePageSize = 2
+const historyMessagePageSize = 200
+const sessionInfoLimit = 2_048
+
+type OptimisticItem = {
+  message: Message
+  parts: Part[]
+}
+
+const hasParts = (parts: Part[] | undefined, want: Part[]) => {
+  if (!parts) return want.length === 0
+  return want.every((part) => Binary.search(parts, part.id, (item) => item.id).found)
+}
+
+function mergeOptimisticPage(
+  page: { session: Message[]; part: { id: string; part: Part[] }[]; cursor?: string; complete: boolean },
+  items: OptimisticItem[],
+) {
+  if (items.length === 0) return { ...page, confirmed: [] as string[] }
+  const session = [...page.session]
+  const part = new Map(page.part.map((item) => [item.id, item.part]))
+  const confirmed: string[] = []
+  for (const item of items) {
+    const result = Binary.search(session, item.message.id, (message) => message.id)
+    if (!result.found) session.splice(result.index, 0, item.message)
+    const current = part.get(item.message.id)
+    if (result.found && hasParts(current, item.parts)) {
+      confirmed.push(item.message.id)
+      continue
+    }
+    part.set(item.message.id, merge(current ?? [], item.parts))
+  }
+  return {
+    ...page,
+    session,
+    part: [...part.entries()].sort((a, b) => cmp(a[0], b[0])).map(([id, parts]) => ({ id, part: parts })),
+    confirmed,
+  }
+}
+
+function runInflight(map: Map<string, Promise<void>>, key: string, task: () => Promise<void>) {
+  const pending = map.get(key)
+  if (pending) return pending
+  const promise = task().finally(() => {
+    if (map.get(key) === promise) map.delete(key)
+  })
+  map.set(key, promise)
+  return promise
+}
+
+function merge<T extends { id: string }>(a: readonly T[], b: readonly T[]) {
+  const items = new Map(a.map((item) => [item.id, item] as const))
+  for (const item of b) items.set(item.id, item)
+  return [...items.values()].sort((x, y) => cmp(x.id, y.id))
+}
+
+export function createServerSession(client: OpencodeClient) {
+  const [data, setData] = createStore({
+    info: {} as Record<string, Session | undefined>,
+    session_status: {} as Record<string, SessionStatus>,
+    session_diff: {} as Record<string, SnapshotFileDiff[]>,
+    todo: {} as Record<string, Todo[]>,
+    permission: {} as Record<string, PermissionRequest[]>,
+    question: {} as Record<string, QuestionRequest[]>,
+    message: {} as Record<string, Message[]>,
+    part: {} as Record<string, Part[]>,
+    part_text_accum_delta: {} as Record<string, string>,
+    session_working(id: string) {
+      return (this.session_status[id]?.type ?? "idle") !== "idle"
+    },
+  })
+  const requests = new Map<string, Promise<Session>>()
+  const inflight = new Map<string, Promise<void>>()
+  const inflightDiff = new Map<string, Promise<void>>()
+  const inflightTodo = new Map<string, Promise<void>>()
+  const optimistic = new Map<string, Map<string, OptimisticItem>>()
+  const seen = new Set<string>()
+  const infoSeen = new Set<string>()
+  const pinned = new Map<string, number>()
+  const generations = new Map<string, number>()
+  const [meta, setMeta] = createStore({
+    limit: {} as Record<string, number | undefined>,
+    cursor: {} as Record<string, string | undefined>,
+    complete: {} as Record<string, boolean | undefined>,
+    loading: {} as Record<string, boolean | undefined>,
+    at: {} as Record<string, number | undefined>,
+  })
+
+  const remember = (session: Session) => {
+    setData("info", session.id, reconcile(session))
+    infoSeen.delete(session.id)
+    infoSeen.add(session.id)
+    if (infoSeen.size > sessionInfoLimit) {
+      const preserve = new Set([
+        ...pinned.keys(),
+        ...requests.keys(),
+        ...Object.entries(data.permission)
+          .filter(([, items]) => items.length > 0)
+          .map(([sessionID]) => sessionID),
+        ...Object.entries(data.question)
+          .filter(([, items]) => items.length > 0)
+          .map(([sessionID]) => sessionID),
+        ...Object.entries(data.session_status)
+          .filter(([, status]) => status.type !== "idle")
+          .map(([sessionID]) => sessionID),
+      ])
+      for (const sessionID of preserve) {
+        let current = data.info[sessionID]
+        while (current) {
+          preserve.add(current.id)
+          current = current.parentID ? data.info[current.parentID] : undefined
+        }
+      }
+      const stale: string[] = []
+      for (const sessionID of infoSeen) {
+        if (infoSeen.size - stale.length <= sessionInfoLimit) break
+        if (!preserve.has(sessionID)) stale.push(sessionID)
+      }
+      stale.forEach((sessionID) => infoSeen.delete(sessionID))
+      setData(
+        "info",
+        produce((draft) => stale.forEach((sessionID) => delete draft[sessionID])),
+      )
+    }
+    return session
+  }
+
+  const resolve = (sessionID: string, options?: { force?: boolean }) => {
+    const cached = data.info[sessionID]
+    if (cached && !options?.force) return Promise.resolve(cached)
+    const pending = requests.get(sessionID)
+    if (pending) return pending
+    const generation = generations.get(sessionID) ?? 0
+    const request = client.session.get({ sessionID }).then((result) => {
+      if (!result.data) throw new Error(`Session not found: ${sessionID}`)
+      if ((generations.get(sessionID) ?? 0) !== generation) return result.data
+      return remember(result.data)
+    })
+    requests.set(sessionID, request)
+    void request.then(
+      () => {
+        if (requests.get(sessionID) === request) requests.delete(sessionID)
+      },
+      () => {
+        if (requests.get(sessionID) === request) requests.delete(sessionID)
+      },
+    )
+    return request
+  }
+
+  const peekLineage = (sessionID: string) => {
+    const session = data.info[sessionID]
+    if (!session) return
+    const seen = new Set([session.id])
+    let root = session
+    while (root.parentID) {
+      if (seen.has(root.parentID)) throw new Error(`Session parent cycle: ${root.parentID}`)
+      seen.add(root.parentID)
+      const parent = data.info[root.parentID]
+      if (!parent) return
+      root = parent
+    }
+    return { session, root }
+  }
+
+  const clearOptimistic = (sessionID: string, messageID?: string) => {
+    if (!messageID) {
+      optimistic.delete(sessionID)
+      return
+    }
+    const items = optimistic.get(sessionID)
+    if (!items) return
+    items.delete(messageID)
+    if (items.size === 0) optimistic.delete(sessionID)
+  }
+
+  const evict = (sessionIDs: string[]) => {
+    if (sessionIDs.length === 0) return
+    sessionIDs.forEach((sessionID) => {
+      generations.set(sessionID, (generations.get(sessionID) ?? 0) + 1)
+      clearOptimistic(sessionID)
+      requests.delete(sessionID)
+      inflight.delete(sessionID)
+      inflightDiff.delete(sessionID)
+      inflightTodo.delete(sessionID)
+    })
+    setData(
+      produce((draft) => {
+        dropSessionCaches(draft, sessionIDs)
+      }),
+    )
+    setMeta(
+      produce((draft) => {
+        for (const sessionID of sessionIDs) {
+          delete draft.limit[sessionID]
+          delete draft.cursor[sessionID]
+          delete draft.complete[sessionID]
+          delete draft.loading[sessionID]
+          delete draft.at[sessionID]
+        }
+      }),
+    )
+  }
+
+  const protectedSessions = () =>
+    new Set([
+      ...pinned.keys(),
+      ...requests.keys(),
+      ...inflight.keys(),
+      ...inflightDiff.keys(),
+      ...inflightTodo.keys(),
+      ...optimistic.keys(),
+      ...Object.entries(data.permission)
+        .filter(([, items]) => items.length > 0)
+        .map(([sessionID]) => sessionID),
+      ...Object.entries(data.question)
+        .filter(([, items]) => items.length > 0)
+        .map(([sessionID]) => sessionID),
+      ...Object.entries(data.session_status)
+        .filter(([, status]) => status.type !== "idle")
+        .map(([sessionID]) => sessionID),
+    ])
+
+  const touch = (sessionID: string) =>
+    evict(
+      pickSessionCacheEvictions({ seen, keep: sessionID, limit: SESSION_CACHE_LIMIT, preserve: protectedSessions() }),
+    )
+
+  const fetchMessages = async (sessionID: string, limit: number, before?: string) => {
+    const response = await retry(() => client.session.messages({ sessionID, limit, before }))
+    const items = (response.data ?? []).filter((item) => !!item?.info?.id)
+    return {
+      session: items.map((item) => cleanMessage(item.info)).sort((a, b) => cmp(a.id, b.id)),
+      part: items.map((item) => ({
+        id: item.info.id,
+        part: item.parts.filter((part) => !!part?.id).sort((a, b) => cmp(a.id, b.id)),
+      })),
+      cursor: response.response.headers.get("x-next-cursor") ?? undefined,
+      complete: !response.response.headers.get("x-next-cursor"),
+    }
+  }
+
+  const loadMessages = async (sessionID: string, limit: number, before?: string, mode?: "replace" | "prepend") => {
+    if (meta.loading[sessionID]) return
+    const generation = generations.get(sessionID) ?? 0
+    setMeta("loading", sessionID, true)
+    await fetchMessages(sessionID, limit, before)
+      .then((page) => {
+        if ((generations.get(sessionID) ?? 0) !== generation) return
+        const next = mergeOptimisticPage(page, [...(optimistic.get(sessionID)?.values() ?? [])])
+        next.confirmed.forEach((messageID) => clearOptimistic(sessionID, messageID))
+        const messages = mode === "prepend" ? merge(data.message[sessionID] ?? [], next.session) : next.session
+        batch(() => {
+          setData("message", sessionID, reconcile(messages, { key: "id" }))
+          for (const item of next.part) {
+            const parts = item.part.filter((part) => !SKIP_PARTS.has(part.type))
+            if (parts.length) setData("part", item.id, reconcile(parts, { key: "id" }))
+          }
+          setMeta("limit", sessionID, messages.length)
+          setMeta("cursor", sessionID, next.cursor)
+          setMeta("complete", sessionID, next.complete)
+          setMeta("at", sessionID, Date.now())
+        })
+      })
+      .finally(() => {
+        if ((generations.get(sessionID) ?? 0) === generation) setMeta("loading", sessionID, false)
+      })
+  }
+
+  const sync = (sessionID: string, options?: { force?: boolean; messageLimit?: number }) => {
+    touch(sessionID)
+    return runInflight(inflight, sessionID, async () => {
+      const cached = data.message[sessionID] !== undefined && meta.limit[sessionID] !== undefined
+      if (cached && data.info[sessionID] && !options?.force) return
+      await Promise.all([
+        resolve(sessionID, options),
+        cached && !options?.force
+          ? Promise.resolve()
+          : loadMessages(sessionID, options?.messageLimit ?? meta.limit[sessionID] ?? initialMessagePageSize),
+      ])
+    })
+  }
+
+  const prefetch = async (sessionID: string, limit: number) => {
+    touch(sessionID)
+    await inflight.get(sessionID)
+    if (
+      Date.now() - (meta.at[sessionID] ?? 0) <= 15_000 &&
+      (meta.complete[sessionID] || (data.message[sessionID]?.length ?? 0) >= limit)
+    )
+      return
+    await runInflight(inflight, sessionID, () => loadMessages(sessionID, limit))
+  }
+
+  const eventSessionID = (event: { type: string; properties?: unknown }) => {
+    const properties = event.properties
+    if (!properties || typeof properties !== "object") return
+    if ("sessionID" in properties && typeof properties.sessionID === "string") return properties.sessionID
+    if (
+      "info" in properties &&
+      properties.info &&
+      typeof properties.info === "object" &&
+      "sessionID" in properties.info &&
+      typeof properties.info.sessionID === "string"
+    )
+      return properties.info.sessionID
+    if (
+      "part" in properties &&
+      properties.part &&
+      typeof properties.part === "object" &&
+      "sessionID" in properties.part &&
+      typeof properties.part.sessionID === "string"
+    )
+      return properties.part.sessionID
+  }
+
+  const apply = (event: { type: string; properties?: unknown }) => {
+    const eventID = eventSessionID(event)
+    if (eventID) {
+      touch(eventID)
+      if (!data.info[eventID]) void resolve(eventID).catch(() => {})
+    }
+    switch (event.type) {
+      case "session.created":
+        remember((event.properties as { info: Session }).info)
+        return
+      case "session.updated": {
+        const info = (event.properties as { info: Session }).info
+        remember(info)
+        if (info.time.archived) evict([info.id])
+        return
+      }
+      case "session.deleted": {
+        const sessionID = (event.properties as { info: Session }).info.id
+        infoSeen.delete(sessionID)
+        setData(
+          "info",
+          produce((draft) => void delete draft[sessionID]),
+        )
+        evict([sessionID])
+        return
+      }
+      case "session.diff": {
+        const props = event.properties as { sessionID: string; diff: SnapshotFileDiff[] }
+        setData("session_diff", props.sessionID, reconcile(cleanDiffs(props.diff), { key: "file" }))
+        return
+      }
+      case "todo.updated": {
+        const props = event.properties as { sessionID: string; todos: Todo[] }
+        setData("todo", props.sessionID, reconcile(props.todos, { key: "id" }))
+        return
+      }
+      case "session.status": {
+        const props = event.properties as { sessionID: string; status: SessionStatus }
+        setData("session_status", props.sessionID, reconcile(props.status))
+        return
+      }
+      case "message.updated": {
+        const info = cleanMessage((event.properties as { info: Message }).info)
+        const messages = data.message[info.sessionID]
+        if (!messages) {
+          setData("message", info.sessionID, [info])
+          return
+        }
+        const result = Binary.search(messages, info.id, (message) => message.id)
+        if (result.found) setData("message", info.sessionID, result.index, reconcile(info))
+        if (!result.found)
+          setData("message", info.sessionID, (value = []) => {
+            const next = value.slice()
+            next.splice(result.index, 0, info)
+            return next
+          })
+        return
+      }
+      case "message.removed": {
+        const props = event.properties as { sessionID: string; messageID: string }
+        setData(
+          produce((draft) => {
+            const messages = draft.message[props.sessionID]
+            if (messages) {
+              const result = Binary.search(messages, props.messageID, (message) => message.id)
+              if (result.found) messages.splice(result.index, 1)
+            }
+            for (const part of draft.part[props.messageID] ?? []) delete draft.part_text_accum_delta[part.id]
+            delete draft.part[props.messageID]
+          }),
+        )
+        return
+      }
+      case "message.part.updated": {
+        const part = (event.properties as { part: Part }).part
+        if (SKIP_PARTS.has(part.type)) return
+        setData(
+          "part_text_accum_delta",
+          produce((draft) => void delete draft[part.id]),
+        )
+        const parts = data.part[part.messageID]
+        if (!parts) {
+          setData("part", part.messageID, [part])
+          return
+        }
+        const result = Binary.search(parts, part.id, (item) => item.id)
+        if (result.found) setData("part", part.messageID, result.index, reconcile(part))
+        if (!result.found)
+          setData("part", part.messageID, (value = []) => {
+            const next = value.slice()
+            next.splice(result.index, 0, part)
+            return next
+          })
+        return
+      }
+      case "message.part.removed": {
+        const props = event.properties as { messageID: string; partID: string }
+        setData(
+          produce((draft) => {
+            delete draft.part_text_accum_delta[props.partID]
+            const parts = draft.part[props.messageID]
+            if (!parts) return
+            const result = Binary.search(parts, props.partID, (part) => part.id)
+            if (result.found) parts.splice(result.index, 1)
+            if (parts.length === 0) delete draft.part[props.messageID]
+          }),
+        )
+        return
+      }
+      case "message.part.delta": {
+        const props = event.properties as { messageID: string; partID: string; field: string; delta: string }
+        const parts = data.part[props.messageID]
+        if (!parts) return
+        const result = Binary.search(parts, props.partID, (part) => part.id)
+        if (!result.found) return
+        const field = props.field as keyof (typeof parts)[number]
+        const current = parts[result.index]?.[field]
+        setData(
+          "part_text_accum_delta",
+          props.partID,
+          (value) => (value ?? (typeof current === "string" ? current : "")) + props.delta,
+        )
+        setData(
+          "part",
+          props.messageID,
+          produce((draft) => {
+            if (!draft) return
+            const part = draft[result.index]
+            const field = props.field as keyof typeof part
+            ;(part[field] as string) = ((part[field] as string | undefined) ?? "") + props.delta
+          }),
+        )
+        return
+      }
+      case "permission.asked": {
+        const permission = event.properties as PermissionRequest
+        const permissions = data.permission[permission.sessionID] ?? []
+        const result = Binary.search(permissions, permission.id, (item) => item.id)
+        if (result.found) setData("permission", permission.sessionID, result.index, reconcile(permission))
+        if (!result.found)
+          setData(
+            "permission",
+            permission.sessionID,
+            produce((draft = []) => void draft.splice(result.index, 0, permission)),
+          )
+        return
+      }
+      case "permission.replied": {
+        const props = event.properties as { sessionID: string; requestID: string }
+        setData(
+          "permission",
+          props.sessionID,
+          produce((draft) => {
+            if (!draft) return
+            const result = Binary.search(draft, props.requestID, (item) => item.id)
+            if (result.found) draft.splice(result.index, 1)
+          }),
+        )
+        return
+      }
+      case "question.asked": {
+        const question = event.properties as QuestionRequest
+        const questions = data.question[question.sessionID] ?? []
+        const result = Binary.search(questions, question.id, (item) => item.id)
+        if (result.found) setData("question", question.sessionID, result.index, reconcile(question))
+        if (!result.found)
+          setData(
+            "question",
+            question.sessionID,
+            produce((draft = []) => void draft.splice(result.index, 0, question)),
+          )
+        return
+      }
+      case "question.replied":
+      case "question.rejected": {
+        const props = event.properties as { sessionID: string; requestID: string }
+        setData(
+          "question",
+          props.sessionID,
+          produce((draft) => {
+            if (!draft) return
+            const result = Binary.search(draft, props.requestID, (item) => item.id)
+            if (result.found) draft.splice(result.index, 1)
+          }),
+        )
+      }
+    }
+  }
+
+  return {
+    data,
+    set: setData,
+    get: (sessionID: string) => data.info[sessionID],
+    peek: (sessionID: string) => data.info[sessionID],
+    remember,
+    resolve,
+    lineage: {
+      peek: peekLineage,
+      async resolve(sessionID: string) {
+        const session = await resolve(sessionID)
+        return { session, root: await rootSession(session, resolve) }
+      },
+    },
+    sync,
+    prefetch,
+    shouldPrefetch(sessionID: string, limit: number) {
+      if (data.message[sessionID] === undefined) return true
+      if (Date.now() - (meta.at[sessionID] ?? 0) > 15_000) return true
+      if (meta.complete[sessionID]) return false
+      return (meta.limit[sessionID] ?? 0) <= limit
+    },
+    fresh(sessionID: string, ttl: number) {
+      return Date.now() - (meta.at[sessionID] ?? 0) <= ttl
+    },
+    optimistic: {
+      add(input: { sessionID: string; message: Message; parts: Part[] }) {
+        const items = optimistic.get(input.sessionID)
+        if (items) items.set(input.message.id, input)
+        if (!items) optimistic.set(input.sessionID, new Map([[input.message.id, input]]))
+        setData("message", input.sessionID, (messages = []) => merge(messages, [input.message]))
+        setData(
+          "part",
+          input.message.id,
+          input.parts.filter((part) => !!part?.id).sort((a, b) => cmp(a.id, b.id)),
+        )
+      },
+      remove(input: { sessionID: string; messageID: string }) {
+        clearOptimistic(input.sessionID, input.messageID)
+        setData("message", input.sessionID, (messages) => messages?.filter((message) => message.id !== input.messageID))
+        setData(
+          "part",
+          produce((draft) => void delete draft[input.messageID]),
+        )
+      },
+    },
+    diff(sessionID: string, options?: { force?: boolean }) {
+      touch(sessionID)
+      if (data.session_diff[sessionID] !== undefined && !options?.force) return Promise.resolve()
+      return runInflight(inflightDiff, sessionID, () => {
+        const generation = generations.get(sessionID) ?? 0
+        return retry(() => client.session.diff({ sessionID })).then((result) => {
+          if ((generations.get(sessionID) ?? 0) !== generation) return
+          setData("session_diff", sessionID, reconcile(cleanDiffs(result.data), { key: "file" }))
+        })
+      })
+    },
+    todo(sessionID: string, options?: { force?: boolean }) {
+      touch(sessionID)
+      if (data.todo[sessionID] !== undefined && !options?.force) return Promise.resolve()
+      return runInflight(inflightTodo, sessionID, () => {
+        const generation = generations.get(sessionID) ?? 0
+        return retry(() => client.session.todo({ sessionID })).then((result) => {
+          if ((generations.get(sessionID) ?? 0) !== generation) return
+          setData("todo", sessionID, reconcile(result.data ?? [], { key: "id" }))
+        })
+      })
+    },
+    history: {
+      more: (sessionID: string) =>
+        data.message[sessionID] !== undefined &&
+        meta.limit[sessionID] !== undefined &&
+        !meta.complete[sessionID] &&
+        !!meta.cursor[sessionID],
+      loading: (sessionID: string) => meta.loading[sessionID] ?? false,
+      async loadMore(sessionID: string, count = historyMessagePageSize) {
+        touch(sessionID)
+        if (meta.loading[sessionID] || meta.complete[sessionID] || !meta.cursor[sessionID]) return
+        await loadMessages(sessionID, count, meta.cursor[sessionID], "prepend")
+      },
+    },
+    evict(sessionID: string) {
+      if (protectedSessions().has(sessionID)) return
+      seen.delete(sessionID)
+      evict([sessionID])
+    },
+    pin(sessionID: string) {
+      pinned.set(sessionID, (pinned.get(sessionID) ?? 0) + 1)
+      touch(sessionID)
+    },
+    unpin(sessionID: string) {
+      const count = pinned.get(sessionID)
+      if (!count || count === 1) pinned.delete(sessionID)
+      if (count && count > 1) pinned.set(sessionID, count - 1)
+    },
+    apply,
+  }
+}
+
+export type ServerSession = ReturnType<typeof createServerSession>

packages/app/src/context/server-sync.tsx

@@ -1,4 +1,4 @@
-import type { Config, OpencodeClient, Path, Project, ProviderAuthResponse, Todo } from "@opencode-ai/sdk/v2/client"
+import type { Config, OpencodeClient, Path, Project, ProviderAuthResponse } from "@opencode-ai/sdk/v2/client"
 import { showToast } from "@/utils/toast"
 import { getFilename } from "@opencode-ai/core/util/path"
 import { type Accessor, batch, createMemo, getOwner, onCleanup, onMount, untrack } from "solid-js"
@@ -17,8 +17,7 @@ import {
   loadProvidersQuery,
 } from "./global-sync/bootstrap"
 import { createChildStoreManager } from "./global-sync/child-store"
-import { applyDirectoryEvent, applyGlobalEvent, cleanupDroppedSessionCaches } from "./global-sync/event-reducer"
-import { clearSessionPrefetchDirectory } from "./global-sync/session-prefetch"
+import { applyDirectoryEvent, applyGlobalEvent } from "./global-sync/event-reducer"
 import { estimateRootSessionTotal, loadRootSessionsWithFallback } from "./global-sync/session-load"
 import { trimSessions } from "./global-sync/session-trim"
 import type { ProjectMeta } from "./global-sync/types"
@@ -38,15 +37,13 @@ import { retry } from "@opencode-ai/core/util/retry"
 import type { ServerScope } from "@/utils/server-scope"
 import { persisted } from "@/utils/persist"
 import { toggleMcp } from "./global-sync/mcp"
+import { createServerSession } from "./server-session"
 
 type GlobalStore = {
   ready: boolean
   error?: InitError
   path: Path
   project: Project[]
-  session_todo: {
-    [sessionID: string]: Todo[]
-  }
   provider: NormalizedProviderListResponse
   provider_auth: ProviderAuthResponse
   config: Config
@@ -118,7 +115,6 @@ export function createServerSyncContextInner(serverSDK: ServerSDK) {
       return !bootstrap.isPending
     },
     project: [],
-    session_todo: {},
     provider_auth: {},
     get path() {
       const EMPTY = { state: "", config: "", worktree: "", directory: "", home: "" }
@@ -188,20 +184,6 @@ export function createServerSyncContextInner(serverSDK: ServerSDK) {
     return (setGlobalStore as (...args: unknown[]) => unknown)(...input)
   }) as typeof setGlobalStore
 
-  const setSessionTodo = (sessionID: string, todos: Todo[] | undefined) => {
-    if (!sessionID) return
-    if (!todos) {
-      setGlobalStore(
-        "session_todo",
-        produce((draft) => {
-          delete draft[sessionID]
-        }),
-      )
-      return
-    }
-    setGlobalStore("session_todo", sessionID, reconcile(todos, { key: "id" }))
-  }
-
   const paused = () => untrack(() => globalStore.reload) !== undefined
 
   const queue = createRefreshQueue({
@@ -211,6 +193,8 @@ export function createServerSyncContextInner(serverSDK: ServerSDK) {
     bootstrapInstance,
   })
 
+  const session = createServerSession(serverSDK.client)
+
   const children = createChildStoreManager({
     owner,
     scope: serverSDK.scope,
@@ -239,7 +223,6 @@ export function createServerSyncContextInner(serverSDK: ServerSDK) {
       sessionMeta.delete(key)
       sdkCache.delete(key)
       clearProviderRev(serverSDK.scope, key)
-      clearSessionPrefetchDirectory(serverSDK.scope, key)
     },
     translate: language.t,
     queryOptions: queryOptionsApi,
@@ -263,11 +246,10 @@ export function createServerSyncContextInner(serverSDK: ServerSDK) {
     if (meta && meta.limit >= retainedLimit) {
       const next = trimSessions(store.session, {
         limit: retainedLimit,
-        permission: store.permission,
+        permission: session.data.permission,
       })
       if (next.length !== store.session.length) {
         setStore("session", reconcile(next, { key: "id" }))
-        cleanupDroppedSessionCaches(store, setStore, next, setSessionTodo)
       }
       children.unpin(key)
       return
@@ -290,11 +272,12 @@ export function createServerSyncContextInner(serverSDK: ServerSDK) {
                 .sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0))
               const limit = Math.max(store.limit, options?.limit ?? 0, sessionMeta.get(key)?.limit ?? 0)
               const childSessions = store.session.filter((s) => !!s.parentID)
-              const sessions = trimSessions([...nonArchived, ...childSessions], {
+              const next = trimSessions([...nonArchived, ...childSessions], {
                 limit,
-                permission: store.permission,
+                permission: session.data.permission,
               })
               batch(() => {
+                next.forEach(session.remember)
                 setStore(
                   "sessionTotal",
                   estimateRootSessionTotal({
@@ -303,8 +286,7 @@ export function createServerSyncContextInner(serverSDK: ServerSDK) {
                     limited: x.limited,
                   }),
                 )
-                setStore("session", reconcile(sessions, { key: "id" }))
-                cleanupDroppedSessionCaches(store, setStore, sessions, setSessionTodo)
+                setStore("session", reconcile(next, { key: "id" }))
               })
               sessionMeta.set(key, { limit })
             })
@@ -358,6 +340,7 @@ export function createServerSyncContextInner(serverSDK: ServerSDK) {
         loadSessions,
         translate: language.t,
         queryClient,
+        session,
       })
     })
 
@@ -375,6 +358,8 @@ export function createServerSyncContextInner(serverSDK: ServerSDK) {
     const event = e.details
     const recent = bootingRoot || Date.now() - bootedAt < 1500
 
+    session.apply(event)
+
     if (directory === "global") {
       applyGlobalEvent({
         event,
@@ -404,8 +389,9 @@ export function createServerSyncContextInner(serverSDK: ServerSDK) {
       store,
       setStore,
       push: queue.push,
-      setSessionTodo,
       retainedLimit: sessionMeta.get(key)?.limit,
+      sessionContent: false,
+      permission: session.data.permission,
       vcsCache: children.vcsCache.get(key),
       loadLsp: () => {
         void queryClient.fetchQuery(queryOptionsApi.lsp(key))
@@ -479,9 +465,7 @@ export function createServerSyncContextInner(serverSDK: ServerSDK) {
     // bootstrap,
     updateConfig: updateConfigMutation.mutateAsync,
     project: projectApi,
-    todo: {
-      set: setSessionTodo,
-    },
+    session,
     mcp: {
       toggle: async (directory: string, name: string) => {
         const key = directoryKey(directory)

packages/app/src/context/settings.tsx

@@ -31,7 +31,6 @@ export interface Settings {
     showReasoningSummaries: boolean
     shellToolPartsExpanded: boolean
     editToolPartsExpanded: boolean
-    showSessionProgressBar: boolean
     showCustomAgents: boolean
     mobileTitlebarPosition: "top" | "bottom"
     newLayoutDesigns?: boolean
@@ -117,7 +116,6 @@ const defaultSettings: Settings = {
     showReasoningSummaries: false,
     shellToolPartsExpanded: false,
     editToolPartsExpanded: false,
-    showSessionProgressBar: true,
     showCustomAgents: false,
     mobileTitlebarPosition: "top",
   },
@@ -239,13 +237,6 @@ export const { use: useSettings, provider: SettingsProvider } = createSimpleCont
         setEditToolPartsExpanded(value: boolean) {
           setStore("general", "editToolPartsExpanded", value)
         },
-        showSessionProgressBar: withFallback(
-          () => store.general?.showSessionProgressBar,
-          defaultSettings.general.showSessionProgressBar,
-        ),
-        setShowSessionProgressBar(value: boolean) {
-          setStore("general", "showSessionProgressBar", value)
-        },
         showCustomAgents,
         setShowCustomAgents(value: boolean) {
           setStore("general", "showCustomAgents", value)

packages/app/src/i18n/ar.ts

@@ -590,8 +590,6 @@ export const dict = {
   "settings.general.row.editToolPartsExpanded.title": "توسيع أجزاء أداة edit",
   "settings.general.row.editToolPartsExpanded.description":
     "إظهار أجزاء أدوات edit و write و patch موسعة بشكل افتراضي في الشريط الزمني",
-  "settings.general.row.showSessionProgressBar.title": "إظهار شريط تقدم الجلسة",
-  "settings.general.row.showSessionProgressBar.description": "عرض شريط التقدم المتحرك أعلى الجلسة أثناء عمل الوكيل",
   "settings.general.row.wayland.title": "استخدام Wayland الأصلي",
   "settings.general.row.wayland.description": "تعطيل التراجع إلى X11 على Wayland. يتطلب إعادة التشغيل.",
   "settings.general.row.wayland.tooltip":

packages/app/src/i18n/br.ts

@@ -598,9 +598,6 @@ export const dict = {
   "settings.general.row.editToolPartsExpanded.title": "Expandir partes da ferramenta de edição",
   "settings.general.row.editToolPartsExpanded.description":
     "Mostrar partes das ferramentas de edição, escrita e patch expandidas por padrão na linha do tempo",
-  "settings.general.row.showSessionProgressBar.title": "Mostrar barra de progresso da sessão",
-  "settings.general.row.showSessionProgressBar.description":
-    "Exibir a barra de progresso animada no topo da sessão quando o agente estiver trabalhando",
   "settings.general.row.wayland.title": "Usar Wayland nativo",
   "settings.general.row.wayland.description": "Desabilitar fallback X11 no Wayland. Requer reinicialização.",
   "settings.general.row.wayland.tooltip":

packages/app/src/i18n/bs.ts

@@ -663,9 +663,6 @@ export const dict = {
   "settings.general.row.editToolPartsExpanded.title": "Proširi dijelove alata za uređivanje",
   "settings.general.row.editToolPartsExpanded.description":
     "Prikaži dijelove alata za uređivanje, pisanje i patch podrazumijevano proširene na vremenskoj traci",
-  "settings.general.row.showSessionProgressBar.title": "Prikaži traku napretka sesije",
-  "settings.general.row.showSessionProgressBar.description":
-    "Prikaži animiranu traku napretka na vrhu sesije kada agent radi",
   "settings.general.row.wayland.title": "Koristi nativni Wayland",
   "settings.general.row.wayland.description": "Onemogući X11 fallback na Waylandu. Zahtijeva restart.",
   "settings.general.row.wayland.tooltip":

packages/app/src/i18n/da.ts

@@ -657,9 +657,6 @@ export const dict = {
   "settings.general.row.editToolPartsExpanded.title": "Udvid edit-værktøjsdele",
   "settings.general.row.editToolPartsExpanded.description":
     "Vis edit-, write- og patch-værktøjsdele udvidet som standard i tidslinjen",
-  "settings.general.row.showSessionProgressBar.title": "Vis sessionens fremdriftslinje",
-  "settings.general.row.showSessionProgressBar.description":
-    "Vis den animerede fremdriftslinje øverst i sessionen, når agenten arbejder",
   "settings.general.row.wayland.title": "Brug native Wayland",
   "settings.general.row.wayland.description": "Deaktiver X11-fallback på Wayland. Kræver genstart.",
   "settings.general.row.wayland.tooltip":

packages/app/src/i18n/de.ts

@@ -609,9 +609,6 @@ export const dict = {
   "settings.general.row.editToolPartsExpanded.title": "Edit-Tool-Abschnitte ausklappen",
   "settings.general.row.editToolPartsExpanded.description":
     "Edit-, Write- und Patch-Tool-Abschnitte standardmäßig in der Timeline ausgeklappt anzeigen",
-  "settings.general.row.showSessionProgressBar.title": "Sitzungsfortschrittsleiste anzeigen",
-  "settings.general.row.showSessionProgressBar.description":
-    "Die animierte Fortschrittsleiste oben in der Sitzung anzeigen, wenn der Agent arbeitet",
   "settings.general.row.wayland.title": "Natives Wayland verwenden",
   "settings.general.row.wayland.description": "X11-Fallback unter Wayland deaktivieren. Erfordert Neustart.",
   "settings.general.row.wayland.tooltip":

packages/app/src/i18n/en.ts

@@ -854,9 +854,6 @@ export const dict = {
   "settings.general.row.editToolPartsExpanded.title": "Expand edit tool parts",
   "settings.general.row.editToolPartsExpanded.description":
     "Show edit, write, and patch tool parts expanded by default in the timeline",
-  "settings.general.row.showSessionProgressBar.title": "Show session progress bar",
-  "settings.general.row.showSessionProgressBar.description":
-    "Display the animated progress bar at the top of the session when the agent is working",
   "settings.general.row.newLayoutDesigns.title": "New layout and designs",
   "settings.general.row.newLayoutDesigns.description": "Enable the redesigned layout, home, composer, and session UI",
   "settings.general.row.pinchZoom.title": "Pinch to zoom",

packages/app/src/i18n/es.ts

@@ -667,9 +667,6 @@ export const dict = {
   "settings.general.row.editToolPartsExpanded.title": "Expandir partes de la herramienta de edición",
   "settings.general.row.editToolPartsExpanded.description":
     "Mostrar las partes de las herramientas de edición, escritura y parcheado expandidas por defecto en la línea de tiempo",
-  "settings.general.row.showSessionProgressBar.title": "Mostrar barra de progreso de la sesión",
-  "settings.general.row.showSessionProgressBar.description":
-    "Mostrar la barra de progreso animada en la parte superior de la sesión cuando el agente esté trabajando",
   "settings.general.row.wayland.title": "Usar Wayland nativo",
   "settings.general.row.wayland.description": "Deshabilitar fallback a X11 en Wayland. Requiere reinicio.",
   "settings.general.row.wayland.tooltip":

packages/app/src/i18n/fr.ts

@@ -606,9 +606,6 @@ export const dict = {
   "settings.general.row.editToolPartsExpanded.title": "Développer les parties de l'outil edit",
   "settings.general.row.editToolPartsExpanded.description":
     "Afficher les parties des outils edit, write et patch développées par défaut dans la chronologie",
-  "settings.general.row.showSessionProgressBar.title": "Afficher la barre de progression de la session",
-  "settings.general.row.showSessionProgressBar.description":
-    "Afficher la barre de progression animée en haut de la session lorsque l'agent travaille",
   "settings.general.row.wayland.title": "Utiliser Wayland natif",
   "settings.general.row.wayland.description": "Désactiver le repli X11 sur Wayland. Nécessite un redémarrage.",
   "settings.general.row.wayland.tooltip":

packages/app/src/i18n/ja.ts

@@ -595,9 +595,6 @@ export const dict = {
   "settings.general.row.editToolPartsExpanded.title": "edit ツールパーツを展開",
   "settings.general.row.editToolPartsExpanded.description":
     "タイムラインで edit、write、patch ツールパーツをデフォルトで展開して表示します",
-  "settings.general.row.showSessionProgressBar.title": "セッション進行状況バーを表示",
-  "settings.general.row.showSessionProgressBar.description":
-    "エージェントの作業中に、セッション上部にアニメーション付きの進行状況バーを表示します",
   "settings.general.row.wayland.title": "ネイティブWaylandを使用",
   "settings.general.row.wayland.description": "WaylandでのX11フォールバックを無効にします。再起動が必要です。",
   "settings.general.row.wayland.tooltip":

packages/app/src/i18n/ko.ts

@@ -591,9 +591,6 @@ export const dict = {
   "settings.general.row.editToolPartsExpanded.title": "edit 도구 파트 펼치기",
   "settings.general.row.editToolPartsExpanded.description":
     "타임라인에서 기본적으로 edit, write, patch 도구 파트를 펼친 상태로 표시합니다",
-  "settings.general.row.showSessionProgressBar.title": "세션 진행 표시줄 표시",
-  "settings.general.row.showSessionProgressBar.description":
-    "에이전트가 작업 중일 때 세션 상단에 애니메이션 진행 표시줄을 표시합니다",
   "settings.general.row.wayland.title": "네이티브 Wayland 사용",
   "settings.general.row.wayland.description": "Wayland에서 X11 폴백을 비활성화합니다. 다시 시작해야 합니다.",
   "settings.general.row.wayland.tooltip":

packages/app/src/i18n/no.ts

@@ -664,9 +664,6 @@ export const dict = {
   "settings.general.row.editToolPartsExpanded.title": "Utvid edit-verktøydeler",
   "settings.general.row.editToolPartsExpanded.description":
     "Vis edit-, write- og patch-verktøydeler utvidet som standard i tidslinjen",
-  "settings.general.row.showSessionProgressBar.title": "Vis fremdriftslinje for sesjonen",
-  "settings.general.row.showSessionProgressBar.description":
-    "Vis den animerte fremdriftslinjen øverst i sesjonen når agenten jobber",
   "settings.general.row.wayland.title": "Bruk innebygd Wayland",
   "settings.general.row.wayland.description": "Deaktiver X11-fallback på Wayland. Krever omstart.",
   "settings.general.row.wayland.tooltip":

packages/app/src/i18n/pl.ts

@@ -596,9 +596,6 @@ export const dict = {
   "settings.general.row.editToolPartsExpanded.title": "Rozwijaj elementy narzędzia edit",
   "settings.general.row.editToolPartsExpanded.description":
     "Domyślnie pokazuj rozwinięte elementy narzędzi edit, write i patch na osi czasu",
-  "settings.general.row.showSessionProgressBar.title": "Pokazuj pasek postępu sesji",
-  "settings.general.row.showSessionProgressBar.description":
-    "Wyświetlaj animowany pasek postępu u góry sesji, gdy agent pracuje",
   "settings.general.row.wayland.title": "Użyj natywnego Wayland",
   "settings.general.row.wayland.description": "Wyłącz fallback X11 na Wayland. Wymaga restartu.",
   "settings.general.row.wayland.tooltip":

packages/app/src/i18n/ru.ts

@@ -664,9 +664,6 @@ export const dict = {
   "settings.general.row.editToolPartsExpanded.title": "Разворачивать элементы инструмента edit",
   "settings.general.row.editToolPartsExpanded.description":
     "Показывать элементы инструментов edit, write и patch в ленте развернутыми по умолчанию",
-  "settings.general.row.showSessionProgressBar.title": "Показывать индикатор прогресса сессии",
-  "settings.general.row.showSessionProgressBar.description":
-    "Показывать анимированный индикатор прогресса вверху сессии, когда агент работает",
   "settings.general.row.wayland.title": "Использовать нативный Wayland",
   "settings.general.row.wayland.description": "Отключить X11 fallback на Wayland. Требуется перезапуск.",
   "settings.general.row.wayland.tooltip":

packages/app/src/i18n/th.ts

@@ -655,9 +655,6 @@ export const dict = {
   "settings.general.row.editToolPartsExpanded.title": "ขยายส่วนเครื่องมือ edit",
   "settings.general.row.editToolPartsExpanded.description":
     "แสดงส่วนเครื่องมือ edit, write และ patch แบบขยายตามค่าเริ่มต้นในไทม์ไลน์",
-  "settings.general.row.showSessionProgressBar.title": "แสดงแถบความคืบหน้าของเซสชัน",
-  "settings.general.row.showSessionProgressBar.description":
-    "แสดงแถบความคืบหน้าแบบเคลื่อนไหวที่ด้านบนของเซสชันเมื่อเอเจนต์กำลังทำงาน",
   "settings.general.row.wayland.title": "ใช้ Wayland แบบเนทีฟ",
   "settings.general.row.wayland.description": "ปิดใช้งาน X11 fallback บน Wayland ต้องรีสตาร์ท",
   "settings.general.row.wayland.tooltip": "บน Linux ที่มีจอภาพรีเฟรชเรตแบบผสม Wayland แบบเนทีฟอาจเสถียรกว่า",

packages/app/src/i18n/tr.ts

@@ -671,10 +671,6 @@ export const dict = {
   "settings.general.row.editToolPartsExpanded.description":
     "Zaman çizelgesinde düzenleme, yazma ve yama araç bileşenlerini varsayılan olarak genişletilmiş göster",
 
-  "settings.general.row.showSessionProgressBar.title": "Oturum ilerleme çubuğunu göster",
-  "settings.general.row.showSessionProgressBar.description":
-    "Ajan çalışırken oturumun üst kısmında animasyonlu ilerleme çubuğunu göster",
-
   "settings.general.row.wayland.title": "Yerel Wayland kullan",
   "settings.general.row.wayland.description":
     "Wayland'da X11 geri dönüşünü devre dışı bırak. Yeniden başlatma gerektirir.",

packages/app/src/i18n/uk.ts

@@ -781,9 +781,6 @@ export const dict = {
   "settings.general.row.editToolPartsExpanded.title": "Розгортати частини інструменту редагування",
   "settings.general.row.editToolPartsExpanded.description":
     "Показувати частини інструментів редагування, запису та патчів розгорнутими за замовчуванням на часовій шкалі",
-  "settings.general.row.showSessionProgressBar.title": "Показувати індикатор прогресу сесії",
-  "settings.general.row.showSessionProgressBar.description":
-    "Відображати анімований індикатор прогресу вгорі сесії, коли агент працює",
 
   "settings.general.row.wayland.title": "Використовувати нативний Wayland",
   "settings.general.row.wayland.description": "Вимкнути резервний X11 на Wayland. Потребує перезапуску.",

packages/app/src/i18n/zh.ts

@@ -664,8 +664,6 @@ export const dict = {
   "settings.general.row.shellToolPartsExpanded.description": "默认在时间线中展开 shell 工具部分",
   "settings.general.row.editToolPartsExpanded.title": "展开编辑工具部分",
   "settings.general.row.editToolPartsExpanded.description": "默认在时间线中展开 edit、write 和 patch 工具部分",
-  "settings.general.row.showSessionProgressBar.title": "显示会话进度条",
-  "settings.general.row.showSessionProgressBar.description": "当智能体正在工作时，在会话顶部显示动画进度条",
   "settings.general.row.wayland.title": "使用原生 Wayland",
   "settings.general.row.wayland.description": "在 Wayland 上禁用 X11 回退。需要重启。",
   "settings.general.row.wayland.tooltip": "在混合刷新率显示器的 Linux 系统上，原生 Wayland 可能更稳定。",

packages/app/src/i18n/zht.ts

@@ -650,8 +650,6 @@ export const dict = {
   "settings.general.row.shellToolPartsExpanded.description": "在時間軸中預設展開 shell 工具區塊",
   "settings.general.row.editToolPartsExpanded.title": "展開 edit 工具區塊",
   "settings.general.row.editToolPartsExpanded.description": "在時間軸中預設展開 edit、write 和 patch 工具區塊",
-  "settings.general.row.showSessionProgressBar.title": "顯示工作階段進度列",
-  "settings.general.row.showSessionProgressBar.description": "當代理程式正在運作時，在工作階段頂部顯示動畫進度列",
   "settings.general.row.wayland.title": "使用原生 Wayland",
   "settings.general.row.wayland.description": "在 Wayland 上停用 X11 後備模式。需要重新啟動。",
   "settings.general.row.wayland.tooltip": "在混合更新率螢幕的 Linux 系統上，原生 Wayland 可能更穩定。",

packages/app/src/index.css

@@ -24,44 +24,6 @@
 }
 
 @layer components {
-  @keyframes session-progress-whip {
-    0% {
-      clip-path: inset(0 100% 0 0 round 999px);
-      animation-timing-function: cubic-bezier(0.2, 0.8, 0.2, 1);
-    }
-
-    48% {
-      clip-path: inset(0 0 0 0 round 999px);
-      animation-timing-function: cubic-bezier(0.65, 0, 0.35, 1);
-    }
-
-    100% {
-      clip-path: inset(0 0 0 100% round 999px);
-    }
-  }
-
-  [data-component="session-progress"] {
-    position: absolute;
-    inset: 0 0 auto;
-    height: 2px;
-    overflow: hidden;
-    pointer-events: none;
-    opacity: 1;
-    transition: opacity 220ms ease-out;
-  }
-
-  [data-component="session-progress"][data-state="hiding"] {
-    opacity: 0;
-  }
-
-  [data-component="session-progress-bar"] {
-    width: 100%;
-    height: 100%;
-    border-radius: 999px;
-    clip-path: inset(0 100% 0 0 round 999px);
-    will-change: clip-path;
-  }
-
   [data-component="getting-started"] {
     container-type: inline-size;
     container-name: getting-started;

packages/app/src/pages/directory-layout.tsx

@@ -2,7 +2,7 @@ import { DataProvider } from "@opencode-ai/session-ui/context"
 import { showToast } from "@/utils/toast"
 import { base64Encode } from "@opencode-ai/core/util/encode"
 import { useLocation, useNavigate, useParams } from "@solidjs/router"
-import { type Accessor, createEffect, createMemo, createResource, type ParentProps, Show } from "solid-js"
+import { type Accessor, createEffect, createMemo, createResource, onCleanup, type ParentProps, Show } from "solid-js"
 import { useLanguage } from "@/context/language"
 import { LocalProvider } from "@/context/local"
 import { SDKProvider } from "@/context/sdk"
@@ -11,7 +11,7 @@ import { decode64 } from "@/utils/base64"
 import { Schema } from "effect"
 import type { ServerConnection } from "@/context/server"
 import { sessionHref } from "@/utils/session-route"
-import { useGlobal } from "@/context/global"
+import { useServerSync } from "@/context/server-sync"
 
 export function DirectoryDataProvider(
   props: ParentProps<{
@@ -24,7 +24,7 @@ export function DirectoryDataProvider(
   const navigate = useNavigate()
   const params = useParams()
   const sync = useSync()
-  const global = useGlobal()
+  const serverSync = useServerSync()
   const directory = () => (typeof props.directory === "function" ? props.directory() : props.directory)
   const slug = createMemo(() => base64Encode(directory()))
   const href = (sessionID: string) => {
@@ -50,15 +50,18 @@ export function DirectoryDataProvider(
         .catch(() => {}),
   )
 
+  createEffect(() => {
+    const sessionID = params.id
+    if (!sessionID) return
+    serverSync().session.pin(sessionID)
+    onCleanup(() => serverSync().session.unpin(sessionID))
+  })
+
   return (
     <DataProvider
       data={sync().data}
       directory={directory()}
-      onNavigateToSession={(sessionID: string) => {
-        const server = props.server?.()
-        if (server && params.id) global.sessionPlacement.inherit(server, params.id, sessionID)
-        navigate(href(sessionID))
-      }}
+      onNavigateToSession={(sessionID: string) => navigate(href(sessionID))}
       onSessionHref={href}
     >
       <LocalProvider>{props.children}</LocalProvider>

packages/app/src/pages/home.tsx

@@ -220,10 +220,9 @@ export function NewHome() {
             void directory.session
               .sync(record.session.id)
               .then(() => {
-                const store = ctx.sync.child(record.session.directory)[0]
                 return Promise.all(
-                  (store.message[record.session.id] ?? []).flatMap((message) =>
-                    (store.part[message.id] ?? []).flatMap((part) => {
+                  (ctx.sync.session.data.message[record.session.id] ?? []).flatMap((message) =>
+                    (ctx.sync.session.data.part[message.id] ?? []).flatMap((part) => {
                       if (part.type !== "text" || !part.text) return []
                       return preloadMarkdown(part.text, part.id, marked)
                     }),
@@ -343,12 +342,6 @@ export function NewHome() {
     if (!conn) return
     const directory = project?.worktree ?? session.directory
     const ctx = global.ensureServerCtx(conn)
-    global.sessionPlacement.set({
-      server: ServerConnection.key(conn),
-      leafID: session.id,
-      rootID: session.id,
-      directory: session.directory,
-    })
     ctx.projects.open(directory)
     ctx.projects.touch(directory)
     startTransition(() => {

packages/app/src/pages/layout-new.tsx

@@ -18,6 +18,7 @@ export default function NewLayout(props: ParentProps) {
   createEffect(() => setV2Toast(true))
   createEffect(() => {
     if (!notification.ready() || !params.id) return
+    if (notification.session.unseenCount(params.id) === 0) return
     notification.session.markViewed(params.id)
   })
 

packages/app/src/pages/layout.tsx

@@ -1,5 +1,4 @@
 import {
-  batch,
   createEffect,
   createMemo,
   createResource,
@@ -26,7 +25,7 @@ import { Tooltip } from "@opencode-ai/ui/tooltip"
 import { DropdownMenu } from "@opencode-ai/ui/dropdown-menu"
 import { Dialog } from "@opencode-ai/ui/dialog"
 import { getFilename } from "@opencode-ai/core/util/path"
-import { Session, type Message } from "@opencode-ai/sdk/v2/client"
+import { Session } from "@opencode-ai/sdk/v2/client"
 import { usePlatform } from "@/context/platform"
 import { useSettings } from "@/context/settings"
 import { createStore, produce, reconcile } from "solid-js/store"
@@ -37,16 +36,7 @@ import { toaster } from "@opencode-ai/ui/toast"
 import { setV2Toast, showToast, ToastRegion } from "@/utils/toast"
 import { useServerSDK } from "@/context/server-sdk"
 import { clearWorkspaceTerminals } from "@/context/terminal"
-import { dropSessionCaches, pickSessionCacheEvictions } from "@/context/global-sync/session-cache"
-import {
-  clearSessionPrefetchInflight,
-  clearSessionPrefetch,
-  getSessionPrefetch,
-  isSessionPrefetchCurrent,
-  runSessionPrefetch,
-  setSessionPrefetch,
-  shouldSkipSessionPrefetch,
-} from "@/context/global-sync/session-prefetch"
+import { pickSessionCacheEvictions } from "@/context/global-sync/session-cache"
 import { useNotification } from "@/context/notification"
 import { usePermission } from "@/context/permission"
 import { Binary } from "@opencode-ai/core/util/binary"
@@ -684,7 +674,6 @@ export default function LegacyLayout(props: ParentProps) {
     serverSDK().url
 
     prefetchToken.value += 1
-    clearSessionPrefetchInflight(serverSDK().scope)
     prefetchQueues.clear()
   })
 
@@ -712,88 +701,12 @@ export default function LegacyLayout(props: ParentProps) {
     return created
   }
 
-  const mergeByID = <T extends { id: string }>(current: T[], incoming: T[]) => {
-    if (current.length === 0) {
-      return incoming.slice().sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0))
-    }
-
-    const map = new Map<string, T>()
-    for (const item of current) {
-      map.set(item.id, item)
-    }
-    for (const item of incoming) {
-      map.set(item.id, item)
-    }
-    return [...map.values()].sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0))
-  }
-
   async function prefetchMessages(directory: string, sessionID: string, token: number) {
-    const [store, setStore] = serverSync().child(directory, { bootstrap: false })
-
-    return runSessionPrefetch({
-      scope: serverSDK().scope,
-      directory,
-      sessionID,
-      task: (rev) =>
-        retry(() => serverSDK().client.session.messages({ directory, sessionID, limit: prefetchChunk }))
-          .then((messages) => {
-            if (prefetchToken.value !== token) return
-            if (!isSessionPrefetchCurrent(serverSDK().scope, directory, sessionID, rev)) return
-
-            const items = (messages.data ?? []).filter((x) => !!x?.info?.id)
-            const next = items.map((x) => x.info).filter((m): m is Message => !!m?.id)
-            const sorted = mergeByID([], next)
-            const stale = markPrefetched(directory, sessionID)
-            const cursor = messages.response.headers.get("x-next-cursor") ?? undefined
-            const meta = {
-              limit: sorted.length,
-              cursor,
-              complete: !cursor,
-              at: Date.now(),
-            }
-
-            if (stale.length > 0) {
-              clearSessionPrefetch(serverSDK().scope, directory, stale)
-              for (const id of stale) {
-                serverSync().todo.set(id, undefined)
-              }
-            }
-
-            const current = store.message[sessionID] ?? []
-            const merged = mergeByID(
-              current.filter((item): item is Message => !!item?.id),
-              sorted,
-            )
-
-            if (!isSessionPrefetchCurrent(serverSDK().scope, directory, sessionID, rev)) return
-
-            batch(() => {
-              if (stale.length > 0) {
-                setStore(
-                  produce((draft) => {
-                    dropSessionCaches(draft, stale)
-                  }),
-                )
-              }
-
-              setStore("message", sessionID, reconcile(merged, { key: "id" }))
-              setSessionPrefetch({ scope: serverSDK().scope, directory, sessionID, ...meta })
-
-              for (const message of items) {
-                const currentParts = store.part[message.info.id] ?? []
-                const mergedParts = mergeByID(
-                  currentParts.filter((item): item is (typeof currentParts)[number] & { id: string } => !!item?.id),
-                  message.parts.filter((item): item is (typeof message.parts)[number] & { id: string } => !!item?.id),
-                )
-
-                setStore("part", message.info.id, reconcile(mergedParts, { key: "id" }))
-              }
-            })
-
-            return meta
-          })
-          .catch(() => undefined),
-    })
+    await serverSync()
+      .session.prefetch(sessionID, prefetchChunk)
+      .catch(() => {})
+    if (prefetchToken.value !== token) return
+    for (const stale of markPrefetched(directory, sessionID)) serverSync().session.evict(stale)
   }
 
   const pumpPrefetch = (directory: string) => {
@@ -820,15 +733,7 @@ export default function LegacyLayout(props: ParentProps) {
     const directory = session.directory
     if (!directory) return
 
-    const [store] = serverSync().child(directory, { bootstrap: false })
-    const cached = untrack(() => {
-      const info = getSessionPrefetch(serverSDK().scope, directory, session.id)
-      return shouldSkipSessionPrefetch({
-        message: store.message[session.id] !== undefined,
-        info,
-        chunk: prefetchChunk,
-      })
-    })
+    const cached = untrack(() => !serverSync().session.shouldPrefetch(session.id, prefetchChunk))
     if (cached) return
 
     const q = queueFor(directory)

packages/app/src/pages/layout/project-avatar-state.ts

@@ -15,7 +15,7 @@ export function useSessionTabAvatarState(
   const hasPermissions = createMemo(() => {
     if (!active()) return false
     const [store] = globalSync().child(directory(), { bootstrap: false })
-    return !!sessionPermissionRequest(store.session, store.permission, sessionId(), (item) => {
+    return !!sessionPermissionRequest(store.session, globalSync().session.data.permission, sessionId(), (item) => {
       return !permission.autoResponds(item, directory())
     })
   })
@@ -23,8 +23,7 @@ export function useSessionTabAvatarState(
   const loading = createMemo(() => {
     if (!active()) return false
     if (hasPermissions()) return false
-    const [store] = globalSync().child(directory(), { bootstrap: false })
-    return store.session_working(sessionId())
+    return globalSync().session.data.session_working(sessionId())
   })
   return { unread, loading }
 }

packages/app/src/pages/layout/sidebar-items.tsx

@@ -33,8 +33,10 @@ export const ProjectIcon = (props: {
   const hasError = createMemo(() => dirs().some((directory) => notification.project.unseenHasError(directory)))
   const hasPermissions = createMemo(() =>
     dirs().some((directory) => {
-      const [store] = serverSync().child(directory, { bootstrap: false })
-      return hasProjectPermissions(store.permission, (item) => !permission.autoResponds(item, directory))
+      return hasProjectPermissions(serverSync().session.data.permission, (item) => {
+        if (serverSync().session.get(item.sessionID)?.directory !== directory) return false
+        return !permission.autoResponds(item, directory)
+      })
     }),
   )
   const notify = createMemo(() => props.notify && (hasPermissions() || unseenCount() > 0))
@@ -151,16 +153,23 @@ export const SessionItem = (props: SessionItemProps): JSX.Element => {
   const hasError = createMemo(() => notification.session.unseenHasError(props.session.id))
   const [sessionStore] = serverSync().child(props.session.directory)
   const hasPermissions = createMemo(() => {
-    return !!sessionPermissionRequest(sessionStore.session, sessionStore.permission, props.session.id, (item) => {
-      return !permission.autoResponds(item, props.session.directory)
-    })
+    return !!sessionPermissionRequest(
+      sessionStore.session,
+      serverSync().session.data.permission,
+      props.session.id,
+      (item) => {
+        return !permission.autoResponds(item, props.session.directory)
+      },
+    )
   })
   const isWorking = createMemo(() => {
     if (hasPermissions()) return false
-    return sessionStore.session_working(props.session.id)
+    return serverSync().session.data.session_working(props.session.id)
   })
 
-  const tint = createMemo(() => messageAgentColor(sessionStore.message[props.session.id], sessionStore.agent))
+  const tint = createMemo(() =>
+    messageAgentColor(serverSync().session.data.message[props.session.id], sessionStore.agent),
+  )
   const tooltip = createMemo(() => props.showTooltip ?? (props.mobile || !props.sidebarExpanded()))
   const currentChild = createMemo(() => {
     if (!props.showChild) return

packages/app/src/pages/layout/sidebar-project.tsx

@@ -304,8 +304,10 @@ export const SortableProject = (props: {
   const projectStore = createMemo(() => serverSync().child(props.project.worktree, { bootstrap: false })[0])
   const isWorking = createMemo(() =>
     dirs().some((directory) => {
-      const [store] = serverSync().child(directory, { bootstrap: false })
-      return Object.keys(store.session_status).some((id) => store.session_working(id))
+      return Object.keys(serverSync().session.data.session_status).some((id) => {
+        if (serverSync().session.get(id)?.directory !== directory) return false
+        return serverSync().session.data.session_working(id)
+      })
     }),
   )
   const projectSessions = createMemo(() => sortedRootSessions(projectStore(), props.sortNow()))

packages/app/src/pages/session.tsx

@@ -516,9 +516,7 @@ export default function Page() {
         todoTimer = undefined
         if (!id) return
         if (status === "idle" && !blocked) return
-        const cached = untrack(
-          () => sync().data.todo[id] !== undefined || serverSync().data.session_todo[id] !== undefined,
-        )
+        const cached = untrack(() => sync().data.todo[id] !== undefined)
 
         todoFrame = requestAnimationFrame(() => {
           todoFrame = undefined

packages/app/src/pages/session/composer/session-composer-state.ts

@@ -50,7 +50,7 @@ export function createSessionComposerState(options?: { closeMs?: number | (() =>
   const todos = createMemo((): Todo[] => {
     const id = params.id
     if (!id) return []
-    return serverSync().data.session_todo[id] ?? []
+    return serverSync().session.data.todo[id] ?? []
   })
 
   const done = createMemo(
@@ -111,7 +111,6 @@ export function createSessionComposerState(options?: { closeMs?: number | (() =>
   const clear = () => {
     const id = params.id
     if (!id) return
-    serverSync().todo.set(id, [])
     sync().set("todo", id, [])
   }
 

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

@@ -56,7 +56,6 @@ import { useFileComponent } from "@opencode-ai/ui/context/file"
 import { shouldMarkBoundaryGesture, normalizeWheelDelta } from "@/pages/session/message-gesture"
 import { SessionContextUsage } from "@/components/session-context-usage"
 import { useDialog } from "@opencode-ai/ui/context/dialog"
-import { createResizeObserver } from "@solid-primitives/resize-observer"
 import { useLanguage } from "@/context/language"
 import { useSessionKey } from "@/pages/session/session-layout"
 import { useServerSDK } from "@/context/server-sdk"
@@ -95,8 +94,6 @@ const taskDescription = (part: PartType, sessionID: string) => {
   if (typeof value === "string" && value) return value
 }
 
-const pace = (width: number) => Math.round(Math.max(1200, Math.min(3200, (Math.max(width, 360) * 2000) / 900)))
-
 const boundaryTarget = (root: HTMLElement, target: EventTarget | null) => {
   const current = target instanceof Element ? target : undefined
   const nested = current?.closest("[data-scrollable]")
@@ -567,18 +564,7 @@ export function MessageTimeline(props: {
     open: false,
     dismiss: null as "escape" | "outside" | null,
   })
-  const [bar, setBar] = createStore({
-    ms: pace(640),
-  })
   let more: HTMLButtonElement | undefined
-  let head: HTMLDivElement | undefined
-
-  const updateTitleMetrics = () => {
-    if (!head || head.clientWidth <= 0) return
-    setBar("ms", pace(head.clientWidth))
-  }
-
-  createResizeObserver(() => head, updateTitleMetrics)
 
   const bindListRoot = (root: HTMLDivElement) => {
     if (root === listRoot()) return
@@ -660,14 +646,14 @@ export function MessageTimeline(props: {
   }
 
   const shareMutation = useMutation(() => ({
-    mutationFn: (id: string) => serverSDK().client.session.share({ sessionID: id, directory: sdk().directory }),
+    mutationFn: (id: string) => serverSDK().client.session.share({ sessionID: id }),
     onError: (err) => {
       console.error("Failed to share session", err)
     },
   }))
 
   const unshareMutation = useMutation(() => ({
-    mutationFn: (id: string) => serverSDK().client.session.unshare({ sessionID: id, directory: sdk().directory }),
+    mutationFn: (id: string) => serverSDK().client.session.unshare({ sessionID: id }),
     onError: (err) => {
       console.error("Failed to unshare session", err)
     },
@@ -1291,10 +1277,6 @@ export function MessageTimeline(props: {
       >
         <Show when={showHeader()}>
           <div
-            ref={(el) => {
-              head = el
-              updateTitleMetrics()
-            }}
             data-session-title
             classList={{
               "sticky top-0 z-30 bg-[linear-gradient(to_bottom,var(--background-stronger)_48px,transparent)]": true,
@@ -1306,17 +1288,6 @@ export function MessageTimeline(props: {
               "md:max-w-200 md:mx-auto 2xl:max-w-[1000px]": props.centered,
             }}
           >
-            <Show when={workingStatus() !== "hidden" && settings.general.showSessionProgressBar()}>
-              <div data-component="session-progress" data-state={workingStatus()} aria-hidden="true">
-                <div
-                  data-component="session-progress-bar"
-                  style={{
-                    background: tint() ?? "var(--icon-interactive-base)",
-                    animation: `session-progress-whip ${bar.ms}ms infinite`,
-                  }}
-                />
-              </div>
-            </Show>
             <div class="h-12 w-full flex items-center justify-between gap-2">
               <div class="flex items-center gap-1 min-w-0 flex-1 pr-3">
                 <div class="flex items-center min-w-0 grow-1">

packages/app/src/pages/session/timeline/model.ts

@@ -1,37 +1,29 @@
 import type { Message, UserMessage } from "@opencode-ai/sdk/v2"
 import { createMemo, createResource, onCleanup, untrack, type Accessor } from "solid-js"
-import { getSessionPrefetch, SESSION_PREFETCH_TTL } from "@/context/global-sync/session-prefetch"
-import { useSDK } from "@/context/sdk"
-import { useServerSDK } from "@/context/server-sdk"
+import { useServerSync } from "@/context/server-sync"
 import { useSync } from "@/context/sync"
 import { same } from "@/utils/same"
 
 const emptyUserMessages: UserMessage[] = []
+const sessionFreshness = 15_000
 
 export function createTimelineModel(input: {
   sessionID: Accessor<string | undefined>
   revertMessageID: Accessor<string | undefined>
 }) {
-  const sdk = useSDK()
-  const serverSDK = useServerSDK()
+  const serverSync = useServerSync()
   const sync = useSync()
   let refreshFrame: number | undefined
   let refreshTimer: number | undefined
 
   const [resource] = createResource(
-    () => [sdk().directory, input.sessionID()] as const,
-    ([directory, id]) => {
+    () => input.sessionID(),
+    (id) => {
       clearRefresh()
       if (!id) return
 
       const cached = untrack(() => sync().data.message[id] !== undefined)
-      const stale = cached
-        ? (() => {
-            const info = getSessionPrefetch(serverSDK().scope, directory, id)
-            if (!info) return true
-            return Date.now() - info.at > SESSION_PREFETCH_TTL
-          })()
-        : false
+      const stale = cached && !serverSync().session.fresh(id, sessionFreshness)
 
       refreshFrame = requestAnimationFrame(() => {
         refreshFrame = undefined

packages/app/src/utils/session-placement.test.ts

@@ -1,38 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { ServerConnection } from "@/context/server"
-import { createSessionPlacementStore } from "./session-placement"
-
-describe("session placement", () => {
-  const local = ServerConnection.Key.make("http://localhost:4096")
-  const remote = ServerConnection.Key.make("https://example.com")
-
-  test("aliases a leaf and root without crossing servers", () => {
-    const store = createSessionPlacementStore()
-    store.set({ server: local, leafID: "child", rootID: "root", directory: "/repo" })
-    store.set({ server: remote, leafID: "child", rootID: "other", directory: "/remote" })
-
-    expect(store.get(local, "child")).toEqual({ rootID: "root", directory: "/repo" })
-    expect(store.get(local, "root")).toEqual({ rootID: "root", directory: "/repo" })
-    expect(store.get(remote, "child")).toEqual({ rootID: "other", directory: "/remote" })
-  })
-
-  test("inherits known placement for in-app child navigation", () => {
-    const store = createSessionPlacementStore()
-    store.set({ server: local, leafID: "parent", rootID: "root", directory: "/repo" })
-
-    expect(store.inherit(local, "parent", "child")).toEqual({ rootID: "root", directory: "/repo" })
-    expect(store.get(local, "child")).toEqual({ rootID: "root", directory: "/repo" })
-    expect(store.inherit(local, "missing", "unknown")).toBeUndefined()
-  })
-
-  test("bounds retained placement aliases", () => {
-    const store = createSessionPlacementStore()
-    for (let index = 0; index < 300; index++) {
-      store.set({ server: local, leafID: `leaf-${index}`, rootID: `root-${index}`, directory: `/repo/${index}` })
-    }
-
-    expect(store.size()).toBeLessThanOrEqual(256)
-    expect(store.get(local, "leaf-0")).toBeUndefined()
-    expect(store.get(local, "leaf-299")).toEqual({ rootID: "root-299", directory: "/repo/299" })
-  })
-})

packages/app/src/utils/session-placement.ts

@@ -1,41 +0,0 @@
-import { ServerConnection } from "@/context/server"
-
-export type SessionPlacement = {
-  rootID: string
-  directory: string
-}
-
-export function createSessionPlacementStore() {
-  const placements = new Map<string, SessionPlacement>()
-  const limit = 256
-  const key = (server: ServerConnection.Key, sessionID: string) => `${server}\0${sessionID}`
-  const write = (id: string, placement: SessionPlacement) => {
-    placements.delete(id)
-    placements.set(id, placement)
-    while (placements.size > limit) placements.delete(placements.keys().next().value!)
-  }
-
-  return {
-    get(server: ServerConnection.Key, sessionID: string) {
-      const id = key(server, sessionID)
-      const placement = placements.get(id)
-      if (placement) write(id, placement)
-      return placement
-    },
-    set(input: SessionPlacement & { server: ServerConnection.Key; leafID: string }) {
-      const placement = { rootID: input.rootID, directory: input.directory }
-      write(key(input.server, input.leafID), placement)
-      write(key(input.server, input.rootID), placement)
-      return placement
-    },
-    inherit(server: ServerConnection.Key, sourceID: string, leafID: string) {
-      const placement = placements.get(key(server, sourceID))
-      if (!placement) return
-      write(key(server, leafID), placement)
-      return placement
-    },
-    size() {
-      return placements.size
-    },
-  }
-}

packages/app/src/utils/session-route.test.ts

@@ -36,4 +36,13 @@ describe("session routes", () => {
       }),
     ).toBe(sessions.root)
   })
+
+  test("rejects a parent cycle", async () => {
+    const sessions: Record<string, { id: string; parentID?: string }> = {
+      child: { id: "child", parentID: "parent" },
+      parent: { id: "parent", parentID: "child" },
+    }
+
+    expect(rootSession(sessions.child, async (id) => sessions[id]!)).rejects.toThrow("Session parent cycle: child")
+  })
 })

packages/app/src/utils/session-route.ts

@@ -18,8 +18,13 @@ export function requireServerKey(segment: string | undefined) {
 
 type SessionParent = { id: string; parentID?: string }
 
-export async function rootSession(session: SessionParent, get: (sessionID: string) => Promise<SessionParent>) {
+export async function rootSession<T extends SessionParent>(session: T, get: (sessionID: string) => Promise<T>) {
+  const seen = new Set([session.id])
   let current = session
-  while (current.parentID) current = await get(current.parentID)
+  while (current.parentID) {
+    if (seen.has(current.parentID)) throw new Error(`Session parent cycle: ${current.parentID}`)
+    seen.add(current.parentID)
+    current = await get(current.parentID)
+  }
   return current
 }

packages/core/src/control-plane/move-session.ts

@@ -84,15 +84,20 @@ export const layer = Layer.effect(
         return yield* new DestinationProjectMismatchError({ expected: current.projectID, actual: destination.id })
       }
 
-      const patch =
-        input.moveChanges && source.directory !== destination.directory
-          ? yield* git
-              .patch(current.location.directory)
-              .pipe(Effect.mapError((error) => new CaptureChangesError({ message: error.message })))
-          : ""
+      const moveChanges = input.moveChanges && source.directory !== destination.directory
+      const sourceRepository = moveChanges ? yield* git.repo.discover(current.location.directory) : undefined
+      if (moveChanges && !sourceRepository)
+        return yield* new CaptureChangesError({ message: "Source is not a Git repository" })
+      const patch = sourceRepository
+        ? yield* git.change
+            .capture({ repository: sourceRepository, path: current.location.directory })
+            .pipe(Effect.mapError((error) => new CaptureChangesError({ message: error.message })))
+        : Git.ChangeSet.make("")
       if (patch) {
-        yield* git
-          .applyPatch({ directory, patch })
+        const repository = yield* git.repo.discover(directory)
+        if (!repository) return yield* new ApplyChangesError({ message: "Destination is not a Git repository" })
+        yield* git.change
+          .apply({ repository, path: directory, changes: patch })
           .pipe(Effect.mapError((error) => new ApplyChangesError({ message: error.message })))
       }
 
@@ -104,16 +109,29 @@ export const layer = Layer.effect(
       })
 
       if (patch) {
-        yield* git.softResetChanges(current.location.directory).pipe(
-          Effect.mapError(
-            (error) =>
-              new ResetSourceChangesError({
-                directory: current.location.directory,
-                message: error.message,
-                cause: error.cause,
-              }),
-          ),
-        )
+        const repository = yield* git.repo.discover(current.location.directory)
+        if (!repository)
+          return yield* new ResetSourceChangesError({
+            directory: current.location.directory,
+            message: "Source is not a Git repository",
+          })
+        yield* git.change
+          .discard({
+            repository,
+            path: current.location.directory,
+            index: "preserve",
+            untracked: "remove",
+          })
+          .pipe(
+            Effect.mapError(
+              (error) =>
+                new ResetSourceChangesError({
+                  directory: current.location.directory,
+                  message: error.message,
+                  cause: error.cause,
+                }),
+            ),
+          )
       }
     })
 

packages/core/src/file.ts

@@ -0,0 +1,6 @@
+export * as File from "./file"
+
+import { Revert } from "@opencode-ai/schema/revert"
+
+export const Diff = Revert.FileDiff
+export type Diff = typeof Diff.Type

packages/core/src/filesystem.ts

@@ -6,7 +6,7 @@ import { FSUtil } from "./fs-util"
 import { Location } from "./location"
 import { PositiveInt, RelativePath } from "./schema"
 import { FileSystemSearch } from "./filesystem/search"
-import { Entry, FileSystem, Match } from "@opencode-ai/schema/filesystem"
+import { Entry, FileSystem, FindInput, Match } from "@opencode-ai/schema/filesystem"
 export { Entry, Match, Submatch } from "@opencode-ai/schema/filesystem"
 
 export const ReadInput = Schema.Struct({
@@ -28,11 +28,7 @@ export const ListInput = Schema.Struct({
 })
 export type ListInput = typeof ListInput.Type
 
-export class FindInput extends Schema.Class<FindInput>("FileSystem.FindInput")({
-  query: Schema.String,
-  type: Schema.Literals(["file", "directory"]).pipe(Schema.optional),
-  limit: PositiveInt.pipe(Schema.optional),
-}) {}
+export { FindInput }
 
 export class GlobInput extends Schema.Class<GlobInput>("FileSystem.GlobInput")({
   pattern: Schema.String,

packages/core/src/filesystem/search.ts

@@ -127,12 +127,19 @@ export const fffLayer = Layer.effect(
         Fff.create({
           basePath: location.directory,
           aiMode: true,
-          enableFsRootScanning: true,
-          enableHomeDirScanning: true,
         }),
       catch: (cause) => cause,
-    }).pipe(Effect.orDie)
-    if (!result.ok) return yield* Effect.die(result.error)
+    }).pipe(
+      Effect.catch((error) => Effect.logWarning("failed to initialize fff", { error }).pipe(Effect.as(undefined))),
+    )
+    if (!result?.ok) {
+      if (result) yield* Effect.logWarning("failed to initialize fff", { error: result.error })
+      return Service.of({
+        find: () => Effect.succeed([]),
+        glob: () => Effect.succeed([]),
+        grep: () => Effect.succeed([]),
+      })
+    }
     yield* Effect.addFinalizer(() => Effect.sync(() => result.value.destroy()).pipe(Effect.ignore))
     return Service.of({
       glob: (input) =>

packages/core/src/filesystem/watcher.ts

@@ -112,7 +112,7 @@ export const layer = Layer.effect(
     }
 
     if (location.vcs?.type === "git") {
-      const resolved = yield* git.dir(location.directory)
+      const resolved = (yield* git.repo.discover(location.directory))?.gitDirectory
       const vcs = resolved ? yield* fs.realPath(resolved).pipe(Effect.catch(() => Effect.succeed(resolved))) : undefined
       if (vcs && !config.includes(".git") && !config.includes(vcs) && (!resolved || !config.includes(resolved))) {
         const ignore = (yield* fs.readDirectoryEntries(vcs).pipe(Effect.catch(() => Effect.succeed([])))).flatMap(

packages/core/src/git.ts

@@ -1,31 +1,50 @@
 export * as Git from "./git"
 
 import path from "path"
+import { randomUUID } from "crypto"
 import { Context, Effect, Layer, Schema, Stream } from "effect"
 import { ChildProcess } from "effect/unstable/process"
-import { AbsolutePath } from "./schema"
+import { AbsolutePath, RelativePath } from "./schema"
 import { FSUtil } from "./fs-util"
 import { AppProcess } from "./process"
 import { LayerNode } from "./effect/layer-node"
+import { File } from "./file"
+import { KeyedMutex } from "./effect/keyed-mutex"
 
-export interface Repo {
-  /**
-   * The root directory of the working tree that contains the input path.
-   *
-   * For `/home/me/app/src/file.ts` in a normal clone, this is `/home/me/app`.
-   * For `/home/me/app-feature/src/file.ts` in a linked worktree, this is
-   * `/home/me/app-feature`.
-   */
-  readonly directory: AbsolutePath
-  /**
-   * The shared Git storage directory used by this repo and any linked worktrees.
-   *
-   * For a normal clone at `/home/me/app`, this is usually `/home/me/app/.git`.
-   * For a linked worktree at `/home/me/app-feature` whose main checkout is
-   * `/home/me/app`, this is usually `/home/me/app/.git`.
-   */
-  readonly store: AbsolutePath
-}
+export class Repository extends Schema.Class<Repository>("Git.Repository")({
+  worktree: AbsolutePath,
+  gitDirectory: AbsolutePath,
+  commonDirectory: AbsolutePath,
+}) {}
+
+export const ChangeSet = Schema.String.pipe(Schema.brand("Git.ChangeSet"))
+export type ChangeSet = typeof ChangeSet.Type
+
+export const TreeID = Schema.String.pipe(Schema.brand("Git.TreeID"))
+export type TreeID = typeof TreeID.Type
+
+export class OperationError extends Schema.TaggedErrorClass<OperationError>()("Git.OperationError", {
+  operation: Schema.Literals([
+    "clone",
+    "fetch",
+    "checkout",
+    "reset",
+    "create",
+    "refresh",
+    "write_tree",
+    "list_files",
+    "diff",
+    "restore",
+  ]),
+  message: Schema.String,
+  directory: Schema.optional(AbsolutePath),
+  cause: Schema.optional(Schema.Defect()),
+}) {}
+
+export class Worktree extends Schema.Class<Worktree>("Git.Worktree")({
+  directory: AbsolutePath,
+  kind: Schema.Literals(["main", "linked"]),
+}) {}
 
 export class WorktreeError extends Schema.TaggedErrorClass<WorktreeError>()("Git.WorktreeError", {
   operation: Schema.Literals(["create", "remove", "list"]),
@@ -43,35 +62,112 @@ export class PatchError extends Schema.TaggedErrorClass<PatchError>()("Git.Patch
 }) {}
 
 export interface Interface {
-  readonly find: (input: AbsolutePath) => Effect.Effect<Repo | undefined>
-  readonly remote: (repo: Repo, name?: string) => Effect.Effect<string | undefined>
-  readonly roots: (repo: Repo) => Effect.Effect<string[]>
-  readonly origin: (directory: string) => Effect.Effect<string | undefined>
-  readonly head: (directory: string) => Effect.Effect<string | undefined>
-  readonly dir: (directory: string) => Effect.Effect<string | undefined>
-  readonly branch: (directory: string) => Effect.Effect<string | undefined>
-  readonly remoteHead: (directory: string) => Effect.Effect<string | undefined>
-  readonly clone: (input: {
-    remote: string
-    target: string
-    branch?: string
-    depth?: number
-  }) => Effect.Effect<Result, AppProcess.AppProcessError>
-  readonly fetch: (directory: string) => Effect.Effect<Result, AppProcess.AppProcessError>
-  readonly fetchBranch: (directory: string, branch: string) => Effect.Effect<Result, AppProcess.AppProcessError>
-  readonly checkout: (directory: string, branch: string) => Effect.Effect<Result, AppProcess.AppProcessError>
-  readonly reset: (directory: string, target: string) => Effect.Effect<Result, AppProcess.AppProcessError>
-  readonly patch: (directory: AbsolutePath) => Effect.Effect<string, PatchError>
-  readonly applyPatch: (input: { directory: AbsolutePath; patch: string }) => Effect.Effect<void, PatchError>
-  readonly resetChanges: (directory: AbsolutePath) => Effect.Effect<void, PatchError>
-  readonly softResetChanges: (directory: AbsolutePath) => Effect.Effect<void, PatchError>
-  readonly worktreeCreate: (input: { repo: Repo; directory: AbsolutePath }) => Effect.Effect<void, WorktreeError>
-  readonly worktreeRemove: (input: {
-    repo: Repo
-    directory: AbsolutePath
-    force: boolean
-  }) => Effect.Effect<void, WorktreeError>
-  readonly worktreeList: (repo: Repo) => Effect.Effect<AbsolutePath[], WorktreeError>
+  readonly repo: {
+    readonly discover: (input: AbsolutePath) => Effect.Effect<Repository | undefined>
+    readonly clone: (input: {
+      remote: string
+      directory: AbsolutePath
+      branch?: string
+      depth?: number
+    }) => Effect.Effect<Repository, OperationError>
+    readonly create: (input: {
+      worktree: AbsolutePath
+      gitDirectory: AbsolutePath
+      seed?: Repository
+    }) => Effect.Effect<Repository, OperationError>
+  }
+  readonly remote: {
+    readonly get: (repository: Repository, name?: string) => Effect.Effect<string | undefined>
+  }
+  readonly history: {
+    readonly head: (repository: Repository) => Effect.Effect<string | undefined>
+    readonly branch: (repository: Repository) => Effect.Effect<string | undefined>
+    readonly defaultRemoteBranch: (repository: Repository, remote?: string) => Effect.Effect<string | undefined>
+    readonly rootCommits: (repository: Repository) => Effect.Effect<readonly string[]>
+  }
+  readonly sync: {
+    readonly fetchRemotes: (repository: Repository, input?: { prune?: boolean }) => Effect.Effect<void, OperationError>
+    readonly fetchBranch: (
+      repository: Repository,
+      input: { remote?: string; branch: string; force?: boolean },
+    ) => Effect.Effect<void, OperationError>
+    readonly checkoutRemoteBranch: (
+      repository: Repository,
+      input: { remote?: string; branch: string; reset?: boolean },
+    ) => Effect.Effect<void, OperationError>
+    readonly resetHard: (repository: Repository, revision: string) => Effect.Effect<void, OperationError>
+  }
+  readonly change: {
+    readonly capture: (input: { repository: Repository; path: AbsolutePath }) => Effect.Effect<ChangeSet, PatchError>
+    readonly apply: (input: {
+      repository: Repository
+      path: AbsolutePath
+      changes: ChangeSet
+    }) => Effect.Effect<void, PatchError>
+    readonly discard: (input: {
+      repository: Repository
+      path: AbsolutePath
+      index: "preserve" | "reset"
+      untracked: "preserve" | "remove"
+    }) => Effect.Effect<void, PatchError>
+  }
+  readonly worktree: {
+    readonly create: (input: {
+      repository: Repository
+      directory: AbsolutePath
+    }) => Effect.Effect<Repository, WorktreeError>
+    readonly remove: (input: {
+      repository: Repository
+      directory: AbsolutePath
+      force: boolean
+    }) => Effect.Effect<void, WorktreeError>
+    readonly list: (repository: Repository) => Effect.Effect<readonly Worktree[], WorktreeError>
+  }
+  readonly index: {
+    /** Refresh only the requested project-relative scope, preserving all other entries. */
+    readonly refresh: (input: {
+      repository: Repository
+      scope: RelativePath
+      ignores?: Repository
+      maximumUntrackedFileBytes?: number
+    }) => Effect.Effect<{ readonly skipped: readonly RelativePath[] }, OperationError>
+    readonly ignored: (input: {
+      repository: Repository
+      paths: readonly RelativePath[]
+    }) => Effect.Effect<ReadonlySet<RelativePath>, OperationError>
+  }
+  readonly tree: {
+    readonly capture: (input: {
+      repository: Repository
+      scopes: readonly RelativePath[]
+      ignores?: Repository
+      maximumUntrackedFileBytes?: number
+    }) => Effect.Effect<TreeID, OperationError>
+    readonly write: (repository: Repository) => Effect.Effect<TreeID, OperationError>
+    readonly files: (input: {
+      repository: Repository
+      from: TreeID
+      to: TreeID
+    }) => Effect.Effect<readonly RelativePath[], OperationError>
+    readonly diff: (input: {
+      repository: Repository
+      from: TreeID
+      to: TreeID
+      context?: number
+      paths?: readonly RelativePath[]
+    }) => Effect.Effect<readonly File.Diff[], OperationError>
+    readonly preview: (input: {
+      repository: Repository
+      current: TreeID
+      files: ReadonlyMap<RelativePath, TreeID>
+      context?: number
+    }) => Effect.Effect<readonly File.Diff[], OperationError>
+    readonly restore: (input: {
+      repository: Repository
+      files: ReadonlyMap<RelativePath, TreeID>
+    }) => Effect.Effect<void, OperationError>
+    readonly checkout: (input: { repository: Repository; tree: TreeID }) => Effect.Effect<void, OperationError>
+  }
 }
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/GitV2") {}
@@ -81,8 +177,11 @@ export const layer = Layer.effect(
   Effect.gen(function* () {
     const fs = yield* FSUtil.Service
     const proc = yield* AppProcess.Service
+    const locks = KeyedMutex.makeUnsafe<string>()
+    const locked = <A, E, R>(repository: Repository, effect: Effect.Effect<A, E, R>) =>
+      locks.withLock(repository.gitDirectory)(effect)
 
-    const find = Effect.fn("Git.find")(function* (input: AbsolutePath) {
+    const discover = Effect.fn("Git.repo.discover")(function* (input: AbsolutePath) {
       const dotgit = yield* fs.up({ targets: [".git"], start: input }).pipe(
         Effect.map((matches) => matches[0]),
         Effect.catch(() => Effect.succeed(undefined)),
@@ -92,23 +191,25 @@ export const layer = Layer.effect(
       const cwd = path.dirname(dotgit)
       const git = run(cwd, proc)
       const topLevel = yield* git(["rev-parse", "--show-toplevel"])
+      const gitDir = yield* git(["rev-parse", "--git-dir"])
       const commonDir = yield* git(["rev-parse", "--git-common-dir"])
-      if (commonDir.exitCode !== 0) return undefined
+      if (gitDir.exitCode !== 0 || commonDir.exitCode !== 0) return undefined
 
-      return {
-        directory: AbsolutePath.make(topLevel.exitCode === 0 ? resolvePath(cwd, topLevel.text) : cwd),
-        store: AbsolutePath.make(resolvePath(cwd, commonDir.text)),
-      } satisfies Repo
+      return new Repository({
+        worktree: AbsolutePath.make(topLevel.exitCode === 0 ? resolvePath(cwd, topLevel.text) : cwd),
+        gitDirectory: AbsolutePath.make(resolvePath(cwd, gitDir.text)),
+        commonDirectory: AbsolutePath.make(resolvePath(cwd, commonDir.text)),
+      })
     })
 
-    const remote = Effect.fn("Git.remote")(function* (repo: Repo, name = "origin") {
-      const result = yield* run(repo.directory, proc)(["remote", "get-url", name])
+    const remote = Effect.fn("Git.remote.get")(function* (repository: Repository, name = "origin") {
+      const result = yield* run(repository.worktree, proc)(["remote", "get-url", name])
       if (result.exitCode !== 0) return undefined
       return result.text.trim() || undefined
     })
 
-    const roots = Effect.fn("Git.roots")(function* (repo: Repo) {
-      const result = yield* run(repo.directory, proc)(["rev-list", "--max-parents=0", "HEAD"])
+    const roots = Effect.fn("Git.history.rootCommits")(function* (repository: Repository) {
+      const result = yield* run(repository.worktree, proc)(["rev-list", "--max-parents=0", "HEAD"])
       if (result.exitCode !== 0) return []
       return result.text
         .split("\n")
@@ -117,116 +218,555 @@ export const layer = Layer.effect(
         .toSorted()
     })
 
-    const origin = Effect.fn("Git.origin")(function* (directory: string) {
-      const result = yield* run(directory, proc)(["config", "--get", "remote.origin.url"])
+    const head = Effect.fn("Git.history.head")(function* (repository: Repository) {
+      const result = yield* run(repository.worktree, proc)(["rev-parse", "HEAD"])
       if (result.exitCode !== 0) return undefined
       return result.text.trim() || undefined
     })
 
-    const head = Effect.fn("Git.head")(function* (directory: string) {
-      const result = yield* run(directory, proc)(["rev-parse", "HEAD"])
+    const branch = Effect.fn("Git.history.branch")(function* (repository: Repository) {
+      const result = yield* run(repository.worktree, proc)(["symbolic-ref", "--quiet", "--short", "HEAD"])
       if (result.exitCode !== 0) return undefined
       return result.text.trim() || undefined
     })
 
-    const dir = Effect.fn("Git.dir")(function* (directory: string) {
-      const result = yield* run(directory, proc)(["rev-parse", "--git-dir"])
+    const remoteHead = Effect.fn("Git.history.defaultRemoteBranch")(function* (
+      repository: Repository,
+      remoteName = "origin",
+    ) {
+      const result = yield* run(repository.worktree, proc)(["symbolic-ref", `refs/remotes/${remoteName}/HEAD`])
       if (result.exitCode !== 0) return undefined
-      return AbsolutePath.make(resolvePath(directory, result.text))
+      return result.text.trim().replace(new RegExp(`^refs/remotes/${remoteName}/`), "") || undefined
     })
 
-    const branch = Effect.fn("Git.branch")(function* (directory: string) {
-      const result = yield* run(directory, proc)(["symbolic-ref", "--quiet", "--short", "HEAD"])
-      if (result.exitCode !== 0) return undefined
-      return result.text.trim() || undefined
-    })
-
-    const remoteHead = Effect.fn("Git.remoteHead")(function* (directory: string) {
-      const result = yield* run(directory, proc)(["symbolic-ref", "refs/remotes/origin/HEAD"])
-      if (result.exitCode !== 0) return undefined
-      return result.text.trim().replace(/^refs\/remotes\//, "") || undefined
-    })
-
-    const clone = Effect.fn("Git.clone")((input: { remote: string; target: string; branch?: string; depth?: number }) =>
-      execute(
-        path.dirname(input.target),
+    const operation = Effect.fnUntraced(function* (
+      operation: OperationError["operation"],
+      directory: AbsolutePath,
+      args: string[],
+    ) {
+      const result = yield* execute(
+        directory,
         proc,
-      )([
+      )(args).pipe(
+        Effect.mapError((cause) => new OperationError({ operation, directory, message: cause.message, cause })),
+      )
+      if (result.exitCode === 0) return
+      return yield* new OperationError({
+        operation,
+        directory,
+        message: result.stderr.trim() || result.text.trim() || `Git ${operation} failed`,
+      })
+    })
+
+    const clone = Effect.fn("Git.repo.clone")(function* (input: {
+      remote: string
+      directory: AbsolutePath
+      branch?: string
+      depth?: number
+    }) {
+      yield* operation("clone", AbsolutePath.make(path.dirname(input.directory)), [
         "clone",
         "--depth",
         String(input.depth ?? 100),
         ...(input.branch ? ["--branch", input.branch] : []),
         "--",
         input.remote,
-        input.target,
-      ]),
-    )
+        input.directory,
+      ])
+      const repository = yield* discover(input.directory)
+      if (repository) return repository
+      return yield* new OperationError({
+        operation: "clone",
+        directory: input.directory,
+        message: "Cloned repository could not be opened",
+      })
+    })
 
-    const fetch = Effect.fn("Git.fetch")((directory: string) => execute(directory, proc)(["fetch", "--all", "--prune"]))
+    const fetch = Effect.fn("Git.sync.fetchRemotes")(function* (
+      repository: Repository,
+      input: { prune?: boolean } = {},
+    ) {
+      yield* operation("fetch", repository.worktree, ["fetch", "--all", ...(input.prune === false ? [] : ["--prune"])])
+    })
 
-    const fetchBranch = Effect.fn("Git.fetchBranch")((directory: string, branch: string) =>
-      execute(directory, proc)(["fetch", "origin", `+refs/heads/${branch}:refs/remotes/origin/${branch}`]),
-    )
+    const fetchBranch = Effect.fn("Git.sync.fetchBranch")(function* (
+      repository: Repository,
+      input: { remote?: string; branch: string; force?: boolean },
+    ) {
+      const remoteName = input.remote ?? "origin"
+      const spec = `refs/heads/${input.branch}:refs/remotes/${remoteName}/${input.branch}`
+      yield* operation("fetch", repository.worktree, ["fetch", remoteName, input.force === false ? spec : `+${spec}`])
+    })
 
-    const checkout = Effect.fn("Git.checkout")((directory: string, branch: string) =>
-      execute(directory, proc)(["checkout", "-B", branch, `origin/${branch}`]),
-    )
+    const checkout = Effect.fn("Git.sync.checkoutRemoteBranch")(function* (
+      repository: Repository,
+      input: { remote?: string; branch: string; reset?: boolean },
+    ) {
+      const remoteName = input.remote ?? "origin"
+      yield* operation("checkout", repository.worktree, [
+        "checkout",
+        ...(input.reset === false ? [input.branch] : ["-B", input.branch, `${remoteName}/${input.branch}`]),
+      ])
+    })
 
-    const reset = Effect.fn("Git.reset")((directory: string, target: string) =>
-      execute(directory, proc)(["reset", "--hard", target]),
-    )
+    const reset = Effect.fn("Git.sync.resetHard")(function* (repository: Repository, revision: string) {
+      yield* operation("reset", repository.worktree, ["reset", "--hard", revision])
+    })
 
-    const patch = Effect.fn("Git.patch")(function* (directory: AbsolutePath) {
-      const root = yield* execute(
-        directory,
-        proc,
-      )(["rev-parse", "--show-toplevel"]).pipe(
-        Effect.mapError((cause) => new PatchError({ operation: "capture", directory, message: cause.message, cause })),
+    const repositoryArgs = (repository: Repository, args: string[]) => [
+      "--git-dir",
+      repository.gitDirectory,
+      "--work-tree",
+      repository.worktree,
+      ...args,
+    ]
+
+    const repositoryOperation = Effect.fnUntraced(function* (
+      operationName: OperationError["operation"],
+      repository: Repository,
+      args: string[],
+      options?: { stdin?: string; env?: Record<string, string> },
+    ) {
+      const result = yield* proc
+        .run(
+          ChildProcess.make("git", repositoryArgs(repository, args), {
+            cwd: repository.worktree,
+            env: options?.env,
+            extendEnv: true,
+          }),
+          { stdin: options?.stdin },
+        )
+        .pipe(
+          Effect.mapError(
+            (cause) =>
+              new OperationError({
+                operation: operationName,
+                directory: repository.worktree,
+                message: cause.message,
+                cause,
+              }),
+          ),
+        )
+      const text = result.stdout.toString("utf8")
+      if (result.exitCode === 0) return { text, stderr: result.stderr.toString("utf8") }
+      return yield* new OperationError({
+        operation: operationName,
+        directory: repository.worktree,
+        message: result.stderr.toString("utf8").trim() || text.trim() || `Git ${operationName} failed`,
+      })
+    })
+
+    const create = Effect.fn("Git.repo.create")(function* (input: {
+      worktree: AbsolutePath
+      gitDirectory: AbsolutePath
+      seed?: Repository
+    }) {
+      yield* fs.ensureDir(input.gitDirectory).pipe(
+        Effect.mapError(
+          (cause) =>
+            new OperationError({
+              operation: "create",
+              directory: input.gitDirectory,
+              message: "Failed to create Git storage",
+              cause,
+            }),
+        ),
       )
-      if (root.exitCode !== 0) {
-        return yield* new PatchError({
-          operation: "capture",
-          directory,
-          message: root.stderr.trim() || root.text.trim() || "Failed to locate repository root",
+      const repository = new Repository({
+        worktree: input.worktree,
+        gitDirectory: input.gitDirectory,
+        commonDirectory: input.gitDirectory,
+      })
+      yield* repositoryOperation("create", repository, ["init"])
+      yield* Effect.forEach(
+        [
+          ["core.autocrlf", "false"],
+          ["core.longpaths", "true"],
+          ["core.symlinks", "true"],
+          ["core.fsmonitor", "false"],
+          ["feature.manyFiles", "true"],
+          ["index.version", "4"],
+          ["index.threads", "true"],
+          ["core.untrackedCache", "true"],
+        ],
+        ([key, value]) => repositoryOperation("create", repository, ["config", key, value]),
+        { discard: true },
+      )
+      if (!input.seed) return repository
+      yield* fs.ensureDir(path.join(input.gitDirectory, "objects", "info")).pipe(
+        Effect.mapError(
+          (cause) =>
+            new OperationError({
+              operation: "create",
+              directory: input.gitDirectory,
+              message: "Failed to configure shared Git objects",
+              cause,
+            }),
+        ),
+      )
+      yield* fs
+        .writeFileString(
+          path.join(input.gitDirectory, "objects", "info", "alternates"),
+          path.join(input.seed.commonDirectory, "objects") + "\n",
+        )
+        .pipe(
+          Effect.mapError(
+            (cause) =>
+              new OperationError({
+                operation: "create",
+                directory: input.gitDirectory,
+                message: "Failed to configure shared Git objects",
+                cause,
+              }),
+          ),
+        )
+      yield* fs
+        .copyFile(path.join(input.seed.gitDirectory, "index"), path.join(input.gitDirectory, "index"))
+        .pipe(Effect.catch(() => Effect.void))
+      return repository
+    })
+
+    const refresh = Effect.fn("Git.index.refresh")(function* (input: {
+      repository: Repository
+      scope: RelativePath
+      ignores?: Repository
+      maximumUntrackedFileBytes?: number
+    }) {
+      const list = (args: string[]) =>
+        repositoryOperation("refresh", input.repository, args).pipe(
+          Effect.map((result) => result.text.split("\0").filter(Boolean)),
+        )
+      const [tracked, untracked] = yield* Effect.all(
+        [
+          list(["diff-files", "--name-only", "-z", "--", input.scope]),
+          list(["ls-files", "--others", "--exclude-standard", "-z", "--", input.scope]),
+        ],
+        { concurrency: 2 },
+      )
+      const candidates = Array.from(new Set([...tracked, ...untracked]))
+      if (!candidates.length) return { skipped: [] }
+      const ignored = input.ignores
+        ? new Set(
+            (yield* repositoryOperation("refresh", input.ignores, ["check-ignore", "--no-index", "--stdin", "-z"], {
+              stdin: candidates.join("\0") + "\0",
+            }).pipe(Effect.catch(() => Effect.succeed({ text: "", stderr: "" })))).text
+              .split("\0")
+              .filter(Boolean),
+          )
+        : new Set<string>()
+      const allowed = candidates.filter((item) => !ignored.has(item))
+      const maximum = input.maximumUntrackedFileBytes
+      const skipped = maximum
+        ? (yield* Effect.forEach(
+            untracked.filter((item) => allowed.includes(item)),
+            (item) =>
+              fs.stat(path.join(input.repository.worktree, item)).pipe(
+                Effect.map((info) =>
+                  info.type === "File" && Number(info.size) > maximum ? RelativePath.make(item) : undefined,
+                ),
+                Effect.catch(() => Effect.succeed(undefined)),
+              ),
+            { concurrency: 8 },
+          )).filter((item): item is RelativePath => item !== undefined)
+        : []
+      const stage = allowed.filter((item) => !skipped.includes(RelativePath.make(item)))
+      const remove = [...ignored, ...skipped]
+      if (remove.length)
+        yield* repositoryOperation(
+          "refresh",
+          input.repository,
+          ["rm", "--cached", "-f", "--ignore-unmatch", "--pathspec-from-file=-", "--pathspec-file-nul"],
+          { stdin: remove.join("\0") + "\0" },
+        )
+      if (stage.length)
+        yield* repositoryOperation(
+          "refresh",
+          input.repository,
+          ["add", "--all", "--sparse", "--pathspec-from-file=-", "--pathspec-file-nul"],
+          { stdin: stage.join("\0") + "\0" },
+        )
+      return { skipped }
+    })
+
+    const ignored = Effect.fn("Git.index.ignored")(function* (input: {
+      repository: Repository
+      paths: readonly RelativePath[]
+    }) {
+      if (!input.paths.length) return new Set<RelativePath>()
+      const result = yield* proc
+        .run(
+          ChildProcess.make("git", repositoryArgs(input.repository, ["check-ignore", "--no-index", "--stdin", "-z"]), {
+            cwd: input.repository.worktree,
+            extendEnv: true,
+          }),
+          { stdin: input.paths.join("\0") + "\0" },
+        )
+        .pipe(
+          Effect.mapError(
+            (cause) =>
+              new OperationError({
+                operation: "list_files",
+                directory: input.repository.worktree,
+                message: cause.message,
+                cause,
+              }),
+          ),
+        )
+      if (result.exitCode !== 0 && result.exitCode !== 1)
+        return yield* new OperationError({
+          operation: "list_files",
+          directory: input.repository.worktree,
+          message: result.stderr.toString("utf8").trim() || "Failed to check ignored paths",
         })
-      }
-      const repo = AbsolutePath.make(resolvePath(directory, root.text))
-      const scope = path.relative(repo, directory).replaceAll("\\", "/") || "."
+      return new Set(
+        result.stdout
+          .toString("utf8")
+          .split("\0")
+          .filter(Boolean)
+          .map((file) => RelativePath.make(file)),
+      )
+    })
+
+    const writeTree = Effect.fn("Git.tree.write")(function* (repository: Repository) {
+      return TreeID.make((yield* repositoryOperation("write_tree", repository, ["write-tree"])).text.trim())
+    })
+
+    const captureTree = Effect.fn("Git.tree.capture")(
+      (input: {
+        repository: Repository
+        scopes: readonly RelativePath[]
+        ignores?: Repository
+        maximumUntrackedFileBytes?: number
+      }) =>
+        locked(
+          input.repository,
+          Effect.gen(function* () {
+            yield* Effect.forEach(input.scopes, (scope) => refresh({ ...input, scope }), { discard: true })
+            return yield* writeTree(input.repository)
+          }),
+        ),
+    )
+
+    const treeFiles = Effect.fn("Git.tree.files")(function* (input: {
+      repository: Repository
+      from: TreeID
+      to: TreeID
+    }) {
+      return (yield* repositoryOperation("list_files", input.repository, [
+        "diff",
+        "--name-only",
+        "-z",
+        input.from,
+        input.to,
+      ])).text
+        .split("\0")
+        .filter(Boolean)
+        .map((file) => RelativePath.make(file))
+    })
+
+    const treeDiff = Effect.fn("Git.tree.diff")(function* (input: {
+      repository: Repository
+      from: TreeID
+      to: TreeID
+      context?: number
+      paths?: readonly RelativePath[]
+    }) {
+      const paths = input.paths ?? (yield* treeFiles(input))
+      return yield* Effect.forEach(paths, (file) =>
+        Effect.gen(function* () {
+          const statusText = (yield* repositoryOperation("diff", input.repository, [
+            "diff",
+            "--name-status",
+            "--no-renames",
+            input.from,
+            input.to,
+            "--",
+            file,
+          ])).text.trim()
+          const status = statusText.startsWith("A") ? "added" : statusText.startsWith("D") ? "deleted" : "modified"
+          const stats = (yield* repositoryOperation("diff", input.repository, [
+            "diff",
+            "--numstat",
+            "--no-renames",
+            input.from,
+            input.to,
+            "--",
+            file,
+          ])).text.split("\t")
+          const binary = stats[0] === "-" || stats[1] === "-"
+          const patch = binary
+            ? ""
+            : (yield* repositoryOperation("diff", input.repository, [
+                "diff",
+                `--unified=${input.context ?? 3}`,
+                "--no-renames",
+                input.from,
+                input.to,
+                "--",
+                file,
+              ])).text
+          return {
+            path: file,
+            status,
+            additions: binary ? 0 : Number(stats[0] ?? 0),
+            deletions: binary ? 0 : Number(stats[1] ?? 0),
+            patch,
+          } satisfies File.Diff
+        }),
+      )
+    })
+
+    const entry = Effect.fnUntraced(function* (repository: Repository, tree: TreeID, file: RelativePath) {
+      const text = (yield* repositoryOperation("restore", repository, [
+        "ls-tree",
+        "-z",
+        tree,
+        "--",
+        file,
+      ])).text.replace(/\0$/, "")
+      if (!text) return
+      const match = text.match(/^(\d+)\s+\w+\s+([0-9a-f]+)\t/)
+      if (!match)
+        return yield* new OperationError({
+          operation: "restore",
+          directory: repository.worktree,
+          message: `Invalid tree entry for ${file}`,
+        })
+      return { mode: match[1], object: match[2] }
+    })
+
+    const preview = Effect.fn("Git.tree.preview")(
+      (input: {
+        repository: Repository
+        current: TreeID
+        files: ReadonlyMap<RelativePath, TreeID>
+        context?: number
+      }) =>
+        locked(
+          input.repository,
+          Effect.gen(function* () {
+            const index = path.join(input.repository.gitDirectory, `preview-${randomUUID()}.index`)
+            const env = { GIT_INDEX_FILE: index }
+            return yield* Effect.gen(function* () {
+              yield* repositoryOperation("diff", input.repository, ["read-tree", input.current], { env })
+              yield* Effect.forEach(
+                input.files,
+                ([file, tree]) =>
+                  Effect.gen(function* () {
+                    const source = yield* entry(input.repository, tree, file)
+                    if (!source) {
+                      yield* repositoryOperation(
+                        "diff",
+                        input.repository,
+                        ["update-index", "--force-remove", "--", file],
+                        { env },
+                      )
+                      return
+                    }
+                    yield* repositoryOperation(
+                      "diff",
+                      input.repository,
+                      ["update-index", "--add", "--cacheinfo", source.mode, source.object, file],
+                      { env },
+                    )
+                  }),
+                { discard: true },
+              )
+              const target = TreeID.make(
+                (yield* repositoryOperation("diff", input.repository, ["write-tree"], { env })).text.trim(),
+              )
+              return yield* treeDiff({
+                repository: input.repository,
+                from: input.current,
+                to: target,
+                context: input.context,
+                paths: Array.from(input.files.keys()),
+              })
+            }).pipe(Effect.ensuring(fs.remove(index).pipe(Effect.catch(() => Effect.void))))
+          }),
+        ),
+    )
+
+    const restore = Effect.fn("Git.tree.restore")(
+      (input: { repository: Repository; files: ReadonlyMap<RelativePath, TreeID> }) =>
+        locked(
+          input.repository,
+          Effect.forEach(
+            input.files,
+            ([file, tree]) =>
+              Effect.gen(function* () {
+                if (yield* entry(input.repository, tree, file)) {
+                  yield* repositoryOperation("restore", input.repository, ["checkout", tree, "--", file])
+                  return
+                }
+                yield* fs.remove(path.join(input.repository.worktree, file), { recursive: true, force: true }).pipe(
+                  Effect.mapError(
+                    (cause) =>
+                      new OperationError({
+                        operation: "restore",
+                        directory: input.repository.worktree,
+                        message: `Failed to remove ${file}`,
+                        cause,
+                      }),
+                  ),
+                )
+              }),
+            { discard: true },
+          ),
+        ),
+    )
+
+    const checkoutTree = Effect.fn("Git.tree.checkout")((input: { repository: Repository; tree: TreeID }) =>
+      locked(
+        input.repository,
+        Effect.gen(function* () {
+          yield* repositoryOperation("restore", input.repository, ["read-tree", input.tree])
+          yield* repositoryOperation("restore", input.repository, ["checkout-index", "--all", "--force"])
+        }),
+      ),
+    )
+
+    const capture = Effect.fn("Git.change.capture")(function* (input: { repository: Repository; path: AbsolutePath }) {
+      const scope = path.relative(input.repository.worktree, input.path).replaceAll("\\", "/") || "."
       const tracked = yield* execute(
-        repo,
+        input.repository.worktree,
         proc,
       )(["diff", "--binary", "HEAD", "--", scope]).pipe(
-        Effect.mapError((cause) => new PatchError({ operation: "capture", directory, message: cause.message, cause })),
+        Effect.mapError(
+          (cause) => new PatchError({ operation: "capture", directory: input.path, message: cause.message, cause }),
+        ),
       )
       if (tracked.exitCode !== 0) {
         return yield* new PatchError({
           operation: "capture",
-          directory,
+          directory: input.path,
           message: tracked.stderr.trim() || tracked.text.trim() || "Failed to capture tracked changes",
         })
       }
 
       const untracked = yield* execute(
-        repo,
+        input.repository.worktree,
         proc,
       )(["ls-files", "--others", "--exclude-standard", "-z", "--", scope]).pipe(
-        Effect.mapError((cause) => new PatchError({ operation: "capture", directory, message: cause.message, cause })),
+        Effect.mapError(
+          (cause) => new PatchError({ operation: "capture", directory: input.path, message: cause.message, cause }),
+        ),
       )
       if (untracked.exitCode !== 0) {
         return yield* new PatchError({
           operation: "capture",
-          directory,
+          directory: input.path,
           message: untracked.stderr.trim() || untracked.text.trim() || "Failed to list untracked changes",
         })
       }
 
       const created = yield* Effect.forEach(untracked.text.split("\0").filter(Boolean), (file) =>
         execute(
-          repo,
+          input.repository.worktree,
           proc,
         )(["diff", "--binary", "--no-index", "--", "/dev/null", file]).pipe(
           Effect.mapError(
-            (cause) => new PatchError({ operation: "capture", directory, message: cause.message, cause }),
+            (cause) => new PatchError({ operation: "capture", directory: input.path, message: cause.message, cause }),
           ),
           Effect.flatMap((result) =>
             // git diff --no-index returns 1 when differences were found.
@@ -235,7 +775,7 @@ export const layer = Layer.effect(
               : Effect.fail(
                   new PatchError({
                     operation: "capture",
-                    directory,
+                    directory: input.path,
                     message:
                       result.stderr.trim() || result.text.trim() || `Failed to capture untracked change: ${file}`,
                   }),
@@ -243,95 +783,81 @@ export const layer = Layer.effect(
           ),
         ),
       )
-      return [tracked.text, ...created].filter(Boolean).join("\n")
+      return ChangeSet.make([tracked.text, ...created].filter(Boolean).join("\n"))
     })
 
-    const applyPatch = Effect.fn("Git.applyPatch")(function* (input: { directory: AbsolutePath; patch: string }) {
+    const apply = Effect.fn("Git.change.apply")(function* (input: {
+      repository: Repository
+      path: AbsolutePath
+      changes: ChangeSet
+    }) {
       const result = yield* proc
         .run(
           ChildProcess.make("git", ["apply", "-"], {
-            cwd: input.directory,
+            cwd: input.path,
             extendEnv: true,
-            stdin: Stream.make(new TextEncoder().encode(input.patch)),
+            stdin: Stream.make(new TextEncoder().encode(input.changes)),
           }),
         )
         .pipe(
           Effect.mapError(
-            (cause) =>
-              new PatchError({ operation: "apply", directory: input.directory, message: cause.message, cause }),
+            (cause) => new PatchError({ operation: "apply", directory: input.path, message: cause.message, cause }),
           ),
         )
       if (result.exitCode === 0) return
       return yield* new PatchError({
         operation: "apply",
-        directory: input.directory,
+        directory: input.path,
         message:
           result.stderr.toString("utf8").trim() || result.stdout.toString("utf8").trim() || "Failed to apply changes",
       })
     })
 
-    const resetChanges = Effect.fn("Git.resetChanges")(function* (directory: AbsolutePath) {
-      const reset = yield* execute(
-        directory,
+    const discard = Effect.fn("Git.change.discard")(function* (input: {
+      repository: Repository
+      path: AbsolutePath
+      index: "preserve" | "reset"
+      untracked: "preserve" | "remove"
+    }) {
+      const scope = path.relative(input.repository.worktree, input.path).replaceAll("\\", "/") || "."
+      const restore = yield* execute(
+        input.repository.worktree,
         proc,
-      )(["reset", "--hard", "HEAD"]).pipe(
-        Effect.mapError((cause) => new PatchError({ operation: "reset", directory, message: cause.message, cause })),
+      )(input.index === "reset" ? ["checkout", "HEAD", "--", scope] : ["checkout", "--", scope]).pipe(
+        Effect.mapError(
+          (cause) => new PatchError({ operation: "reset", directory: input.path, message: cause.message, cause }),
+        ),
       )
-      if (reset.exitCode !== 0) {
+      if (restore.exitCode !== 0) {
         return yield* new PatchError({
           operation: "reset",
-          directory,
-          message: reset.stderr.trim() || reset.text.trim() || "Failed to reset tracked changes",
+          directory: input.path,
+          message: restore.stderr.trim() || restore.text.trim() || "Failed to restore tracked changes",
         })
       }
+      if (input.untracked === "preserve") return
       const clean = yield* execute(
-        directory,
+        input.repository.worktree,
         proc,
-      )(["clean", "-fd"]).pipe(
-        Effect.mapError((cause) => new PatchError({ operation: "reset", directory, message: cause.message, cause })),
+      )(["clean", "-fd", "--", scope]).pipe(
+        Effect.mapError(
+          (cause) => new PatchError({ operation: "reset", directory: input.path, message: cause.message, cause }),
+        ),
       )
       if (clean.exitCode === 0) return
       return yield* new PatchError({
         operation: "reset",
-        directory,
+        directory: input.path,
         message: clean.stderr.trim() || clean.text.trim() || "Failed to clean untracked changes",
       })
     })
 
-    const softResetChanges = Effect.fn("Git.softResetChanges")(function* (directory: AbsolutePath) {
-      const checkout = yield* execute(
-        directory,
-        proc,
-      )(["checkout", "--", "."]).pipe(
-        Effect.mapError((cause) => new PatchError({ operation: "reset", directory, message: cause.message, cause })),
-      )
-      if (checkout.exitCode !== 0) {
-        return yield* new PatchError({
-          operation: "reset",
-          directory,
-          message: checkout.stderr.trim() || checkout.text.trim() || "Failed to restore tracked changes",
-        })
-      }
-      const clean = yield* execute(
-        directory,
-        proc,
-      )(["clean", "-fd", "--", "."]).pipe(
-        Effect.mapError((cause) => new PatchError({ operation: "reset", directory, message: cause.message, cause })),
-      )
-      if (clean.exitCode === 0) return
-      return yield* new PatchError({
-        operation: "reset",
-        directory,
-        message: clean.stderr.trim() || clean.text.trim() || "Failed to clean untracked changes",
-      })
-    })
-
-    const worktree = Effect.fnUntraced(function* (
+    const worktreeRun = Effect.fnUntraced(function* (
       operation: "create" | "remove" | "list",
-      repo: Repo,
+      repository: Repository,
       args: string[],
       worktreeDirectory?: AbsolutePath,
-      cwd = repo.directory,
+      cwd = repository.worktree,
     ) {
       const result = yield* proc
         .run(ChildProcess.make("git", args, { cwd, extendEnv: true, stdin: "ignore" }))
@@ -350,52 +876,69 @@ export const layer = Layer.effect(
       })
     })
 
-    const worktreeCreate = Effect.fn("Git.worktreeCreate")(function* (input: { repo: Repo; directory: AbsolutePath }) {
-      yield* worktree("create", input.repo, ["worktree", "add", "--detach", input.directory, "HEAD"], input.directory)
+    const worktreeCreate = Effect.fn("Git.worktree.create")(function* (input: {
+      repository: Repository
+      directory: AbsolutePath
+    }) {
+      yield* worktreeRun(
+        "create",
+        input.repository,
+        ["worktree", "add", "--detach", input.directory, "HEAD"],
+        input.directory,
+      )
+      const repository = yield* discover(input.directory)
+      if (repository) return repository
+      return yield* new WorktreeError({
+        operation: "create",
+        directory: input.directory,
+        message: "Created worktree could not be opened",
+      })
     })
 
-    const worktreeRemove = Effect.fn("Git.worktreeRemove")(function* (input: {
-      repo: Repo
+    const worktreeRemove = Effect.fn("Git.worktree.remove")(function* (input: {
+      repository: Repository
       directory: AbsolutePath
       force: boolean
     }) {
-      yield* worktree(
+      yield* worktreeRun(
         "remove",
-        input.repo,
+        input.repository,
         ["worktree", "remove", ...(input.force ? ["--force"] : []), input.directory],
         input.directory,
-        input.repo.store,
+        input.repository.commonDirectory,
       )
     })
 
-    const worktreeList = Effect.fn("Git.worktreeList")(function* (repo: Repo) {
-      return (yield* worktree("list", repo, ["worktree", "list", "--porcelain"]))
+    const worktreeList = Effect.fn("Git.worktree.list")(function* (repository: Repository) {
+      return (yield* worktreeRun("list", repository, ["worktree", "list", "--porcelain"]))
         .split("\n")
         .filter((line) => line.startsWith("worktree "))
-        .map((line) => AbsolutePath.make(resolvePath(repo.directory, line.slice("worktree ".length).trim())))
+        .map(
+          (line, index) =>
+            new Worktree({
+              directory: AbsolutePath.make(resolvePath(repository.worktree, line.slice("worktree ".length).trim())),
+              kind: index === 0 ? "main" : "linked",
+            }),
+        )
     })
 
     return Service.of({
-      find,
-      remote,
-      roots,
-      origin,
-      head,
-      dir,
-      branch,
-      remoteHead,
-      clone,
-      fetch,
-      fetchBranch,
-      checkout,
-      reset,
-      patch,
-      applyPatch,
-      resetChanges,
-      softResetChanges,
-      worktreeCreate,
-      worktreeRemove,
-      worktreeList,
+      repo: { discover, clone, create },
+      remote: { get: remote },
+      history: { head, branch, defaultRemoteBranch: remoteHead, rootCommits: roots },
+      sync: { fetchRemotes: fetch, fetchBranch, checkoutRemoteBranch: checkout, resetHard: reset },
+      change: { capture, apply, discard },
+      worktree: { create: worktreeCreate, remove: worktreeRemove, list: worktreeList },
+      index: { refresh, ignored },
+      tree: {
+        capture: captureTree,
+        write: writeTree,
+        files: treeFiles,
+        diff: treeDiff,
+        preview,
+        restore,
+        checkout: checkoutTree,
+      },
     })
   }),
 )
@@ -403,7 +946,7 @@ export const layer = Layer.effect(
 export const defaultLayer = layer.pipe(Layer.provide(FSUtil.defaultLayer), Layer.provide(AppProcess.defaultLayer))
 export const node = LayerNode.make(layer, [FSUtil.node, AppProcess.node])
 
-export interface Result {
+interface Result {
   readonly exitCode: number
   readonly text: string
   readonly stderr: string

packages/core/src/integration.ts

@@ -16,9 +16,7 @@ import {
 } from "effect"
 import { Integration } from "@opencode-ai/schema/integration"
 import { Credential } from "./credential"
-import { withStatics } from "./schema"
 import { State } from "./state"
-import { Identifier } from "./util/identifier"
 import { EventV2 } from "./event"
 import { IntegrationConnection } from "./integration/connection"
 
@@ -28,10 +26,7 @@ export type ID = Integration.ID
 export const MethodID = Integration.MethodID
 export type MethodID = Integration.MethodID
 
-export const AttemptID = Schema.String.pipe(
-  Schema.brand("Integration.AttemptID"),
-  withStatics((schema) => ({ create: () => schema.make("con_" + Identifier.ascending()) })),
-)
+export const AttemptID = Integration.AttemptID
 export type AttemptID = typeof AttemptID.Type
 
 export const When = Integration.When
@@ -58,12 +53,8 @@ export type EnvMethod = Integration.EnvMethod
 export const Method = Integration.Method
 export type Method = Integration.Method
 
-export class Info extends Schema.Class<Info>("Integration.Info")({
-  id: ID,
-  name: Schema.String,
-  methods: Schema.mutable(Schema.Array(Method)),
-  connections: Schema.mutable(Schema.Array(IntegrationConnection.Info)),
-}) {}
+export const Info = Integration.Info
+export type Info = Integration.Info
 
 export const Inputs = Integration.Inputs
 export type Inputs = Integration.Inputs
@@ -102,28 +93,10 @@ export interface EnvImplementation {
 
 export type Implementation = OAuthImplementation | KeyImplementation | EnvImplementation
 
-export class Attempt extends Schema.Class<Attempt>("Integration.Attempt")({
-  attemptID: AttemptID,
-  url: Schema.String,
-  instructions: Schema.String,
-  mode: Schema.Literals(["auto", "code"]),
-  time: Schema.Struct({
-    created: Schema.Number,
-    expires: Schema.Number,
-  }),
-}) {}
+export const Attempt = Integration.Attempt
+export type Attempt = Integration.Attempt
 
-const Time = Schema.Struct({
-  created: Schema.Number,
-  expires: Schema.Number,
-})
-
-export const AttemptStatus = Schema.Union([
-  Schema.Struct({ status: Schema.Literal("pending"), time: Time }),
-  Schema.Struct({ status: Schema.Literal("complete"), time: Time }),
-  Schema.Struct({ status: Schema.Literal("failed"), message: Schema.String, time: Time }),
-  Schema.Struct({ status: Schema.Literal("expired"), time: Time }),
-]).pipe(Schema.toTaggedUnion("status"))
+export const AttemptStatus = Integration.AttemptStatus
 export type AttemptStatus = typeof AttemptStatus.Type
 
 export class CodeRequiredError extends Schema.TaggedErrorClass<CodeRequiredError>()("Integration.CodeRequired", {

packages/core/src/location-layer.ts

@@ -47,6 +47,7 @@ import * as SessionRunnerLLM from "./session/runner/llm"
 import { SessionRunnerModel } from "./session/runner/model"
 import { SystemContextBuiltIns } from "./system-context/builtins"
 import { FetchHttpClient } from "effect/unstable/http"
+import { Snapshot } from "./snapshot"
 
 export class LocationServiceMap extends LayerMap.Service<LocationServiceMap>()("@opencode/example/LocationServiceMap", {
   lookup: (ref: Location.Ref) => {
@@ -96,11 +97,13 @@ export class LocationServiceMap extends LayerMap.Service<LocationServiceMap>()("
       Layer.provide(image),
     )
     const model = SessionRunnerModel.locationLayer.pipe(Layer.provide(services))
+    const snapshot = Snapshot.locationLayer.pipe(Layer.provide(services))
     const runner = SessionRunnerLLM.defaultLayer.pipe(
       Layer.provide(services),
       Layer.provide(model),
       Layer.provide(skillGuidance),
       Layer.provide(referenceGuidance),
+      Layer.provide(snapshot),
     )
 
     // Kick off a background project copy refresh to update locations now that we
@@ -116,6 +119,7 @@ export class LocationServiceMap extends LayerMap.Service<LocationServiceMap>()("
       todos,
       questions,
       model,
+      snapshot,
       runner,
       builtInTools,
       referenceGuidance,

packages/core/src/location.ts

@@ -1,30 +1,15 @@
-import { Context, Effect, Layer, Schema } from "effect"
-import { Ref } from "@opencode-ai/schema/location"
+import { Context, Effect, Layer } from "effect"
+import { Info, Ref, response } from "@opencode-ai/schema/location"
 import { Project } from "./project"
-import { AbsolutePath, optionalOmitUndefined } from "./schema"
-import { WorkspaceV2 } from "./workspace"
 
 export * as Location from "./location"
 
-export { Ref }
-
-export class Info extends Schema.Class<Info>("Location.Info")({
-  directory: AbsolutePath,
-  workspaceID: optionalOmitUndefined(WorkspaceV2.ID),
-  project: Schema.Struct({
-    id: Project.ID,
-    directory: AbsolutePath,
-  }),
-}) {}
+export { Info, Ref, response }
 
 export interface Interface extends Info {
   readonly vcs?: Project.Vcs
 }
 
-export function response<S extends Schema.Top>(data: S) {
-  return Schema.Struct({ location: Info, data })
-}
-
 export class Service extends Context.Service<Service, Interface>()("@opencode/Location") {}
 
 export const layer = (ref: Ref) =>

packages/core/src/permission/saved.ts

@@ -4,22 +4,13 @@ import { eq } from "drizzle-orm"
 import { Context, Effect, Layer, Schema } from "effect"
 import { Database } from "../database/database"
 import { ProjectV2 } from "../project"
-import { withStatics } from "../schema"
-import { Identifier } from "../util/identifier"
 import { PermissionTable } from "./sql"
+import { PermissionSaved } from "@opencode-ai/schema/permission-saved"
 
-export const ID = Schema.String.pipe(
-  Schema.brand("PermissionSaved.ID"),
-  withStatics((schema) => ({ create: () => schema.make("psv_" + Identifier.ascending()) })),
-)
+export const ID = PermissionSaved.ID
 export type ID = typeof ID.Type
 
-export const Info = Schema.Struct({
-  id: ID,
-  projectID: ProjectV2.ID,
-  action: Schema.String,
-  resource: Schema.String,
-}).annotate({ identifier: "PermissionSaved.Info" })
+export const Info = PermissionSaved.Info
 export type Info = typeof Info.Type
 
 export const ListInput = Schema.Struct({

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

@@ -118,11 +118,6 @@ export const OpencodePlugin = define<HttpClient.HttpClient | EventV2.Service | S
           Object.assign(provider.request.body, withoutCredentials(item.options))
         })
 
-        const modelIDs = new Set(Object.keys(item.models ?? {}))
-        for (const model of catalog.provider.get(providerID)?.models.values() ?? []) {
-          if (!modelIDs.has(model.id)) catalog.model.remove(providerID, model.id)
-        }
-
         for (const [modelID, config] of Object.entries(item.models ?? {})) {
           catalog.model.update(providerID, modelID, (model) => {
             if (config.family !== undefined) model.family = config.family

packages/core/src/project.ts

@@ -70,8 +70,8 @@ export const layer = Layer.effect(
       )
     })
 
-    const remote = Effect.fnUntraced(function* (repo: Git.Repo) {
-      const origin = yield* git.remote(repo)
+    const remote = Effect.fnUntraced(function* (repo: Git.Repository) {
+      const origin = yield* git.remote.get(repo)
       if (!origin) return undefined
       const normalized = url(origin)
       if (!normalized) return undefined
@@ -102,22 +102,22 @@ export const layer = Layer.effect(
       return `${host.toLowerCase()}/${pathname}`
     }
 
-    const root = Effect.fnUntraced(function* (repo: Git.Repo) {
-      const root = (yield* git.roots(repo))[0]
+    const root = Effect.fnUntraced(function* (repo: Git.Repository) {
+      const root = (yield* git.history.rootCommits(repo))[0]
       return root ? ID.make(root) : undefined
     })
 
     const resolve = Effect.fn("Project.resolve")(function* (input: AbsolutePath) {
-      const repo = yield* git.find(input)
+      const repo = yield* git.repo.discover(input)
       if (!repo) return { id: ID.global, directory: AbsolutePath.make(path.parse(input).root), vcs: undefined }
 
-      const previous = yield* cached(repo.store)
+      const previous = yield* cached(repo.commonDirectory)
       const id = (yield* remote(repo)) ?? previous ?? (yield* root(repo))
       return {
         previous,
         id: id ?? ID.global,
-        directory: repo.directory,
-        vcs: { type: "git" as const, store: repo.store },
+        directory: repo.worktree,
+        vcs: { type: "git" as const, store: repo.commonDirectory },
       }
     })
 

packages/core/src/project/copy-strategies.ts

@@ -1,4 +1,3 @@
-import path from "path"
 import { Effect } from "effect"
 import { AbsolutePath } from "../schema"
 import { Git } from "../git"
@@ -8,28 +7,26 @@ export function makeGitWorktreeStrategy(input: {
   git: Git.Interface
   canonical: (directory: AbsolutePath) => Effect.Effect<AbsolutePath, DirectoryUnavailableError>
 }) {
-  const repo = (sourceDirectory: AbsolutePath) =>
-    ({ directory: sourceDirectory, store: sourceDirectory }) satisfies Git.Repo
-
   return {
     id: StrategyID.make("git_worktree"),
     create: Effect.fn("ProjectCopy.GitWorktree.create")(function* (options) {
-      yield* input.git.worktreeCreate({ repo: repo(options.sourceDirectory), directory: options.directory })
+      const repository = yield* input.git.repo.discover(options.sourceDirectory)
+      if (!repository) return yield* new DirectoryUnavailableError({ directory: options.sourceDirectory })
+      yield* input.git.worktree.create({ repository, directory: options.directory })
       return { directory: yield* input.canonical(options.directory) }
     }),
     remove: Effect.fn("ProjectCopy.GitWorktree.remove")(function* (options) {
-      const found = yield* input.git.find(options.directory)
+      const found = yield* input.git.repo.discover(options.directory)
       if (!found) return yield* new DirectoryUnavailableError({ directory: options.directory })
-      yield* input.git.worktreeRemove({ repo: found, directory: options.directory, force: options.force })
+      yield* input.git.worktree.remove({ repository: found, directory: options.directory, force: options.force })
     }),
     list: Effect.fn("ProjectCopy.GitWorktree.list")(function* (directory) {
-      const found = yield* input.git.find(directory)
+      const found = yield* input.git.repo.discover(directory)
       if (!found) return yield* new DirectoryUnavailableError({ directory })
-      const core = path.basename(found.store) === ".git" ? path.dirname(found.store) : found.store
-      const entries = yield* input.git.worktreeList(found)
+      const entries = yield* input.git.worktree.list(found)
       return yield* Effect.forEach(entries, (entry) =>
-        input.canonical(entry).pipe(
-          Effect.map((directory) => ({ directory, type: entry === core ? "root" : "copy" }) as const),
+        input.canonical(entry.directory).pipe(
+          Effect.map((directory) => ({ directory, type: entry.kind === "main" ? "root" : "copy" }) as const),
           Effect.catchTag("ProjectCopy.DirectoryUnavailableError", () => Effect.succeed(undefined)),
         ),
       ).pipe(Effect.map((items) => items.filter((item): item is ListEntry => item !== undefined)))

packages/core/src/project/copy.ts

@@ -14,24 +14,15 @@ import { EventV2 } from "../event"
 import { Database } from "../database/database"
 import { Location } from "../location"
 import { ProjectDirectoriesEvent } from "@opencode-ai/schema/project-directories"
+import { ProjectCopy } from "@opencode-ai/schema/project-copy"
 
-export const StrategyID = Schema.Trim.pipe(Schema.check(Schema.isNonEmpty()), Schema.brand("ProjectCopy.StrategyID"))
+export const StrategyID = ProjectCopy.StrategyID
 export type StrategyID = typeof StrategyID.Type
 
-export const CreateInput = Schema.Struct({
-  projectID: Project.ID,
-  strategy: StrategyID,
-  sourceDirectory: AbsolutePath,
-  directory: AbsolutePath,
-  name: Schema.optional(Schema.String),
-}).annotate({ identifier: "ProjectCopy.CreateInput" })
+export const CreateInput = ProjectCopy.CreateInput
 export type CreateInput = typeof CreateInput.Type
 
-export const RemoveInput = Schema.Struct({
-  projectID: Project.ID,
-  directory: AbsolutePath,
-  force: Schema.Boolean,
-}).annotate({ identifier: "ProjectCopy.RemoveInput" })
+export const RemoveInput = ProjectCopy.RemoveInput
 export type RemoveInput = typeof RemoveInput.Type
 
 export const RefreshInput = Schema.Struct({
@@ -45,9 +36,7 @@ export const RefreshResult = Schema.Struct({
 }).annotate({ identifier: "ProjectCopy.RefreshResult" })
 export type RefreshResult = typeof RefreshResult.Type
 
-export const Copy = Schema.Struct({
-  directory: AbsolutePath,
-}).annotate({ identifier: "ProjectCopy.Copy" })
+export const Copy = ProjectCopy.Copy
 export type Copy = typeof Copy.Type
 
 export const ListEntry = Schema.Struct({

packages/core/src/pty.ts

@@ -2,11 +2,10 @@ export * as Pty from "./pty"
 
 import type { Disp, Proc } from "#pty"
 import { Context, Effect, Layer, Schema, Types } from "effect"
-import { PtyEvent, PtyInfo } from "@opencode-ai/schema/pty"
+import { PtyEvent, PtyInfo, Pty } from "@opencode-ai/schema/pty"
 import { Config } from "./config"
 import { EventV2 } from "./event"
 import { Location } from "./location"
-import { PositiveInt } from "./schema"
 import { PtyID } from "./pty/schema"
 import { Shell } from "./shell"
 import { lazy } from "./util/lazy"
@@ -40,25 +39,11 @@ export const Info = PtyInfo
 
 export type Info = Types.DeepMutable<typeof Info.Type>
 
-export const CreateInput = Schema.Struct({
-  command: Schema.optional(Schema.String),
-  args: Schema.optional(Schema.Array(Schema.String)),
-  cwd: Schema.optional(Schema.String),
-  title: Schema.optional(Schema.String),
-  env: Schema.optional(Schema.Record(Schema.String, Schema.String)),
-})
+export const CreateInput = Pty.CreateInput
 
 export type CreateInput = Types.DeepMutable<typeof CreateInput.Type>
 
-export const UpdateInput = Schema.Struct({
-  title: Schema.optional(Schema.String),
-  size: Schema.optional(
-    Schema.Struct({
-      rows: PositiveInt,
-      cols: PositiveInt,
-    }),
-  ),
-})
+export const UpdateInput = Pty.UpdateInput
 
 export type UpdateInput = Types.DeepMutable<typeof UpdateInput.Type>
 

packages/core/src/pty/ticket.ts

@@ -1,18 +1,15 @@
 export * as PtyTicket from "./ticket"
 
 import { WorkspaceV2 } from "../workspace"
-import { PositiveInt } from "../schema"
+import { PtyTicket } from "@opencode-ai/schema/pty-ticket"
 import { PtyID } from "./schema"
-import { Cache, Context, Duration, Effect, Layer, Schema } from "effect"
+import { Cache, Context, Duration, Effect, Layer } from "effect"
 import { LayerNode } from "../effect/layer-node"
 
 const DEFAULT_TTL = Duration.seconds(60)
 const CAPACITY = 10_000
 
-export const ConnectToken = Schema.Struct({
-  ticket: Schema.String,
-  expires_in: PositiveInt,
-})
+export const ConnectToken = PtyTicket.ConnectToken
 
 export type Scope = {
   readonly ptyID: PtyID

packages/core/src/reference.ts

@@ -1,6 +1,6 @@
 export * as Reference from "./reference"
 
-import { Context, Effect, Layer, Schema, Scope, Types } from "effect"
+import { Context, Effect, Layer, Scope, Types } from "effect"
 import { Reference } from "@opencode-ai/schema/reference"
 import { Global } from "./global"
 import { EventV2 } from "./event"
@@ -20,13 +20,8 @@ export type Source = Reference.Source
 
 export const Event = Reference.Event
 
-export class Info extends Schema.Class<Info>("Reference.Info")({
-  name: Schema.String,
-  path: AbsolutePath,
-  description: Schema.String.pipe(Schema.optional),
-  hidden: Schema.Boolean.pipe(Schema.optional),
-  source: Source,
-}) {}
+export const Info = Reference.Info
+export type Info = Reference.Info
 
 type Data = {
   sources: Map<string, Types.DeepMutable<Source>>

packages/core/src/repository-cache.ts

@@ -4,6 +4,7 @@ import { FSUtil } from "./fs-util"
 import { Git } from "./git"
 import { Global } from "./global"
 import { Repository } from "./repository"
+import { AbsolutePath } from "./schema"
 import { EffectFlock } from "./util/effect-flock"
 
 export type Result = {
@@ -142,15 +143,15 @@ export const layer: Layer.Layer<Service, never, FSUtil.Service | Git.Service | E
                 yield* cacheOperation(fs.ensureDir(path.dirname(localPath)), "ensure cache directory", localPath)
 
                 const exists = yield* fs.existsSafe(localPath)
-                const hasGitDir = yield* fs.existsSafe(path.join(localPath, ".git"))
-                const origin = hasGitDir ? yield* git.origin(localPath) : undefined
+                const existing = yield* git.repo.discover(AbsolutePath.make(localPath))
+                const origin = existing ? yield* git.remote.get(existing) : undefined
                 const originReference = origin ? Repository.parse(origin) : undefined
-                const reuse = hasGitDir && Boolean(originReference && Repository.same(originReference, cloneTarget))
+                const reuse = Boolean(existing && originReference && Repository.same(originReference, cloneTarget))
                 if (exists && !reuse) {
                   yield* cacheOperation(fs.remove(localPath, { recursive: true }), "remove stale cache", localPath)
                 }
 
-                const currentBranch = reuse ? yield* git.branch(localPath) : undefined
+                const currentBranch = reuse && existing ? yield* git.history.branch(existing) : undefined
                 const status = statusForRepository({
                   reuse,
                   refresh: input.refresh,
@@ -158,86 +159,55 @@ export const layer: Layer.Layer<Service, never, FSUtil.Service | Git.Service | E
                 })
 
                 if (status === "cloned") {
-                  const result = yield* git
-                    .clone({ remote: input.reference.remote, target: localPath, branch: input.branch })
-                    .pipe(
-                      Effect.mapError((error) => new CloneFailedError({ repository, message: errorMessage(error) })),
-                    )
-                  if (result.exitCode !== 0) {
-                    return yield* new CloneFailedError({
-                      repository,
-                      message: resultMessage(result, `Failed to clone ${repository}`),
+                  yield* git.repo
+                    .clone({
+                      remote: input.reference.remote,
+                      directory: AbsolutePath.make(localPath),
+                      branch: input.branch,
                     })
-                  }
+                    .pipe(Effect.mapError((error) => new CloneFailedError({ repository, message: error.message })))
                 }
 
                 if (status === "refreshed") {
-                  const fetch = yield* git
-                    .fetch(localPath)
-                    .pipe(
-                      Effect.mapError((error) => new FetchFailedError({ repository, message: errorMessage(error) })),
-                    )
-                  if (fetch.exitCode !== 0) {
-                    return yield* new FetchFailedError({
-                      repository,
-                      message: resultMessage(fetch, `Failed to refresh ${repository}`),
-                    })
-                  }
+                  if (!existing)
+                    return yield* new FetchFailedError({ repository, message: "Repository is unavailable" })
+                  yield* git.sync
+                    .fetchRemotes(existing)
+                    .pipe(Effect.mapError((error) => new FetchFailedError({ repository, message: error.message })))
 
                   if (input.branch) {
                     const requestedBranch = input.branch
-                    const fetchBranch = yield* git
-                      .fetchBranch(localPath, requestedBranch)
-                      .pipe(
-                        Effect.mapError((error) => new FetchFailedError({ repository, message: errorMessage(error) })),
-                      )
-                    if (fetchBranch.exitCode !== 0) {
-                      return yield* new FetchFailedError({
-                        repository,
-                        message: resultMessage(fetchBranch, `Failed to fetch ${requestedBranch}`),
-                      })
-                    }
+                    yield* git.sync
+                      .fetchBranch(existing, { branch: requestedBranch })
+                      .pipe(Effect.mapError((error) => new FetchFailedError({ repository, message: error.message })))
 
-                    const checkout = yield* git.checkout(localPath, requestedBranch).pipe(
+                    yield* git.sync.checkoutRemoteBranch(existing, { branch: requestedBranch }).pipe(
                       Effect.mapError(
                         (error) =>
                           new CheckoutFailedError({
                             repository,
                             branch: requestedBranch,
-                            message: errorMessage(error),
+                            message: error.message,
                           }),
                       ),
                     )
-                    if (checkout.exitCode !== 0) {
-                      return yield* new CheckoutFailedError({
-                        repository,
-                        branch: requestedBranch,
-                        message: resultMessage(checkout, `Failed to checkout ${requestedBranch}`),
-                      })
-                    }
                   }
 
-                  const reset = yield* git
-                    .reset(localPath, yield* resetTarget(git, localPath, input.branch))
-                    .pipe(
-                      Effect.mapError((error) => new ResetFailedError({ repository, message: errorMessage(error) })),
-                    )
-                  if (reset.exitCode !== 0) {
-                    return yield* new ResetFailedError({
-                      repository,
-                      message: resultMessage(reset, `Failed to reset ${repository}`),
-                    })
-                  }
+                  yield* git.sync
+                    .resetHard(existing, yield* resetTarget(git, existing, input.branch))
+                    .pipe(Effect.mapError((error) => new ResetFailedError({ repository, message: error.message })))
                 }
 
+                const checkout = yield* git.repo.discover(AbsolutePath.make(localPath))
+
                 return {
                   repository,
                   host: input.reference.host,
                   remote: input.reference.remote,
                   localPath,
                   status,
-                  head: yield* git.head(localPath),
-                  branch: yield* git.branch(localPath),
+                  head: checkout ? yield* git.history.head(checkout) : undefined,
+                  branch: checkout ? yield* git.history.branch(checkout) : undefined,
                 } satisfies Result
               }),
               `repository-cache:${localPath}`,
@@ -275,17 +245,17 @@ function cacheOperation<A, E, R>(effect: Effect.Effect<A, E, R>, operation: stri
   )
 }
 
-const resetTarget = Effect.fnUntraced(function* (git: Git.Interface, cwd: string, requestedBranch?: string) {
+const resetTarget = Effect.fnUntraced(function* (
+  git: Git.Interface,
+  repository: Git.Repository,
+  requestedBranch?: string,
+) {
   if (requestedBranch) return `origin/${requestedBranch}`
-  const remoteHead = yield* git.remoteHead(cwd)
-  if (remoteHead) return remoteHead
-  const currentBranch = yield* git.branch(cwd)
+  const remoteHead = yield* git.history.defaultRemoteBranch(repository)
+  if (remoteHead) return `origin/${remoteHead}`
+  const currentBranch = yield* git.history.branch(repository)
   if (currentBranch) return `origin/${currentBranch}`
   return "HEAD"
 })
 
-function resultMessage(result: Git.Result, fallback: string) {
-  return result.stderr.trim() || result.text.trim() || fallback
-}
-
 export * as RepositoryCache from "./repository-cache"

packages/core/src/session.ts

@@ -29,6 +29,12 @@ import { SessionExecution } from "./session/execution"
 import { MessageDecodeError } from "./session/error"
 import { SessionEvent } from "./session/event"
 import { SessionInput } from "./session/input"
+import { Snapshot } from "./snapshot"
+import { SessionRevert } from "./session/revert"
+import { Revert } from "@opencode-ai/schema/revert"
+
+export const RevertState = Revert.State
+export type RevertState = Revert.State
 
 // get project -> project.locations
 //
@@ -94,6 +100,8 @@ export class PromptConflictError extends Schema.TaggedErrorClass<PromptConflictE
   sessionID: SessionSchema.ID,
   messageID: SessionMessage.ID,
 }) {}
+export const MessageNotFoundError = SessionRevert.MessageNotFoundError
+export type MessageNotFoundError = SessionRevert.MessageNotFoundError
 
 export type Error = NotFoundError | MessageDecodeError | OperationUnavailableError | PromptConflictError
 
@@ -149,248 +157,292 @@ export interface Interface {
   readonly wait: (id: SessionSchema.ID) => Effect.Effect<void, NotFoundError | OperationUnavailableError>
   readonly resume: (sessionID: SessionSchema.ID) => Effect.Effect<void, NotFoundError | SessionRunner.RunError>
   readonly interrupt: (sessionID: SessionSchema.ID) => Effect.Effect<void>
+  readonly revert: {
+    readonly stage: (input: {
+      sessionID: SessionSchema.ID
+      messageID: SessionMessage.ID
+      files?: boolean
+    }) => Effect.Effect<Revert.State, NotFoundError | MessageNotFoundError | Snapshot.Error>
+    readonly clear: (sessionID: SessionSchema.ID) => Effect.Effect<void, NotFoundError | Snapshot.Error>
+    readonly commit: (sessionID: SessionSchema.ID) => Effect.Effect<void, NotFoundError>
+  }
 }
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/v2/Session") {}
 
-export const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const db = (yield* Database.Service).db
-    const events = yield* EventV2.Service
-    const projects = yield* ProjectV2.Service
-    const execution = yield* SessionExecution.Service
-    const store = yield* SessionStore.Service
-    const decodeMessage = Schema.decodeUnknownEffect(SessionMessage.Message)
-    const isDurableSessionEvent = Schema.is(SessionEvent.Durable)
-    const decode = (row: typeof SessionMessageTable.$inferSelect) =>
-      decodeMessage({ ...row.data, id: row.id, type: row.type }).pipe(
-        Effect.mapError(
-          () =>
-            new MessageDecodeError({
-              sessionID: SessionSchema.ID.make(row.session_id),
-              messageID: SessionMessage.ID.make(row.id),
-            }),
-        ),
-      )
-
-    const result = Service.of({
-      create: Effect.fn("V2Session.create")(function* (input) {
-        const sessionID = input.id ?? SessionSchema.ID.create()
-        const recorded = yield* store.get(sessionID)
-        if (recorded) return recorded
-        const project = yield* projects.resolve(input.location.directory)
-        yield* db
-          .insert(ProjectTable)
-          .values({ id: project.id, worktree: project.directory, vcs: project.vcs?.type, sandboxes: [] })
-          .onConflictDoNothing()
-          .run()
-          .pipe(Effect.orDie)
-        const now = Date.now()
-        const info = SessionV1.SessionInfo.make({
-          id: sessionID,
-          slug: Slug.create(),
-          version: InstallationVersion,
-          projectID: project.id,
-          directory: input.location.directory,
-          path: path.relative(project.directory, input.location.directory).replaceAll("\\", "/"),
-          workspaceID: input.location.workspaceID ? WorkspaceV2.ID.make(input.location.workspaceID) : undefined,
-          title: `New session - ${new Date(now).toISOString()}`,
-          agent: input.agent,
-          model: input.model
-            ? {
-                id: ModelV2.ID.make(input.model.id),
-                providerID: input.model.providerID,
-                variant: input.model.variant,
-              }
-            : undefined,
-          cost: 0,
-          tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
-          time: { created: now, updated: now },
-        })
-        const projected = yield* events
-          .publish(SessionV1.Event.Created, { sessionID, info }, { location: input.location })
-          .pipe(
-            Effect.as({ type: "created" } as const),
-            Effect.catchDefect((defect) => {
-              if (!(defect instanceof SessionProjector.SessionAlreadyProjected)) {
-                return Effect.die(defect)
-              }
-              // Concurrent creation lost the projection race. The existing Session identity wins.
-              return store
-                .get(sessionID)
-                .pipe(
-                  Effect.flatMap((session) =>
-                    session ? Effect.succeed({ type: "existing", session } as const) : Effect.die(defect),
-                  ),
-                )
-            }),
-          )
-        if (projected.type === "existing") return projected.session
-        // TODO: Restore recorded sessions onto replacement synchronized workspaces in a future API slice.
-        return yield* result.get(sessionID).pipe(Effect.orDie)
-      }),
-      get: Effect.fn("V2Session.get")(function* (sessionID) {
-        const session = yield* store.get(sessionID)
-        if (!session) return yield* new NotFoundError({ sessionID })
-        return session
-      }),
-      list: Effect.fn("V2Session.list")(function* (input = {}) {
-        const direction = input.anchor?.direction ?? "next"
-        const requestedOrder = input.order ?? "desc"
-        const order = direction === "previous" ? (requestedOrder === "asc" ? "desc" : "asc") : requestedOrder
-        const sortColumn = SessionTable.time_created
-        const conditions: SQL[] = []
-        if ("directory" in input) conditions.push(eq(SessionTable.directory, input.directory))
-        if (input.workspaceID) conditions.push(eq(SessionTable.workspace_id, input.workspaceID))
-        if ("project" in input) conditions.push(eq(SessionTable.project_id, input.project))
-        if (input.search) conditions.push(like(SessionTable.title, `%${input.search}%`))
-        if (input.anchor) {
-          conditions.push(
-            order === "asc"
-              ? or(
-                  gt(sortColumn, input.anchor.time),
-                  and(eq(sortColumn, input.anchor.time), gt(SessionTable.id, input.anchor.id)),
-                )!
-              : or(
-                  lt(sortColumn, input.anchor.time),
-                  and(eq(sortColumn, input.anchor.time), lt(SessionTable.id, input.anchor.id)),
-                )!,
-          )
-        }
-        const query = db
-          .select()
-          .from(SessionTable)
-          .where(conditions.length > 0 ? and(...conditions) : undefined)
-          .orderBy(
-            order === "asc" ? asc(sortColumn) : desc(sortColumn),
-            order === "asc" ? asc(SessionTable.id) : desc(SessionTable.id),
-          )
-        const rows = yield* (input.limit === undefined ? query.all() : query.limit(input.limit).all()).pipe(
-          Effect.orDie,
-        )
-        return (direction === "previous" ? rows.toReversed() : rows).map((row) => fromRow(row))
-      }),
-      messages: Effect.fn("V2Session.messages")(function* (input) {
-        yield* result.get(input.sessionID)
-        const direction = input.cursor?.direction ?? "next"
-        const requestedOrder = input.order ?? "desc"
-        const order = direction === "previous" ? (requestedOrder === "asc" ? "desc" : "asc") : requestedOrder
-        const anchor = input.cursor
-          ? yield* db
-              .select({ seq: SessionMessageTable.seq })
-              .from(SessionMessageTable)
-              .where(
-                and(eq(SessionMessageTable.session_id, input.sessionID), eq(SessionMessageTable.id, input.cursor.id)),
-              )
-              .get()
-              .pipe(Effect.orDie)
-          : undefined
-        if (input.cursor && !anchor) return []
-        const boundary = anchor
-          ? order === "asc"
-            ? gt(SessionMessageTable.seq, anchor.seq)
-            : lt(SessionMessageTable.seq, anchor.seq)
-          : undefined
-        const where = boundary
-          ? and(eq(SessionMessageTable.session_id, input.sessionID), boundary)
-          : eq(SessionMessageTable.session_id, input.sessionID)
-        const query = db
-          .select()
-          .from(SessionMessageTable)
-          .where(where)
-          .orderBy(order === "asc" ? asc(SessionMessageTable.seq) : desc(SessionMessageTable.seq))
-        const rows = yield* (input.limit === undefined ? query.all() : query.limit(input.limit).all()).pipe(
-          Effect.orDie,
-        )
-        return yield* Effect.forEach(direction === "previous" ? rows.toReversed() : rows, decode)
-      }),
-      message: Effect.fn("V2Session.message")(function* (input) {
-        const stored = yield* store.message(input.messageID)
-        return stored?.sessionID === input.sessionID ? stored.message : undefined
-      }),
-      context: Effect.fn("V2Session.context")(function* (sessionID) {
-        yield* result.get(sessionID)
-        return yield* store.context(sessionID)
-      }),
-      events: (input) =>
-        Stream.unwrap(
-          result
-            .get(input.sessionID)
-            .pipe(Effect.as(events.durable({ aggregateID: input.sessionID, after: input.after }))),
-        ).pipe(Stream.filter((event): event is SessionEvent.DurableEvent => isDurableSessionEvent(event))),
-      prompt: Effect.fn("V2Session.prompt")((input) =>
-        Effect.uninterruptible(
-          Effect.gen(function* () {
-            yield* result.get(input.sessionID)
-            const messageID = input.id ?? SessionMessage.ID.create()
-            const delivery = input.delivery ?? "steer"
-            const expected = { sessionID: input.sessionID, messageID, prompt: input.prompt, delivery }
-            const admitted = yield* SessionInput.admit(db, events, {
-              id: messageID,
-              sessionID: input.sessionID,
-              prompt: input.prompt,
-              delivery,
-            }).pipe(
-              Effect.catchDefect((defect) =>
-                defect instanceof SessionInput.LifecycleConflict
-                  ? new PromptConflictError({ sessionID: input.sessionID, messageID })
-                  : Effect.die(defect),
+export const layer = Layer.unwrap(
+  Effect.promise(() => import("./location-layer")).pipe(
+    Effect.map(({ LocationServiceMap }) =>
+      Layer.effect(
+        Service,
+        Effect.gen(function* () {
+          const database = yield* Database.Service
+          const db = database.db
+          const events = yield* EventV2.Service
+          const projects = yield* ProjectV2.Service
+          const execution = yield* SessionExecution.Service
+          const store = yield* SessionStore.Service
+          const locations = yield* LocationServiceMap
+          const decodeMessage = Schema.decodeUnknownEffect(SessionMessage.Message)
+          const isDurableSessionEvent = Schema.is(SessionEvent.Durable)
+          const decode = (row: typeof SessionMessageTable.$inferSelect) =>
+            decodeMessage({ ...row.data, id: row.id, type: row.type }).pipe(
+              Effect.mapError(
+                () =>
+                  new MessageDecodeError({
+                    sessionID: SessionSchema.ID.make(row.session_id),
+                    messageID: SessionMessage.ID.make(row.id),
+                  }),
               ),
             )
-            if (!SessionInput.equivalent(admitted, expected))
-              return yield* new PromptConflictError({ sessionID: input.sessionID, messageID })
-            if (input.resume !== false) yield* execution.wake(admitted.sessionID)
-            return admitted
-          }),
-        ),
-      ),
-      shell: Effect.fn("V2Session.shell")(function* () {
-        return yield* new OperationUnavailableError({ operation: "shell" })
-      }),
-      skill: Effect.fn("V2Session.skill")(function* () {
-        return yield* new OperationUnavailableError({ operation: "skill" })
-      }),
-      switchAgent: Effect.fn("V2Session.switchAgent")(function* (input) {
-        yield* result.get(input.sessionID)
-        yield* events.publish(SessionEvent.AgentSwitched, {
-          sessionID: input.sessionID,
-          messageID: SessionMessage.ID.create(),
-          timestamp: yield* DateTime.now,
-          agent: input.agent,
-        })
-      }),
-      switchModel: Effect.fn("V2Session.switchModel")(function* (input) {
-        yield* result.get(input.sessionID)
-        yield* events.publish(SessionEvent.ModelSwitched, {
-          sessionID: input.sessionID,
-          messageID: SessionMessage.ID.create(),
-          timestamp: yield* DateTime.now,
-          model: input.model,
-        })
-      }),
-      compact: Effect.fn("V2Session.compact")(function* (input) {
-        yield* result.get(input.sessionID)
-        return yield* new OperationUnavailableError({ operation: "compact" })
-      }),
-      wait: Effect.fn("V2Session.wait")(function* (sessionID) {
-        yield* result.get(sessionID)
-        return yield* new OperationUnavailableError({ operation: "wait" })
-      }),
-      resume: Effect.fn("V2Session.resume")(function* (sessionID) {
-        yield* result.get(sessionID)
-        yield* execution.resume(sessionID)
-      }),
-      interrupt: Effect.fn("V2Session.interrupt")((sessionID) =>
-        Effect.uninterruptible(execution.interrupt(sessionID)),
-      ),
-    })
 
-    return result
-  }),
+          const result = Service.of({
+            create: Effect.fn("V2Session.create")(function* (input) {
+              const sessionID = input.id ?? SessionSchema.ID.create()
+              const recorded = yield* store.get(sessionID)
+              if (recorded) return recorded
+              const project = yield* projects.resolve(input.location.directory)
+              yield* db
+                .insert(ProjectTable)
+                .values({ id: project.id, worktree: project.directory, vcs: project.vcs?.type, sandboxes: [] })
+                .onConflictDoNothing()
+                .run()
+                .pipe(Effect.orDie)
+              const now = Date.now()
+              const info = SessionV1.SessionInfo.make({
+                id: sessionID,
+                slug: Slug.create(),
+                version: InstallationVersion,
+                projectID: project.id,
+                directory: input.location.directory,
+                path: path.relative(project.directory, input.location.directory).replaceAll("\\", "/"),
+                workspaceID: input.location.workspaceID ? WorkspaceV2.ID.make(input.location.workspaceID) : undefined,
+                title: `New session - ${new Date(now).toISOString()}`,
+                agent: input.agent,
+                model: input.model
+                  ? {
+                      id: ModelV2.ID.make(input.model.id),
+                      providerID: input.model.providerID,
+                      variant: input.model.variant,
+                    }
+                  : undefined,
+                cost: 0,
+                tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+                time: { created: now, updated: now },
+              })
+              const projected = yield* events
+                .publish(SessionV1.Event.Created, { sessionID, info }, { location: input.location })
+                .pipe(
+                  Effect.as({ type: "created" } as const),
+                  Effect.catchDefect((defect) => {
+                    if (!(defect instanceof SessionProjector.SessionAlreadyProjected)) {
+                      return Effect.die(defect)
+                    }
+                    // Concurrent creation lost the projection race. The existing Session identity wins.
+                    return store
+                      .get(sessionID)
+                      .pipe(
+                        Effect.flatMap((session) =>
+                          session ? Effect.succeed({ type: "existing", session } as const) : Effect.die(defect),
+                        ),
+                      )
+                  }),
+                )
+              if (projected.type === "existing") return projected.session
+              // TODO: Restore recorded sessions onto replacement synchronized workspaces in a future API slice.
+              return yield* result.get(sessionID).pipe(Effect.orDie)
+            }),
+            get: Effect.fn("V2Session.get")(function* (sessionID) {
+              const session = yield* store.get(sessionID)
+              if (!session) return yield* new NotFoundError({ sessionID })
+              return session
+            }),
+            list: Effect.fn("V2Session.list")(function* (input = {}) {
+              const direction = input.anchor?.direction ?? "next"
+              const requestedOrder = input.order ?? "desc"
+              const order = direction === "previous" ? (requestedOrder === "asc" ? "desc" : "asc") : requestedOrder
+              const sortColumn = SessionTable.time_created
+              const conditions: SQL[] = []
+              if ("directory" in input) conditions.push(eq(SessionTable.directory, input.directory))
+              if (input.workspaceID) conditions.push(eq(SessionTable.workspace_id, input.workspaceID))
+              if ("project" in input) conditions.push(eq(SessionTable.project_id, input.project))
+              if (input.search) conditions.push(like(SessionTable.title, `%${input.search}%`))
+              if (input.anchor) {
+                conditions.push(
+                  order === "asc"
+                    ? or(
+                        gt(sortColumn, input.anchor.time),
+                        and(eq(sortColumn, input.anchor.time), gt(SessionTable.id, input.anchor.id)),
+                      )!
+                    : or(
+                        lt(sortColumn, input.anchor.time),
+                        and(eq(sortColumn, input.anchor.time), lt(SessionTable.id, input.anchor.id)),
+                      )!,
+                )
+              }
+              const query = db
+                .select()
+                .from(SessionTable)
+                .where(conditions.length > 0 ? and(...conditions) : undefined)
+                .orderBy(
+                  order === "asc" ? asc(sortColumn) : desc(sortColumn),
+                  order === "asc" ? asc(SessionTable.id) : desc(SessionTable.id),
+                )
+              const rows = yield* (input.limit === undefined ? query.all() : query.limit(input.limit).all()).pipe(
+                Effect.orDie,
+              )
+              return (direction === "previous" ? rows.toReversed() : rows).map((row) => fromRow(row))
+            }),
+            messages: Effect.fn("V2Session.messages")(function* (input) {
+              yield* result.get(input.sessionID)
+              const direction = input.cursor?.direction ?? "next"
+              const requestedOrder = input.order ?? "desc"
+              const order = direction === "previous" ? (requestedOrder === "asc" ? "desc" : "asc") : requestedOrder
+              const anchor = input.cursor
+                ? yield* db
+                    .select({ seq: SessionMessageTable.seq })
+                    .from(SessionMessageTable)
+                    .where(
+                      and(
+                        eq(SessionMessageTable.session_id, input.sessionID),
+                        eq(SessionMessageTable.id, input.cursor.id),
+                      ),
+                    )
+                    .get()
+                    .pipe(Effect.orDie)
+                : undefined
+              if (input.cursor && !anchor) return []
+              const boundary = anchor
+                ? order === "asc"
+                  ? gt(SessionMessageTable.seq, anchor.seq)
+                  : lt(SessionMessageTable.seq, anchor.seq)
+                : undefined
+              const where = boundary
+                ? and(eq(SessionMessageTable.session_id, input.sessionID), boundary)
+                : eq(SessionMessageTable.session_id, input.sessionID)
+              const query = db
+                .select()
+                .from(SessionMessageTable)
+                .where(where)
+                .orderBy(order === "asc" ? asc(SessionMessageTable.seq) : desc(SessionMessageTable.seq))
+              const rows = yield* (input.limit === undefined ? query.all() : query.limit(input.limit).all()).pipe(
+                Effect.orDie,
+              )
+              return yield* Effect.forEach(direction === "previous" ? rows.toReversed() : rows, decode)
+            }),
+            message: Effect.fn("V2Session.message")(function* (input) {
+              const stored = yield* store.message(input.messageID)
+              return stored?.sessionID === input.sessionID ? stored.message : undefined
+            }),
+            context: Effect.fn("V2Session.context")(function* (sessionID) {
+              yield* result.get(sessionID)
+              return yield* store.context(sessionID)
+            }),
+            events: (input) =>
+              Stream.unwrap(
+                result
+                  .get(input.sessionID)
+                  .pipe(Effect.as(events.durable({ aggregateID: input.sessionID, after: input.after }))),
+              ).pipe(Stream.filter((event): event is SessionEvent.DurableEvent => isDurableSessionEvent(event))),
+            prompt: Effect.fn("V2Session.prompt")((input) =>
+              Effect.uninterruptible(
+                Effect.gen(function* () {
+                  yield* result.get(input.sessionID)
+                  const messageID = input.id ?? SessionMessage.ID.create()
+                  const delivery = input.delivery ?? "steer"
+                  const expected = { sessionID: input.sessionID, messageID, prompt: input.prompt, delivery }
+                  const admitted = yield* SessionInput.admit(db, events, {
+                    id: messageID,
+                    sessionID: input.sessionID,
+                    prompt: input.prompt,
+                    delivery,
+                  }).pipe(
+                    Effect.catchDefect((defect) =>
+                      defect instanceof SessionInput.LifecycleConflict
+                        ? new PromptConflictError({ sessionID: input.sessionID, messageID })
+                        : Effect.die(defect),
+                    ),
+                  )
+                  if (!SessionInput.equivalent(admitted, expected))
+                    return yield* new PromptConflictError({ sessionID: input.sessionID, messageID })
+                  if (input.resume !== false) yield* execution.wake(admitted.sessionID)
+                  return admitted
+                }),
+              ),
+            ),
+            shell: Effect.fn("V2Session.shell")(function* () {
+              return yield* new OperationUnavailableError({ operation: "shell" })
+            }),
+            skill: Effect.fn("V2Session.skill")(function* () {
+              return yield* new OperationUnavailableError({ operation: "skill" })
+            }),
+            switchAgent: Effect.fn("V2Session.switchAgent")(function* (input) {
+              yield* result.get(input.sessionID)
+              yield* events.publish(SessionEvent.AgentSwitched, {
+                sessionID: input.sessionID,
+                messageID: SessionMessage.ID.create(),
+                timestamp: yield* DateTime.now,
+                agent: input.agent,
+              })
+            }),
+            switchModel: Effect.fn("V2Session.switchModel")(function* (input) {
+              yield* result.get(input.sessionID)
+              yield* events.publish(SessionEvent.ModelSwitched, {
+                sessionID: input.sessionID,
+                messageID: SessionMessage.ID.create(),
+                timestamp: yield* DateTime.now,
+                model: input.model,
+              })
+            }),
+            compact: Effect.fn("V2Session.compact")(function* (input) {
+              yield* result.get(input.sessionID)
+              return yield* new OperationUnavailableError({ operation: "compact" })
+            }),
+            wait: Effect.fn("V2Session.wait")(function* (sessionID) {
+              yield* result.get(sessionID)
+              return yield* new OperationUnavailableError({ operation: "wait" })
+            }),
+            resume: Effect.fn("V2Session.resume")(function* (sessionID) {
+              yield* result.get(sessionID)
+              yield* execution.resume(sessionID)
+            }),
+            interrupt: Effect.fn("V2Session.interrupt")((sessionID) =>
+              Effect.uninterruptible(execution.interrupt(sessionID)),
+            ),
+            revert: {
+              stage: Effect.fn("V2Session.revert.stage")(function* (input) {
+                const session = yield* result.get(input.sessionID)
+                return yield* SessionRevert.stage({ session, messageID: input.messageID, files: input.files }).pipe(
+                  Effect.provideService(Database.Service, database),
+                  Effect.provideService(EventV2.Service, events),
+                  Effect.provide(locations.get(session.location)),
+                )
+              }),
+              clear: Effect.fn("V2Session.revert.clear")(function* (sessionID) {
+                const session = yield* result.get(sessionID)
+                yield* SessionRevert.clear(session).pipe(
+                  Effect.provideService(EventV2.Service, events),
+                  Effect.provide(locations.get(session.location)),
+                )
+              }),
+              commit: Effect.fn("V2Session.revert.commit")(function* (sessionID) {
+                const session = yield* result.get(sessionID)
+                yield* SessionRevert.commit(session).pipe(Effect.provideService(EventV2.Service, events))
+              }),
+            },
+          })
+
+          return result
+        }),
+      ),
+    ),
+  ),
 )
 
 export const defaultLayer = layer.pipe(
+  Layer.provide(
+    Layer.unwrap(Effect.promise(() => import("./location-layer")).pipe(Effect.map((m) => m.LocationServiceMap.layer))),
+  ),
   Layer.provide(SessionExecution.noopLayer),
   Layer.provide(SessionStore.defaultLayer),
   Layer.provide(SessionProjector.defaultLayer),

packages/core/src/session/info.ts

@@ -8,6 +8,8 @@ import { AbsolutePath, RelativePath } from "../schema"
 import { WorkspaceV2 } from "../workspace"
 import { SessionSchema } from "./schema"
 import { SessionTable } from "./sql"
+import { SessionMessageID } from "./message-id"
+import { Snapshot } from "../snapshot"
 
 export function fromRow(row: typeof SessionTable.$inferSelect): SessionSchema.Info {
   return SessionSchema.Info.make({
@@ -38,6 +40,7 @@ export function fromRow(row: typeof SessionTable.$inferSelect): SessionSchema.In
       workspaceID: row.workspace_id ? WorkspaceV2.ID.make(row.workspace_id) : undefined,
     }),
     subpath: row.path ? RelativePath.make(row.path) : undefined,
+    revert: row.revert ? { ...row.revert, messageID: SessionMessageID.ID.make(row.revert.messageID) } : undefined,
     time: {
       created: DateTime.makeUnsafe(row.time_created),
       updated: DateTime.makeUnsafe(row.time_updated),

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

@@ -212,7 +212,12 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
           draft.finish = event.data.finish
           draft.cost = event.data.cost
           draft.tokens = event.data.tokens
-          if (event.data.snapshot) draft.snapshot = { ...draft.snapshot, end: event.data.snapshot }
+          if (event.data.snapshot || event.data.files)
+            draft.snapshot = {
+              ...draft.snapshot,
+              end: event.data.snapshot,
+              files: event.data.files ? Array.from(event.data.files) : undefined,
+            }
         })
       },
       "session.next.step.failed": (event) => {
@@ -380,6 +385,9 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
           }),
         )
       },
+      "session.next.revert.staged": () => Effect.void,
+      "session.next.revert.cleared": () => Effect.void,
+      "session.next.revert.committed": () => Effect.void,
     })
   })
 }

packages/core/src/session/projector.ts

@@ -1,6 +1,6 @@
 export * as SessionProjector from "./projector"
 
-import { and, desc, eq, sql } from "drizzle-orm"
+import { and, desc, eq, gt, or, sql } from "drizzle-orm"
 import { DateTime, Effect, Layer, Schema } from "effect"
 import { Database } from "../database/database"
 import { EventV2 } from "../event"
@@ -13,8 +13,9 @@ import { SessionMessageUpdater } from "./message-updater"
 import { SessionInput } from "./input"
 import { WorkspaceV2 } from "../workspace"
 import { SessionContextEpoch } from "./context-epoch"
-import { MessageTable, PartTable, SessionMessageTable, SessionTable } from "./sql"
+import { MessageTable, PartTable, SessionInputTable, SessionMessageTable, SessionTable } from "./sql"
 import type { DeepMutable } from "../schema"
+import { SessionMessageID } from "./message-id"
 
 type DatabaseService = Database.Interface["db"]
 
@@ -66,7 +67,7 @@ function sessionRow(info: SessionV1.SessionInfo): typeof SessionTable.$inferInse
     tokens_reasoning: (info.tokens ?? { reasoning: 0 }).reasoning,
     tokens_cache_read: (info.tokens ?? { cache: { read: 0 } }).cache.read,
     tokens_cache_write: (info.tokens ?? { cache: { write: 0 } }).cache.write,
-    revert: info.revert ?? null,
+    revert: info.revert ? { ...info.revert, messageID: SessionMessageID.ID.make(info.revert.messageID) } : null,
     permission: info.permission ? [...info.permission] : undefined,
     time_created: info.time.created,
     time_updated: info.time.updated,
@@ -393,6 +394,65 @@ export const layer = Layer.effectDiscard(
     yield* events.project(SessionEvent.Reasoning.Ended, (event) => run(db, event))
     // yield* events.project(SessionEvent.Retried, (event) => run(db, event))
     yield* events.project(SessionEvent.Compaction.Ended, (event) => run(db, event))
+    yield* events.project(SessionEvent.RevertEvent.Staged, (event) =>
+      db
+        .update(SessionTable)
+        .set({
+          revert: { ...event.data.revert, files: event.data.revert.files ? [...event.data.revert.files] : undefined },
+          time_updated: DateTime.toEpochMillis(event.data.timestamp),
+        })
+        .where(eq(SessionTable.id, event.data.sessionID))
+        .run()
+        .pipe(Effect.orDie, Effect.asVoid),
+    )
+    yield* events.project(SessionEvent.RevertEvent.Cleared, (event) =>
+      db
+        .update(SessionTable)
+        .set({ revert: null, time_updated: DateTime.toEpochMillis(event.data.timestamp) })
+        .where(eq(SessionTable.id, event.data.sessionID))
+        .run()
+        .pipe(Effect.orDie, Effect.asVoid),
+    )
+    yield* events.project(SessionEvent.RevertEvent.Committed, (event) =>
+      Effect.gen(function* () {
+        const boundary = yield* db
+          .select({ seq: SessionMessageTable.seq })
+          .from(SessionMessageTable)
+          .where(
+            and(
+              eq(SessionMessageTable.session_id, event.data.sessionID),
+              eq(SessionMessageTable.id, event.data.messageID),
+            ),
+          )
+          .get()
+          .pipe(Effect.orDie)
+        if (!boundary) return yield* Effect.die(`Revert boundary message not found: ${event.data.messageID}`)
+        yield* db
+          .delete(SessionMessageTable)
+          .where(
+            and(eq(SessionMessageTable.session_id, event.data.sessionID), gt(SessionMessageTable.seq, boundary.seq)),
+          )
+          .run()
+          .pipe(Effect.orDie)
+        yield* db
+          .delete(SessionInputTable)
+          .where(
+            and(
+              eq(SessionInputTable.session_id, event.data.sessionID),
+              or(gt(SessionInputTable.admitted_seq, boundary.seq), gt(SessionInputTable.promoted_seq, boundary.seq)),
+            ),
+          )
+          .run()
+          .pipe(Effect.orDie)
+        yield* db
+          .update(SessionTable)
+          .set({ revert: null, time_updated: DateTime.toEpochMillis(event.data.timestamp) })
+          .where(eq(SessionTable.id, event.data.sessionID))
+          .run()
+          .pipe(Effect.orDie)
+        yield* SessionContextEpoch.reset(db, event.data.sessionID)
+      }),
+    )
   }),
 )
 

packages/core/src/session/revert.ts

@@ -0,0 +1,121 @@
+export * as SessionRevert from "./revert"
+
+import { and, asc, eq, gt } from "drizzle-orm"
+import { DateTime, Effect, Schema } from "effect"
+import { Database } from "../database/database"
+import { EventV2 } from "../event"
+import { RelativePath } from "../schema"
+import { Snapshot } from "../snapshot"
+import { SessionEvent } from "./event"
+import { SessionMessage } from "./message"
+import { SessionSchema } from "./schema"
+import { SessionMessageTable } from "./sql"
+
+export class MessageNotFoundError extends Schema.TaggedErrorClass<MessageNotFoundError>()(
+  "Session.MessageNotFoundError",
+  {
+    sessionID: SessionSchema.ID,
+    messageID: SessionMessage.ID,
+  },
+) {}
+
+interface BoundaryInput {
+  readonly sessionID: SessionSchema.ID
+  readonly messageID: SessionMessage.ID
+}
+
+const plan = Effect.fn("SessionRevert.plan")(function* (input: BoundaryInput) {
+  const db = (yield* Database.Service).db
+  const boundary = yield* db
+    .select({ seq: SessionMessageTable.seq })
+    .from(SessionMessageTable)
+    .where(and(eq(SessionMessageTable.session_id, input.sessionID), eq(SessionMessageTable.id, input.messageID)))
+    .get()
+    .pipe(Effect.orDie)
+  if (!boundary) return yield* new MessageNotFoundError(input)
+  const rows = yield* db
+    .select()
+    .from(SessionMessageTable)
+    .where(
+      and(
+        eq(SessionMessageTable.session_id, input.sessionID),
+        eq(SessionMessageTable.type, "assistant"),
+        gt(SessionMessageTable.seq, boundary.seq),
+      ),
+    )
+    .orderBy(asc(SessionMessageTable.seq))
+    .all()
+    .pipe(Effect.orDie)
+  const decode = Schema.decodeUnknownEffect(SessionMessage.Message)
+  const files = new Map<RelativePath, Snapshot.ID>()
+  for (const row of rows) {
+    const message = yield* decode({ ...row.data, id: row.id, type: row.type }).pipe(Effect.orDie)
+    if (message.type !== "assistant" || !message.snapshot?.start) continue
+    for (const file of message.snapshot.files ?? [])
+      if (!files.has(file)) files.set(file, Snapshot.ID.make(message.snapshot.start))
+  }
+  return files
+})
+
+export const stage = Effect.fn("SessionRevert.stage")(function* (input: {
+  readonly session: SessionSchema.Info
+  readonly messageID: SessionMessage.ID
+  readonly files?: boolean
+}) {
+  const snapshot = yield* Snapshot.Service
+  const events = yield* EventV2.Service
+  const original = input.session.revert?.snapshot
+    ? Snapshot.ID.make(input.session.revert.snapshot)
+    : yield* snapshot.capture()
+  const next = yield* plan({ sessionID: input.session.id, messageID: input.messageID })
+  const restore = new Map<RelativePath, Snapshot.ID>()
+  if (original) {
+    for (const file of input.session.revert?.files ?? []) restore.set(file.path, original)
+  }
+  if (input.files !== false) for (const [file, tree] of next) restore.set(file, tree)
+  if (restore.size) yield* snapshot.restore({ files: restore })
+  const paths = input.files === false ? [] : Array.from(next.keys())
+  const files = original
+    ? yield* snapshot.diff({ from: original, to: (yield* snapshot.capture()) ?? original, paths })
+    : []
+  const revert = {
+    messageID: input.messageID,
+    snapshot: original,
+    diff: files
+      .map((file) => file.patch)
+      .join("")
+      .trim(),
+    files,
+  } satisfies SessionSchema.Info["revert"]
+  yield* events.publish(SessionEvent.RevertEvent.Staged, {
+    sessionID: input.session.id,
+    timestamp: yield* DateTime.now,
+    revert,
+  })
+  return revert
+})
+
+export const clear = Effect.fn("SessionRevert.clear")(function* (session: SessionSchema.Info) {
+  if (!session.revert) return
+  const snapshot = yield* Snapshot.Service
+  const original = session.revert.snapshot ? Snapshot.ID.make(session.revert.snapshot) : undefined
+  if (original)
+    yield* snapshot.restore({
+      files: new Map((session.revert.files ?? []).map((file) => [file.path, original])),
+    })
+  const events = yield* EventV2.Service
+  yield* events.publish(SessionEvent.RevertEvent.Cleared, {
+    sessionID: session.id,
+    timestamp: yield* DateTime.now,
+  })
+})
+
+export const commit = Effect.fn("SessionRevert.commit")(function* (session: SessionSchema.Info) {
+  if (!session.revert) return
+  const events = yield* EventV2.Service
+  yield* events.publish(SessionEvent.RevertEvent.Committed, {
+    sessionID: session.id,
+    messageID: session.revert.messageID,
+    timestamp: yield* DateTime.now,
+  })
+})

packages/core/src/session/runner/llm.ts

@@ -6,6 +6,7 @@ import {
   Message,
   SystemPart,
   isContextOverflowFailure,
+  type LLMErrorReason,
   type ProviderErrorEvent,
 } from "@opencode-ai/llm"
 import { Cause, DateTime, Effect, FiberSet, Layer, Option, Semaphore, Stream } from "effect"
@@ -32,9 +33,10 @@ import { SessionSchema } from "../schema"
 import { SessionStore } from "../store"
 import { type RunError, Service } from "./index"
 import { SessionRunnerModel } from "./model"
-import { createLLMEventPublisher } from "./publish-llm-event"
+import { createLLMEventPublisher, providerError } from "./publish-llm-event"
 import { toLLMMessages } from "./to-llm-message"
 import { MAX_STEPS_PROMPT } from "./max-steps"
+import { Snapshot } from "../../snapshot"
 
 /**
  * Runs one durable coding-agent Session until it settles.
@@ -86,6 +88,29 @@ import { MAX_STEPS_PROMPT } from "./max-steps"
  * explicit loop starts the next provider turn after local settlement. Configured agent step limits bound the loop.
  */
 
+const providerCategories = {
+  InvalidRequest: "invalid-request",
+  NoRoute: "no-route",
+  Authentication: "authentication",
+  RateLimit: "rate-limit",
+  QuotaExceeded: "quota-exceeded",
+  ContentPolicy: "content-policy",
+  ProviderInternal: "provider-internal",
+  Transport: "transport",
+  InvalidProviderOutput: "invalid-provider-output",
+  UnknownProvider: "unknown",
+} as const satisfies Record<LLMErrorReason["_tag"], Parameters<typeof providerError>[0]["category"]>
+
+const toSessionProviderError = (reason: LLMErrorReason) =>
+  providerError({
+    category: providerCategories[reason._tag],
+    status:
+      ("http" in reason ? reason.http?.response?.status : undefined) ??
+      ("status" in reason ? reason.status : undefined),
+    retryable: reason.retryable,
+    retryAfterMs: "retryAfterMs" in reason ? reason.retryAfterMs : undefined,
+  })
+
 export const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
@@ -100,6 +125,7 @@ export const layer = Layer.effect(
     const skillGuidance = yield* SkillGuidance.Service
     const referenceGuidance = yield* ReferenceGuidance.Service
     const config = yield* Config.Service
+    const snapshots = yield* Snapshot.Service
     const db = (yield* Database.Service).db
     const compaction = SessionCompaction.make({ events, llm, config: yield* config.entries() })
     const getSession = Effect.fn("SessionRunner.getSession")(function* (sessionID: SessionSchema.ID) {
@@ -205,6 +231,7 @@ export const layer = Layer.effect(
       })
       if (yield* compaction.compactIfNeeded({ sessionID: session.id, entries, model, request }))
         return yield* Effect.die(continueAfterCompaction(currentStep))
+      const startSnapshot = yield* snapshots.capture()
       const publisher = createLLMEventPublisher(events, {
         sessionID: session.id,
         agent: agent.id,
@@ -213,6 +240,7 @@ export const layer = Layer.effect(
           providerID: ProviderV2.ID.make(model.provider),
           ...(session.model?.variant === undefined ? {} : { variant: session.model.variant }),
         },
+        snapshot: startSnapshot,
       })
       const withPublication = Semaphore.makeUnsafe(1).withPermit
       const publish = (event: LLMEvent, outputPaths: ReadonlyArray<string> = []) =>
@@ -279,7 +307,7 @@ export const layer = Layer.effect(
           const llmFailure = failure instanceof LLMError ? failure : undefined
           if (llmFailure && !publisher.hasProviderError()) {
             yield* withPublication(publisher.failUnsettledTools("Provider did not return a tool result", true))
-            yield* withPublication(publisher.failAssistant(llmFailure.reason.message))
+            yield* withPublication(publisher.failAssistant(toSessionProviderError(llmFailure.reason)))
           }
           if (stream._tag === "Failure" && Cause.hasInterrupts(stream.cause)) yield* FiberSet.clear(toolFibers)
           const settled = yield* restore(awaitToolFibers(toolFibers)).pipe(Effect.exit)
@@ -295,13 +323,35 @@ export const layer = Layer.effect(
             yield* FiberSet.clear(toolFibers)
             yield* withPublication(publisher.failUnsettledTools("Tool execution interrupted"))
             if (publisher.hasActiveAssistant())
-              yield* withPublication(publisher.failAssistant("Provider turn interrupted"))
+              yield* withPublication(publisher.failAssistant({ type: "unknown", message: "Provider turn interrupted" }))
           }
           if (settled._tag === "Failure" && !Cause.hasInterrupts(settled.cause)) {
             const failure = Cause.squash(settled.cause)
             const message = failure instanceof Error ? failure.message : String(failure)
             yield* withPublication(publisher.failUnsettledTools(`Tool execution failed: ${message}`))
           }
+          const stepSettlement = publisher.stepSettlement()
+          if (stepSettlement && !publisher.hasProviderError()) {
+            const endSnapshot = yield* snapshots.capture()
+            const files =
+              startSnapshot && endSnapshot
+                ? yield* snapshots
+                    .files({ from: startSnapshot, to: endSnapshot })
+                    .pipe(Effect.catch(() => Effect.succeed(undefined)))
+                : undefined
+            yield* withPublication(
+              events.publish(SessionEvent.Step.Ended, {
+                sessionID: session.id,
+                timestamp: yield* DateTime.now,
+                assistantMessageID: yield* publisher.startAssistant(),
+                finish: stepSettlement.finish,
+                cost: 0,
+                tokens: stepSettlement.tokens,
+                snapshot: endSnapshot,
+                files,
+              }),
+            )
+          }
           if (publisher.hasProviderError())
             yield* withPublication(publisher.failUnsettledTools("Tool execution interrupted"))
           if (stream._tag === "Success" && !publisher.hasProviderError())

packages/core/src/session/runner/publish-llm-event.ts

@@ -10,6 +10,7 @@ type Input = {
   readonly sessionID: SessionSchema.ID
   readonly agent: string
   readonly model: ModelV2.Ref
+  readonly snapshot?: string
 }
 
 const safe = (value: number | undefined) => Math.max(0, Number.isFinite(value) ? (value ?? 0) : 0)
@@ -49,6 +50,33 @@ const settledOutput = (value: ToolOutput | undefined, result: ToolResultValue):
   return { structured: record(settled.structured), content: settled.content }
 }
 
+const providerMessages: Record<SessionMessage.ProviderErrorCategory, string> = {
+  "invalid-request": "Provider rejected the request",
+  "no-route": "No provider route is available",
+  authentication: "Provider authentication failed",
+  "rate-limit": "Provider rate limit exceeded",
+  "quota-exceeded": "Provider quota exceeded",
+  "content-policy": "Provider content policy rejected the request",
+  "provider-internal": "Provider service error",
+  transport: "Provider connection failed",
+  "invalid-provider-output": "Provider returned an invalid response",
+  unknown: "Provider request failed",
+}
+
+export const providerError = (input: {
+  readonly category: SessionMessage.ProviderErrorCategory
+  readonly status?: number
+  readonly retryable?: boolean
+  readonly retryAfterMs?: number
+}): SessionMessage.ProviderError => ({
+  type: "provider",
+  category: input.category,
+  message: providerMessages[input.category],
+  status: input.status,
+  retryable: input.retryable ?? (input.category === "rate-limit" || input.category === "provider-internal"),
+  retryAfterMs: input.retryAfterMs,
+})
+
 /** Persist one provider turn without executing tools or starting a continuation turn. */
 export const createLLMEventPublisher = (events: EventV2.Interface, input: Input) => {
   const tools = new Map<
@@ -68,6 +96,7 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
   let assistantActive = false
   let assistantFailed = false
   let providerFailed = false
+  let stepSettlement: { readonly finish: string; readonly tokens: ReturnType<typeof tokens> } | undefined
 
   const startAssistant = Effect.fnUntraced(function* () {
     if (assistantMessageID !== undefined) return assistantMessageID
@@ -77,6 +106,7 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
       ...input,
       assistantMessageID,
       timestamp: yield* timestamp,
+      snapshot: input.snapshot,
     })
     return assistantMessageID
   })
@@ -193,7 +223,7 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
     yield* flushFragments()
   })
 
-  const failAssistant = Effect.fnUntraced(function* (message: string) {
+  const failAssistant = Effect.fnUntraced(function* (error: SessionMessage.Error) {
     if (assistantFailed) return
     yield* flush()
     const assistantMessageID = yield* startAssistant()
@@ -203,7 +233,7 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
       sessionID: input.sessionID,
       timestamp: yield* timestamp,
       assistantMessageID,
-      error: { type: "unknown", message },
+      error,
     })
   })
 
@@ -393,20 +423,18 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
       case "step-finish":
         yield* flush()
         assistantActive = false
-        yield* events.publish(SessionEvent.Step.Ended, {
-          sessionID: input.sessionID,
-          timestamp: yield* timestamp,
-          assistantMessageID: yield* startAssistant(),
-          finish: event.reason,
-          cost: 0,
-          tokens: tokens(event.usage),
-        })
+        if (stepSettlement) return yield* Effect.die("Duplicate step finish")
+        stepSettlement = { finish: event.reason, tokens: tokens(event.usage) }
         return
       case "finish":
         return
       case "provider-error":
         providerFailed = true
-        yield* failAssistant(event.message)
+        yield* failAssistant(
+          event.category === undefined
+            ? { type: "unknown", message: event.message }
+            : providerError({ category: event.category, status: event.status, retryable: event.retryable }),
+        )
         return
     }
   })
@@ -419,6 +447,8 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
     hasActiveAssistant: () => assistantActive,
     hasAssistantStarted: () => assistantMessageID !== undefined,
     hasProviderError: () => providerFailed,
+    stepSettlement: () => stepSettlement,
+    startAssistant,
     assistantMessageID: assistantMessageIDForTool,
   }
 }

packages/core/src/session/runner/to-llm-message.ts

@@ -70,16 +70,20 @@ const toolResult = (tool: SessionMessage.AssistantTool, providerMetadata: Provid
 const assistant = (message: SessionMessage.Assistant, model: Model) => {
   const sameModel =
     String(message.model.providerID) === String(model.provider) && String(message.model.id) === String(model.id)
+  const preserveProviderMetadata = sameModel && message.finish !== "error"
   const content = message.content.flatMap((item): ContentPart[] => {
     if (item.type === "text") return [{ type: "text", text: item.text }]
     if (item.type === "reasoning")
-      return sameModel
+      return preserveProviderMetadata
         ? [{ type: "reasoning", text: item.text, providerMetadata: item.providerMetadata }]
         : item.text.length > 0
           ? [{ type: "text", text: item.text }]
           : []
-    const call = toolCall(item, sameModel ? item.provider?.metadata : undefined)
-    const result = toolResult(item, sameModel ? (item.provider?.resultMetadata ?? item.provider?.metadata) : undefined)
+    const call = toolCall(item, preserveProviderMetadata ? item.provider?.metadata : undefined)
+    const result = toolResult(
+      item,
+      preserveProviderMetadata ? (item.provider?.resultMetadata ?? item.provider?.metadata) : undefined,
+    )
     return item.provider?.executed === true && result ? [call, result] : [call]
   })
   const meaningful = content.filter((part) => {
@@ -89,7 +93,12 @@ const assistant = (message: SessionMessage.Assistant, model: Model) => {
   })
   const results = message.content
     .filter((item): item is SessionMessage.AssistantTool => item.type === "tool" && item.provider?.executed !== true)
-    .map((item) => toolResult(item, sameModel ? (item.provider?.resultMetadata ?? item.provider?.metadata) : undefined))
+    .map((item) =>
+      toolResult(
+        item,
+        preserveProviderMetadata ? (item.provider?.resultMetadata ?? item.provider?.metadata) : undefined,
+      ),
+    )
     .filter((message) => message !== undefined)
     .map(Message.tool)
   if (meaningful.length === 0) return results

packages/core/src/session/sql.ts

@@ -13,6 +13,7 @@ import { WorkspaceV2 } from "../workspace"
 import { Timestamps } from "../database/schema.sql"
 import type { SystemContext } from "../system-context/index"
 import { AgentV2 } from "../agent"
+import type { Revert } from "@opencode-ai/schema/revert"
 
 type SessionMessageData = Omit<(typeof SessionMessage.Message)["Encoded"], "type" | "id">
 type V1MessageData = Omit<SessionV1.Info, "id" | "sessionID">
@@ -37,7 +38,7 @@ export const SessionTable = sqliteTable(
     summary_additions: integer(),
     summary_deletions: integer(),
     summary_files: integer(),
-    summary_diffs: text({ mode: "json" }).$type<Snapshot.FileDiff[]>(),
+    summary_diffs: text({ mode: "json" }).$type<Snapshot.LegacyFileDiff[]>(),
     metadata: text({ mode: "json" }).$type<Record<string, unknown>>(),
     cost: real().notNull().default(0),
     tokens_input: integer().notNull().default(0),
@@ -45,7 +46,7 @@ export const SessionTable = sqliteTable(
     tokens_reasoning: integer().notNull().default(0),
     tokens_cache_read: integer().notNull().default(0),
     tokens_cache_write: integer().notNull().default(0),
-    revert: text({ mode: "json" }).$type<{ messageID: MessageID; partID?: PartID; snapshot?: string; diff?: string }>(),
+    revert: text({ mode: "json" }).$type<Revert.State>(),
     permission: text({ mode: "json" }).$type<PermissionV1.Ruleset>(),
     agent: text(),
     model: text({ mode: "json" }).$type<{

packages/core/src/snapshot.ts

@@ -1,9 +1,259 @@
-export namespace Snapshot {
-  export type FileDiff = {
-    file?: string
-    patch?: string
-    additions: number
-    deletions: number
-    status?: "added" | "deleted" | "modified"
-  }
+export * as Snapshot from "./snapshot"
+
+import path from "path"
+import { Context, Effect, Layer, Schema } from "effect"
+import { Config } from "./config"
+import { File } from "./file"
+import { FSUtil } from "./fs-util"
+import { Git } from "./git"
+import { Global } from "./global"
+import { Location } from "./location"
+import { AbsolutePath, RelativePath } from "./schema"
+import { Hash } from "./util/hash"
+
+export const ID = Schema.String.pipe(Schema.brand("Snapshot.ID"))
+export type ID = typeof ID.Type
+
+export class Error extends Schema.TaggedErrorClass<Error>()("Snapshot.Error", {
+  operation: Schema.Literals(["capture", "files", "diff", "preview", "restore"]),
+  message: Schema.String,
+  cause: Schema.optional(Schema.Defect()),
+}) {}
+
+export interface CompareInput {
+  readonly from: ID
+  readonly to: ID
+}
+
+export interface DiffInput extends CompareInput {
+  readonly context?: number
+  readonly paths?: readonly RelativePath[]
+}
+
+export interface RestoreInput {
+  /** Paths are relative to the project root. */
+  readonly files: ReadonlyMap<RelativePath, ID>
+}
+
+export interface PreviewInput extends RestoreInput {
+  readonly context?: number
+}
+
+export interface Interface {
+  /**
+   * Capture the current Location-scoped filesystem state as a content-addressed
+   * tree. Returns `undefined` when snapshots are disabled, unsupported, or the
+   * best-effort capture fails.
+   */
+  readonly capture: () => Effect.Effect<ID | undefined>
+
+  /**
+   * List project-relative paths changed between two captured trees without
+   * loading file contents or generating patches.
+   */
+  readonly files: (input: CompareInput) => Effect.Effect<readonly RelativePath[], Error>
+
+  /**
+   * Generate structured per-file diffs between two captured trees. `context`
+   * controls unchanged lines around each unified diff hunk.
+   */
+  readonly diff: (input: DiffInput) => Effect.Effect<readonly File.Diff[], Error>
+
+  /**
+   * Preview the filesystem result of a selective restore without modifying the
+   * worktree. Each project-relative path maps to the tree it would be restored
+   * from.
+   */
+  readonly preview: (input: PreviewInput) => Effect.Effect<readonly File.Diff[], Error>
+
+  /**
+   * Restore selected project-relative paths from their associated trees. A path
+   * absent from its selected tree is removed; paths outside the map are untouched.
+   */
+  readonly restore: (input: RestoreInput) => Effect.Effect<void, Error>
+
+  /**
+   * Replace the snapshot index with a captured tree and check out all its entries.
+   * Files absent from the tree remain untouched. Prefer selective `restore` when
+   * only known paths should change.
+   */
+  readonly checkout: (snapshot: ID) => Effect.Effect<void, Error>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@opencode/v2/Snapshot") {}
+
+export const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const config = yield* Config.Service
+    const fs = yield* FSUtil.Service
+    const git = yield* Git.Service
+    const global = yield* Global.Service
+    const location = yield* Location.Service
+    const source = yield* git.repo.discover(location.project.directory)
+    const worktree = source
+      ? AbsolutePath.make(yield* fs.realPath(source.worktree).pipe(Effect.orDie))
+      : location.project.directory
+    const gitDirectory = AbsolutePath.make(path.join(global.data, "snapshot", location.project.id, Hash.fast(worktree)))
+
+    const scope = Effect.fnUntraced(function* () {
+      const relative = path.relative(worktree, location.directory)
+      if (relative.startsWith("..") || path.isAbsolute(relative))
+        return yield* new Error({ operation: "capture", message: "Location is outside the project" })
+      return RelativePath.make(relative.replaceAll("\\", "/") || ".")
+    })
+
+    const repository = Effect.fnUntraced(function* () {
+      if (!source) return yield* new Error({ operation: "capture", message: "Project is not a Git repository" })
+      if (yield* fs.existsSafe(path.join(gitDirectory, "HEAD")))
+        return new Git.Repository({
+          worktree,
+          gitDirectory,
+          commonDirectory: gitDirectory,
+        })
+      return yield* git.repo
+        .create({
+          worktree,
+          gitDirectory,
+          seed: source,
+        })
+        .pipe(Effect.mapError((cause) => failure("capture", cause)))
+    })
+
+    const enabled = Effect.fnUntraced(function* () {
+      if (location.vcs?.type !== "git") return false
+      return Config.latest(yield* config.entries(), "snapshots") !== false
+    })
+
+    const capture = Effect.fn("Snapshot.capture")(function* () {
+      if (!(yield* enabled())) return undefined
+      return yield* Effect.gen(function* () {
+        const repo = yield* repository()
+        return ID.make(
+          yield* git.tree.capture({
+            repository: repo,
+            scopes: [yield* scope()],
+            ignores: source,
+            maximumUntrackedFileBytes: 2 * 1024 * 1024,
+          }),
+        )
+      }).pipe(
+        Effect.catch((cause) => Effect.logWarning("failed to capture snapshot", { cause }).pipe(Effect.as(undefined))),
+      )
+    })
+
+    const compare = Effect.fnUntraced(function* (operation: "files" | "diff", input: CompareInput) {
+      const repo = yield* repository().pipe(Effect.mapError((cause) => failure(operation, cause)))
+      return { repository: repo, from: Git.TreeID.make(input.from), to: Git.TreeID.make(input.to) }
+    })
+
+    const files = Effect.fn("Snapshot.files")(function* (input: CompareInput) {
+      const comparison = yield* compare("files", input)
+      const files = yield* git.tree.files(comparison).pipe(Effect.mapError((cause) => failure("files", cause)))
+      if (!source) return files
+      const ignored = yield* git.index
+        .ignored({ repository: source, paths: files })
+        .pipe(Effect.mapError((cause) => failure("files", cause)))
+      return files.filter((file) => !ignored.has(file))
+    })
+
+    const diff = Effect.fn("Snapshot.diff")(function* (input: DiffInput) {
+      const comparison = yield* compare("diff", input)
+      const files = yield* git.tree.files(comparison).pipe(Effect.mapError((cause) => failure("diff", cause)))
+      const ignored = source
+        ? yield* git.index
+            .ignored({ repository: source, paths: files })
+            .pipe(Effect.mapError((cause) => failure("diff", cause)))
+        : new Set<RelativePath>()
+      return yield* git.tree
+        .diff({
+          ...comparison,
+          context: input.context,
+          paths: (input.paths ?? files).filter((file) => !ignored.has(file)),
+        })
+        .pipe(Effect.mapError((cause) => failure("diff", cause)))
+    })
+
+    const plan = Effect.fnUntraced(function* (operation: "preview" | "restore", input: RestoreInput) {
+      const files = new Map<RelativePath, Git.TreeID>()
+      for (const [file, snapshot] of input.files) {
+        const absolute = path.resolve(worktree, file)
+        if (!FSUtil.contains(worktree, absolute))
+          return yield* new Error({ operation, message: `Path escapes the project: ${file}` })
+        files.set(file, Git.TreeID.make(snapshot))
+      }
+      return files
+    })
+
+    const preview = Effect.fn("Snapshot.preview")(function* (input: PreviewInput) {
+      if (!(yield* enabled())) return yield* new Error({ operation: "preview", message: "Snapshots are disabled" })
+      const repo = yield* repository().pipe(Effect.mapError((cause) => failure("preview", cause)))
+      const files = yield* plan("preview", input)
+      const current = yield* git.tree
+        .capture({
+          repository: repo,
+          scopes: Array.from(files.keys()),
+          ignores: source,
+          maximumUntrackedFileBytes: 2 * 1024 * 1024,
+        })
+        .pipe(Effect.mapError((cause) => failure("preview", cause)))
+      return yield* git.tree
+        .preview({
+          repository: repo,
+          current,
+          files,
+          context: input.context,
+        })
+        .pipe(Effect.mapError((cause) => failure("preview", cause)))
+    })
+
+    const restore = Effect.fn("Snapshot.restore")(function* (input: RestoreInput) {
+      if (!(yield* enabled())) return yield* new Error({ operation: "restore", message: "Snapshots are disabled" })
+      const repo = yield* repository().pipe(Effect.mapError((cause) => failure("restore", cause)))
+      yield* git.tree
+        .restore({ repository: repo, files: yield* plan("restore", input) })
+        .pipe(Effect.mapError((cause) => failure("restore", cause)))
+    })
+
+    const checkout = Effect.fn("Snapshot.checkout")(function* (snapshot: ID) {
+      const repo = yield* repository().pipe(Effect.mapError((cause) => failure("restore", cause)))
+      yield* git.tree
+        .checkout({ repository: repo, tree: Git.TreeID.make(snapshot) })
+        .pipe(Effect.mapError((cause) => failure("restore", cause)))
+    })
+
+    return Service.of({ capture, files, diff, preview, restore, checkout })
+  }),
+)
+
+export const locationLayer = layer.pipe(Layer.provideMerge(Config.locationLayer))
+
+export const noopLayer = Layer.succeed(
+  Service,
+  Service.of({
+    capture: () => Effect.succeed(undefined),
+    files: () => Effect.succeed([]),
+    diff: () => Effect.succeed([]),
+    preview: () => Effect.succeed([]),
+    restore: () => Effect.void,
+    checkout: () => Effect.void,
+  }),
+)
+
+function failure(operation: Error["operation"], cause: unknown) {
+  if (cause instanceof Error && cause.operation === operation) return cause
+  return new Error({
+    operation,
+    message: cause instanceof globalThis.Error ? cause.message : String(cause),
+    cause,
+  })
+}
+
+/** Legacy persisted session diff shape. */
+export type LegacyFileDiff = {
+  file?: string
+  patch?: string
+  additions: number
+  deletions: number
+  status?: "added" | "deleted" | "modified"
 }

packages/core/src/v1/config/provider-options.ts

@@ -40,7 +40,14 @@ const openai: Lowerer = {
       settings: omit(options, ["apiKey", "baseURL", "organization", "project", "headers", "body"]),
     }
   },
-  request: snake,
+  request(options) {
+    const result = snake(options)
+    if (options.textVerbosity !== undefined) {
+      result.text = { ...(isRecord(result.text) ? result.text : {}), verbosity: options.textVerbosity }
+      delete result.text_verbosity
+    }
+    return result
+  },
 }
 
 const anthropic: Lowerer = {

packages/core/test/config/provider-options.test.ts

@@ -39,8 +39,16 @@ describe("ConfigProviderOptionsV1", () => {
       body: { store: true },
       settings: { timeout: 1000 },
     })
-    expect(lowerer.request({ reasoningEffort: "high", nestedValue: { camelCase: true } })).toEqual({
+    expect(
+      lowerer.request({
+        reasoningEffort: "high",
+        textVerbosity: "low",
+        text: { outputFormat: "plain" },
+        nestedValue: { camelCase: true },
+      }),
+    ).toEqual({
       reasoning_effort: "high",
+      text: { output_format: "plain", verbosity: "low" },
       nested_value: { camel_case: true },
     })
   })
@@ -130,7 +138,10 @@ describe("ConfigProviderOptionsV1", () => {
       body: { trace: true },
       settings: { resourceName: "resource" },
     })
-    expect(lowerer.request({ reasoningEffort: "high" })).toEqual({ reasoning_effort: "high" })
+    expect(lowerer.request({ reasoningEffort: "high", textVerbosity: "low" })).toEqual({
+      reasoning_effort: "high",
+      text: { verbosity: "low" },
+    })
   })
 
   test("lowers Amazon Bedrock provider and request options", () => {

packages/core/test/git.test.ts

@@ -4,7 +4,7 @@ import fs from "fs/promises"
 import path from "path"
 import { Effect } from "effect"
 import { Git } from "@opencode-ai/core/git"
-import { AbsolutePath } from "@opencode-ai/core/schema"
+import { AbsolutePath, RelativePath } from "@opencode-ai/core/schema"
 import { branch, commit, gitRemote } from "./fixture/git"
 import { tmpdir } from "./fixture/tmpdir"
 import { testEffect } from "./lib/effect"
@@ -16,14 +16,16 @@ describe("Git", () => {
     withRemote((fixture) =>
       Effect.gen(function* () {
         const git = yield* Git.Service
-        const target = path.join(fixture.root, "checkout")
-        const result = yield* git.clone({ remote: fixture.remote, target })
+        const target = AbsolutePath.make(path.join(fixture.root, "checkout"))
+        const repository = yield* git.repo.clone({ remote: fixture.remote, directory: target })
 
-        expect(result.exitCode).toBe(0)
-        expect(yield* git.origin(target)).toBe(fixture.remote)
-        expect(yield* git.head(target)).toBeString()
-        expect(yield* git.branch(target)).toBe("main")
-        expect(yield* git.remoteHead(target)).toBe("origin/main")
+        expect(yield* git.remote.get(repository)).toBe(fixture.remote)
+        expect(yield* git.history.head(repository)).toBeString()
+        expect(yield* git.history.branch(repository)).toBe("main")
+        expect(yield* git.history.defaultRemoteBranch(repository)).toBe("main")
+        expect(repository.worktree).toBe(target)
+        expect(repository.gitDirectory).toBe(AbsolutePath.make(path.join(target, ".git")))
+        expect(repository.commonDirectory).toBe(repository.gitDirectory)
         expect(yield* read(path.join(target, "README.md"))).toBe("one\n")
       }),
     ),
@@ -33,19 +35,19 @@ describe("Git", () => {
     withRemote((fixture) =>
       Effect.gen(function* () {
         const git = yield* Git.Service
-        const target = path.join(fixture.root, "checkout")
-        yield* git.clone({ remote: fixture.remote, target })
+        const target = AbsolutePath.make(path.join(fixture.root, "checkout"))
+        const repository = yield* git.repo.clone({ remote: fixture.remote, directory: target })
 
         yield* Effect.promise(() => commit(fixture.source, "two\n", "second"))
-        expect((yield* git.fetch(target)).exitCode).toBe(0)
-        expect((yield* git.reset(target, "origin/main")).exitCode).toBe(0)
+        yield* git.sync.fetchRemotes(repository)
+        yield* git.sync.resetHard(repository, "origin/main")
         expect(yield* read(path.join(target, "README.md"))).toBe("two\n")
 
         yield* Effect.promise(() => branch(fixture.source, "feature/docs", "feature\n"))
-        expect((yield* git.fetchBranch(target, "feature/docs")).exitCode).toBe(0)
-        expect((yield* git.checkout(target, "feature/docs")).exitCode).toBe(0)
-        expect((yield* git.reset(target, "origin/feature/docs")).exitCode).toBe(0)
-        expect(yield* git.branch(target)).toBe("feature/docs")
+        yield* git.sync.fetchBranch(repository, { branch: "feature/docs" })
+        yield* git.sync.checkoutRemoteBranch(repository, { branch: "feature/docs" })
+        yield* git.sync.resetHard(repository, "origin/feature/docs")
+        expect(yield* git.history.branch(repository)).toBe("feature/docs")
         expect(yield* read(path.join(target, "README.md"))).toBe("feature\n")
       }),
     ),
@@ -90,17 +92,72 @@ describe("Git worktrees", () => {
         Effect.promise(() => fs.rm(worktree, { recursive: true, force: true })).pipe(Effect.ignore),
       )
       const git = yield* Git.Service
-      const repo = { directory, store: AbsolutePath.make(path.join(directory, ".git")) }
+      const repo = yield* git.repo.discover(directory)
+      if (!repo) throw new Error("Repository not found")
 
-      yield* git.worktreeCreate({ repo, directory: worktree })
+      yield* git.worktree.create({ repository: repo, directory: worktree })
 
-      expect((yield* git.worktreeList(repo)).some((entry) => entry.endsWith("-git-worktree"))).toBe(true)
-      const linked = yield* git.find(worktree)
-      expect(linked?.directory).toBe(AbsolutePath.make(yield* Effect.promise(() => fs.realpath(worktree))))
-      expect(linked?.store).toBe(repo.store)
+      expect((yield* git.worktree.list(repo)).some((entry) => entry.directory.endsWith("-git-worktree"))).toBe(true)
+      const linked = yield* git.repo.discover(worktree)
+      expect(linked?.worktree).toBe(AbsolutePath.make(yield* Effect.promise(() => fs.realpath(worktree))))
+      expect(linked?.commonDirectory).toBe(repo.commonDirectory)
+      expect(linked?.gitDirectory).not.toBe(repo.gitDirectory)
       if (!linked) throw new Error("Linked worktree not found")
-      yield* git.worktreeRemove({ repo: linked, directory: worktree, force: false })
-      expect((yield* git.worktreeList(repo)).some((entry) => entry.endsWith("-git-worktree"))).toBe(false)
+      yield* git.worktree.remove({ repository: linked, directory: worktree, force: false })
+      expect((yield* git.worktree.list(repo)).some((entry) => entry.directory.endsWith("-git-worktree"))).toBe(false)
+    }),
+  )
+})
+
+describe("Git trees", () => {
+  it.live("captures, compares, previews, and restores scoped trees", () =>
+    Effect.gen(function* () {
+      const root = yield* Effect.acquireRelease(
+        Effect.promise(() => tmpdir()),
+        (dir) => Effect.promise(() => dir[Symbol.asyncDispose]()),
+      )
+      yield* Effect.promise(async () => {
+        await initRepo(root.path)
+        await fs.mkdir(path.join(root.path, "scope"))
+        await fs.writeFile(path.join(root.path, "scope", "tracked.txt"), "one\n")
+        await fs.writeFile(path.join(root.path, "outside.txt"), "outside\n")
+        await $`git add .`.cwd(root.path).quiet()
+        await $`git commit -m initial`.cwd(root.path).quiet()
+      })
+      const git = yield* Git.Service
+      const source = yield* git.repo.discover(AbsolutePath.make(root.path))
+      if (!source) throw new Error("Repository not found")
+      const storage = AbsolutePath.make(path.join(root.path, ".snapshot"))
+      const repository = yield* git.repo.create({ worktree: source.worktree, gitDirectory: storage, seed: source })
+      yield* git.index.refresh({ repository, scope: RelativePath.make("scope") })
+      const before = yield* git.tree.write(repository)
+
+      yield* Effect.promise(async () => {
+        await fs.writeFile(path.join(root.path, "scope", "tracked.txt"), "two\n")
+        await fs.writeFile(path.join(root.path, "scope", "added.txt"), "added\n")
+        await fs.writeFile(path.join(root.path, "outside.txt"), "changed outside\n")
+      })
+      yield* git.index.refresh({ repository, scope: RelativePath.make("scope") })
+      const after = yield* git.tree.write(repository)
+
+      expect(yield* git.tree.files({ repository, from: before, to: after })).toEqual([
+        RelativePath.make("scope/added.txt"),
+        RelativePath.make("scope/tracked.txt"),
+      ])
+      const diffs = yield* git.tree.diff({ repository, from: before, to: after, context: 1 })
+      expect(diffs.map((item) => [item.path, item.status])).toEqual([
+        [RelativePath.make("scope/added.txt"), "added"],
+        [RelativePath.make("scope/tracked.txt"), "modified"],
+      ])
+
+      const files = new Map([[RelativePath.make("scope/tracked.txt"), before]])
+      const preview = yield* git.tree.preview({ repository, current: after, files, context: 1 })
+      expect(preview).toHaveLength(1)
+      expect(preview[0]?.path).toBe(RelativePath.make("scope/tracked.txt"))
+      yield* git.tree.restore({ repository, files })
+      expect(yield* read(path.join(root.path, "scope", "tracked.txt"))).toBe("one\n")
+      expect(yield* read(path.join(root.path, "scope", "added.txt"))).toBe("added\n")
+      expect(yield* read(path.join(root.path, "outside.txt"))).toBe("changed outside\n")
     }),
   )
 })

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

@@ -14,6 +14,7 @@ import { ProjectTable } from "@opencode-ai/core/project/sql"
 import { ProjectDirectories } from "@opencode-ai/core/project/directories"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { SessionV2 } from "@opencode-ai/core/session"
+import { LocationServiceMap } from "@opencode-ai/core/location-layer"
 import { SessionExecution } from "@opencode-ai/core/session/execution"
 import { SessionProjector } from "@opencode-ai/core/session/projector"
 import { SessionTable } from "@opencode-ai/core/session/sql"
@@ -28,6 +29,7 @@ const project = Project.layer.pipe(
   Layer.provide(ProjectDirectories.defaultLayer),
 )
 const sessions = SessionV2.layer.pipe(
+  Layer.provide(LocationServiceMap.layer),
   Layer.provide(Database.defaultLayer),
   Layer.provide(EventV2.defaultLayer),
   Layer.provide(project),

packages/core/test/permission.test.ts

@@ -11,6 +11,7 @@ import { Project } from "@opencode-ai/core/project"
 import { ProjectTable } from "@opencode-ai/core/project/sql"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { SessionV2 } from "@opencode-ai/core/session"
+import { LocationServiceMap } from "@opencode-ai/core/location-layer"
 import { SessionTable } from "@opencode-ai/core/session/sql"
 import { SessionExecution } from "@opencode-ai/core/session/execution"
 import { SessionStore } from "@opencode-ai/core/session/store"
@@ -23,6 +24,7 @@ const current = Layer.succeed(
   Location.Service.of(location({ directory: AbsolutePath.make("/project") })),
 )
 const sessions = SessionV2.layer.pipe(
+  Layer.provide(LocationServiceMap.layer),
   Layer.provide(EventV2.defaultLayer),
   Layer.provide(Database.defaultLayer),
   Layer.provide(SessionStore.defaultLayer),

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

@@ -161,7 +161,7 @@ describe("OpencodePlugin", () => {
           expect(
             required(yield* catalog.model.get(ProviderV2.ID.make("remote"), ModelV2.ID.make("disabled"))).enabled,
           ).toBe(false)
-          expect(yield* catalog.model.get(ProviderV2.ID.make("remote"), ModelV2.ID.make("stale"))).toBeUndefined()
+          expect(yield* catalog.model.get(ProviderV2.ID.make("remote"), ModelV2.ID.make("stale"))).toBeDefined()
           expect(authorization).toContain("Bearer secret")
         }),
       ({ server }) => Effect.promise(() => server.stop(true)),

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

@@ -13,6 +13,7 @@ import { ProjectTable } from "@opencode-ai/core/project/sql"
 import { ProviderV2 } from "@opencode-ai/core/provider"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { SessionV2 } from "@opencode-ai/core/session"
+import { LocationServiceMap } from "@opencode-ai/core/location-layer"
 import { SessionV1 } from "@opencode-ai/core/v1/session"
 import { Prompt } from "@opencode-ai/core/session/prompt"
 import { SessionProjector } from "@opencode-ai/core/session/projector"
@@ -34,6 +35,7 @@ const projects = Layer.succeed(
   }),
 )
 const sessions = SessionV2.layer.pipe(
+  Layer.provide(LocationServiceMap.layer),
   Layer.provide(EventV2.defaultLayer),
   Layer.provide(Database.defaultLayer),
   Layer.provide(SessionStore.defaultLayer),

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

@@ -10,6 +10,7 @@ import { ProjectTable } from "@opencode-ai/core/project/sql"
 import { ProviderV2 } from "@opencode-ai/core/provider"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { SessionV2 } from "@opencode-ai/core/session"
+import { LocationServiceMap } from "@opencode-ai/core/location-layer"
 import { SessionEvent } from "@opencode-ai/core/session/event"
 import { SessionMessage } from "@opencode-ai/core/session/message"
 import { Prompt } from "@opencode-ai/core/session/prompt"
@@ -20,6 +21,7 @@ import { SessionInput } from "@opencode-ai/core/session/input"
 import { SessionStore } from "@opencode-ai/core/session/store"
 import { SessionInputTable, SessionMessageTable, SessionTable } from "@opencode-ai/core/session/sql"
 import { testEffect } from "./lib/effect"
+import { Snapshot } from "@opencode-ai/core/snapshot"
 
 const it = testEffect(Layer.mergeAll(Database.defaultLayer, EventV2.defaultLayer, SessionProjector.defaultLayer))
 const sessionID = SessionV2.ID.make("ses_projector_test")
@@ -41,6 +43,58 @@ const assistantRow = (
 }
 
 describe("SessionProjector", () => {
+  it.effect("projects staged, cleared, and committed reverts", () =>
+    Effect.gen(function* () {
+      const db = (yield* Database.Service).db
+      yield* db
+        .insert(ProjectTable)
+        .values({ id: Project.ID.global, worktree: AbsolutePath.make("/project"), sandboxes: [] })
+        .run()
+      yield* db
+        .insert(SessionTable)
+        .values({
+          id: sessionID,
+          project_id: Project.ID.global,
+          slug: "test",
+          directory: "/project",
+          title: "test",
+          version: "test",
+        })
+        .run()
+      const boundary = SessionMessage.ID.make("msg_boundary")
+      yield* db
+        .insert(SessionMessageTable)
+        .values([assistantRow(boundary, 1), assistantRow(SessionMessage.ID.make("msg_later"), 2)])
+        .run()
+      const events = yield* EventV2.Service
+      yield* events.publish(SessionEvent.RevertEvent.Staged, {
+        sessionID,
+        timestamp: DateTime.makeUnsafe(1),
+        revert: { messageID: boundary, snapshot: Snapshot.ID.make("tree"), diff: "patch", files: [] },
+      })
+      expect((yield* db.select({ revert: SessionTable.revert }).from(SessionTable).get())?.revert).toMatchObject({
+        messageID: boundary,
+        snapshot: "tree",
+        files: [],
+      })
+      yield* events.publish(SessionEvent.RevertEvent.Cleared, { sessionID, timestamp: DateTime.makeUnsafe(2) })
+      expect((yield* db.select({ revert: SessionTable.revert }).from(SessionTable).get())?.revert).toBeNull()
+      yield* events.publish(SessionEvent.RevertEvent.Staged, {
+        sessionID,
+        timestamp: DateTime.makeUnsafe(3),
+        revert: { messageID: boundary, files: [] },
+      })
+      yield* events.publish(SessionEvent.RevertEvent.Committed, {
+        sessionID,
+        messageID: boundary,
+        timestamp: DateTime.makeUnsafe(4),
+      })
+      expect(
+        (yield* db.select({ id: SessionMessageTable.id }).from(SessionMessageTable).all()).map((row) => row.id),
+      ).toEqual([boundary])
+    }),
+  )
+
   it.effect("orders projected messages and context by durable aggregate sequence", () =>
     Effect.gen(function* () {
       const { db } = yield* Database.Service
@@ -110,6 +164,7 @@ describe("SessionProjector", () => {
     }).pipe(
       Effect.provide(
         SessionV2.layer.pipe(
+          Layer.provide(LocationServiceMap.layer),
           Layer.provide(EventV2.defaultLayer),
           Layer.provide(Database.defaultLayer),
           Layer.provide(Project.defaultLayer),

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

@@ -9,6 +9,7 @@ import { Project } from "@opencode-ai/core/project"
 import { ProjectTable } from "@opencode-ai/core/project/sql"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { SessionV2 } from "@opencode-ai/core/session"
+import { LocationServiceMap } from "@opencode-ai/core/location-layer"
 import { Prompt } from "@opencode-ai/core/session/prompt"
 import { SessionMessage } from "@opencode-ai/core/session/message"
 import { SessionProjector } from "@opencode-ai/core/session/projector"
@@ -39,6 +40,7 @@ const execution = Layer.succeed(
   }),
 )
 const sessions = SessionV2.layer.pipe(
+  Layer.provide(LocationServiceMap.layer),
   Layer.provide(EventV2.defaultLayer),
   Layer.provide(Database.defaultLayer),
   Layer.provide(SessionStore.defaultLayer),

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

@@ -327,6 +327,83 @@ Recent work
     ])
   })
 
+  test("drops same-model provider metadata from errored turns without dropping useful output", () => {
+    const messages = toLLMMessages(
+      [
+        SessionMessage.Assistant.make({
+          id: id("assistant-error"),
+          type: "assistant",
+          agent: "build",
+          model: { id: ModelV2.ID.make("model"), providerID: ProviderV2.ID.make("provider") },
+          finish: "error",
+          error: { type: "unknown", message: "Interrupted" },
+          content: [
+            SessionMessage.AssistantText.make({ type: "text", id: "text-error", text: "Partial answer" }),
+            SessionMessage.AssistantReasoning.make({
+              type: "reasoning",
+              id: "reasoning-error",
+              text: "Visible thought",
+              providerMetadata: { openai: { reasoningEncryptedContent: "stale-secret" } },
+            }),
+            SessionMessage.AssistantTool.make({
+              type: "tool",
+              id: "tool-error",
+              name: "read",
+              provider: {
+                executed: false,
+                metadata: { openai: { itemId: "stale-call" } },
+                resultMetadata: { openai: { itemId: "stale-result" } },
+              },
+              state: SessionMessage.ToolStateError.make({
+                status: "error",
+                input: { path: "README.md" },
+                content: [{ type: "text", text: "Permission denied" }],
+                structured: {},
+                error: { type: "unknown", message: "Permission denied" },
+              }),
+              time: { created, completed: created },
+            }),
+          ],
+          time: { created, completed: created },
+        }),
+      ],
+      model,
+    )
+
+    expect(messages).toHaveLength(2)
+    expect(messages[0]?.content).toEqual([
+      { type: "text", text: "Partial answer" },
+      { type: "text", text: "Visible thought" },
+      {
+        type: "tool-call",
+        id: "tool-error",
+        name: "read",
+        input: { path: "README.md" },
+        providerExecuted: false,
+        providerMetadata: undefined,
+      },
+    ])
+    expect(messages[1]?.content).toEqual([
+      {
+        type: "tool-result",
+        id: "tool-error",
+        name: "read",
+        result: {
+          type: "error",
+          value: {
+            error: { type: "unknown", message: "Permission denied" },
+            content: [{ type: "text", text: "Permission denied" }],
+            structured: {},
+          },
+        },
+        providerExecuted: false,
+        cache: undefined,
+        metadata: undefined,
+        providerMetadata: undefined,
+      },
+    ])
+  })
+
   test("drops provider-native continuation metadata after a model switch", () => {
     const messages = toLLMMessages(
       [

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

@@ -12,6 +12,8 @@ import { Project } from "@opencode-ai/core/project"
 import { ProjectTable } from "@opencode-ai/core/project/sql"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { SessionV2 } from "@opencode-ai/core/session"
+import { LocationServiceMap } from "@opencode-ai/core/location-layer"
+import { Snapshot } from "@opencode-ai/core/snapshot"
 import { Prompt } from "@opencode-ai/core/session/prompt"
 import { SessionProjector } from "@opencode-ai/core/session/projector"
 import { SessionExecution } from "@opencode-ai/core/session/execution"
@@ -71,6 +73,7 @@ const skillGuidance = Layer.mock(SkillGuidance.Service, { load: () => Effect.suc
 const referenceGuidance = Layer.mock(ReferenceGuidance.Service, { load: () => Effect.succeed(SystemContext.empty) })
 const config = Layer.succeed(Config.Service, Config.Service.of({ entries: () => Effect.succeed([]) }))
 const runner = SessionRunnerLLM.defaultLayer.pipe(
+  Layer.provide(Snapshot.noopLayer),
   Layer.provide(Database.defaultLayer),
   Layer.provide(SessionStore.defaultLayer),
   Layer.provide(EventV2.defaultLayer),
@@ -99,6 +102,7 @@ const execution = Layer.effect(
   }),
 ).pipe(Layer.provide(runner))
 const sessions = SessionV2.layer.pipe(
+  Layer.provide(LocationServiceMap.layer),
   Layer.provide(EventV2.defaultLayer),
   Layer.provide(Database.defaultLayer),
   Layer.provide(SessionStore.defaultLayer),

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

@@ -125,3 +125,12 @@ test("old success event data containing result still decodes", () => {
   })
   expect(decoded.result).toMatchObject({ type: "content" })
 })
+
+test("step finish records settlement without publishing step ended", async () => {
+  const { published, publisher } = capture()
+  await Effect.runPromise(publisher.publish(LLMEvent.stepStart({ index: 0 })))
+  await Effect.runPromise(publisher.publish(LLMEvent.stepFinish({ index: 0, reason: "stop" })))
+
+  expect(published.some((event) => event.type === "session.next.step.ended.2")).toBe(false)
+  expect(publisher.stepSettlement()).toMatchObject({ finish: "stop" })
+})

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

@@ -4,6 +4,11 @@ import {
   LLMError,
   LLMEvent,
   Model,
+  HttpContext,
+  HttpRateLimitDetails,
+  HttpRequestDetails,
+  HttpResponseDetails,
+  RateLimitReason,
   TransportReason,
   InvalidRequestReason,
   type LLMClientShape,
@@ -19,6 +24,8 @@ import { ProjectTable } from "@opencode-ai/core/project/sql"
 import { QuestionV2 } from "@opencode-ai/core/question"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { SessionV2 } from "@opencode-ai/core/session"
+import { LocationServiceMap } from "@opencode-ai/core/location-layer"
+import { Snapshot } from "@opencode-ai/core/snapshot"
 import { ContextSnapshotDecodeError } from "@opencode-ai/core/session/error"
 import { SessionEvent } from "@opencode-ai/core/session/event"
 import { SessionInput } from "@opencode-ai/core/session/input"
@@ -230,6 +237,7 @@ const config = Layer.succeed(
   }),
 )
 const runner = SessionRunnerLLM.layer.pipe(
+  Layer.provide(Snapshot.noopLayer),
   Layer.provide(Database.defaultLayer),
   Layer.provide(SessionStore.defaultLayer),
   Layer.provide(EventV2.defaultLayer),
@@ -258,6 +266,7 @@ const execution = Layer.effect(
   }),
 ).pipe(Layer.provide(runner))
 const sessions = SessionV2.layer.pipe(
+  Layer.provide(LocationServiceMap.layer),
   Layer.provide(EventV2.defaultLayer),
   Layer.provide(Database.defaultLayer),
   Layer.provide(SessionStore.defaultLayer),
@@ -515,7 +524,7 @@ const verifyPartialFlushOnFailure = (kind: FragmentKind) =>
       {
         type: "assistant",
         finish: "error",
-        error: { type: "unknown", message: "Provider unavailable" },
+        error: { type: "provider", category: "transport", message: "Provider connection failed", retryable: false },
         content: [fixture.expectedContent],
       },
     ])
@@ -2980,11 +2989,106 @@ describe("SessionRunnerLLM", () => {
       yield* replaySessionProjection(sessionID)
       expect(yield* session.context(sessionID)).toMatchObject([
         { type: "user", text: "Fail raw stream durably" },
-        { type: "assistant", finish: "error", error: { type: "unknown", message: "Provider unavailable" } },
+        {
+          type: "assistant",
+          finish: "error",
+          error: { type: "provider", category: "transport", message: "Provider connection failed", retryable: false },
+        },
       ])
     }),
   )
 
+  it.effect("preserves sanitized HTTP rate-limit details in the durable event and projection", () =>
+    Effect.gen(function* () {
+      yield* setup
+      const session = yield* SessionV2.Service
+      const db = yield* Database.Service
+      yield* session.prompt({ sessionID, prompt: Prompt.make({ text: "Fail with rate limit" }), resume: false })
+      const failure = new LLMError({
+        module: "RequestExecutor",
+        method: "execute",
+        reason: new RateLimitReason({
+          message: "secret provider response message",
+          retryAfterMs: 12_000,
+          rateLimit: new HttpRateLimitDetails({ retryAfterMs: 12_000, limit: { requests: "secret-limit" } }),
+          http: new HttpContext({
+            request: new HttpRequestDetails({
+              method: "POST",
+              url: "https://secret.example/v1/responses?api_key=credential",
+              headers: { authorization: "Bearer credential" },
+            }),
+            response: new HttpResponseDetails({ status: 429, headers: { "x-secret": "secret-header" } }),
+            body: '{"secret":"provider body"}',
+            requestId: "secret-request-id",
+          }),
+        }),
+      })
+      responseStream = Stream.fail(failure)
+
+      expect(yield* session.resume(sessionID).pipe(Effect.flip)).toBe(failure)
+
+      const event = yield* db.db
+        .select({ data: EventTable.data })
+        .from(EventTable)
+        .where(eq(EventTable.type, EventV2.versionedType(SessionEvent.Step.Failed.type, 2)))
+        .get()
+        .pipe(Effect.orDie)
+      const expected = {
+        type: "provider",
+        category: "rate-limit",
+        message: "Provider rate limit exceeded",
+        status: 429,
+        retryable: true,
+        retryAfterMs: 12_000,
+      }
+      expect(event?.data.error).toEqual(expected)
+      expect(yield* session.context(sessionID)).toMatchObject([
+        { type: "user", text: "Fail with rate limit" },
+        { type: "assistant", finish: "error", error: expected },
+      ])
+      expect(JSON.stringify(event)).not.toMatch(
+        /secret provider|secret\.example|credential|secret-header|provider body|secret-request-id|secret-limit/,
+      )
+      expect(JSON.stringify(yield* session.context(sessionID))).not.toMatch(
+        /secret provider|secret\.example|credential|secret-header|provider body|secret-request-id|secret-limit/,
+      )
+    }),
+  )
+
+  it.effect("projects in-band rate limits without fabricating an HTTP status", () =>
+    Effect.gen(function* () {
+      yield* setup
+      const session = yield* SessionV2.Service
+      yield* session.prompt({ sessionID, prompt: Prompt.make({ text: "Fail in band" }), resume: false })
+      response = [
+        LLMEvent.providerError({
+          message: "rate_limit_exceeded: secret provider message",
+          category: "rate-limit",
+          retryable: true,
+        }),
+      ]
+
+      yield* session.resume(sessionID)
+
+      expect(yield* session.context(sessionID)).toMatchObject([
+        { type: "user", text: "Fail in band" },
+        {
+          type: "assistant",
+          finish: "error",
+          error: {
+            type: "provider",
+            category: "rate-limit",
+            message: "Provider rate limit exceeded",
+            retryable: true,
+          },
+        },
+      ])
+      const assistant = (yield* session.context(sessionID))[1]
+      expect(assistant?.type === "assistant" ? assistant.error : undefined).not.toHaveProperty("status")
+      expect(JSON.stringify(assistant)).not.toContain("secret provider message")
+    }),
+  )
+
   it.effect("does not continue automatically after a provider error follows a local tool call", () =>
     Effect.gen(function* () {
       yield* setup
@@ -3096,7 +3200,12 @@ describe("SessionRunnerLLM", () => {
         {
           type: "assistant",
           finish: "error",
-          error: { type: "unknown", message: "Provider unavailable" },
+          error: {
+            type: "provider",
+            category: "transport",
+            message: "Provider connection failed",
+            retryable: false,
+          },
           content: [{ type: "tool", id: "call-hosted-raw-failure", state: { status: "error" } }],
         },
       ])

packages/core/test/shared-schema.test.ts

@@ -122,6 +122,8 @@ test("Core reuses the canonical shared schemas", async () => {
     [coreSessionInput.Admitted, SessionInput.Admitted],
     [coreSessionMessage.ID, SessionMessage.ID],
     [coreSessionMessage.UnknownError, SessionMessage.UnknownError],
+    [coreSessionMessage.ProviderError, SessionMessage.ProviderError],
+    [coreSessionMessage.Error, SessionMessage.Error],
     [coreSessionMessage.AgentSwitched, SessionMessage.AgentSwitched],
     [coreSessionMessage.ModelSwitched, SessionMessage.ModelSwitched],
     [coreSessionMessage.User, SessionMessage.User],
@@ -178,3 +180,17 @@ test("shared record schemas construct and decode plain objects", () => {
   expect(Prompt.fromUserMessage({ text: "hello" })).toEqual(made)
   expect(Workspace.ID.ascending("")).toStartWith("wrk_")
 })
+
+test("assistant errors retain legacy unknown decode compatibility", () => {
+  const assistant = Schema.decodeUnknownSync(SessionMessage.Assistant)({
+    id: "msg_legacy_error",
+    type: "assistant",
+    agent: "build",
+    model: { id: "model", providerID: "provider" },
+    content: [],
+    error: { type: "unknown", message: "Legacy failure" },
+    time: { created: 0 },
+  })
+
+  expect(assistant.error).toEqual({ type: "unknown", message: "Legacy failure" })
+})