fix(core): prioritize manual compaction

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

@@ -8,7 +8,7 @@ import type {
   QuestionRequest,
   Session,
   SessionStatus,
-  FileDiffInfo,
+  SnapshotFileDiff,
   Todo,
 } from "@opencode-ai/sdk/v2/client"
 import type { State, VcsCache } from "./types"
@@ -188,7 +188,7 @@ export function applyDirectoryEvent(input: {
       break
     }
     case "session.diff": {
-      const props = event.properties as { sessionID: string; diff: FileDiffInfo[] }
+      const props = event.properties as { sessionID: string; diff: SnapshotFileDiff[] }
       input.setStore("session_diff", props.sessionID, reconcile(list(props.diff), { key: "file" }))
       break
     }

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

@@ -5,7 +5,7 @@ import type {
   PermissionRequest,
   QuestionRequest,
   SessionStatus,
-  FileDiffInfo,
+  SnapshotFileDiff,
   Todo,
 } from "@opencode-ai/sdk/v2/client"
 import { dropSessionCaches, pickSessionCacheEvictions } from "./session-cache"
@@ -33,7 +33,7 @@ describe("app session cache", () => {
   test("dropSessionCaches clears orphaned parts without message rows", () => {
     const store: {
       session_status: Record<string, SessionStatus | undefined>
-      session_diff: Record<string, FileDiffInfo[] | undefined>
+      session_diff: Record<string, SnapshotFileDiff[] | undefined>
       todo: Record<string, Todo[] | undefined>
       message: Record<string, Message[] | undefined>
       part: Record<string, Part[] | undefined>
@@ -67,7 +67,7 @@ describe("app session cache", () => {
     const m = msg("msg_1", "ses_1")
     const store: {
       session_status: Record<string, SessionStatus | undefined>
-      session_diff: Record<string, FileDiffInfo[] | undefined>
+      session_diff: Record<string, SnapshotFileDiff[] | undefined>
       todo: Record<string, Todo[] | undefined>
       message: Record<string, Message[] | undefined>
       part: Record<string, Part[] | undefined>

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

@@ -4,7 +4,7 @@ import type {
   PermissionRequest,
   QuestionRequest,
   SessionStatus,
-  FileDiffInfo,
+  SnapshotFileDiff,
   Todo,
 } from "@opencode-ai/sdk/v2/client"
 
@@ -12,7 +12,7 @@ export const SESSION_CACHE_LIMIT = 40
 
 type SessionCache = {
   session_status: Record<string, SessionStatus | undefined>
-  session_diff: Record<string, FileDiffInfo[] | undefined>
+  session_diff: Record<string, SnapshotFileDiff[] | undefined>
   todo: Record<string, Todo[] | undefined>
   message: Record<string, Message[] | undefined>
   part: Record<string, Part[] | undefined>

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

@@ -13,7 +13,7 @@ import type {
   ReferenceInfo,
   Session,
   SessionStatus,
-  FileDiffInfo,
+  SnapshotFileDiff,
   Todo,
   VcsInfo,
 } from "@opencode-ai/sdk/v2/client"
@@ -51,7 +51,7 @@ export type State = {
   }
   session_working(id: string): boolean
   session_diff: {
-    [sessionID: string]: FileDiffInfo[]
+    [sessionID: string]: SnapshotFileDiff[]
   }
   todo: {
     [sessionID: string]: Todo[]

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

@@ -8,7 +8,7 @@ import type {
   QuestionRequest,
   Session,
   SessionStatus,
-  FileDiffInfo,
+  SnapshotFileDiff,
   Todo,
 } from "@opencode-ai/sdk/v2/client"
 import { batch } from "solid-js"
@@ -139,7 +139,7 @@ export function createServerSession(client: OpencodeClient, options?: { retry?:
   const [data, setData] = createStore({
     info: {} as Record<string, Session | undefined>,
     session_status: {} as Record<string, SessionStatus>,
-    session_diff: {} as Record<string, FileDiffInfo[]>,
+    session_diff: {} as Record<string, SnapshotFileDiff[]>,
     todo: {} as Record<string, Todo[]>,
     permission: {} as Record<string, PermissionRequest[]>,
     question: {} as Record<string, QuestionRequest[]>,
@@ -769,7 +769,7 @@ export function createServerSession(client: OpencodeClient, options?: { retry?:
         return
       }
       case "session.diff": {
-        const props = event.properties as { sessionID: string; diff: FileDiffInfo[] }
+        const props = event.properties as { sessionID: string; diff: SnapshotFileDiff[] }
         setData("session_diff", props.sessionID, reconcile(cleanDiffs(props.diff), { key: "file" }))
         return
       }

packages/app/src/pages/session/review-tab.tsx

@@ -1,6 +1,6 @@
 import { createEffect, onCleanup, type JSX } from "solid-js"
 import { makeEventListener } from "@solid-primitives/event-listener"
-import type { FileDiffInfo, VcsFileDiff } from "@opencode-ai/sdk/v2"
+import type { SnapshotFileDiff, VcsFileDiff } from "@opencode-ai/sdk/v2"
 import { SessionReview } from "@opencode-ai/session-ui/session-review"
 import type {
   SessionReviewCommentActions,
@@ -14,7 +14,7 @@ import type { LineComment } from "@/context/comments"
 
 export type DiffStyle = "unified" | "split"
 
-type ReviewDiff = FileDiffInfo | VcsFileDiff
+type ReviewDiff = SnapshotFileDiff | VcsFileDiff
 
 export interface SessionReviewTabProps {
   title?: JSX.Element

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

@@ -8,7 +8,7 @@ import { ResizeHandle } from "@opencode-ai/ui/resize-handle"
 import { Mark } from "@opencode-ai/ui/logo"
 import { DragDropProvider, DragDropSensors, DragOverlay, SortableProvider, closestCenter } from "@thisbeyond/solid-dnd"
 import type { DragEvent } from "@thisbeyond/solid-dnd"
-import type { FileDiffInfo, VcsFileDiff } from "@opencode-ai/sdk/v2"
+import type { SnapshotFileDiff, VcsFileDiff } from "@opencode-ai/sdk/v2"
 import { ConstrainDragYAxis, getDraggableId } from "@/utils/solid-dnd"
 import { useDialog } from "@opencode-ai/ui/context/dialog"
 
@@ -23,6 +23,7 @@ import { useFile, type SelectedLineRange } from "@/context/file"
 import { useLanguage } from "@/context/language"
 import { useLayout } from "@/context/layout"
 import { useSettings } from "@/context/settings"
+import { useSync } from "@/context/sync"
 import { createFileTabListSync } from "@/pages/session/file-tab-scroll"
 import { FileTabContent } from "@/pages/session/file-tabs"
 import {
@@ -35,9 +36,15 @@ import {
 import { setSessionHandoff } from "@/pages/session/handoff"
 import { useSessionLayout } from "@/pages/session/session-layout"
 
+type RenderDiff = (SnapshotFileDiff & { file: string }) | VcsFileDiff
+
+function renderDiff(value: SnapshotFileDiff | VcsFileDiff): value is RenderDiff {
+  return typeof value.file === "string"
+}
+
 export function SessionSidePanel(props: {
   canReview: () => boolean
-  diffs: () => (FileDiffInfo | VcsFileDiff)[]
+  diffs: () => (SnapshotFileDiff | VcsFileDiff)[]
   diffsReady: () => boolean
   empty: () => string
   hasReview: () => boolean
@@ -52,6 +59,7 @@ export function SessionSidePanel(props: {
 }) {
   const layout = useLayout()
   const settings = useSettings()
+  const sync = useSync()
   const file = useFile()
   const language = useLanguage()
   const command = useCommand()
@@ -80,7 +88,7 @@ export function SessionSidePanel(props: {
   })
   const treeWidth = createMemo(() => (fileOpen() ? `${layout.fileTree.width()}px` : "0px"))
 
-  const diffs = createMemo(() => props.diffs())
+  const diffs = createMemo(() => props.diffs().filter(renderDiff))
   const diffFiles = createMemo(() => diffs().map((d) => d.file))
   const kinds = createMemo(() => {
     const merge = (a: "add" | "del" | "mix" | undefined, b: "add" | "del" | "mix") => {

packages/app/src/pages/session/v2/review-diff-kinds.ts

@@ -1,13 +1,17 @@
-import type { FileDiffInfo, VcsFileDiff } from "@opencode-ai/sdk/v2"
+import type { SnapshotFileDiff, VcsFileDiff } from "@opencode-ai/sdk/v2"
 import type { Kind } from "@/components/file-tree-v2"
 import { normalizeFileTreeV2Path } from "@/components/file-tree-v2-model"
 
-export type RenderDiff = FileDiffInfo | VcsFileDiff
+export type RenderDiff = (SnapshotFileDiff & { file: string }) | VcsFileDiff
 
 export function normalizePath(p: string) {
   return normalizeFileTreeV2Path(p)
 }
 
+export function filterRenderableDiff(value: SnapshotFileDiff | VcsFileDiff): value is RenderDiff {
+  return typeof value.file === "string"
+}
+
 export function reviewDiffKinds(diffs: RenderDiff[]) {
   const merge = (a: Kind | undefined, b: Kind) => {
     if (!a) return b

packages/app/src/pages/session/v2/review-panel-v2.tsx

@@ -1,5 +1,5 @@
 import { createMemo, createSignal, Show, type JSX } from "solid-js"
-import type { FileDiffInfo, VcsFileDiff } from "@opencode-ai/sdk/v2"
+import type { SnapshotFileDiff, VcsFileDiff } from "@opencode-ai/sdk/v2"
 import {
   SESSION_REVIEW_V2_SIDEBAR_WIDTH_MAX,
   SESSION_REVIEW_V2_SIDEBAR_WIDTH_MIN,
@@ -21,11 +21,16 @@ import type {
 import FileTreeV2 from "@/components/file-tree-v2"
 import { useLanguage } from "@/context/language"
 import { useSDK } from "@/context/sdk"
-import { filterReviewFiles, reviewDiffKinds, type RenderDiff } from "@/pages/session/v2/review-diff-kinds"
+import {
+  filterRenderableDiff,
+  filterReviewFiles,
+  reviewDiffKinds,
+  type RenderDiff,
+} from "@/pages/session/v2/review-diff-kinds"
 import type { ReviewPanelV2State } from "@/pages/session/v2/review-panel-v2-state"
 import { applyFileListKeyDown, SessionFileListV2 } from "@/pages/session/v2/session-file-list-v2"
 
-type ReviewDiff = FileDiffInfo | VcsFileDiff
+type ReviewDiff = SnapshotFileDiff | VcsFileDiff
 
 export type ReviewPanelV2Props = {
   title?: JSX.Element
@@ -49,7 +54,7 @@ export type ReviewPanelV2Props = {
 export function ReviewPanelV2(props: ReviewPanelV2Props) {
   const sdk = useSDK()
 
-  const diffs = createMemo(() => props.diffs())
+  const diffs = createMemo(() => props.diffs().filter(filterRenderableDiff))
   const filteredFiles = createMemo(() =>
     filterReviewFiles(
       diffs().map((diff) => diff.file),

packages/app/src/utils/diffs.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test"
-import type { FileDiffInfo } from "@opencode-ai/sdk/v2"
+import type { SnapshotFileDiff } from "@opencode-ai/sdk/v2"
 import type { Message } from "@opencode-ai/sdk/v2/client"
 import { diffs, message } from "./diffs"
 
@@ -9,7 +9,7 @@ const item = {
   additions: 1,
   deletions: 1,
   status: "modified",
-} satisfies FileDiffInfo
+} satisfies SnapshotFileDiff
 
 describe("diffs", () => {
   test("keeps valid arrays", () => {

packages/app/src/utils/diffs.ts

@@ -1,7 +1,7 @@
-import type { FileDiffInfo } from "@opencode-ai/sdk/v2"
+import type { SnapshotFileDiff, VcsFileDiff } from "@opencode-ai/sdk/v2"
 import type { Message } from "@opencode-ai/sdk/v2/client"
 
-type Diff = FileDiffInfo
+type Diff = SnapshotFileDiff | VcsFileDiff
 
 function diff(value: unknown): value is Diff {
   if (!value || typeof value !== "object" || Array.isArray(value)) return false

packages/cli/src/mini/catalog.shared.ts

@@ -37,8 +37,7 @@ function defaultCost(model: CurrentModel) {
 
 export function runAgent(input: CurrentAgent): RunAgent {
   return {
-    id: input.id,
-    name: input.name,
+    name: input.id,
     description: input.description,
     mode: input.mode,
     hidden: input.hidden,
@@ -54,7 +53,7 @@ export function runCommand(input: CurrentCommand): RunCommand {
 
 export function runSkill(input: CurrentSkill): RunCommand {
   return {
-    name: input.id,
+    name: input.name,
     description: input.description,
     source: "skill",
   }

packages/cli/src/mini/footer.prompt.tsx

@@ -333,10 +333,10 @@ export function createPromptState(input: PromptInput): PromptState {
       .map((item) => ({
         kind: "mention",
         display: "@" + item.name,
-        value: item.id,
+        value: item.name,
         part: {
           type: "agent",
-          name: item.id,
+          name: item.name,
           source: {
             start: 0,
             end: 0,

packages/cli/src/mini/noninteractive.ts

@@ -281,6 +281,7 @@ export async function runNonInteractivePrompt(input: Input) {
             metadata: {
               structured: event.data.structured,
               content: event.data.content,
+              outputPaths: event.data.outputPaths,
               result: event.data.result,
               providerCall: current.provider,
               providerResult: { executed: event.data.executed, state: event.data.resultState },

packages/cli/src/mini/run.ts

@@ -89,11 +89,12 @@ async function execute(input: RunCommandInput, prepared: Prepared, transport: Tr
     !explicitModel && !sessionModel
       ? await client.model
           .default({ location: { directory: cwd, workspace } })
-          .then((result) => (result.data ? { providerID: result.data.providerID, modelID: result.data.id } : undefined))
+          .then((result) =>
+            result.data ? { providerID: result.data.providerID, modelID: result.data.id } : undefined,
+          )
       : undefined
   const model = pickRunModel(explicitModel, input.variant, sessionModel, defaultModel)
-  if (input.variant && !model)
-    return reportError(input, "Cannot select a variant before selecting a model", session?.id)
+  if (input.variant && !model) return reportError(input, "Cannot select a variant before selecting a model", session?.id)
   if (model) {
     await waitForCatalogReady({ sdk: client, directory: cwd, workspace, model })
     const available = await client.model.list({ location: { directory: cwd, workspace } })
@@ -111,7 +112,9 @@ async function execute(input: RunCommandInput, prepared: Prepared, transport: Tr
   if (!session && input.title !== undefined) {
     await client.session.rename({
       sessionID: selected.id,
-      title: input.title || prepared.message.slice(0, 50) + (prepared.message.length > 50 ? "..." : ""),
+      title:
+        input.title ||
+        prepared.message.slice(0, 50) + (prepared.message.length > 50 ? "..." : ""),
     })
   }
 
@@ -197,7 +200,7 @@ async function validateAgent(client: OpenCodeClient, directory: string, name?: s
     warning(`failed to list agents${server ? ` from ${server}` : ""}. Falling back to default agent`)
     return
   }
-  const agent = agents.find((item) => item.id === name)
+  const agent = agents.find((item) => item.name === name)
   if (!agent) {
     warning(`agent "${name}" not found. Falling back to default agent`)
     return

packages/cli/src/mini/stream-v2.subagent.ts

@@ -16,7 +16,7 @@
 // backgrounding is intentionally absent: subagent jobs block the parent
 // session, so only whole-session `v2.session.background(parentID)` exists.
 import type { EventSubscribeOutput, OpenCodeClient } from "@opencode-ai/client/promise"
-import type { SessionMessageAssistantTool, SessionMessageInfo, ToolPart } from "@opencode-ai/sdk/v2"
+import type { SessionMessage, SessionMessageAssistantTool, ToolPart } from "@opencode-ai/sdk/v2"
 import { Locale } from "@opencode-ai/tui/util/locale"
 import type { FooterSubagentDetail, FooterSubagentState, FooterSubagentTab, StreamCommit } from "./types"
 
@@ -54,7 +54,7 @@ export function legacyTool(input: {
     callID: tool.id,
     tool: tool.name,
   }
-  if (tool.state.status === "streaming") {
+  if (tool.state.status === "pending") {
     return {
       ...base,
       state: { status: "pending", input: {}, raw: tool.state.input },
@@ -83,6 +83,7 @@ export function legacyTool(input: {
         metadata: {
           structured: tool.state.structured,
           content: tool.state.content,
+          outputPaths: tool.state.outputPaths,
           result: tool.state.result,
           providerCall,
           providerResult,
@@ -178,7 +179,7 @@ export type SubagentTrackerInput = {
 export type SubagentTracker = {
   main(event: V2Event): void
   foreign(sessionID: string, event: V2Event): void
-  hydrate(next: { messages: SessionMessageInfo[]; active: Record<string, unknown> }): Promise<void>
+  hydrate(next: { messages: SessionMessage[]; active: Record<string, unknown> }): Promise<void>
   select(sessionID: string | undefined): void
   snapshot(): FooterSubagentState
 }
@@ -315,7 +316,7 @@ export function createSubagentTracker(input: SubagentTrackerInput): SubagentTrac
       messageID,
       tool: item,
     })
-    if (item.state.status === "streaming") return
+    if (item.state.status === "pending") return
     child.callIDs.add(item.id)
     if (item.state.status === "running") {
       setFrame(child, `tool:${item.id}`, toolCommit(part, "start"))
@@ -326,7 +327,7 @@ export function createSubagentTracker(input: SubagentTrackerInput): SubagentTrac
     setFrame(child, `tool:${item.id}`, toolCommit(part, "final"))
   }
 
-  const rebuild = (child: ChildState, messages: SessionMessageInfo[]) => {
+  const rebuild = (child: ChildState, messages: SessionMessage[]) => {
     child.frames = []
     child.text.clear()
     child.projectedText.clear()
@@ -411,7 +412,7 @@ export function createSubagentTracker(input: SubagentTrackerInput): SubagentTrac
         for (const [id, prompt] of pendingPrompts) {
           if (!child.prompts.has(id)) child.prompts.set(id, prompt)
         }
-        rebuild(child, structuredClone(response.data).toReversed() as SessionMessageInfo[])
+        rebuild(child, structuredClone(response.data).toReversed() as SessionMessage[])
         for (const [id, tool] of pendingTools) {
           if (!child.finishedTools.has(id) && !child.tools.has(id)) child.tools.set(id, tool)
         }
@@ -621,6 +622,7 @@ export function createSubagentTracker(input: SubagentTrackerInput): SubagentTrac
                 input: current?.input ?? {},
                 structured: event.data.structured,
                 content: event.data.content,
+                outputPaths: event.data.outputPaths,
                 result: event.data.result,
               },
           time: {

packages/cli/src/mini/stream-v2.transport.ts

@@ -2,7 +2,7 @@ import type { EventSubscribeOutput, OpenCodeClient } from "@opencode-ai/client/p
 import type {
   PermissionRequest,
   QuestionRequest,
-  SessionMessageInfo,
+  SessionMessage,
   SessionMessageAssistantTool,
 } from "@opencode-ai/sdk/v2"
 import { Event } from "@opencode-ai/schema/event"
@@ -389,7 +389,7 @@ export async function createSessionTransport(input: StreamInput): Promise<Sessio
       messageID,
       tool: item,
     })
-    if (item.state.status === "streaming") return
+    if (item.state.status === "pending") return
     if (item.state.status === "running") {
       if (state.tools.get(item.id)?.running) return
       state.tools.set(item.id, {
@@ -417,7 +417,7 @@ export async function createSessionTransport(input: StreamInput): Promise<Sessio
     ])
   }
 
-  const renderMessage = (message: SessionMessageInfo, render: boolean, reuseVisibleWait: boolean) => {
+  const renderMessage = (message: SessionMessage, render: boolean, reuseVisibleWait: boolean) => {
     if (message.type === "user") {
       const waiting = state.wait?.messageID === message.id
       if (waiting && state.wait) state.wait.promoted = true
@@ -438,34 +438,34 @@ export async function createSessionTransport(input: StreamInput): Promise<Sessio
       return
     }
     if (message.type === "shell") {
-      state.shellCommands.set(message.shellID, message.command)
-      if (state.shellWait?.messageID === message.id) state.shellWait.callID = message.shellID
+      state.shellCommands.set(message.shell.id, message.shell.command)
+      if (state.shellWait?.messageID === message.id) state.shellWait.callID = message.shell.id
       const completed = message.time.completed !== undefined
       if (!render) {
         // Suppressed history: mark settled shells rendered so live redelivery
         // stays silent. A still-running shell stays unmarked and renders in
         // full when its live shell.ended event arrives.
         if (completed) {
-          state.shellStarted.add(message.shellID)
-          state.shellEnded.add(message.shellID)
+          state.shellStarted.add(message.shell.id)
+          state.shellEnded.add(message.shell.id)
         }
         return
       }
-      if (!state.shellStarted.has(message.shellID)) {
-        state.shellStarted.add(message.shellID)
+      if (!state.shellStarted.has(message.shell.id)) {
+        state.shellStarted.add(message.shell.id)
         write([
-          shellCommit(message.shellID, message.command, {
+          shellCommit(message.shell.id, message.shell.command, {
             text: "running shell",
             phase: "start",
             toolState: "running",
           }),
         ])
       }
-      if (completed && message.output && !state.shellEnded.has(message.shellID)) {
-        state.shellEnded.add(message.shellID)
-        write(shellTerminal(message.shellID, message.command, message, message.output))
+      if (completed && message.output && !state.shellEnded.has(message.shell.id)) {
+        state.shellEnded.add(message.shell.id)
+        write(shellTerminal(message.shell.id, message.shell.command, message.shell, message.output))
       }
-      if (completed && state.shellWait?.callID === message.shellID) state.shellWait.resolve()
+      if (completed && state.shellWait?.callID === message.shell.id) state.shellWait.resolve()
       return
     }
     if (message.type !== "assistant") return
@@ -534,7 +534,7 @@ export async function createSessionTransport(input: StreamInput): Promise<Sessio
       input.sdk.question.list({ sessionID: input.sessionID }),
       input.sdk.session.active(),
     ])
-    const projected = structuredClone(messages.data).toReversed() as SessionMessageInfo[]
+    const projected = structuredClone(messages.data).toReversed() as SessionMessage[]
     for (const message of projected) renderMessage(message, next.render, next.reuseVisibleWait)
     state.permissions = permissions.map(permission)
     state.questions = questions.map(question)
@@ -762,6 +762,7 @@ export async function createSessionTransport(input: StreamInput): Promise<Sessio
               input: current?.input ?? {},
               structured: event.data.structured,
               content: event.data.content,
+              outputPaths: event.data.outputPaths,
               result: event.data.result,
             },
         time: { created: current?.started ?? event.created, ran: current?.started, completed: event.created },

packages/cli/src/mini/types.ts

@@ -113,7 +113,6 @@ export type FooterQueuedPrompt = {
 }
 
 export type RunAgent = {
-  id: string
   name: string
   description?: string
   mode: "subagent" | "primary" | "all"

packages/client/src/effect/api.ts

@@ -1,9 +1,7 @@
-import type { ModelApi, ProviderApi, WebsearchApi } from "./api/api.js"
+import type { ModelApi, ProviderApi } from "./api/api.js"
 
 export type * from "./api/api.js"
 
-export type WebSearchApi<E = never> = WebsearchApi<E>
-
 export interface CatalogApi<E = never> {
   readonly provider: ProviderApi<E>
   readonly model: ModelApi<E>

packages/client/src/effect/api/api.ts

@@ -923,40 +923,6 @@ export interface DebugApi<E = never> {
   readonly location: { readonly list: DebugLocationListOperation<E>; readonly evict: DebugLocationEvictOperation<E> }
 }
 
-type Endpoint26_0Request = Parameters<RawClient["server.websearch"]["websearch.provider.get"]>[0]
-export type Endpoint26_0Input = { readonly location?: Endpoint26_0Request["query"]["location"] }
-export type Endpoint26_0Output = EffectValue<ReturnType<RawClient["server.websearch"]["websearch.provider.get"]>>
-export type WebsearchProviderGetOperation<E = never> = (
-  input?: Endpoint26_0Input,
-) => Effect.Effect<Endpoint26_0Output, E>
-
-type Endpoint26_1Request = Parameters<RawClient["server.websearch"]["websearch.provider.select"]>[0]
-export type Endpoint26_1Input = {
-  readonly location?: Endpoint26_1Request["query"]["location"]
-  readonly providerID: Endpoint26_1Request["payload"]["providerID"]
-}
-export type Endpoint26_1Output = EffectValue<ReturnType<RawClient["server.websearch"]["websearch.provider.select"]>>
-export type WebsearchProviderSelectOperation<E = never> = (
-  input: Endpoint26_1Input,
-) => Effect.Effect<Endpoint26_1Output, E>
-
-type Endpoint26_2Request = Parameters<RawClient["server.websearch"]["websearch.query"]>[0]
-export type Endpoint26_2Input = {
-  readonly location?: Endpoint26_2Request["query"]["location"]
-  readonly query: Endpoint26_2Request["payload"]["query"]
-  readonly providerID?: Endpoint26_2Request["payload"]["providerID"]
-}
-export type Endpoint26_2Output = EffectValue<ReturnType<RawClient["server.websearch"]["websearch.query"]>>
-export type WebsearchQueryOperation<E = never> = (input: Endpoint26_2Input) => Effect.Effect<Endpoint26_2Output, E>
-
-export interface WebsearchApi<E = never> {
-  readonly provider: {
-    readonly get: WebsearchProviderGetOperation<E>
-    readonly select: WebsearchProviderSelectOperation<E>
-  }
-  readonly query: WebsearchQueryOperation<E>
-}
-
 export interface AppApi<E = never> {
   readonly health: HealthApi<E>
   readonly location: LocationApi<E>
@@ -984,5 +950,4 @@ export interface AppApi<E = never> {
   readonly projectCopy: ProjectCopyApi<E>
   readonly vcs: VcsApi<E>
   readonly debug: DebugApi<E>
-  readonly websearch: WebsearchApi<E>
 }

packages/client/src/effect/generated/client.ts

@@ -1099,39 +1099,6 @@ const adaptGroup25 = (raw: RawClient["server.debug"]) => ({
   location: { list: Endpoint25_0(raw), evict: Endpoint25_1(raw) },
 })
 
-type Endpoint26_0Request = Parameters<RawClient["server.websearch"]["websearch.provider.get"]>[0]
-type Endpoint26_0Input = { readonly location?: Endpoint26_0Request["query"]["location"] }
-const Endpoint26_0 = (raw: RawClient["server.websearch"]) => (input?: Endpoint26_0Input) =>
-  raw["websearch.provider.get"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))
-
-type Endpoint26_1Request = Parameters<RawClient["server.websearch"]["websearch.provider.select"]>[0]
-type Endpoint26_1Input = {
-  readonly location?: Endpoint26_1Request["query"]["location"]
-  readonly providerID: Endpoint26_1Request["payload"]["providerID"]
-}
-const Endpoint26_1 = (raw: RawClient["server.websearch"]) => (input: Endpoint26_1Input) =>
-  raw["websearch.provider.select"]({
-    query: { location: input["location"] },
-    payload: { providerID: input["providerID"] },
-  }).pipe(Effect.mapError(mapClientError))
-
-type Endpoint26_2Request = Parameters<RawClient["server.websearch"]["websearch.query"]>[0]
-type Endpoint26_2Input = {
-  readonly location?: Endpoint26_2Request["query"]["location"]
-  readonly query: Endpoint26_2Request["payload"]["query"]
-  readonly providerID?: Endpoint26_2Request["payload"]["providerID"]
-}
-const Endpoint26_2 = (raw: RawClient["server.websearch"]) => (input: Endpoint26_2Input) =>
-  raw["websearch.query"]({
-    query: { location: input["location"] },
-    payload: { query: input["query"], providerID: input["providerID"] },
-  }).pipe(Effect.mapError(mapClientError))
-
-const adaptGroup26 = (raw: RawClient["server.websearch"]) => ({
-  provider: { get: Endpoint26_0(raw), select: Endpoint26_1(raw) },
-  query: Endpoint26_2(raw),
-})
-
 const adaptClient = (raw: RawClient) => ({
   health: adaptGroup0(raw["server.health"]),
   location: adaptGroup1(raw["server.location"]),
@@ -1159,7 +1126,6 @@ const adaptClient = (raw: RawClient) => ({
   projectCopy: adaptGroup23(raw["server.projectCopy"]),
   vcs: adaptGroup24(raw["server.vcs"]),
   debug: adaptGroup25(raw["server.debug"]),
-  websearch: adaptGroup26(raw["server.websearch"]),
 })
 
 export const make = (options?: { readonly baseUrl?: URL | string }) =>

packages/client/src/effect/index.ts

@@ -14,7 +14,6 @@ export type {
   PluginApi,
   ProviderApi,
   ReferenceApi,
-  WebSearchApi,
   SessionApi,
   SkillApi,
 } from "./api.js"
@@ -37,7 +36,6 @@ export { Provider } from "@opencode-ai/schema/provider"
 export { Pty } from "@opencode-ai/schema/pty"
 export { Question } from "@opencode-ai/schema/question"
 export { Reference } from "@opencode-ai/schema/reference"
-export { WebSearch } from "@opencode-ai/schema/websearch"
 export { AbsolutePath, RelativePath } from "@opencode-ai/schema/schema"
 export { Session } from "@opencode-ai/schema/session"
 export { SessionInput } from "@opencode-ai/schema/session-input"

packages/client/src/promise/api.ts

@@ -7,7 +7,6 @@ import type {
   PluginApi as EffectPluginApi,
   ProviderApi as EffectProviderApi,
   ReferenceApi as EffectReferenceApi,
-  WebsearchApi,
   SessionApi as EffectSessionApi,
   SkillApi as EffectSkillApi,
 } from "../effect/api/api.js"
@@ -37,7 +36,6 @@ export type ModelApi = PromisifyApi<EffectModelApi<unknown>>
 export type PluginApi = PromisifyApi<EffectPluginApi<unknown>>
 export type ProviderApi = PromisifyApi<EffectProviderApi<unknown>>
 export type ReferenceApi = PromisifyApi<EffectReferenceApi<unknown>>
-export type WebSearchApi = PromisifyApi<WebsearchApi<unknown>>
 export type SessionApi = PromisifyApi<EffectSessionApi<unknown>>
 export type SkillApi = PromisifyApi<EffectSkillApi<unknown>>
 

packages/client/src/promise/generated/client.ts

@@ -184,12 +184,6 @@ import type {
   DebugLocationListOutput,
   DebugLocationEvictInput,
   DebugLocationEvictOutput,
-  WebsearchProviderGetInput,
-  WebsearchProviderGetOutput,
-  WebsearchProviderSelectInput,
-  WebsearchProviderSelectOutput,
-  WebsearchQueryInput,
-  WebsearchQueryOutput,
 } from "./types"
 import { ClientError } from "./client-error"
 
@@ -1566,48 +1560,6 @@ export function make(options: ClientOptions) {
           ),
       },
     },
-    websearch: {
-      provider: {
-        get: (input?: WebsearchProviderGetInput, requestOptions?: RequestOptions) =>
-          request<WebsearchProviderGetOutput>(
-            {
-              method: "GET",
-              path: `/api/websearch/provider`,
-              query: { location: input?.["location"] },
-              successStatus: 200,
-              declaredStatuses: [401, 400],
-              empty: false,
-            },
-            requestOptions,
-          ),
-        select: (input: WebsearchProviderSelectInput, requestOptions?: RequestOptions) =>
-          request<WebsearchProviderSelectOutput>(
-            {
-              method: "POST",
-              path: `/api/websearch/provider`,
-              query: { location: input["location"] },
-              body: { providerID: input["providerID"] },
-              successStatus: 204,
-              declaredStatuses: [400, 503, 401],
-              empty: true,
-            },
-            requestOptions,
-          ),
-      },
-      query: (input: WebsearchQueryInput, requestOptions?: RequestOptions) =>
-        request<WebsearchQueryOutput>(
-          {
-            method: "POST",
-            path: `/api/websearch`,
-            query: { location: input["location"] },
-            body: { query: input["query"], providerID: input["providerID"] },
-            successStatus: 200,
-            declaredStatuses: [400, 503, 401],
-            empty: false,
-          },
-          requestOptions,
-        ),
-    },
   }
 }
 

packages/client/src/promise/index.ts

@@ -9,7 +9,6 @@ export type {
   PluginApi,
   ProviderApi,
   ReferenceApi,
-  WebSearchApi,
   SessionApi,
   SkillApi,
 } from "./api.js"

packages/client/test/contract-identity.test.ts

@@ -38,7 +38,7 @@ test("Core and Server reuse the authoritative Schema and Protocol values", () =>
   expect(ProjectV2.Directory).toBe(Project.Directory)
   expect(ProjectV2.Directories).toBe(Project.Directories)
   expect(CoreSessionInput.Admitted).toBe(SessionInput.Admitted)
-  expect(CoreSessionMessage.Info).toBe(SessionMessage.Info)
+  expect(CoreSessionMessage.Message).toBe(SessionMessage.Message)
   expect(Api.groups["server.session"].identifier).toBe("server.session")
   expect(Api.groups["server.project"].identifier).toBe("server.project")
   expect(Object.keys(ClientApi.groups)).toEqual(Object.keys(Api.groups))

packages/client/test/promise.test.ts

@@ -31,7 +31,6 @@ test("exposes every standard HTTP API group", () => {
     "projectCopy",
     "vcs",
     "debug",
-    "websearch",
   ])
   expect(Object.keys(client.debug)).toEqual(["location"])
   expect(Object.keys(client.debug.location)).toEqual(["list", "evict"])
@@ -39,8 +38,6 @@ test("exposes every standard HTTP API group", () => {
   expect(Object.keys(client.integration)).toEqual(["list", "get", "connect", "attempt"])
   expect(Object.keys(client.integration.connect)).toEqual(["key", "oauth"])
   expect(Object.keys(client.integration.attempt)).toEqual(["status", "complete", "cancel"])
-  expect(Object.keys(client.websearch)).toEqual(["provider", "query"])
-  expect(Object.keys(client.websearch.provider)).toEqual(["get", "select"])
   expect(Object.keys(client.file)).toEqual(["read", "list", "find"])
   expect(Object.keys(client.vcs)).toEqual(["status", "diff"])
   expect(Object.keys(client.pty)).toEqual(["list", "create", "get", "update", "remove"])
@@ -48,56 +45,6 @@ test("exposes every standard HTTP API group", () => {
   expect(Object.keys(client.project)).toEqual(["list", "current", "directories"])
 })
 
-test("websearch.query uses the public HTTP contract", async () => {
-  let request: Request | undefined
-  const client = OpenCode.make({
-    baseUrl: "http://localhost:3000",
-    fetch: async (input, init) => {
-      request = input instanceof Request ? input : new Request(input, init)
-      return Response.json({
-        location: { directory: "/tmp/project", project: { id: "proj_test", directory: "/tmp/project" } },
-        data: { providerID: "exa", text: "result", metadata: { requestID: "req_test" } },
-      })
-    },
-  })
-
-  const result = await client.websearch.query({
-    query: "opencode",
-    providerID: "exa",
-    location: { directory: "/tmp/project" },
-  })
-
-  expect(result.data).toEqual({ providerID: "exa", text: "result", metadata: { requestID: "req_test" } })
-  expect(request?.method).toBe("POST")
-  expect(request?.url).toBe("http://localhost:3000/api/websearch?location%5Bdirectory%5D=%2Ftmp%2Fproject")
-  expect(await request?.json()).toEqual({ query: "opencode", providerID: "exa" })
-})
-
-test("websearch provider methods use the public HTTP contract", async () => {
-  const requests: Request[] = []
-  const client = OpenCode.make({
-    baseUrl: "http://localhost:3000",
-    fetch: async (input, init) => {
-      const request = input instanceof Request ? input : new Request(input, init)
-      requests.push(request)
-      if (request.method === "POST") return new Response(null, { status: 204 })
-      return Response.json({
-        location: { directory: "/tmp/project", project: { id: "proj_test", directory: "/tmp/project" } },
-        data: "exa",
-      })
-    },
-  })
-
-  expect(await client.websearch.provider.get({ location: { directory: "/tmp/project" } })).toMatchObject({ data: "exa" })
-  await client.websearch.provider.select({ providerID: "parallel", location: { directory: "/tmp/project" } })
-
-  expect(requests.map((request) => [request.method, request.url])).toEqual([
-    ["GET", "http://localhost:3000/api/websearch/provider?location%5Bdirectory%5D=%2Ftmp%2Fproject"],
-    ["POST", "http://localhost:3000/api/websearch/provider?location%5Bdirectory%5D=%2Ftmp%2Fproject"],
-  ])
-  expect(await requests[1]?.json()).toEqual({ providerID: "parallel" })
-})
-
 test("MCP resource catalog uses the public HTTP contract", async () => {
   let request: Request | undefined
   const client = OpenCode.make({

packages/core/src/agent.ts

@@ -8,8 +8,6 @@ import { State } from "./state"
 
 export const ID = Agent.ID
 export type ID = typeof ID.Type
-export const Name = Agent.Name
-export type Name = Agent.Name
 export const defaultID = ID.make("build")
 
 export const Color = Agent.Color

packages/core/src/aisdk.ts

@@ -305,7 +305,6 @@ function modelFromLanguage(info: ModelV2.Info, language: LanguageModelV3) {
   const route: AnyRoute = {
     id: `ai-sdk:${ProviderV2.packageName(info.package) ?? "unknown"}`,
     provider: ProviderID.make(info.providerID),
-    providerMetadataKey: optionKey,
     protocol: "ai-sdk",
     endpoint: Endpoint.path("/", { baseURL: "https://ai-sdk.local" }),
     auth: Auth.none,
@@ -418,7 +417,7 @@ function assistantPart(part: ContentPart): AssistantContent {
     case "media":
       return [{ type: "file", mediaType: part.mediaType, data: part.data, filename: part.filename }]
     case "reasoning":
-      return [{ type: "reasoning", text: part.text, providerOptions: providerOptions(part.providerMetadata) }]
+      return [{ type: "reasoning", text: part.text }]
     case "tool-call":
       return [
         {
@@ -427,7 +426,6 @@ function assistantPart(part: ContentPart): AssistantContent {
           toolName: part.name,
           input: part.input,
           providerExecuted: part.providerExecuted,
-          providerOptions: providerOptions(part.providerMetadata),
         },
       ]
     case "tool-result":
@@ -443,7 +441,6 @@ function toolResultPart(part: ContentPart): ToolResultContent[] {
       toolCallId: part.id,
       toolName: part.name,
       output: toolOutput(part.result),
-      providerOptions: providerOptions(part.providerMetadata),
     },
   ]
 }

packages/core/src/config.ts

@@ -1,5 +1,4 @@
 export * as Config from "./config"
-export * as ConfigGlobal from "./config/global"
 
 import { makeLocationNode } from "./effect/app-node"
 import path from "path"
@@ -24,7 +23,6 @@ import { ConfigModel } from "./config/model"
 import { ConfigPlugin } from "./config/plugin"
 import { ConfigProvider } from "./config/provider"
 import { ConfigReference } from "./config/reference"
-import { ConfigWebSearch } from "./config/websearch"
 import { ConfigToolOutput } from "./config/tool-output"
 import { ConfigVariable } from "./config/variable"
 import { ConfigWatcher } from "./config/watcher"
@@ -104,9 +102,6 @@ export class Info extends Schema.Class<Info>("Config.Info")({
   references: ConfigReference.Info.pipe(Schema.optional).annotate({
     description: "Named local directories or Git repositories available as external context",
   }),
-  websearch: ConfigWebSearch.Info.pipe(Schema.optional).annotate({
-    description: "Web search provider selection",
-  }),
   plugins: ConfigPlugin.Plugins.pipe(Schema.optional).annotate({
     description: "Ordered plugin enablement directives and external package declarations",
   }),

packages/core/src/config/global.ts

@@ -1,50 +0,0 @@
-export * as ConfigGlobal from "./global"
-
-import { randomUUID } from "node:crypto"
-import path from "node:path"
-import { Context, Effect, Layer } from "effect"
-import { applyEdits, modify, type JSONPath } from "jsonc-parser"
-import { makeGlobalNode } from "../effect/app-node"
-import { FSUtil } from "../fs-util"
-import { Global } from "../global"
-import { EffectFlock } from "../util/effect-flock"
-
-export interface Interface {
-  readonly update: (path: JSONPath, value: unknown) => Effect.Effect<void, FSUtil.Error | EffectFlock.LockError>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/ConfigGlobal") {}
-
-const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const fs = yield* FSUtil.Service
-    const global = yield* Global.Service
-    const flock = yield* EffectFlock.Service
-
-    return Service.of({
-      update: Effect.fn("ConfigGlobal.update")(function* (jsonPath, value) {
-        yield* flock.withLock(
-          Effect.gen(function* () {
-            const existing = yield* Effect.filter(
-              ["opencode.jsonc", "opencode.json"].map((name) => path.join(global.config, name)),
-              fs.existsSafe,
-            )
-            const filepath = existing[0] ?? path.join(global.config, "opencode.json")
-            const text = (yield* fs.readFileStringSafe(filepath)) ?? "{}"
-            const next = applyEdits(
-              text,
-              modify(text, jsonPath, value, { formattingOptions: { tabSize: 2, insertSpaces: true } }),
-            )
-            const temp = `${filepath}.${randomUUID()}.tmp`
-            yield* fs.writeWithDirs(temp, next)
-            yield* fs.rename(temp, filepath).pipe(Effect.ensuring(fs.remove(temp).pipe(Effect.ignore)))
-          }),
-          "global-config",
-        )
-      }),
-    })
-  }),
-)
-
-export const node = makeGlobalNode({ service: Service, layer, deps: [EffectFlock.node, FSUtil.node, Global.node] })

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

@@ -1,7 +1,6 @@
 export * as ConfigProviderPlugin from "./provider"
 
 import { define } from "@opencode-ai/plugin/v2/effect/plugin"
-import { Money } from "@opencode-ai/schema/money"
 import { Effect, Stream } from "effect"
 import { Config } from "../../config"
 import { ModelV2 } from "../../model"
@@ -92,8 +91,8 @@ export const Plugin = define({
                   input: cost.input,
                   output: cost.output,
                   cache: {
-                    read: cost.cache?.read ?? Money.USDPerMillionTokens.zero,
-                    write: cost.cache?.write ?? Money.USDPerMillionTokens.zero,
+                    read: cost.cache?.read ?? 0,
+                    write: cost.cache?.write ?? 0,
                   },
                 }))
               }

packages/core/src/config/provider.ts

@@ -1,7 +1,6 @@
 export * as ConfigProvider from "./provider"
 
 import { Schema } from "effect"
-import { Money } from "@opencode-ai/schema/money"
 import { ModelV2 } from "../model"
 
 const JsonRecord = Schema.Record(Schema.String, Schema.Json)
@@ -18,8 +17,8 @@ export class Request extends Schema.Class<Request>("ConfigV2.Provider.Request")(
 }) {}
 
 class Cache extends Schema.Class<Cache>("ConfigV2.Model.Cost.Cache")({
-  read: Money.USDPerMillionTokens.pipe(Schema.optional),
-  write: Money.USDPerMillionTokens.pipe(Schema.optional),
+  read: Schema.Finite.pipe(Schema.optional),
+  write: Schema.Finite.pipe(Schema.optional),
 }) {}
 
 class Cost extends Schema.Class<Cost>("ConfigV2.Model.Cost")({
@@ -27,8 +26,8 @@ class Cost extends Schema.Class<Cost>("ConfigV2.Model.Cost")({
     type: Schema.Literal("context"),
     size: Schema.Int,
   }).pipe(Schema.optional),
-  input: Money.USDPerMillionTokens,
-  output: Money.USDPerMillionTokens,
+  input: Schema.Finite,
+  output: Schema.Finite,
   cache: Cache.pipe(Schema.optional),
 }) {}
 

packages/core/src/config/websearch.ts

@@ -1,8 +0,0 @@
-export * as ConfigWebSearch from "./websearch"
-
-import { Integration } from "@opencode-ai/schema/integration"
-import { Schema } from "effect"
-
-export class Info extends Schema.Class<Info>("ConfigWebSearch.Info")({
-  provider: Integration.ID,
-}) {}

packages/core/src/database/migration.gen.ts

@@ -48,6 +48,5 @@ export const migrations = (
     import("./migration/20260705180000_rename_instructions"),
     import("./migration/20260706223930_add-session-fork"),
     import("./migration/20260707010146_durable_session_inbox"),
-    import("./migration/20260707120000_migrate_prelaunch_v2_state"),
   ])
 ).map((module) => module.default) satisfies DatabaseMigration.Migration[]

packages/core/src/database/migration/20260707120000_migrate_prelaunch_v2_state.ts

@@ -1,227 +0,0 @@
-import { sql } from "drizzle-orm"
-import { Effect, Schema } from "effect"
-import type { DatabaseMigration } from "../migration"
-
-const decodeJson = Schema.decodeUnknownSync(Schema.UnknownFromJsonString)
-const isObject = Schema.is(Schema.Record(Schema.String, Schema.Unknown))
-
-export default {
-  id: "20260707120000_migrate_prelaunch_v2_state",
-  up(tx) {
-    return Effect.gen(function* () {
-      yield* tx.run(
-        sql`DELETE FROM session_message WHERE type = 'compaction' AND json_extract(data, '$.status') = 'queued'`,
-      )
-      const messages = yield* tx.all<{ id: string; type: string; data: string }>(
-        sql`SELECT id, type, data FROM session_message WHERE type IN ('skill', 'shell', 'assistant', 'compaction', 'synthetic')`,
-      )
-      for (const row of messages) {
-        const data = object(decodeJson(row.data))
-        yield* tx.run(
-          sql`UPDATE session_message SET data = ${JSON.stringify(messageData(row.type, data))} WHERE id = ${row.id}`,
-        )
-      }
-
-      yield* tx.run(sql`DELETE FROM event WHERE type = 'session.compaction.delta.1'`)
-      const events = yield* tx.all<{ id: string; aggregateID: string; seq: number; type: string; data: string }>(sql`
-        SELECT id, aggregate_id as aggregateID, seq, type, data
-        FROM event
-        WHERE type IN (
-          'session.skill.activated.1',
-          'session.skill.activated.2',
-          'session.compaction.started.1',
-          'session.compaction.started.2',
-          'session.compaction.ended.1',
-          'session.compaction.failed.1',
-          'session.compaction.failed.2',
-          'session.revert.staged.1',
-          'session.revert.staged.2'
-        )
-        ORDER BY aggregate_id, seq
-      `)
-      const compactionReasons = new Map<string, "auto" | "manual">()
-      for (const row of events) {
-        const data = object(decodeJson(row.data))
-        if (row.type.startsWith("session.compaction.ended.")) {
-          compactionReasons.delete(row.aggregateID)
-          continue
-        }
-        const event = eventData(row.type, data, compactionReasons.get(row.aggregateID))
-        if (row.type.startsWith("session.compaction.started."))
-          compactionReasons.set(row.aggregateID, event.data.reason === "auto" ? "auto" : "manual")
-        if (row.type.startsWith("session.compaction.failed.")) compactionReasons.delete(row.aggregateID)
-        yield* tx.run(
-          sql`UPDATE event SET type = ${event.type}, data = ${JSON.stringify(event.data)} WHERE id = ${row.id}`,
-        )
-      }
-    })
-  },
-} satisfies DatabaseMigration.Migration
-
-function messageData(type: string, data: Record<string, unknown>) {
-  if (type === "skill")
-    return defined({
-      metadata: data.metadata,
-      time: data.time,
-      skill: data.skill ?? data.id ?? data.name,
-      name: data.name,
-      text: data.text,
-    })
-  if (type === "shell") {
-    const shell = object(data.shell)
-    return defined({
-      metadata: data.metadata,
-      time: data.time,
-      shellID: data.shellID ?? shell.id,
-      command: data.command ?? shell.command,
-      status: data.status ?? shell.status,
-      exit: data.exit ?? shell.exit,
-      output: data.output,
-    })
-  }
-  if (type === "assistant")
-    return defined({
-      metadata: data.metadata,
-      time: data.time,
-      agent: data.agent,
-      model: data.model,
-      content: Array.isArray(data.content) ? data.content.map(assistantContent) : data.content,
-      snapshot: data.snapshot,
-      finish: data.finish,
-      cost: data.cost,
-      tokens: data.tokens,
-      error: data.error,
-      retry: data.retry,
-    })
-  if (type === "compaction") {
-    if (data.status === "failed")
-      return defined({
-        metadata: data.metadata,
-        time: data.time,
-        status: data.status,
-        reason: data.reason,
-        error: data.error ?? genericCompactionError,
-      })
-    return defined({
-      metadata: data.metadata,
-      time: data.time,
-      status: data.status,
-      reason: data.reason,
-      summary: data.summary,
-      recent: data.recent,
-    })
-  }
-  if (type === "synthetic")
-    return defined({ metadata: data.metadata, time: data.time, text: data.text, description: data.description })
-  const { sessionID: _, ...current } = data
-  return current
-}
-
-function assistantContent(value: unknown) {
-  const content = object(value)
-  if (content.type === "text") return defined({ type: content.type, text: content.text })
-  if (content.type === "reasoning")
-    return defined({ type: content.type, text: content.text, state: content.state, time: content.time })
-  if (content.type !== "tool") return content
-  return defined({
-    type: content.type,
-    id: content.id,
-    name: content.name,
-    executed: content.executed,
-    providerState: content.providerState,
-    providerResultState: content.providerResultState,
-    state: toolState(content.state),
-    time: content.time,
-  })
-}
-
-function toolState(value: unknown) {
-  const state = object(value)
-  if (state.status === "pending" || state.status === "streaming")
-    return defined({ status: "streaming", input: state.input })
-  if (state.status === "running")
-    return defined({ status: state.status, input: state.input, structured: state.structured, content: state.content })
-  if (state.status === "completed")
-    return defined({
-      status: state.status,
-      input: state.input,
-      structured: state.structured,
-      content: state.content,
-      result: state.result,
-    })
-  if (state.status === "error")
-    return defined({
-      status: state.status,
-      input: state.input,
-      structured: state.structured,
-      content: state.content,
-      error: state.error,
-      result: state.result,
-    })
-  return state
-}
-
-function eventData(type: string, data: Record<string, unknown>, compactionReason?: "auto" | "manual") {
-  if (type.startsWith("session.skill.activated."))
-    return {
-      type: "session.skill.activated.1",
-      data: defined({ sessionID: data.sessionID, id: data.id ?? data.name, name: data.name, text: data.text }),
-    }
-  if (type.startsWith("session.compaction.started."))
-    return {
-      type: "session.compaction.started.1",
-      data: defined({
-        sessionID: data.sessionID,
-        reason: data.reason,
-        recent: data.recent ?? "",
-        inputID: data.inputID,
-      }),
-    }
-  if (type.startsWith("session.compaction.failed."))
-    return {
-      type: "session.compaction.failed.1",
-      data: defined({
-        sessionID: data.sessionID,
-        reason: data.reason ?? compactionReason ?? "manual",
-        error: data.error ?? genericCompactionError,
-        inputID: data.inputID,
-      }),
-    }
-  const revert = object(data.revert)
-  return {
-    type: "session.revert.staged.1",
-    data: defined({
-      sessionID: data.sessionID,
-      revert: defined({
-        messageID: revert.messageID,
-        partID: revert.partID,
-        snapshot: revert.snapshot,
-        files: Array.isArray(revert.files)
-          ? revert.files.map((value) => {
-              const file = object(value)
-              return defined({
-                file: file.file ?? file.path,
-                patch: file.patch,
-                additions: file.additions,
-                deletions: file.deletions,
-                status: file.status,
-              })
-            })
-          : undefined,
-      }),
-    }),
-  }
-}
-
-const genericCompactionError = {
-  type: "compaction.failed",
-  message: "Compaction failed before recording an error",
-}
-
-function object(value: unknown): Record<string, unknown> {
-  return isObject(value) ? value : {}
-}
-
-function defined(value: Record<string, unknown>) {
-  return Object.fromEntries(Object.entries(value).filter((entry) => entry[1] !== undefined))
-}

packages/core/src/file.ts

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

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

@@ -46,7 +46,7 @@ const layer = Layer.effect(
         .flatMap((item) => item.info.watcher?.ignore ?? [])
       const home = path.resolve(location.directory) === path.resolve(os.homedir())
 
-      if (!home && location.vcs) {
+      if (!home) {
         yield* watcher
           .subscribe({
             path: location.directory,

packages/core/src/form.ts

@@ -67,7 +67,6 @@ export class InvalidFormError extends Schema.TaggedErrorClass<InvalidFormError>(
 export type CreateInput =
   | (Omit<Form.FormInfo, "id"> & { readonly id?: ID })
   | (Omit<Form.UrlInfo, "id"> & { readonly id?: ID })
-  | (Omit<Form.IntegrationInfo, "id"> & { readonly id?: ID })
 
 export interface ReplyInput {
   readonly id: ID
@@ -139,9 +138,7 @@ export const layer = Layer.effect(
           const form: Info =
             input.mode === "form"
               ? { ...base, mode: "form", fields: input.fields }
-              : input.mode === "url"
-                ? { ...base, mode: "url", url: input.url }
-                : { ...base, mode: "integration", integrationID: input.integrationID }
+              : { ...base, mode: "url", url: input.url }
           const entry: Entry = {
             form,
             state: { status: "pending" },
@@ -231,9 +228,9 @@ export const locationLayer = layer
 export const node = makeLocationNode({ service: Service, layer, deps: [EventV2.node] })
 
 function validateAnswer(form: Info, answer: Answer) {
-  if (form.mode !== "form") {
+  if (form.mode === "url") {
     if (Object.keys(answer).length === 0) return
-    return `${form.mode === "url" ? "URL" : "Integration"} forms must be answered with an empty answer`
+    return "URL forms must be answered with an empty answer"
   }
   const fields = new Map(form.fields.map((field) => [field.key, field]))
   for (const key of Object.keys(answer)) {

packages/core/src/git.ts

@@ -606,7 +606,7 @@ const layer = Layer.effect(
                 file,
               ])).text
           return {
-            file,
+            path: file,
             status,
             additions: binary ? 0 : Number(stats[0] ?? 0),
             deletions: binary ? 0 : Number(stats[1] ?? 0),

packages/core/src/integration.ts

@@ -16,7 +16,6 @@ import {
   Types,
 } from "effect"
 import { Integration } from "@opencode-ai/schema/integration"
-import { WebSearch } from "@opencode-ai/schema/websearch"
 import { Credential } from "./credential"
 import { State } from "./state"
 import { EventV2 } from "./event"
@@ -95,15 +94,6 @@ export interface EnvImplementation {
 
 export type Implementation = OAuthImplementation | KeyImplementation | EnvImplementation
 
-export interface WebSearchImplementation {
-  readonly integrationID: ID
-  readonly connection: Integration.WebSearch["connection"]
-  readonly execute: (
-    input: WebSearch.Input,
-    context: { readonly credential?: Credential.Value; readonly sessionID?: string },
-  ) => Effect.Effect<WebSearch.ProviderOutput, unknown>
-}
-
 export const Attempt = Integration.Attempt
 export type Attempt = Integration.Attempt
 
@@ -129,7 +119,6 @@ type Entry = {
   ref: Types.DeepMutable<Ref>
   methods: Types.DeepMutable<Method>[]
   implementations: Map<MethodID, Types.DeepMutable<OAuthImplementation>>
-  websearch?: Types.DeepMutable<WebSearchImplementation>
 }
 
 type Data = {
@@ -146,11 +135,6 @@ export type Draft = {
     update: (implementation: Implementation) => void
     remove: (integrationID: ID, method: Method) => void
   }
-  websearch: {
-    list: () => readonly WebSearchImplementation[]
-    update: (implementation: WebSearchImplementation) => void
-    remove: (integrationID: ID) => void
-  }
 }
 
 export interface Interface extends State.Transformable<Draft> {
@@ -207,10 +191,6 @@ export interface Interface extends State.Transformable<Draft> {
     /** Cancels an attempt and releases its resources. */
     readonly cancel: (attemptID: AttemptID) => Effect.Effect<void>
   }
-  readonly websearch: {
-    readonly list: () => Effect.Effect<readonly WebSearchImplementation[]>
-    readonly get: (integrationID: ID) => Effect.Effect<WebSearchImplementation | undefined>
-  }
 }
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/v2/Integration") {}
@@ -301,30 +281,6 @@ const layer = Layer.effect(
             if (method.type === "oauth") current.implementations.delete(method.id)
           },
         },
-        websearch: {
-          list: () =>
-            Array.from(draft.integrations.values()).flatMap((entry) =>
-              entry.websearch ? [entry.websearch as WebSearchImplementation] : [],
-            ),
-          update: (implementation) => {
-            const current = draft.integrations.get(implementation.integrationID) ?? {
-              ref: {
-                id: implementation.integrationID,
-                name: implementation.integrationID,
-              },
-              methods: [],
-              implementations: new Map<MethodID, Types.DeepMutable<OAuthImplementation>>(),
-            }
-            if (!draft.integrations.has(implementation.integrationID)) {
-              draft.integrations.set(implementation.integrationID, current)
-            }
-            current.websearch = implementation as Types.DeepMutable<WebSearchImplementation>
-          },
-          remove: (integrationID) => {
-            const current = draft.integrations.get(integrationID)
-            if (current) delete current.websearch
-          },
-        },
       }),
       finalize: () => events.publish(Event.Updated, {}).pipe(Effect.asVoid),
     })
@@ -349,7 +305,6 @@ const layer = Layer.effect(
         id: entry.ref.id,
         name: entry.ref.name,
         methods: entry.methods,
-        websearch: entry.websearch ? { connection: entry.websearch.connection } : undefined,
         connections,
       })
 
@@ -559,16 +514,6 @@ const layer = Layer.effect(
           if (attempt) yield* Scope.close(attempt.scope, Exit.void)
         }),
       },
-      websearch: {
-        list: Effect.fn("Integration.websearch.list")(function* () {
-          return Array.from(state.get().integrations.values()).flatMap((entry) =>
-            entry.websearch ? [entry.websearch as WebSearchImplementation] : [],
-          )
-        }),
-        get: Effect.fn("Integration.websearch.get")(function* (integrationID) {
-          return state.get().integrations.get(integrationID)?.websearch as WebSearchImplementation | undefined
-        }),
-      },
     })
   }),
 )

packages/core/src/location-services.ts

@@ -34,7 +34,6 @@ import { Pty } from "./pty"
 import { QuestionV2 } from "./question"
 import { Shell } from "./shell"
 import { Reference } from "./reference"
-import { WebSearch } from "./websearch"
 import { ReferenceGuidance } from "./reference/guidance"
 import { Ripgrep } from "./ripgrep"
 import { SessionRunnerLLM } from "./session/runner/llm"
@@ -52,6 +51,7 @@ import { SessionInstructions } from "./session/instructions"
 import { McpTool } from "./tool/mcp"
 import { ReadToolFileSystem } from "./tool/read-filesystem"
 import { ToolRegistry } from "./tool/registry"
+import { WebSearchTool } from "./tool/websearch"
 import { ToolOutputStore } from "./tool-output-store"
 import { Vcs } from "./vcs"
 
@@ -84,13 +84,13 @@ const pluginSupervisorNode = makeLocationNode({
     Form.node,
     ReadToolFileSystem.node,
     Reference.node,
-    WebSearch.node,
     Ripgrep.node,
     SessionInstructions.node,
     SessionTodo.node,
     Shell.node,
     SkillV2.node,
     ToolRegistry.toolsNode,
+    WebSearchTool.configNode,
   ],
 })
 
@@ -100,7 +100,6 @@ const locationServiceNodes = [
   AgentV2.node,
   CommandV2.node,
   Reference.node,
-  WebSearch.node,
   Integration.node,
   Catalog.node,
   AISDK.node,

packages/core/src/models-dev.ts

@@ -2,7 +2,6 @@ import path from "path"
 import { Context, Duration, Effect, Layer, Option, Schedule, Schema } from "effect"
 import { HttpClient, HttpClientRequest } from "effect/unstable/http"
 import { ModelsDev } from "@opencode-ai/schema/models-dev"
-import { Money } from "@opencode-ai/schema/money"
 import { Global } from "./global"
 import { Flag } from "./flag/flag"
 import { Flock } from "./util/flock"
@@ -19,10 +18,10 @@ export type CatalogModelStatus = typeof CatalogModelStatus.Type
 const USER_AGENT = `opencode/${InstallationChannel}/${InstallationVersion}/${Flag.OPENCODE_CLIENT}`
 
 const CostTier = Schema.Struct({
-  input: Money.USDPerMillionTokens,
-  output: Money.USDPerMillionTokens,
-  cache_read: Schema.optional(Money.USDPerMillionTokens),
-  cache_write: Schema.optional(Money.USDPerMillionTokens),
+  input: Schema.Finite,
+  output: Schema.Finite,
+  cache_read: Schema.optional(Schema.Finite),
+  cache_write: Schema.optional(Schema.Finite),
   tier: Schema.Struct({
     type: Schema.Literal("context"),
     size: Schema.Finite,
@@ -30,17 +29,17 @@ const CostTier = Schema.Struct({
 })
 
 const Cost = Schema.Struct({
-  input: Money.USDPerMillionTokens,
-  output: Money.USDPerMillionTokens,
-  cache_read: Schema.optional(Money.USDPerMillionTokens),
-  cache_write: Schema.optional(Money.USDPerMillionTokens),
+  input: Schema.Finite,
+  output: Schema.Finite,
+  cache_read: Schema.optional(Schema.Finite),
+  cache_write: Schema.optional(Schema.Finite),
   tiers: Schema.optional(Schema.Array(CostTier)),
   context_over_200k: Schema.optional(
     Schema.Struct({
-      input: Money.USDPerMillionTokens,
-      output: Money.USDPerMillionTokens,
-      cache_read: Schema.optional(Money.USDPerMillionTokens),
-      cache_write: Schema.optional(Money.USDPerMillionTokens),
+      input: Schema.Finite,
+      output: Schema.Finite,
+      cache_read: Schema.optional(Schema.Finite),
+      cache_write: Schema.optional(Schema.Finite),
     }),
   ),
 })

packages/core/src/plugin/agent.ts

@@ -125,7 +125,6 @@ export const Plugin = define({
 
     yield* ctx.agent.transform((draft) => {
       draft.update(AgentV2.defaultID, (item) => {
-        item.name = AgentV2.Name.make("Build")
         item.description = "The default agent. Executes tools based on configured permissions."
         item.mode = "primary"
         item.permissions.push(
@@ -137,7 +136,6 @@ export const Plugin = define({
       })
 
       draft.update(AgentV2.ID.make("plan"), (item) => {
-        item.name = AgentV2.Name.make("Plan")
         item.description = "Plan mode. Disallows all edit tools."
         item.mode = "primary"
         item.permissions.push(
@@ -157,7 +155,6 @@ export const Plugin = define({
       })
 
       draft.update(AgentV2.ID.make("general"), (item) => {
-        item.name = AgentV2.Name.make("General")
         item.description =
           "General-purpose agent for researching complex questions and executing multi-step tasks. Use this agent to execute multiple units of work in parallel."
         item.mode = "subagent"
@@ -170,7 +167,6 @@ export const Plugin = define({
       })
 
       draft.update(AgentV2.ID.make("explore"), (item) => {
-        item.name = AgentV2.Name.make("Explore")
         item.description =
           'Fast agent specialized for exploring codebases. Use this when you need to quickly find files by patterns (eg. "src/components/**/*.tsx"), search code for keywords (eg. "API endpoints"), or answer questions about the codebase (eg. "how do API endpoints work?"). When calling this agent, specify the desired thoroughness level: "quick" for basic searches, "medium" for moderate exploration, or "very thorough" for comprehensive analysis across multiple locations and naming conventions.'
         item.system = PROMPT_EXPLORE
@@ -193,7 +189,6 @@ export const Plugin = define({
       })
 
       draft.update(AgentV2.ID.make("compaction"), (item) => {
-        item.name = AgentV2.Name.make("Compaction")
         item.mode = "primary"
         item.hidden = true
         item.system = PROMPT_COMPACTION
@@ -201,7 +196,6 @@ export const Plugin = define({
       })
 
       draft.update(AgentV2.ID.make("title"), (item) => {
-        item.name = AgentV2.Name.make("Title")
         item.mode = "primary"
         item.hidden = true
         item.system = PROMPT_TITLE
@@ -209,7 +203,6 @@ export const Plugin = define({
       })
 
       draft.update(AgentV2.ID.make("summary"), (item) => {
-        item.name = AgentV2.Name.make("Summary")
         item.mode = "primary"
         item.hidden = true
         item.system = PROMPT_SUMMARY

packages/core/src/plugin/host.ts

@@ -1,8 +1,6 @@
 export * as PluginHost from "./host"
 
-import { Plugin } from "@opencode-ai/plugin/v2/effect"
-import type { IntegrationDefinition, IntegrationMethodRegistration } from "@opencode-ai/plugin/v2/effect/integration"
-import type { CredentialOAuth } from "@opencode-ai/sdk/v2/types"
+import type { Plugin } from "@opencode-ai/plugin/v2/effect"
 import { EventManifest } from "@opencode-ai/schema/event-manifest"
 import { Effect, Schema, Stream } from "effect"
 import { AgentV2 } from "../agent"
@@ -199,7 +197,6 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: PluginV2.Int
             connection.type === "credential" ? { ...connection, id: Credential.ID.make(connection.id) } : connection,
           ),
       },
-      register: (definition) => integration.transform((draft) => registerIntegration(draft, definition)),
       transform: (callback) =>
         integration.transform((draft) => {
           callback({
@@ -209,7 +206,72 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: PluginV2.Int
             remove: (id) => draft.remove(Integration.ID.make(id)),
             method: {
               list: (id) => mutable(draft.method.list(Integration.ID.make(id))),
-              update: (input) => draft.method.update(methodImplementation(input)),
+              update: (input) => {
+                if ("authorize" in input) {
+                  const methodID = Integration.MethodID.make(input.method.id)
+                  const refresh = input.refresh
+                  draft.method.update({
+                    integrationID: Integration.ID.make(input.integrationID),
+                    method: { ...input.method, id: methodID },
+                    authorize: (inputs) =>
+                      input.authorize(inputs).pipe(
+                        Effect.map((authorization) => {
+                          if (authorization.mode === "auto") {
+                            return {
+                              ...authorization,
+                              callback: authorization.callback.pipe(
+                                Effect.map((credential) =>
+                                  Credential.OAuth.make({
+                                    ...credential,
+                                    methodID: Integration.MethodID.make(credential.methodID),
+                                  }),
+                                ),
+                              ),
+                            }
+                          }
+                          return {
+                            ...authorization,
+                            callback: (code: string) =>
+                              authorization.callback(code).pipe(
+                                Effect.map((credential) =>
+                                  Credential.OAuth.make({
+                                    ...credential,
+                                    methodID: Integration.MethodID.make(credential.methodID),
+                                  }),
+                                ),
+                              ),
+                          }
+                        }),
+                      ),
+                    ...(refresh
+                      ? {
+                          refresh: (value: Credential.OAuth) =>
+                            refresh(value).pipe(
+                              Effect.map((next) =>
+                                Credential.OAuth.make({
+                                  ...next,
+                                  methodID: Integration.MethodID.make(next.methodID),
+                                }),
+                              ),
+                            ),
+                        }
+                      : {}),
+                    ...(input.label ? { label: input.label } : {}),
+                  })
+                  return
+                }
+                if (input.method.type === "env") {
+                  draft.method.update({
+                    integrationID: Integration.ID.make(input.integrationID),
+                    method: { type: "env", names: input.method.names },
+                  })
+                  return
+                }
+                draft.method.update({
+                  integrationID: Integration.ID.make(input.integrationID),
+                  method: { type: "key", label: input.method.label },
+                })
+              },
               remove: (id, method) =>
                 draft.method.remove(Integration.ID.make(id), Schema.decodeUnknownSync(Integration.Method)(method)),
             },
@@ -321,75 +383,3 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: PluginV2.Int
     },
   } satisfies Plugin.Context
 })
-
-function registerIntegration(draft: Integration.Draft, definition: IntegrationDefinition) {
-  const integrationID = Integration.ID.make(definition.id)
-  draft.update(integrationID, (integration) => (integration.name = definition.name))
-  for (const method of definition.methods ?? []) {
-    if (method.type === "env") {
-      draft.method.update(methodImplementation({ integrationID: definition.id, method }))
-      continue
-    }
-    if (method.type === "key") {
-      draft.method.update(methodImplementation({ integrationID: definition.id, method }))
-      continue
-    }
-    const { authorize, refresh, credentialLabel, ...info } = method
-    draft.method.update(
-      methodImplementation({
-        integrationID: definition.id,
-        method: info,
-        authorize,
-        ...(refresh ? { refresh } : {}),
-        ...(credentialLabel ? { label: credentialLabel } : {}),
-      }),
-    )
-  }
-  if (!definition.websearch) return
-  draft.websearch.update({
-    integrationID,
-    connection: definition.websearch.connection,
-    execute: definition.websearch.execute,
-  })
-}
-
-function methodImplementation(input: IntegrationMethodRegistration): Integration.Implementation {
-  if ("authorize" in input) {
-    const refresh = input.refresh
-    return {
-      integrationID: Integration.ID.make(input.integrationID),
-      method: { ...input.method, id: Integration.MethodID.make(input.method.id) },
-      authorize: (inputs) =>
-        input.authorize(inputs).pipe(
-          Effect.map((authorization) => {
-            if (authorization.mode === "auto") {
-              return {
-                ...authorization,
-                callback: authorization.callback.pipe(Effect.map(credential)),
-              }
-            }
-            return {
-              ...authorization,
-              callback: (code: string) => authorization.callback(code).pipe(Effect.map(credential)),
-            }
-          }),
-        ),
-      ...(refresh ? { refresh: (value: Credential.OAuth) => refresh(value).pipe(Effect.map(credential)) } : {}),
-      ...(input.label ? { label: input.label } : {}),
-    }
-  }
-  if (input.method.type === "env") {
-    return {
-      integrationID: Integration.ID.make(input.integrationID),
-      method: { type: "env", names: input.method.names },
-    }
-  }
-  return {
-    integrationID: Integration.ID.make(input.integrationID),
-    method: { type: "key", label: input.method.label },
-  }
-}
-
-function credential(value: CredentialOAuth) {
-  return Credential.OAuth.make({ ...value, methodID: Integration.MethodID.make(value.methodID) })
-}

packages/core/src/plugin/internal.ts

@@ -26,13 +26,12 @@ import { ModelsDev } from "../models-dev"
 import { Npm } from "../npm"
 import { PermissionV2 } from "../permission"
 import { Reference } from "../reference"
-import { WebSearch } from "../websearch"
 import { Ripgrep } from "../ripgrep"
 import { SessionInstructions } from "../session/instructions"
 import { SessionTodo } from "../session/todo"
 import { Shell } from "../shell"
 import { SkillV2 } from "../skill"
-import { PatchTool } from "../tool/patch"
+import { ApplyPatchTool } from "../tool/apply-patch"
 import { EditTool } from "../tool/edit"
 import { GlobTool } from "../tool/glob"
 import { GrepTool } from "../tool/grep"
@@ -51,7 +50,6 @@ import { AgentPlugin } from "./agent"
 import { CommandPlugin } from "./command"
 import { ModelsDevPlugin } from "./models-dev"
 import { ProviderPlugins } from "./provider"
-import { WebSearchPlugins } from "./websearch"
 import { PluginRuntime } from "./runtime"
 import { SkillPlugin } from "./skill"
 import { VariantPlugin } from "./variant"
@@ -78,13 +76,13 @@ const services = Effect.fn("PluginInternal.services")(function* () {
   const form = yield* Form.Service
   const read = yield* ReadToolFileSystem.Service
   const reference = yield* Reference.Service
-  const websearch = yield* WebSearch.Service
   const ripgrep = yield* Ripgrep.Service
   const instructions = yield* SessionInstructions.Service
   const todo = yield* SessionTodo.Service
   const shell = yield* Shell.Service
   const skill = yield* SkillV2.Service
   const tools = yield* Tools.Service
+  const websearch = yield* WebSearchTool.ConfigService
   return Context.mergeAll(
     Context.make(AgentV2.Service, agent),
     Context.make(Catalog.Service, catalog),
@@ -107,13 +105,13 @@ const services = Effect.fn("PluginInternal.services")(function* () {
     Context.make(Form.Service, form),
     Context.make(ReadToolFileSystem.Service, read),
     Context.make(Reference.Service, reference),
-    Context.make(WebSearch.Service, websearch),
     Context.make(Ripgrep.Service, ripgrep),
     Context.make(SessionInstructions.Service, instructions),
     Context.make(SessionTodo.Service, todo),
     Context.make(Shell.Service, shell),
     Context.make(SkillV2.Service, skill),
     Context.make(Tools.Service, tools),
+    Context.make(WebSearchTool.ConfigService, websearch),
   )
 })
 
@@ -129,8 +127,7 @@ const pre = [
   SkillPlugin.Plugin,
   ModelsDevPlugin,
   ...ProviderPlugins,
-  ...WebSearchPlugins,
-  PatchTool.Plugin,
+  ApplyPatchTool.Plugin,
   EditTool.Plugin,
   GlobTool.Plugin,
   GrepTool.Plugin,

packages/core/src/plugin/models-dev.ts

@@ -1,6 +1,5 @@
 import { define } from "@opencode-ai/plugin/v2/effect/plugin"
-import { Money } from "@opencode-ai/schema/money"
-import type { ModelInfo } from "@opencode-ai/sdk/v2/types"
+import type { ModelV2Info } from "@opencode-ai/sdk/v2/types"
 import { Effect, Stream } from "effect"
 import { EventV2 } from "../event"
 import { ModelV2 } from "../model"
@@ -12,13 +11,13 @@ function released(date: string) {
   return Number.isFinite(time) ? time : 0
 }
 
-function cost(input: ModelsDev.Model["cost"]): ModelInfo["cost"] {
+function cost(input: ModelsDev.Model["cost"]): ModelV2Info["cost"] {
   const base = {
-    input: input?.input ?? Money.USDPerMillionTokens.zero,
-    output: input?.output ?? Money.USDPerMillionTokens.zero,
+    input: input?.input ?? 0,
+    output: input?.output ?? 0,
     cache: {
-      read: input?.cache_read ?? Money.USDPerMillionTokens.zero,
-      write: input?.cache_write ?? Money.USDPerMillionTokens.zero,
+      read: input?.cache_read ?? 0,
+      write: input?.cache_write ?? 0,
     },
   }
   return [
@@ -28,8 +27,8 @@ function cost(input: ModelsDev.Model["cost"]): ModelInfo["cost"] {
       input: item.input,
       output: item.output,
       cache: {
-        read: item.cache_read ?? Money.USDPerMillionTokens.zero,
-        write: item.cache_write ?? Money.USDPerMillionTokens.zero,
+        read: item.cache_read ?? 0,
+        write: item.cache_write ?? 0,
       },
     })) ?? []),
     ...(input?.context_over_200k
@@ -42,8 +41,8 @@ function cost(input: ModelsDev.Model["cost"]): ModelInfo["cost"] {
             input: input.context_over_200k.input,
             output: input.context_over_200k.output,
             cache: {
-              read: input.context_over_200k.cache_read ?? Money.USDPerMillionTokens.zero,
-              write: input.context_over_200k.cache_write ?? Money.USDPerMillionTokens.zero,
+              read: input.context_over_200k.cache_read ?? 0,
+              write: input.context_over_200k.cache_write ?? 0,
             },
           },
         ]
@@ -51,13 +50,13 @@ function cost(input: ModelsDev.Model["cost"]): ModelInfo["cost"] {
   ]
 }
 
-function mergeCost(base: ModelInfo["cost"], override: ModelsDev.Model["cost"] | undefined) {
+function mergeCost(base: ModelV2Info["cost"], override: ModelsDev.Model["cost"] | undefined) {
   if (!override) return base
   const next = cost(override)
   const [baseDefault, ...baseTiers] = base
   const [nextDefault, ...nextTiers] = next
-  const tierKey = (item: ModelInfo["cost"][number]) => `${item.tier?.type ?? "base"}:${item.tier?.size ?? 0}`
-  const merge = (left: ModelInfo["cost"][number], right: ModelInfo["cost"][number]) => ({
+  const tierKey = (item: ModelV2Info["cost"][number]) => `${item.tier?.type ?? "base"}:${item.tier?.size ?? 0}`
+  const merge = (left: ModelV2Info["cost"][number], right: ModelV2Info["cost"][number]) => ({
     ...left,
     ...right,
     tier: right.tier ?? left.tier,
@@ -68,25 +67,12 @@ function mergeCost(base: ModelInfo["cost"], override: ModelsDev.Model["cost"] |
     const current = tiers.get(tierKey(item))
     tiers.set(tierKey(item), current ? merge(current, item) : item)
   }
-  return [
-    merge(
-      baseDefault ?? {
-        input: Money.USDPerMillionTokens.zero,
-        output: Money.USDPerMillionTokens.zero,
-        cache: {
-          read: Money.USDPerMillionTokens.zero,
-          write: Money.USDPerMillionTokens.zero,
-        },
-      },
-      nextDefault,
-    ),
-    ...tiers.values(),
-  ]
+  return [merge(baseDefault ?? { input: 0, output: 0, cache: { read: 0, write: 0 } }, nextDefault), ...tiers.values()]
 }
 
 const OPENAI_INCLUDE_ENCRYPTED_REASONING = ["reasoning.encrypted_content"]
 
-function reasoningVariants(provider: ModelsDev.Provider, model: ModelsDev.Model): NonNullable<ModelInfo["variants"]> {
+function reasoningVariants(provider: ModelsDev.Provider, model: ModelsDev.Model): NonNullable<ModelV2Info["variants"]> {
   const npm = model.provider?.npm ?? provider.npm
   const options = model.reasoning_options ?? []
   const effort = options.find((option) => option.type === "effort")
@@ -131,7 +117,7 @@ function settingsForEffort(npm: string | undefined, effort: string): ProviderV2.
 function budgetVariants(
   npm: string | undefined,
   option: Extract<NonNullable<ModelsDev.Model["reasoning_options"]>[number], { type: "budget_tokens" }>,
-): NonNullable<ModelInfo["variants"]> {
+): NonNullable<ModelV2Info["variants"]> {
   const max = option.max
   const high =
     option.max === undefined
@@ -160,7 +146,7 @@ function modeName(model: ModelsDev.Model, mode: string) {
   return `${model.name} ${mode.charAt(0).toUpperCase()}${mode.slice(1)}`
 }
 
-function mergeVariants(model: ModelInfo, next: NonNullable<ModelInfo["variants"]>) {
+function mergeVariants(model: ModelV2Info, next: NonNullable<ModelV2Info["variants"]>) {
   const variants = model.variants ?? []
   const existing = new Map(variants.map((variant) => [variant.id, variant]))
   const nextIDs = new Set(next.map((variant) => variant.id))
@@ -171,13 +157,13 @@ function mergeVariants(model: ModelInfo, next: NonNullable<ModelInfo["variants"]
 }
 
 function applyModel(
-  draft: ModelInfo,
+  draft: ModelV2Info,
   model: ModelsDev.Model,
   input: {
     readonly name?: string
-    readonly cost?: ModelInfo["cost"]
+    readonly cost?: ModelV2Info["cost"]
     readonly request?: NonNullable<NonNullable<ModelsDev.Model["experimental"]>["modes"]>[string]["provider"]
-    readonly variants?: NonNullable<ModelInfo["variants"]>
+    readonly variants?: NonNullable<ModelV2Info["variants"]>
   } = {},
 ) {
   draft.name = input.name ?? model.name

packages/core/src/plugin/promise.ts

@@ -1,7 +1,6 @@
 export * as PluginPromise from "./promise"
 
 import { Plugin } from "@opencode-ai/plugin/v2/effect"
-import type { IntegrationDefinition } from "@opencode-ai/plugin/v2/integration"
 import { Effect, Scope, Stream } from "effect"
 
 type HostRegistration = { readonly dispose: Effect.Effect<void> }
@@ -88,7 +87,6 @@ export function fromPromise(plugin: PromisePlugin) {
               complete: (input) => run(host.integration.attempt.complete(input)),
               cancel: (input) => run(host.integration.attempt.cancel(input)),
             },
-            register: (definition) => register(host.integration.register(adaptIntegration(definition))),
             transform: transform(host.integration),
             reload: () => run(host.integration.reload()),
             connection: {
@@ -129,54 +127,3 @@ export function fromPromise(plugin: PromisePlugin) {
       }),
   })
 }
-
-function adaptIntegration(definition: IntegrationDefinition) {
-  const { methods, websearch, ...definitionInfo } = definition
-  return {
-    ...definitionInfo,
-    methods: methods?.map((method) => {
-      if (method.type !== "oauth") return method
-      const { authorize, refresh, ...methodInfo } = method
-      return {
-        ...methodInfo,
-        authorize: (inputs: Parameters<typeof authorize>[0]) =>
-          Effect.tryPromise({ try: () => authorize(inputs), catch: (cause) => cause }).pipe(
-            Effect.map((authorization) => {
-              if (authorization.mode === "auto") {
-                return {
-                  ...authorization,
-                  callback: Effect.tryPromise({ try: () => authorization.callback, catch: (cause) => cause }),
-                }
-              }
-              return {
-                ...authorization,
-                callback: (code: string) =>
-                  Effect.tryPromise({ try: () => authorization.callback(code), catch: (cause) => cause }),
-              }
-            }),
-          ),
-        ...(refresh
-          ? {
-              refresh: (credential: Parameters<typeof refresh>[0]) =>
-                Effect.tryPromise({ try: () => refresh(credential), catch: (cause) => cause }),
-            }
-          : {}),
-      }
-    }),
-    ...(websearch
-      ? {
-          websearch: {
-            connection: websearch.connection,
-            execute: (
-              input: Parameters<typeof websearch.execute>[0],
-              execution: Omit<Parameters<typeof websearch.execute>[1], "signal">,
-            ) =>
-              Effect.tryPromise({
-                try: (signal) => websearch.execute(input, { ...execution, signal }),
-                catch: (cause) => cause,
-              }),
-          },
-        }
-      : {}),
-  }
-}

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

@@ -10,7 +10,6 @@ import { Integration } from "../../integration"
 import { ModelV2 } from "../../model"
 import { ProviderV2 } from "../../provider"
 import { ConfigProviderV1 } from "../../v1/config/provider"
-import { Money } from "@opencode-ai/schema/money"
 import { ConfigProviderOptionsV1 } from "../../v1/config/provider-options"
 import { ConfigV1 } from "../../v1/config/config"
 
@@ -221,23 +220,20 @@ function withoutCredentials(body: Readonly<Record<string, unknown>> | undefined)
 
 function remoteCost(input: NonNullable<(typeof ConfigProviderV1.Model.Type)["cost"]>) {
   const base = {
-    input: Money.USDPerMillionTokens.make(input.input),
-    output: Money.USDPerMillionTokens.make(input.output),
-    cache: {
-      read: Money.USDPerMillionTokens.make(input.cache_read ?? 0),
-      write: Money.USDPerMillionTokens.make(input.cache_write ?? 0),
-    },
+    input: input.input,
+    output: input.output,
+    cache: { read: input.cache_read ?? 0, write: input.cache_write ?? 0 },
   }
   if (!input.context_over_200k) return [base]
   return [
     base,
     {
       tier: { type: "context" as const, size: 200_000 },
-      input: Money.USDPerMillionTokens.make(input.context_over_200k.input),
-      output: Money.USDPerMillionTokens.make(input.context_over_200k.output),
+      input: input.context_over_200k.input,
+      output: input.context_over_200k.output,
       cache: {
-        read: Money.USDPerMillionTokens.make(input.context_over_200k.cache_read ?? 0),
-        write: Money.USDPerMillionTokens.make(input.context_over_200k.cache_write ?? 0),
+        read: input.context_over_200k.cache_read ?? 0,
+        write: input.context_over_200k.cache_write ?? 0,
       },
     },
   ]

packages/core/src/plugin/skill.ts

@@ -33,8 +33,7 @@ export const Plugin = define({
         SkillV2.EmbeddedSource.make({
           type: "embedded",
           skill: SkillV2.Info.make({
-            id: SkillV2.ID.make("opencode"),
-            name: SkillV2.Name.make("OpenCode"),
+            name: "opencode",
             description: OpencodeDescription,
             location: AbsolutePath.make("/builtin/opencode.md"),
             content: OpencodeContent,
@@ -45,8 +44,7 @@ export const Plugin = define({
         SkillV2.EmbeddedSource.make({
           type: "embedded",
           skill: SkillV2.Info.make({
-            id: SkillV2.ID.make("report"),
-            name: SkillV2.Name.make("Report"),
+            name: "report",
             description: REPORT_DESCRIPTION,
             slash: true,
             location: AbsolutePath.make("/builtin/report.md"),
@@ -105,22 +103,15 @@ const configuredPlugins = Effect.fn("SkillPlugin.configuredPlugins")(function* (
 })
 
 function terminal() {
-  return (
-    [
-      process.env.TERM_PROGRAM ? `TERM_PROGRAM=${process.env.TERM_PROGRAM}` : undefined,
-      process.env.TERM ? `TERM=${process.env.TERM}` : undefined,
-      process.env.COLORTERM ? `COLORTERM=${process.env.COLORTERM}` : undefined,
-    ]
-      .filter((item): item is string => item !== undefined)
-      .join(", ") || "Unavailable: terminal environment variables are not set"
-  )
+  return [
+    process.env.TERM_PROGRAM ? `TERM_PROGRAM=${process.env.TERM_PROGRAM}` : undefined,
+    process.env.TERM ? `TERM=${process.env.TERM}` : undefined,
+    process.env.COLORTERM ? `COLORTERM=${process.env.COLORTERM}` : undefined,
+  ]
+    .filter((item): item is string => item !== undefined)
+    .join(", ") || "Unavailable: terminal environment variables are not set"
 }
 
 function shell() {
-  return (
-    process.env.SHELL ??
-    process.env.ComSpec ??
-    process.env.COMSPEC ??
-    "Unavailable: shell environment variable is not set"
-  )
+  return process.env.SHELL ?? process.env.ComSpec ?? process.env.COMSPEC ?? "Unavailable: shell environment variable is not set"
 }

packages/core/src/plugin/websearch/exa.ts

@@ -1,60 +0,0 @@
-export * as WebSearchExa from "./exa"
-
-import { define } from "@opencode-ai/plugin/v2/effect/plugin"
-import { Effect, Schema, Scope } from "effect"
-import { HttpClient } from "effect/unstable/http"
-import { WebSearchMcp } from "./mcp"
-
-export const endpoint = "https://mcp.exa.ai/mcp"
-
-const Input = Schema.Struct({
-  query: Schema.String,
-  numResults: Schema.Number.pipe(Schema.optional),
-})
-
-const Output = Schema.Struct({
-  content: Schema.Array(
-    Schema.Struct({
-      type: Schema.Literal("text"),
-      text: Schema.String,
-      _meta: Schema.Struct({ searchTime: Schema.Number }).pipe(Schema.optional),
-    }),
-  ),
-})
-
-export const Plugin = define<HttpClient.HttpClient | Scope.Scope>({
-  id: "opencode.websearch.exa",
-  effect: Effect.fn("WebSearchExa.Plugin")(function* (ctx) {
-    const http = yield* HttpClient.HttpClient
-    yield* ctx.integration.register({
-      id: "exa",
-      name: "Exa",
-      methods: [
-        { type: "key", label: "API key (optional)" },
-        { type: "env", names: ["EXA_API_KEY"] },
-      ],
-      websearch: {
-        connection: "optional",
-        execute: (input, context) => {
-          const url = new URL(endpoint)
-          if (context.credential?.type === "key") url.searchParams.set("exaApiKey", context.credential.key)
-          return WebSearchMcp.call(
-            http,
-            url.toString(),
-            "web_search_exa",
-            { input: Input, output: Output },
-            { query: input.query, numResults: 8 },
-          ).pipe(
-            Effect.map((result) => {
-              const content = result?.content.find((item) => item.text)
-              return {
-                text: content?.text ?? "",
-                ...(content?._meta ? { metadata: content._meta } : {}),
-              }
-            }),
-          )
-        },
-      },
-    })
-  }),
-})

packages/core/src/plugin/websearch/index.ts

@@ -1,4 +0,0 @@
-import { WebSearchExa } from "./exa"
-import { WebSearchParallel } from "./parallel"
-
-export const WebSearchPlugins = [WebSearchExa.Plugin, WebSearchParallel.Plugin] as const

packages/core/src/plugin/websearch/mcp.ts

@@ -1,69 +0,0 @@
-export * as WebSearchMcp from "./mcp"
-
-import { Duration, Effect, Schema } from "effect"
-import { HttpClient, HttpClientRequest } from "effect/unstable/http"
-import { collectBoundedResponseBody } from "../../tool/http-body"
-
-export const MAX_RESPONSE_BYTES = 256 * 1024
-
-export const parseResponse = <F extends Schema.Struct.Fields>(body: string, result: Schema.Struct<F>) => {
-  const decode = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Struct({ result })))
-  const parse = (payload: string) => {
-    const trimmed = payload.trim()
-    if (!trimmed.startsWith("{")) return Effect.succeed(undefined)
-    return decode(trimmed).pipe(Effect.map((response) => response.result))
-  }
-  return Effect.gen(function* () {
-    const trimmed = body.trim()
-    const direct = trimmed ? yield* parse(trimmed) : undefined
-    if (direct) return direct
-    for (const line of body.split("\n")) {
-      if (!line.startsWith("data: ")) continue
-      const data = yield* parse(line.substring(6))
-      if (data) return data
-    }
-  })
-}
-
-const Request = <F extends Schema.Struct.Fields>(args: Schema.Struct<F>) =>
-  Schema.Struct({
-    jsonrpc: Schema.Literal("2.0"),
-    id: Schema.Literal(1),
-    method: Schema.Literal("tools/call"),
-    params: Schema.Struct({ name: Schema.String, arguments: args }),
-  })
-
-export const call = <F extends Schema.Struct.Fields, R extends Schema.Struct.Fields>(
-  http: HttpClient.HttpClient,
-  url: string,
-  tool: string,
-  schema: { readonly input: Schema.Struct<F>; readonly output: Schema.Struct<R> },
-  value: Schema.Struct.Type<F>,
-  headers: Record<string, string> = {},
-) =>
-  Effect.gen(function* () {
-    const request = yield* HttpClientRequest.post(url).pipe(
-      HttpClientRequest.accept("application/json, text/event-stream"),
-      HttpClientRequest.setHeaders(headers),
-      HttpClientRequest.schemaBodyJson(Request(schema.input))({
-        jsonrpc: "2.0" as const,
-        id: 1 as const,
-        method: "tools/call" as const,
-        params: { name: tool, arguments: value },
-      }),
-    )
-    return yield* Effect.gen(function* () {
-      const response = yield* HttpClient.filterStatusOk(http).execute(request)
-      const body = yield* collectBoundedResponseBody(
-        response,
-        MAX_RESPONSE_BYTES,
-        () => new Error(`${tool} response exceeded ${MAX_RESPONSE_BYTES} bytes`),
-      )
-      return yield* parseResponse(body.toString("utf8"), schema.output)
-    }).pipe(
-      Effect.timeoutOrElse({
-        duration: Duration.seconds(25),
-        orElse: () => Effect.fail(new Error(`${tool} request timed out`)),
-      }),
-    )
-  })

packages/core/src/plugin/websearch/parallel.ts

@@ -1,92 +0,0 @@
-export * as WebSearchParallel from "./parallel"
-
-import { define } from "@opencode-ai/plugin/v2/effect/plugin"
-import { Effect, Schema, Scope } from "effect"
-import { HttpClient } from "effect/unstable/http"
-import { InstallationVersion } from "../../installation/version"
-import { WebSearchMcp } from "./mcp"
-
-export const endpoint = "https://search.parallel.ai/mcp"
-
-const Input = Schema.Struct({
-  objective: Schema.String,
-  search_queries: Schema.Array(Schema.String),
-  session_id: Schema.String.check(Schema.isMaxLength(100)).pipe(Schema.optional),
-  model_name: Schema.String.check(Schema.isMaxLength(100)).pipe(Schema.optional),
-})
-
-const Metadata = Schema.Struct({
-  search_id: Schema.String,
-  results: Schema.Array(
-    Schema.Struct({
-      url: Schema.String,
-      title: Schema.NullOr(Schema.String).pipe(Schema.optional),
-      publish_date: Schema.NullOr(Schema.String).pipe(Schema.optional),
-      excerpts: Schema.Array(Schema.String),
-    }),
-  ),
-  warnings: Schema.NullOr(
-    Schema.Array(
-      Schema.Struct({
-        type: Schema.Literals(["spec_validation_warning", "input_validation_warning", "warning"]),
-        message: Schema.String,
-        detail: Schema.NullOr(Schema.Record(Schema.String, Schema.Json)).pipe(Schema.optional),
-      }),
-    ),
-  ).pipe(Schema.optional),
-  usage: Schema.NullOr(
-    Schema.Array(
-      Schema.Struct({
-        name: Schema.String,
-        count: Schema.Int,
-      }),
-    ),
-  ).pipe(Schema.optional),
-  session_id: Schema.String,
-})
-const Output = Schema.Struct({
-  content: Schema.Array(Schema.Struct({ type: Schema.Literal("text"), text: Schema.String })),
-  structuredContent: Metadata,
-})
-
-export const Plugin = define<HttpClient.HttpClient | Scope.Scope>({
-  id: "opencode.websearch.parallel",
-  effect: Effect.fn("WebSearchParallel.Plugin")(function* (ctx) {
-    const http = yield* HttpClient.HttpClient
-    yield* ctx.integration.register({
-      id: "parallel",
-      name: "Parallel",
-      methods: [
-        { type: "key", label: "API key (optional)" },
-        { type: "env", names: ["PARALLEL_API_KEY"] },
-      ],
-      websearch: {
-        connection: "optional",
-        execute: (input, context) =>
-          WebSearchMcp.call(
-            http,
-            endpoint,
-            "web_search",
-            { input: Input, output: Output },
-            {
-              objective: input.query,
-              search_queries: [input.query],
-              ...(context.sessionID ? { session_id: context.sessionID } : {}),
-            },
-            {
-              "User-Agent": `opencode/${InstallationVersion}`,
-              ...(context.credential?.type === "key" ? { Authorization: `Bearer ${context.credential.key}` } : {}),
-            },
-          ).pipe(
-            Effect.map((result) => {
-              const content = result?.content.find((item) => item.text)
-              return {
-                text: content?.text ?? "",
-                ...(result ? { metadata: result.structuredContent } : {}),
-              }
-            }),
-          ),
-      },
-    })
-  }),
-})

packages/core/src/session.ts

@@ -1,7 +1,7 @@
 export * as SessionV2 from "./session"
 export * from "./session/schema"
 
-import { Effect, Layer, Schema, Context, Stream, Scope } from "effect"
+import { DateTime, Effect, Layer, Schema, Context, Stream, Scope } from "effect"
 import { ListAnchor } from "@opencode-ai/schema/session"
 import { and, asc, desc, eq, gt, isNull, like, lt, or, type SQL } from "drizzle-orm"
 import { ProjectV2 } from "./project"
@@ -19,7 +19,6 @@ import { SessionSchema } from "./session/schema"
 import { AbsolutePath, PositiveInt, RelativePath } from "./schema"
 import { AgentV2 } from "./agent"
 import { SessionV1 } from "./v1/session"
-import { Money } from "@opencode-ai/schema/money"
 import { InstallationVersion } from "./installation/version"
 import { Slug } from "./util/slug"
 import { ProjectTable } from "./project/sql"
@@ -35,7 +34,7 @@ import { SessionEvent } from "./session/event"
 import { SessionInput } from "./session/input"
 import { Snapshot } from "./snapshot"
 import { SessionRevert } from "./session/revert"
-import { Session } from "@opencode-ai/schema/session"
+import { Revert } from "@opencode-ai/schema/revert"
 import { FSUtil } from "./fs-util"
 import { Mime } from "./mime"
 import type { EventLog } from "@opencode-ai/schema/event-log"
@@ -47,8 +46,8 @@ import { Shell as ShellSchema } from "@opencode-ai/schema/shell"
 import { KeyedMutex } from "./effect/keyed-mutex"
 import { fileURLToPath } from "url"
 
-export const RevertState = Session.Revert
-export type RevertState = Session.Revert
+export const RevertState = Revert.State
+export type RevertState = Revert.State
 
 // get project -> project.locations
 //
@@ -137,7 +136,7 @@ export class BusyError extends Schema.TaggedErrorClass<BusyError>()("Session.Bus
   sessionID: SessionSchema.ID,
 }) {}
 export class SkillNotFoundError extends Schema.TaggedErrorClass<SkillNotFoundError>()("Session.SkillNotFoundError", {
-  skill: SkillV2.ID,
+  skill: Schema.String,
 }) {}
 export const MessageNotFoundError = SessionRevert.MessageNotFoundError
 export type MessageNotFoundError = SessionRevert.MessageNotFoundError
@@ -171,14 +170,14 @@ export interface Interface {
       id: SessionMessage.ID
       direction: "previous" | "next"
     }
-  }) => Effect.Effect<SessionMessage.Info[], NotFoundError | MessageDecodeError>
+  }) => Effect.Effect<SessionMessage.Message[], NotFoundError | MessageDecodeError>
   readonly message: (input: {
     sessionID: SessionSchema.ID
     messageID: SessionMessage.ID
-  }) => Effect.Effect<SessionMessage.Info | undefined>
+  }) => Effect.Effect<SessionMessage.Message | undefined>
   readonly context: (
     sessionID: SessionSchema.ID,
-  ) => Effect.Effect<SessionMessage.Info[], NotFoundError | MessageDecodeError>
+  ) => Effect.Effect<SessionMessage.Message[], NotFoundError | MessageDecodeError>
   /**
    * Durable, ordered, gap-free session log read. Replays public durable
    * session events after the exclusive `after` cursor, emits a `Synced`
@@ -192,10 +191,7 @@ export interface Interface {
     after?: number
     follow?: boolean
   }) => Stream.Stream<SessionEvent.DurableEvent | EventLog.Synced, NotFoundError>
-  readonly switchAgent: (input: {
-    sessionID: SessionSchema.ID
-    agent: AgentV2.ID
-  }) => Effect.Effect<void, NotFoundError>
+  readonly switchAgent: (input: { sessionID: SessionSchema.ID; agent: string }) => Effect.Effect<void, NotFoundError>
   readonly switchModel: (input: {
     sessionID: SessionSchema.ID
     model: ModelV2.Ref
@@ -213,7 +209,7 @@ export interface Interface {
     sessionID: SessionSchema.ID
     command: string
     arguments?: string
-    agent?: AgentV2.ID
+    agent?: string
     model?: ModelV2.Ref
     files?: PromptInput.Prompt["files"]
     agents?: PromptInput.Prompt["agents"]
@@ -231,7 +227,7 @@ export interface Interface {
   readonly skill: (input: {
     id?: SessionMessage.ID
     sessionID: SessionSchema.ID
-    skill: SkillV2.ID
+    skill: string
     resume?: boolean
   }) => Effect.Effect<void, NotFoundError | SkillNotFoundError>
   readonly compact: (
@@ -254,7 +250,7 @@ export interface Interface {
       sessionID: SessionSchema.ID
       messageID: SessionMessage.ID
       files?: boolean
-    }) => Effect.Effect<Session.Revert, NotFoundError | MessageNotFoundError | BusyError | Snapshot.Error>
+    }) => Effect.Effect<Revert.State, NotFoundError | MessageNotFoundError | BusyError | Snapshot.Error>
     readonly clear: (sessionID: SessionSchema.ID) => Effect.Effect<void, NotFoundError | BusyError | Snapshot.Error>
     readonly commit: (sessionID: SessionSchema.ID) => Effect.Effect<void, NotFoundError | BusyError>
   }
@@ -277,7 +273,7 @@ const layer = Layer.effect(
     const scope = yield* Scope.Scope
     const activeShells = new Set<SessionSchema.ID>()
     const shellLocks = KeyedMutex.makeUnsafe<SessionSchema.ID>()
-    const decodeMessage = Schema.decodeUnknownEffect(SessionMessage.Info)
+    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(
@@ -326,7 +322,7 @@ const layer = Layer.effect(
                 variant: input.model.variant,
               }
             : undefined,
-          cost: Money.USD.zero,
+          cost: 0,
           tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
           time: { created: now, updated: now },
         })
@@ -533,7 +529,7 @@ const layer = Layer.effect(
         })
         const model = command.model ?? commandAgent?.model ?? input.model
         if (agent !== undefined && session.agent !== AgentV2.ID.make(agent))
-          yield* result.switchAgent({ sessionID: input.sessionID, agent: AgentV2.ID.make(agent) })
+          yield* result.switchAgent({ sessionID: input.sessionID, agent })
         if (model !== undefined) yield* result.switchModel({ sessionID: input.sessionID, model })
 
         return yield* result.prompt({
@@ -595,13 +591,12 @@ const layer = Layer.effect(
       skill: Effect.fn("V2Session.skill")(function* (input) {
         const session = yield* result.get(input.sessionID)
         const skills = yield* SkillV2.Service.pipe(Effect.provide(locations.get(session.location)))
-        const skill = (yield* skills.list()).find((item) => item.id === input.skill)
+        const skill = (yield* skills.list()).find((item) => item.name === input.skill)
         if (!skill) return yield* new SkillNotFoundError({ skill: input.skill })
         yield* events.publish(
           SessionEvent.Skill.Activated,
           {
             sessionID: input.sessionID,
-            id: skill.id,
             name: skill.name,
             text: skill.content,
           },

packages/core/src/session/compaction.ts

@@ -64,21 +64,19 @@ type Dependencies = {
 
 export type AutoInput = {
   readonly sessionID: SessionSchema.ID
-  readonly messages: readonly SessionMessage.Info[]
+  readonly messages: readonly SessionMessage.Message[]
   readonly request: LLMRequest
 }
 
 type CompactInput = {
   readonly sessionID: SessionSchema.ID
-  readonly messages: readonly SessionMessage.Info[]
+  readonly messages: readonly SessionMessage.Message[]
   readonly model: Model
-  readonly inputID?: SessionMessage.ID
 }
 
 export type ManualInput = {
   readonly session: SessionSchema.Info
-  readonly messages: readonly SessionMessage.Info[]
-  readonly inputID: SessionMessage.ID
+  readonly messages: readonly SessionMessage.Message[]
 }
 
 export interface Interface {
@@ -101,7 +99,7 @@ export const serializeToolContent = (content: SessionMessage.ToolStateCompleted[
     )
     .join("\n")
 
-const serialize = (message: SessionMessage.Info) => {
+const serialize = (message: SessionMessage.Message) => {
   if (message.type === "user") {
     const files =
       message.files?.map(
@@ -130,7 +128,7 @@ const serialize = (message: SessionMessage.Info) => {
   if (message.type === "system") return `[System update]: ${message.text}`
   if (message.type === "synthetic") return `[Synthetic context]: ${message.text}`
   if (message.type === "skill") return `[Skill activated: ${message.name}]\n${message.text}`
-  if (message.type === "shell") return `[Shell]: ${message.command}\n${truncate(message.output?.output ?? "")}`
+  if (message.type === "shell") return `[Shell]: ${message.shell.command}\n${truncate(message.output?.output ?? "")}`
   return ""
 }
 
@@ -149,7 +147,7 @@ const settings = (documents: readonly Config.Entry[]) => {
 }
 
 const select = (
-  messages: readonly SessionMessage.Info[],
+  messages: readonly SessionMessage.Message[],
   tokens: number,
 ): { readonly head: string; readonly recent: string } | undefined => {
   const conversation = messages
@@ -200,7 +198,6 @@ const make = (dependencies: Dependencies) => {
     readonly context: readonly string[]
     readonly recent: string
     readonly output?: number
-    readonly inputID?: SessionMessage.ID
   }) {
     const context = input.model.route.defaults.limits?.context
     if (context === undefined || context <= 0) return false
@@ -211,8 +208,6 @@ const make = (dependencies: Dependencies) => {
     yield* dependencies.events.publish(SessionEvent.Compaction.Started, {
       sessionID: input.sessionID,
       reason: input.reason,
-      recent: input.recent,
-      inputID: input.inputID,
     })
 
     const chunks: string[] = []
@@ -240,27 +235,9 @@ const make = (dependencies: Dependencies) => {
         }),
         Effect.as(true),
         Effect.catchTag("LLM.Error", () => Effect.succeed(false)),
-        Effect.onInterrupt(() =>
-          input.reason === "auto"
-            ? dependencies.events.publish(SessionEvent.Compaction.Failed, {
-                sessionID: input.sessionID,
-                reason: input.reason,
-                error: { type: "compaction.interrupted", message: "Compaction was interrupted" },
-                inputID: input.inputID,
-              })
-            : Effect.void,
-        ),
       )
     const summary = chunks.join("")
-    if (!summarized || failed || !summary.trim()) {
-      yield* dependencies.events.publish(SessionEvent.Compaction.Failed, {
-        sessionID: input.sessionID,
-        reason: input.reason,
-        error: { type: "compaction.failed", message: "Compaction produced no summary" },
-        inputID: input.inputID,
-      })
-      return false
-    }
+    if (!summarized || failed || !summary.trim()) return false
     yield* dependencies.events.publish(SessionEvent.Compaction.Ended, {
       sessionID: input.sessionID,
       reason: input.reason,
@@ -307,7 +284,6 @@ const make = (dependencies: Dependencies) => {
       ),
       recent: forcedShortContext ? "" : selected.recent,
       output: input.output,
-      inputID: input.inputID,
     })
   })
   const compactManual = Effect.fn("SessionCompaction.compactManual")(function* (input: CompactInput) {
@@ -351,7 +327,6 @@ export const layer = Layer.effect(
           sessionID: input.session.id,
           messages: input.messages,
           model: resolved.model,
-          inputID: input.inputID,
         })
       }),
     })

packages/core/src/session/history.ts

@@ -8,7 +8,7 @@ import { InstructionCheckpointTable, SessionMessageTable } from "./sql"
 
 type DatabaseService = Database.Interface["db"]
 
-const decode = Schema.decodeUnknownEffect(SessionMessage.Info)
+const decode = Schema.decodeUnknownEffect(SessionMessage.Message)
 
 export const latestCompaction = Effect.fnUntraced(function* (db: DatabaseService, sessionID: SessionSchema.ID) {
   return yield* db

packages/core/src/session/info.ts

@@ -1,4 +1,4 @@
-import { DateTime, Schema } from "effect"
+import { DateTime } from "effect"
 import { AgentV2 } from "../agent"
 import { Location } from "../location"
 import { ModelV2 } from "../model"
@@ -9,10 +9,7 @@ import { WorkspaceV2 } from "../workspace"
 import { SessionSchema } from "./schema"
 import { SessionTable } from "./sql"
 import { SessionMessage } from "./message"
-import { PersistedRevert } from "@opencode-ai/schema/session-revert"
-import { Money } from "@opencode-ai/schema/money"
-
-const decodeRevert = Schema.decodeUnknownSync(PersistedRevert)
+import { Snapshot } from "../snapshot"
 
 export function fromRow(row: typeof SessionTable.$inferSelect): SessionSchema.Info {
   return SessionSchema.Info.make({
@@ -34,7 +31,7 @@ export function fromRow(row: typeof SessionTable.$inferSelect): SessionSchema.In
           variant: ModelV2.VariantID.make(row.model.variant ?? "default"),
         }
       : undefined,
-    cost: Money.USD.make(row.cost),
+    cost: row.cost,
     tokens: {
       input: row.tokens_input,
       output: row.tokens_output,
@@ -49,7 +46,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 ? decodeRevert(row.revert) : undefined,
+    revert: row.revert ? { ...row.revert, messageID: SessionMessage.ID.make(row.revert.messageID) } : undefined,
     time: {
       created: DateTime.makeUnsafe(row.time_created),
       updated: DateTime.makeUnsafe(row.time_updated),

packages/core/src/session/input.ts

@@ -2,7 +2,7 @@ export * as SessionInput from "./input"
 
 import { and, asc, eq, isNull } from "drizzle-orm"
 import { DateTime, Effect, Schema } from "effect"
-import { Admitted, Compaction, Delivery, Info, PromptEntry } from "@opencode-ai/schema/session-input"
+import { Admitted, Compaction, Delivery, Entry, PromptEntry } from "@opencode-ai/schema/session-input"
 import type { Database } from "../database/database"
 import type { EventV2 } from "../event"
 import { KeyedMutex } from "../effect/keyed-mutex"
@@ -14,7 +14,7 @@ import { SessionInputTable, SessionMessageTable } from "./sql"
 
 type DatabaseService = Database.Interface["db"]
 
-export { Admitted, Compaction, Delivery, Info, PromptEntry }
+export { Admitted, Compaction, Delivery, Entry, PromptEntry }
 
 const decodePrompt = Schema.decodeUnknownSync(Prompt)
 const encodePrompt = Schema.encodeSync(Prompt)
@@ -24,7 +24,7 @@ export class LifecycleConflict extends Schema.TaggedErrorClass<LifecycleConflict
   id: SessionMessage.ID,
 }) {}
 
-const fromRow = (row: typeof SessionInputTable.$inferSelect): Info => {
+const fromRow = (row: typeof SessionInputTable.$inferSelect): Entry => {
   const base = {
     admittedSeq: row.admitted_seq,
     id: SessionMessage.ID.make(row.id),

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

@@ -4,7 +4,7 @@ import { SessionEvent } from "./event"
 import { SessionMessage } from "./message"
 
 export type MemoryState = {
-  messages: SessionMessage.Info[]
+  messages: SessionMessage.Message[]
 }
 
 export interface Adapter {
@@ -14,13 +14,13 @@ export interface Adapter {
     messageID: SessionMessage.ID,
   ) => Effect.Effect<SessionMessage.Assistant | undefined, never, never>
   readonly getShell: (
-    shellID: SessionMessage.Shell["shellID"],
+    shellID: SessionMessage.Shell["shell"]["id"],
   ) => Effect.Effect<SessionMessage.Shell | undefined, never, never>
   readonly getCompaction: () => Effect.Effect<SessionMessage.Compaction | undefined, never, never>
   readonly updateAssistant: (assistant: SessionMessage.Assistant) => Effect.Effect<void, never, never>
   readonly updateShell: (shell: SessionMessage.Shell) => Effect.Effect<void, never, never>
   readonly updateCompaction: (compaction: SessionMessage.Compaction) => Effect.Effect<void, never, never>
-  readonly appendMessage: (message: SessionMessage.Info) => Effect.Effect<void, never, never>
+  readonly appendMessage: (message: SessionMessage.Message) => Effect.Effect<void, never, never>
 }
 
 export function memory(state: MemoryState): Adapter {
@@ -29,7 +29,9 @@ export function memory(state: MemoryState): Adapter {
   const shellIndex = (messageID: SessionMessage.ID) =>
     state.messages.findLastIndex((message) => message.id === messageID)
   const compactionIndex = () =>
-    state.messages.findLastIndex((message) => message.type === "compaction" && message.status === "running")
+    state.messages.findLastIndex(
+      (message) => message.type === "compaction" && (message.status === "queued" || message.status === "running"),
+    )
   // A newer step supersedes stale incomplete rows; never resume an older assistant projection.
   const latestAssistantIndex = () => state.messages.findLastIndex((message) => message.type === "assistant")
 
@@ -62,7 +64,7 @@ export function memory(state: MemoryState): Adapter {
     getShell(shellID) {
       return Effect.sync(() => {
         return state.messages.find((message): message is SessionMessage.Shell => {
-          return message.type === "shell" && message.shellID === shellID
+          return message.type === "shell" && message.shell.id === shellID
         })
       })
     },
@@ -184,13 +186,13 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
             id: SessionMessage.ID.fromEvent(event.id),
             type: "system",
             text: event.data.text,
-            metadata: event.metadata,
             time: { created: event.created },
           }),
         ),
       "session.synthetic": (event) => {
         return adapter.appendMessage(
           SessionMessage.Synthetic.make({
+            sessionID: event.data.sessionID,
             text: event.data.text,
             description: event.data.description,
             metadata: event.data.metadata,
@@ -205,10 +207,8 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
           SessionMessage.Skill.make({
             id: SessionMessage.ID.fromEvent(event.id),
             type: "skill",
-            skill: event.data.id,
             name: event.data.name,
             text: event.data.text,
-            metadata: event.metadata,
             time: { created: event.created },
           }),
         )
@@ -219,9 +219,7 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
             id: SessionMessage.ID.fromEvent(event.id),
             type: "shell",
             metadata: event.metadata,
-            shellID: event.data.shell.id,
-            command: event.data.shell.command,
-            status: event.data.shell.status,
+            shell: event.data.shell,
             time: { created: event.created },
           }),
         )
@@ -232,8 +230,7 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
           if (currentShell) {
             yield* adapter.updateShell(
               produce(currentShell, (draft) => {
-                draft.status = event.data.shell.status
-                draft.exit = event.data.shell.exit
+                draft.shell = castDraft(event.data.shell)
                 draft.output = event.data.output
                 draft.time.completed = event.created
               }),
@@ -273,7 +270,6 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
               type: "assistant",
               agent: event.data.agent,
               model: event.data.model,
-              metadata: event.metadata,
               time: { created: event.created },
               content: [],
               snapshot: event.data.snapshot ? { start: event.data.snapshot } : undefined,
@@ -333,7 +329,7 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
                 id: event.data.callID,
                 name: event.data.name,
                 time: { created: event.created },
-                state: SessionMessage.ToolStateStreaming.make({ status: "streaming", input: "" }),
+                state: SessionMessage.ToolStatePending.make({ status: "pending", input: "" }),
               }),
             ),
           )
@@ -343,7 +339,7 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
       "session.tool.input.ended": (event) => {
         return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
           const match = latestTool(draft, event.data.callID)
-          if (match && match.state.status === "streaming") match.state.input = event.data.text
+          if (match && match.state.status === "pending") match.state.input = event.data.text
         })
       },
       "session.tool.called": (event) => {
@@ -386,6 +382,7 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
                 input: match.state.input,
                 structured: event.data.structured,
                 content: [...event.data.content],
+                outputPaths: event.data.outputPaths ? [...event.data.outputPaths] : [],
                 result: event.data.result,
               }),
             )
@@ -395,7 +392,7 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
       "session.tool.failed": (event) => {
         return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
           const match = latestTool(draft, event.data.callID)
-          if (match && (match.state.status === "streaming" || match.state.status === "running")) {
+          if (match && (match.state.status === "pending" || match.state.status === "running")) {
             match.executed = event.data.executed || match.executed === true
             match.providerResultState = event.data.resultState
             match.time.completed = event.created
@@ -451,30 +448,31 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
           }
         })
       },
-      "session.compaction.admitted": () => Effect.void,
-      "session.compaction.started": (event) =>
+      "session.compaction.admitted": (event) =>
         adapter.appendMessage(
-          SessionMessage.CompactionRunning.make({
-            id: event.data.inputID ?? SessionMessage.ID.fromEvent(event.id),
+          SessionMessage.Compaction.make({
+            id: event.data.inputID,
             type: "compaction",
-            status: "running",
+            status: "queued",
             metadata: event.metadata,
-            reason: event.data.reason,
+            reason: "manual",
             summary: "",
-            recent: event.data.recent ?? "",
+            recent: "",
             time: { created: event.created },
           }),
         ),
-      "session.compaction.delta": (event) =>
+      "session.compaction.started": (event) =>
         Effect.gen(function* () {
+          if (event.data.reason !== "manual") return
           const current = yield* adapter.getCompaction()
-          if (current?.status !== "running") return
-          yield* adapter.updateCompaction({ ...current, summary: current.summary + event.data.text })
+          if (!current) return
+          yield* adapter.updateCompaction({ ...current, status: "running" })
         }),
+      "session.compaction.delta": () => Effect.void,
       "session.compaction.ended": (event) => {
         return Effect.gen(function* () {
-          const current = yield* adapter.getCompaction()
-          if (current?.status === "running") {
+          const current = event.data.reason === "manual" ? yield* adapter.getCompaction() : undefined
+          if (current) {
             yield* adapter.updateCompaction({
               ...current,
               status: "completed",
@@ -498,20 +496,11 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
           )
         })
       },
-      "session.compaction.failed": (event) =>
+      "session.compaction.failed": () =>
         Effect.gen(function* () {
           const current = yield* adapter.getCompaction()
-          const failed = SessionMessage.CompactionFailed.make({
-            id: current?.id ?? event.data.inputID ?? SessionMessage.ID.fromEvent(event.id),
-            type: "compaction",
-            status: "failed",
-            metadata: current?.metadata ?? event.metadata,
-            reason: event.data.reason,
-            error: event.data.error,
-            time: current?.time ?? { created: event.created },
-          })
-          if (current?.status === "running") return yield* adapter.updateCompaction(failed)
-          yield* adapter.appendMessage(failed)
+          if (!current) return
+          yield* adapter.updateCompaction({ ...current, status: "failed" })
         }),
       "session.revert.staged": () => Effect.void,
       "session.revert.cleared": () => Effect.void,

packages/core/src/session/projector.ts

@@ -24,14 +24,15 @@ import {
 } from "./sql"
 import type { DeepMutable } from "../schema"
 import { Slug } from "../util/slug"
-import { Money } from "@opencode-ai/schema/money"
 
 type DatabaseService = Database.Interface["db"]
-type CurrentDurableEvent = Extract<SessionEvent.Event, { readonly durable: object }>
-type MessageEvent = Exclude<CurrentDurableEvent, typeof SessionEvent.Forked.Type | typeof SessionEvent.Deleted.Type>
+type MessageEvent = Exclude<
+  SessionEvent.DurableEvent,
+  typeof SessionEvent.Forked.Type | typeof SessionEvent.Deleted.Type
+>
 
-const decodeMessage = Schema.decodeUnknownSync(SessionMessage.Info)
-const encodeMessage = Schema.encodeSync(SessionMessage.Info)
+const decodeMessage = Schema.decodeUnknownSync(SessionMessage.Message)
+const encodeMessage = Schema.encodeSync(SessionMessage.Message)
 
 export class SessionAlreadyProjected extends Error {}
 
@@ -86,14 +87,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
-      ? {
-          messageID: SessionMessage.ID.make(info.revert.messageID),
-          partID: info.revert.partID,
-          snapshot: info.revert.snapshot,
-          diff: info.revert.diff,
-        }
-      : null,
+    revert: info.revert ? { ...info.revert, messageID: SessionMessage.ID.make(info.revert.messageID) } : null,
     permission: info.permission ? [...info.permission] : undefined,
     time_created: info.time.created,
     time_updated: info.time.updated,
@@ -157,7 +151,7 @@ const publishSessionUsage = Effect.fn("SessionProjector.publishUsage")(function*
   if (!row) return
   yield* events.publish(SessionEvent.UsageUpdated, {
     sessionID,
-    cost: Money.USD.make(row.cost),
+    cost: row.cost,
     tokens: {
       input: row.input,
       output: row.output,
@@ -263,7 +257,7 @@ const projectFork = Effect.fn("SessionProjector.projectFork")(function* (
           eq(SessionMessageTable.session_id, event.data.parentID),
           gt(SessionMessageTable.seq, cursor),
           lt(SessionMessageTable.seq, copiedSeq + 1),
-          sql`${SessionMessageTable.type} != 'compaction' or json_extract(${SessionMessageTable.data}, '$.status') != 'running'`,
+          sql`${SessionMessageTable.type} != 'compaction' or json_extract(${SessionMessageTable.data}, '$.status') not in ('queued', 'running')`,
         ),
       )
       .orderBy(asc(SessionMessageTable.seq))
@@ -286,7 +280,7 @@ const projectFork = Effect.fn("SessionProjector.projectFork")(function* (
             seq: row.seq,
             time_created: row.time_created,
             time_updated: row.time_updated,
-            data: row.data,
+            data: row.type === "synthetic" ? { ...row.data, sessionID: event.data.sessionID } : row.data,
           }
         }),
       )
@@ -342,7 +336,7 @@ function run(db: DatabaseService, event: MessageEvent) {
   return Effect.gen(function* () {
     const decodeRow = (row: typeof SessionMessageTable.$inferSelect) =>
       decodeMessage({ ...row.data, id: row.id, type: row.type })
-    const updateMessage = (message: SessionMessage.Info) => {
+    const updateMessage = (message: SessionMessage.Message) => {
       if (event.durable === undefined)
         return Effect.die(new Error("Durable Session event is missing aggregate sequence"))
       const encoded = encodeMessage(message)
@@ -359,7 +353,7 @@ function run(db: DatabaseService, event: MessageEvent) {
         .run()
         .pipe(Effect.orDie)
     }
-    const appendMessage = (message: SessionMessage.Info) => insertMessage(db, event, message)
+    const appendMessage = (message: SessionMessage.Message) => insertMessage(db, event, message)
     const adapter: SessionMessageUpdater.Adapter = {
       getModel() {
         return db
@@ -418,7 +412,7 @@ function run(db: DatabaseService, event: MessageEvent) {
               and(
                 eq(SessionMessageTable.session_id, event.data.sessionID),
                 eq(SessionMessageTable.type, "shell"),
-                sql`json_extract(${SessionMessageTable.data}, '$.shellID') = ${shellID}`,
+                sql`json_extract(${SessionMessageTable.data}, '$.shell.id') = ${shellID}`,
               ),
             )
             .orderBy(desc(SessionMessageTable.seq))
@@ -439,7 +433,7 @@ function run(db: DatabaseService, event: MessageEvent) {
               and(
                 eq(SessionMessageTable.session_id, event.data.sessionID),
                 eq(SessionMessageTable.type, "compaction"),
-                sql`json_extract(${SessionMessageTable.data}, '$.status') = 'running'`,
+                sql`json_extract(${SessionMessageTable.data}, '$.status') in ('queued', 'running')`,
               ),
             )
             .orderBy(desc(SessionMessageTable.seq))
@@ -460,7 +454,7 @@ function run(db: DatabaseService, event: MessageEvent) {
   })
 }
 
-function insertMessage(db: DatabaseService, event: SessionEvent.DurableEvent, message: SessionMessage.Info) {
+function insertMessage(db: DatabaseService, event: SessionEvent.DurableEvent, message: SessionMessage.Message) {
   if (event.durable === undefined) return Effect.die(new Error("Durable Session event is missing aggregate sequence"))
   const encoded = encodeMessage(message)
   const { id, type, ...data } = encoded
@@ -667,12 +661,14 @@ const layer = Layer.effectDiscard(
       Effect.gen(function* () {
         if (event.durable === undefined)
           return yield* Effect.die(new Error("Durable Session event is missing aggregate sequence"))
-        yield* SessionInput.projectCompactionAdmitted(db, {
+        const admitted = yield* SessionInput.projectCompactionAdmitted(db, {
           admittedSeq: event.durable.seq,
           id: event.data.inputID,
           sessionID: event.data.sessionID,
           timeCreated: event.created,
         })
+        if (admitted.id !== event.data.inputID) return
+        yield* run(db, event)
       }),
     )
     yield* events.project(SessionEvent.Execution.Succeeded, (event) => run(db, event))
@@ -680,7 +676,15 @@ const layer = Layer.effectDiscard(
     yield* events.project(SessionEvent.Execution.Interrupted, (event) => run(db, event))
     yield* events.project(SessionEvent.InstructionsUpdated, (event) => run(db, event))
     yield* events.project(SessionEvent.Synthetic, (event) => run(db, event))
-    yield* events.project(SessionEvent.Skill.Activated, (event) => run(db, event))
+    yield* events.project(SessionEvent.Skill.Activated, (event) =>
+      insertMessage(db, event, {
+        id: SessionMessage.ID.fromEvent(event.id),
+        type: "skill",
+        name: event.data.name,
+        text: event.data.text,
+        time: { created: event.created },
+      }),
+    )
     yield* events.project(SessionEvent.Shell.Started, (event) => run(db, event))
     yield* events.project(SessionEvent.Shell.Ended, (event) => run(db, event))
     yield* events.project(SessionEvent.Step.Started, (event) => run(db, event))
@@ -726,26 +730,22 @@ const layer = Layer.effectDiscard(
         yield* run(db, event)
         if (event.durable === undefined)
           return yield* Effect.die(new Error("Durable Session event is missing aggregate sequence"))
-        if (event.data.reason === "manual")
-          yield* SessionInput.settleCompaction(db, {
-            sessionID: event.data.sessionID,
-            handledSeq: event.durable.seq,
-          })
+        yield* SessionInput.settleCompaction(db, {
+          sessionID: event.data.sessionID,
+          handledSeq: event.durable.seq,
+        })
       }),
     )
     yield* events.project(SessionEvent.RevertEvent.Staged, (event) =>
-      Effect.gen(function* () {
-        const revert = event.data.revert
-        yield* db
-          .update(SessionTable)
-          .set({
-            revert: { ...revert, files: revert.files ? [...revert.files] : undefined },
-            time_updated: DateTime.toEpochMillis(event.created),
-          })
-          .where(eq(SessionTable.id, event.data.sessionID))
-          .run()
-          .pipe(Effect.orDie)
-      }),
+      db
+        .update(SessionTable)
+        .set({
+          revert: { ...event.data.revert, files: event.data.revert.files ? [...event.data.revert.files] : undefined },
+          time_updated: DateTime.toEpochMillis(event.created),
+        })
+        .where(eq(SessionTable.id, event.data.sessionID))
+        .run()
+        .pipe(Effect.orDie, Effect.asVoid),
     )
     yield* events.project(SessionEvent.RevertEvent.Cleared, (event) =>
       db

packages/core/src/session/revert.ts

@@ -1,7 +1,7 @@
 export * as SessionRevert from "./revert"
 
 import { and, asc, eq, gt } from "drizzle-orm"
-import { Effect, Schema } from "effect"
+import { DateTime, Effect, Schema } from "effect"
 import { Database } from "../database/database"
 import { EventV2 } from "../event"
 import { RelativePath } from "../schema"
@@ -46,7 +46,7 @@ const plan = Effect.fn("SessionRevert.plan")(function* (input: BoundaryInput) {
     .orderBy(asc(SessionMessageTable.seq))
     .all()
     .pipe(Effect.orDie)
-  const decode = Schema.decodeUnknownEffect(SessionMessage.Info)
+  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)
@@ -70,7 +70,7 @@ export const stage = Effect.fn("SessionRevert.stage")(function* (input: {
   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(RelativePath.make(file.file), 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 })
@@ -81,6 +81,10 @@ export const stage = Effect.fn("SessionRevert.stage")(function* (input: {
   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, {
@@ -96,7 +100,7 @@ export const clear = Effect.fn("SessionRevert.clear")(function* (session: Sessio
   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) => [RelativePath.make(file.file), original])),
+      files: new Map((session.revert.files ?? []).map((file) => [file.path, original])),
     })
   const events = yield* EventV2.Service
   yield* events.publish(SessionEvent.RevertEvent.Cleared, {

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

@@ -11,7 +11,6 @@ import {
   type ProviderErrorEvent,
 } from "@opencode-ai/llm"
 import { SessionError } from "@opencode-ai/schema/session-error"
-import { Money } from "@opencode-ai/schema/money"
 import { Cause, Effect, Exit, Fiber, FiberSet, Layer, Option, Semaphore, Stream } from "effect"
 import { AgentV2 } from "../../agent"
 import { Config } from "../../config"
@@ -68,13 +67,13 @@ export function calculateCost(costs: ModelV2.Info["cost"], tokens: StepTokens) {
     .filter((cost) => cost.tier?.type === "context" && context > cost.tier.size)
     .toSorted((a, b) => (b.tier?.size ?? 0) - (a.tier?.size ?? 0))[0]
   const cost = tier ?? costs.find((cost) => cost.tier === undefined)
-  if (!cost) return Money.USD.zero
-  return Money.USD.make(
+  if (!cost) return 0
+  return (
     (tokens.input * cost.input +
       (tokens.output + tokens.reasoning) * cost.output +
       tokens.cache.read * cost.cache.read +
       tokens.cache.write * cost.cache.write) /
-      1_000_000,
+    1_000_000
   )
 }
 
@@ -166,7 +165,7 @@ const layer = Layer.effect(
       for (const message of yield* store.context(sessionID)) {
         if (message.type !== "assistant") continue
         for (const tool of message.content) {
-          if (tool.type !== "tool" || (tool.state.status !== "streaming" && tool.state.status !== "running")) continue
+          if (tool.type !== "tool" || (tool.state.status !== "pending" && tool.state.status !== "running")) continue
           yield* events.publish(SessionEvent.Tool.Failed, {
             sessionID,
             assistantMessageID: message.id,
@@ -233,7 +232,6 @@ const layer = Layer.effect(
       }
       const resolved = yield* models.resolve(session)
       const model = resolved.model
-      const providerMetadataKey = model.route.providerMetadataKey ?? model.provider
       const entries = yield* SessionHistory.entriesForRunner(db, session.id, checkpoint.baselineSeq)
       const context = entries.map((entry) => entry.message)
       const isLastStep = agent.info?.steps !== undefined && currentStep >= agent.info.steps
@@ -251,7 +249,7 @@ const layer = Layer.effect(
           .filter((part): part is string => part !== undefined && part.length > 0)
           .map(SystemPart.make),
         messages: [
-          ...toLLMMessages(context, resolved.ref, providerMetadataKey),
+          ...toLLMMessages(context, resolved.ref),
           ...(isLastStep ? [Message.assistant(MAX_STEPS_PROMPT)] : []),
         ],
         tools: toolMaterialization?.definitions ?? [],
@@ -294,7 +292,7 @@ const layer = Layer.effect(
         // The selected catalog identity, not model.id: route-level ids are provider API
         // model ids (for example gpt-5.5-fast resolves to api id gpt-5.5).
         model: resolved.ref,
-        providerMetadataKey,
+        provider: model.provider,
         snapshot: startSnapshot,
         assistantMessageID,
       })
@@ -302,7 +300,8 @@ const layer = Layer.effect(
       // Durable publishes are serialized so tool fibers and step settlement never interleave
       // mid-event.
       const serialized = <A, E, R>(effect: Effect.Effect<A, E, R>) => publication.withPermit(effect)
-      const publish = (event: LLMEvent, error?: SessionError.Error) => serialized(publisher.publish(event, error))
+      const publish = (event: LLMEvent, outputPaths: ReadonlyArray<string> = [], error?: SessionError.Error) =>
+        serialized(publisher.publish(event, outputPaths, error))
       let overflowFailure: ProviderErrorEvent | undefined
       const providerStream = llm.stream(hookedRequest).pipe(
         Stream.runForEach((event) =>
@@ -316,25 +315,10 @@ const layer = Layer.effect(
             }
             yield* publish(event)
             if (event.type !== "tool-call" || event.providerExecuted) return
-            if (!toolMaterialization) {
+            if (!toolMaterialization || !advertisedTools.has(event.name)) {
               yield* serialized(
                 publisher.failUnsettledTools({
                   type: "tool.execution",
-                  message: "Tools are disabled after the maximum agent steps",
-                }),
-              )
-              return
-            }
-            // A request hook hid this registered tool from the current request. Fail only
-            // this call durably and continue so the model can react, instead of executing
-            // a tool that was not advertised. Unregistered tools flow through settle, which
-            // durably fails them as unknown.
-            if (!advertisedTools.has(event.name) && availableTools.has(event.name)) {
-              needsContinuation = true
-              yield* publish(
-                LLMEvent.toolError({
-                  id: event.id,
-                  name: event.name,
                   message: `Tool is not available for this request: ${event.name}`,
                 }),
               )
@@ -360,6 +344,7 @@ const layer = Layer.effect(
                         result: settlement.result,
                         output: settlement.output,
                       }),
+                      settlement.outputPaths ?? [],
                       settlement.error,
                     ).pipe(
                       Effect.andThen(
@@ -599,30 +584,12 @@ const layer = Layer.effect(
               return yield* compaction.compactManual({
                 session,
                 messages: yield* store.context(sessionID),
-                inputID: pending.id,
               })
             }),
           ).pipe(Effect.exit)
           if (Exit.isSuccess(compacted) && compacted.value) return true
-          if (Exit.isFailure(compacted)) {
-            const unsettled = yield* SessionInput.pendingCompaction(db, sessionID)
-            if (unsettled)
-              yield* events.publish(SessionEvent.Compaction.Failed, {
-                sessionID,
-                reason: "manual",
-                error: { type: "compaction.failed", message: Cause.pretty(compacted.cause) },
-                inputID: unsettled.id,
-              })
-            return yield* Effect.failCause(compacted.cause)
-          }
-          const unsettled = yield* SessionInput.pendingCompaction(db, sessionID)
-          if (unsettled)
-            yield* events.publish(SessionEvent.Compaction.Failed, {
-              sessionID,
-              reason: "manual",
-              error: { type: "compaction.failed", message: "Compaction could not start" },
-              inputID: unsettled.id,
-            })
+          yield* events.publish(SessionEvent.Compaction.Failed, { sessionID })
+          if (Exit.isFailure(compacted)) return yield* Effect.failCause(compacted.cause)
           return true
         }),
       )
@@ -657,13 +624,10 @@ const layer = Layer.effect(
           }
           needsContinuation = result.needsContinuation
           step = result.step + 1
-          if (needsContinuation) {
-            promotion = (yield* SessionInput.pendingCompaction(db, input.sessionID)) ? undefined : "steer"
-            continue
-          }
+          // Manual compaction is a barrier: handle it before continuing or promoting steers.
           yield* runPendingCompaction(input.sessionID)
           promotion = "steer"
-          needsContinuation = yield* SessionInput.hasPending(db, input.sessionID, "steer")
+          if (!needsContinuation) needsContinuation = yield* SessionInput.hasPending(db, input.sessionID, "steer")
         }
         yield* runPendingCompaction(input.sessionID)
         const hasSteer = yield* SessionInput.hasPending(db, input.sessionID, "steer")

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

@@ -6,16 +6,13 @@ import { SessionEvent } from "../event"
 import { SessionMessage } from "../message"
 import { SessionSchema } from "../schema"
 import { SessionError } from "@opencode-ai/schema/session-error"
-import { Money } from "@opencode-ai/schema/money"
-import { AgentV2 } from "../../agent"
-import { Snapshot } from "../../snapshot"
 
 type Input = {
   readonly sessionID: SessionSchema.ID
-  readonly agent: AgentV2.ID
+  readonly agent: string
   readonly model: ModelV2.Ref
-  readonly providerMetadataKey: string
-  readonly snapshot?: Snapshot.ID
+  readonly provider: string
+  readonly snapshot?: string
   readonly assistantMessageID?: SessionMessage.ID
 }
 
@@ -87,9 +84,7 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
     assistantMessageID ??= SessionMessage.ID.create()
     stepStarted = true
     yield* events.publish(SessionEvent.Step.Started, {
-      sessionID: input.sessionID,
-      agent: input.agent,
-      model: input.model,
+      ...input,
       assistantMessageID,
       snapshot: input.snapshot,
     })
@@ -99,7 +94,8 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
     assistantMessageID === undefined
       ? Effect.die(new Error("Tool event before assistant step start"))
       : Effect.succeed(assistantMessageID)
-  const providerState = (metadata: ProviderMetadata | undefined) => metadata?.[input.providerMetadataKey]
+  const providerState = (metadata: ProviderMetadata | undefined) => metadata?.[input.provider]
+
   const fragments = (
     name: string,
     ended: (id: string, value: string, ordinal: number, state?: Record<string, unknown>) => Effect.Effect<void>,
@@ -230,7 +226,7 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
   })
 
   const publishStepFailure = Effect.fnUntraced(function* (usage?: {
-    readonly cost: Money.USD
+    readonly cost: number
     readonly tokens: ReturnType<typeof tokens>
   }) {
     if (stepFailed || stepFailure === undefined) return
@@ -269,7 +265,11 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
     return tool ? Effect.succeed(tool.assistantMessageID) : Effect.die(new Error(`Unknown tool call: ${callID}`))
   }
 
-  const publish = Effect.fn("SessionRunner.publishLLMEvent")(function* (event: LLMEvent, error?: SessionError.Error) {
+  const publish = Effect.fn("SessionRunner.publishLLMEvent")(function* (
+    event: LLMEvent,
+    outputPaths: ReadonlyArray<string> = [],
+    error?: SessionError.Error,
+  ) {
     switch (event.type) {
       case "step-start":
         yield* startAssistant()
@@ -353,13 +353,14 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
         if (tool.called) return yield* Effect.die(new Error(`Duplicate tool call: ${event.id}`))
         tool.called = true
         tool.providerExecuted = event.providerExecuted === true
+        const state = providerState(event.providerMetadata)
         yield* events.publish(SessionEvent.Tool.Called, {
           sessionID: input.sessionID,
           assistantMessageID: tool.assistantMessageID,
           callID: event.id,
           input: record(event.input),
           executed: tool.providerExecuted,
-          state: providerState(event.providerMetadata),
+          state,
         })
         return
       }
@@ -394,6 +395,7 @@ export const createLLMEventPublisher = (events: EventV2.Interface, input: Input)
           assistantMessageID: tool.assistantMessageID,
           callID: event.id,
           ...result,
+          outputPaths,
           ...(executed ? { result: event.result } : {}),
           executed,
           resultState,

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

@@ -69,7 +69,7 @@ const providerMetadata = (
 ): ProviderMetadata | undefined => (state === undefined ? undefined : { [provider]: state })
 
 const toolInput = (tool: SessionMessage.AssistantTool) =>
-  tool.state.status === "streaming"
+  tool.state.status === "pending"
     ? Option.getOrElse(decodeToolInput(tool.state.input), () => tool.state.input)
     : tool.state.input
 
@@ -113,7 +113,7 @@ const toolResult = (tool: SessionMessage.AssistantTool, providerMetadata: Provid
   }
 }
 
-const assistant = (message: SessionMessage.Assistant, model: ModelV2.Ref, providerMetadataKey: string) => {
+const assistant = (message: SessionMessage.Assistant, model: ModelV2.Ref) => {
   const sameModel =
     String(message.model.providerID) === String(model.providerID) && String(message.model.id) === String(model.id)
   const reuseProviderMetadata = sameModel && message.error === undefined
@@ -125,7 +125,7 @@ const assistant = (message: SessionMessage.Assistant, model: ModelV2.Ref, provid
             {
               type: "reasoning",
               text: item.text,
-              providerMetadata: providerMetadata(providerMetadataKey, item.state),
+              providerMetadata: providerMetadata(model.providerID, item.state),
             },
           ]
         : item.text.length > 0
@@ -133,13 +133,13 @@ const assistant = (message: SessionMessage.Assistant, model: ModelV2.Ref, provid
           : []
     const call = toolCall(
       item,
-      reuseProviderMetadata ? providerMetadata(providerMetadataKey, item.providerState) : undefined,
+      reuseProviderMetadata ? providerMetadata(model.providerID, item.providerState) : undefined,
     )
     if (item.executed !== true) return [call]
     const result = toolResult(
       item,
       reuseProviderMetadata
-        ? providerMetadata(providerMetadataKey, item.providerResultState ?? item.providerState)
+        ? providerMetadata(model.providerID, item.providerResultState ?? item.providerState)
         : undefined,
     )
     return result ? [call, result] : [call]
@@ -155,7 +155,7 @@ const assistant = (message: SessionMessage.Assistant, model: ModelV2.Ref, provid
       toolResult(
         item,
         reuseProviderMetadata
-          ? providerMetadata(providerMetadataKey, item.providerResultState ?? item.providerState)
+          ? providerMetadata(model.providerID, item.providerResultState ?? item.providerState)
           : undefined,
       ),
     )
@@ -168,7 +168,7 @@ const assistant = (message: SessionMessage.Assistant, model: ModelV2.Ref, provid
   ]
 }
 
-function toLLMMessage(message: SessionMessage.Info, model: ModelV2.Ref, providerMetadataKey: string): Message[] {
+function toLLMMessage(message: SessionMessage.Message, model: ModelV2.Ref): Message[] {
   switch (message.type) {
     case "agent-switched":
     case "model-switched":
@@ -202,12 +202,12 @@ function toLLMMessage(message: SessionMessage.Info, model: ModelV2.Ref, provider
         Message.make({
           id: message.id,
           role: "user",
-          content: `Shell command: ${message.command}\n\n${message.output?.output ?? ""}`,
+          content: `Shell command: ${message.shell.command}\n\n${message.output?.output ?? ""}`,
           metadata: message.metadata,
         }),
       ]
     case "assistant":
-      return assistant(message, model, providerMetadataKey)
+      return assistant(message, model)
     case "compaction":
       if (message.status !== "completed") return []
       return [
@@ -232,8 +232,5 @@ ${message.recent}
 }
 
 /** Translate projected V2 Session history into canonical @opencode-ai/llm context. */
-export const toLLMMessages = (
-  messages: readonly SessionMessage.Info[],
-  model: ModelV2.Ref,
-  providerMetadataKey: string = model.providerID,
-) => messages.flatMap((message) => toLLMMessage(message, model, providerMetadataKey))
+export const toLLMMessages = (messages: readonly SessionMessage.Message[], model: ModelV2.Ref) =>
+  messages.flatMap((message) => toLLMMessage(message, model))

packages/core/src/session/sql.ts

@@ -5,7 +5,7 @@ import { ProjectTable } from "../project/sql"
 import type { SessionMessage } from "./message"
 import type { Prompt } from "@opencode-ai/schema/prompt"
 import type { SessionInput } from "./input"
-import type { FileDiff } from "@opencode-ai/schema/file-diff"
+import type { Snapshot } from "../snapshot"
 import { PermissionV1 } from "../v1/permission"
 import { ProjectV2 } from "../project"
 import type { SessionSchema } from "./schema"
@@ -13,11 +13,10 @@ import type { MessageID, PartID, SessionV1 } from "../v1/session"
 import { WorkspaceV2 } from "../workspace"
 import { Timestamps } from "../database/schema.sql"
 import type { Instructions } from "../instructions/index"
-import type { Session } from "@opencode-ai/schema/session"
-import type { RevertV1 } from "@opencode-ai/schema/session-revert"
+import type { Revert } from "@opencode-ai/schema/revert"
 import type { Schema } from "effect"
 
-type SessionMessageData = Omit<(typeof SessionMessage.Info)["Encoded"], "type" | "id">
+type SessionMessageData = Omit<(typeof SessionMessage.Message)["Encoded"], "type" | "id">
 type V1MessageData = Omit<SessionV1.Info, "id" | "sessionID">
 type V1PartData = Omit<SessionV1.Part, "id" | "sessionID" | "messageID">
 
@@ -42,7 +41,7 @@ export const SessionTable = sqliteTable(
     summary_additions: integer(),
     summary_deletions: integer(),
     summary_files: integer(),
-    summary_diffs: text({ mode: "json" }).$type<FileDiff.LegacyInfo[]>(),
+    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),
@@ -50,7 +49,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<Session.Revert | RevertV1>(),
+    revert: text({ mode: "json" }).$type<Revert.State>(),
     permission: text({ mode: "json" }).$type<PermissionV1.Ruleset>(),
     agent: text(),
     model: text({ mode: "json" }).$type<{
@@ -149,7 +148,7 @@ export const SessionInputTable = sqliteTable(
       .$type<SessionSchema.ID>()
       .notNull()
       .references(() => SessionTable.id, { onDelete: "cascade" }),
-    type: text().$type<SessionInput.Info["type"]>().notNull(),
+    type: text().$type<SessionInput.Entry["type"]>().notNull(),
     prompt: text({ mode: "json" }).$type<Prompt>(),
     delivery: text().$type<SessionInput.Delivery>(),
     admitted_seq: integer().notNull(),

packages/core/src/session/store.ts

@@ -13,10 +13,10 @@ import { fromRow } from "./info"
 
 export interface Interface {
   readonly get: (sessionID: Session.ID) => Effect.Effect<Session.Info | undefined>
-  readonly context: (sessionID: Session.ID) => Effect.Effect<SessionMessage.Info[], MessageDecodeError>
+  readonly context: (sessionID: Session.ID) => Effect.Effect<SessionMessage.Message[], MessageDecodeError>
   readonly message: (
     messageID: SessionMessage.ID,
-  ) => Effect.Effect<{ readonly sessionID: Session.ID; readonly message: SessionMessage.Info } | undefined>
+  ) => Effect.Effect<{ readonly sessionID: Session.ID; readonly message: SessionMessage.Message } | undefined>
 }
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/v2/SessionStore") {}
@@ -25,7 +25,7 @@ const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
     const { db } = yield* Database.Service
-    const decodeMessage = Schema.decodeUnknownEffect(SessionMessage.Info)
+    const decodeMessage = Schema.decodeUnknownEffect(SessionMessage.Message)
 
     return Service.of({
       get: Effect.fn("SessionStore.get")(function* (sessionID) {

packages/core/src/skill.ts

@@ -28,15 +28,11 @@ export type Source = typeof Source.Type
 
 export const Info = Skill.Info
 export type Info = Skill.Info
-export const ID = Skill.ID
-export type ID = Skill.ID
-export const Name = Skill.Name
-export type Name = Skill.Name
 
 export const Event = Skill.Event
 
 export const available = (skills: ReadonlyArray<Info>, agent: AgentV2.Info) =>
-  skills.filter((skill) => PermissionV2.evaluate("skill", skill.id, agent.permissions).effect !== "deny")
+  skills.filter((skill) => PermissionV2.evaluate("skill", skill.name, agent.permissions).effect !== "deny")
 
 const Frontmatter = Schema.Struct({
   name: Schema.String.pipe(Schema.optional),
@@ -100,7 +96,7 @@ const layer = Layer.effect(
           source: Source.key(source),
           type: source.type,
           directories: [],
-          skills: [source.skill.id],
+          skills: [source.skill.name],
         })
         return { skills: [source.skill], directories: [] }
       }
@@ -116,13 +112,15 @@ const layer = Layer.effect(
           if (!markdown) continue
           const frontmatter = decodeFrontmatter(markdown.data).valueOrUndefined
           if (!frontmatter) continue
-          const id =
-            path.dirname(filepath) === directory
-              ? path.basename(filepath, ".md")
-              : path.basename(path.dirname(filepath))
+          const name =
+            frontmatter.name !== undefined
+              ? frontmatter.name
+              : path.dirname(filepath) === directory
+                ? path.basename(filepath, ".md")
+                : undefined
+          if (!name) continue
           skills.push({
-            id: ID.make(id),
-            name: Name.make(frontmatter.name ?? id),
+            name,
             description: frontmatter.description,
             slash: metadataBoolean(frontmatter.metadata, "opencode/slash") ?? frontmatter.slash,
             autoinvoke: metadataBoolean(frontmatter.metadata, "opencode/autoinvoke"),
@@ -135,7 +133,7 @@ const layer = Layer.effect(
         source: Source.key(source),
         type: source.type,
         directories,
-        skills: skills.map((skill) => skill.id),
+        skills: skills.map((skill) => skill.name),
       })
       return { skills, directories }
     })
@@ -150,7 +148,7 @@ const layer = Layer.effect(
       yield* Effect.logInfo("skill cache invalidated", {
         file,
         sources: invalidated.map(([key]) => key),
-        skills: invalidated.flatMap(([, loaded]) => loaded.skills.map((skill) => skill.id)),
+        skills: invalidated.flatMap(([, loaded]) => loaded.skills.map((skill) => skill.name)),
       })
       yield* events.publish(Event.Updated, {}).pipe(Effect.asVoid)
     })
@@ -161,12 +159,12 @@ const layer = Layer.effect(
     )
 
     const list = Effect.fn("SkillV2.list")(function* () {
-      const skills = new Map<ID, Info>()
+      const skills = new Map<string, Info>()
       for (const source of state.get().sources) {
         const key = Source.key(source)
         const loaded = cache.get(key) ?? (yield* load(source))
         cache.set(key, loaded)
-        for (const skill of loaded.skills) skills.set(skill.id, skill)
+        for (const skill of loaded.skills) skills.set(skill.name, skill)
       }
       return Array.from(skills.values())
     })
@@ -182,8 +180,4 @@ const layer = Layer.effect(
   }),
 )
 
-export const node = makeLocationNode({
-  service: Service,
-  layer,
-  deps: [SkillDiscovery.node, FSUtil.node, EventV2.node],
-})
+export const node = makeLocationNode({ service: Service, layer, deps: [SkillDiscovery.node, FSUtil.node, EventV2.node] })

packages/core/src/skill/guidance.ts

@@ -8,8 +8,7 @@ import { SkillV2 } from "../skill"
 import { Instructions } from "../instructions/index"
 
 const Summary = Schema.Struct({
-  id: SkillV2.ID,
-  name: SkillV2.Name,
+  name: Schema.String,
   description: Schema.String,
 })
 type Summary = typeof Summary.Type
@@ -17,7 +16,6 @@ type Summary = typeof Summary.Type
 const entries = (skills: ReadonlyArray<Summary>) =>
   skills.flatMap((skill) => [
     "  <skill>",
-    `    <id>${skill.id}</id>`,
     `    <name>${skill.name}</name>`,
     `    <description>${skill.description}</description>`,
     "  </skill>",
@@ -36,8 +34,8 @@ const update = (previous: ReadonlyArray<Summary>, current: ReadonlyArray<Summary
   const diff = Instructions.diffByKey(
     previous,
     current,
-    (skill) => skill.id,
-    (before, after) => before.name !== after.name || before.description !== after.description,
+    (skill) => skill.name,
+    (before, after) => before.description !== after.description,
   )
   // Additions and removals render as small deltas; anything else restates the full list.
   if (diff.changed.length > 0 || (diff.added.length === 0 && diff.removed.length === 0))
@@ -52,7 +50,7 @@ const update = (previous: ReadonlyArray<Summary>, current: ReadonlyArray<Summary
     ...(diff.removed.length === 0
       ? []
       : [
-          `The following skill IDs are no longer available and must not be used: ${diff.removed.map((skill) => skill.id).join(", ")}.`,
+          `The following skills are no longer available and must not be used: ${diff.removed.map((skill) => skill.name).join(", ")}.`,
         ]),
   ].join("\n")
 }
@@ -79,9 +77,9 @@ const layer = Layer.effect(
           .flatMap((skill) =>
             skill.description === undefined || skill.autoinvoke === false
               ? []
-              : [{ id: skill.id, name: skill.name, description: skill.description }],
+              : [{ name: skill.name, description: skill.description }],
           )
-          .toSorted((a, b) => a.id.localeCompare(b.id))
+          .toSorted((a, b) => a.name.localeCompare(b.name))
         return Instructions.make({
           key: Instructions.Key.make("core/skill-guidance"),
           codec: Schema.toCodecJson(Schema.Array(Summary)),

packages/core/src/snapshot.ts

@@ -10,10 +10,10 @@ import { Git } from "./git"
 import { Global } from "./global"
 import { Location } from "./location"
 import { AbsolutePath, RelativePath } from "./schema"
-import { ID } from "@opencode-ai/schema/snapshot"
 import { Hash } from "./util/hash"
 
-export { ID }
+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"]),
@@ -253,3 +253,12 @@ function failure(operation: Error["operation"], cause: unknown) {
     cause,
   })
 }
+
+/** Legacy persisted session diff shape. */
+export type LegacyFileDiff = {
+  file?: string
+  patch?: string
+  additions: number
+  deletions: number
+  status?: "added" | "deleted" | "modified"
+}

packages/core/src/tool/apply-patch.ts

@@ -1,4 +1,4 @@
-export * as PatchTool from "./patch"
+export * as ApplyPatchTool from "./apply-patch"
 
 import type { Context as PluginContext } from "@opencode-ai/plugin/v2/effect/plugin"
 import { ToolFailure } from "@opencode-ai/llm"
@@ -55,8 +55,8 @@ type Prepared =
     })
 
 export const Plugin = {
-  id: "opencode.tool.patch",
-  effect: Effect.fn("PatchTool.Plugin")(function* (ctx: PluginContext) {
+  id: "opencode.tool.apply-patch",
+  effect: Effect.fn("ApplyPatchTool.Plugin")(function* (ctx: PluginContext) {
     const mutation = yield* LocationMutation.Service
     const files = yield* FileMutation.Service
     const fs = yield* FSUtil.Service

packages/core/src/tool/skill.ts

@@ -13,11 +13,11 @@ export const name = "skill"
 const FILE_LIMIT = 10
 
 export const Input = Schema.Struct({
-  id: SkillV2.ID.annotate({ description: "The ID of the skill from the available skills list" }),
+  name: Schema.String.annotate({ description: "The name of the skill from the available skills list" }),
 })
 
 export const Output = Schema.Struct({
-  name: SkillV2.Name,
+  name: Schema.String,
   directory: Schema.String,
   output: Schema.String,
 })
@@ -27,7 +27,7 @@ export const description = [
   "",
   "Use this tool to inject the skill's instructions and resources into the current conversation. The output may contain detailed workflow guidance as well as references to scripts, files, etc. in the same directory as the skill.",
   "",
-  "The skill ID must match one of the available skills in the instructions.",
+  "The skill name must match one of the available skills in the instructions.",
 ].join("\n")
 
 export const toModelOutput = (skill: SkillV2.Info, files: ReadonlyArray<string>) => {
@@ -70,13 +70,13 @@ export const Plugin = {
             execute: (input, context) =>
               Effect.gen(function* () {
                 const current = yield* skills.list()
-                const skill = current.find((skill) => skill.id === input.id)
-                if (!skill) return yield* unableToLoad(input.id)
+                const skill = current.find((skill) => skill.name === input.name)
+                if (!skill) return yield* unableToLoad(input.name)
                 return yield* Effect.gen(function* () {
                   yield* permission.assert({
                     action: name,
-                    resources: [skill.id],
-                    save: [skill.id],
+                    resources: [skill.name],
+                    save: [skill.name],
                     sessionID: context.sessionID,
                     agent: context.agent,
                     source: { type: "tool", messageID: context.assistantMessageID, callID: context.toolCallID },
@@ -94,7 +94,7 @@ export const Plugin = {
                     directory,
                     output: toModelOutput(skill, files),
                   }
-                }).pipe(Effect.mapError((error) => unableToLoad(input.id, error)))
+                }).pipe(Effect.mapError((error) => unableToLoad(input.name, error)))
               }),
           }),
         ),

packages/core/src/tool/websearch.ts

@@ -2,34 +2,197 @@ export * as WebSearchTool from "./websearch"
 
 import type { Context as PluginContext } from "@opencode-ai/plugin/v2/effect/plugin"
 import { ToolFailure } from "@opencode-ai/llm"
-import { Effect, Schema } from "effect"
-import { Integration } from "../integration"
+import { Context, Duration, Effect, Layer, Schema } from "effect"
+import { HttpClient, HttpClientRequest } from "effect/unstable/http"
+import { makeLocationNode } from "../effect/app-node"
+import { truthy } from "../flag/flag"
+import { InstallationVersion } from "../installation/version"
+import { PositiveInt } from "../schema"
 import { PermissionV2 } from "../permission"
-import { WebSearch } from "../websearch"
 import { Tool } from "./tool"
+import { collectBoundedResponseBody } from "./http-body"
+import { checksum } from "../util/encode"
 
 export const name = "websearch"
 export const NO_RESULTS = "No search results found. Please try a different query."
+export const EXA_URL = "https://mcp.exa.ai/mcp"
+export const PARALLEL_URL = "https://search.parallel.ai/mcp"
+export const MAX_NUM_RESULTS = 20
+export const MAX_CONTEXT_CHARACTERS = 50_000
+export const MAX_RESPONSE_BYTES = 256 * 1024
 
-export const description = `Search the web using the user's selected search integration. Use this for current information beyond knowledge cutoff.
+/**
+ * Provider-independent local web search retained in V2 core for launch parity.
+ * This invokes the legacy Exa/Parallel product backends itself. It is distinct
+ * from provider-hosted web search tools, which remain route-owned and execute
+ * at the model provider. Ownership of this compromise can be revisited later.
+ */
+export const description = `Search the web using the session's local web search provider. Use this for current information beyond knowledge cutoff.
+
+This is a provider-independent local tool backed by Exa or Parallel. Provider-hosted web search tools are separate and execute at the model provider.
+
+Optional controls support result count, live crawling ('fallback' or 'preferred'), search type ('auto', 'fast', or 'deep'), and maximum context characters.
 
 The current year is ${new Date().getFullYear()}. Use this year when searching for recent information or current events.`
 
 export const Input = Schema.Struct({
   query: Schema.String.annotate({ description: "Websearch query" }),
+  numResults: Schema.optional(PositiveInt.check(Schema.isLessThanOrEqualTo(MAX_NUM_RESULTS))).annotate({
+    description: `Number of search results to return (default: 8, maximum: ${MAX_NUM_RESULTS})`,
+  }),
+  livecrawl: Schema.optional(Schema.Literals(["fallback", "preferred"])).annotate({
+    description:
+      "Live crawl mode - 'fallback': use live crawling as backup if cached unavailable, 'preferred': prioritize live crawling (default: 'fallback')",
+  }),
+  type: Schema.optional(Schema.Literals(["auto", "fast", "deep"])).annotate({
+    description: "Search type - 'auto': balanced search (default), 'fast': quick results, 'deep': comprehensive search",
+  }),
+  contextMaxCharacters: Schema.optional(PositiveInt.check(Schema.isLessThanOrEqualTo(MAX_CONTEXT_CHARACTERS))).annotate(
+    {
+      description: `Maximum characters for context string optimized for models (default: 10000, maximum: ${MAX_CONTEXT_CHARACTERS})`,
+    },
+  ),
 })
 
+export const Provider = Schema.Literals(["exa", "parallel"])
+export type Provider = typeof Provider.Type
+
+export interface Config {
+  readonly provider?: Provider
+  readonly enableExa: boolean
+  readonly enableParallel: boolean
+  readonly exaApiKey?: string
+  readonly parallelApiKey?: string
+}
+
+export class ConfigService extends Context.Service<ConfigService, Config>()("@opencode/v2/WebSearchConfig") {}
+
+/** Isolates the retained product environment contract from the generic tool implementation. */
+export const defaultConfigLayer = Layer.sync(ConfigService, () =>
+  ConfigService.of({
+    provider:
+      process.env.OPENCODE_WEBSEARCH_PROVIDER === "exa" || process.env.OPENCODE_WEBSEARCH_PROVIDER === "parallel"
+        ? process.env.OPENCODE_WEBSEARCH_PROVIDER
+        : undefined,
+    enableExa: truthy("OPENCODE_EXPERIMENTAL") || truthy("OPENCODE_ENABLE_EXA") || truthy("OPENCODE_EXPERIMENTAL_EXA"),
+    enableParallel: truthy("OPENCODE_ENABLE_PARALLEL") || truthy("OPENCODE_EXPERIMENTAL_PARALLEL"),
+    exaApiKey: process.env.EXA_API_KEY,
+    parallelApiKey: process.env.PARALLEL_API_KEY,
+  }),
+)
+
+export const configNode = makeLocationNode({ service: ConfigService, layer: defaultConfigLayer, deps: [] })
+
+export function selectProvider(
+  sessionID: string,
+  flags: Pick<Config, "enableExa" | "enableParallel"> = { enableExa: false, enableParallel: false },
+  override?: Provider,
+): Provider {
+  if (override) return override
+  if (flags.enableParallel) return "parallel"
+  if (flags.enableExa) return "exa"
+  return Number.parseInt(checksum(sessionID) ?? "0", 36) % 2 === 0 ? "exa" : "parallel"
+}
+
+const McpResult = Schema.Struct({
+  result: Schema.Struct({
+    content: Schema.Array(Schema.Struct({ type: Schema.String, text: Schema.String })),
+  }),
+})
+const decodeMcpResult = Schema.decodeUnknownEffect(Schema.fromJsonString(McpResult))
+
+const parsePayload = (payload: string) =>
+  Effect.gen(function* () {
+    const trimmed = payload.trim()
+    if (!trimmed.startsWith("{")) return undefined
+    return (yield* decodeMcpResult(trimmed)).result.content.find((item) => item.text)?.text
+  })
+
+export const parseResponse = Effect.fn("WebSearchTool.parseResponse")(function* (body: string) {
+  const trimmed = body.trim()
+  const direct = trimmed ? yield* parsePayload(trimmed) : undefined
+  if (direct) return direct
+  for (const line of body.split("\n")) {
+    if (!line.startsWith("data: ")) continue
+    const data = yield* parsePayload(line.substring(6))
+    if (data) return data
+  }
+  return undefined
+})
+
+const ExaArgs = Schema.Struct({
+  query: Schema.String,
+  type: Schema.String,
+  numResults: Schema.Number,
+  livecrawl: Schema.String,
+  contextMaxCharacters: Schema.optional(Schema.Number),
+})
+const ParallelArgs = Schema.Struct({
+  objective: Schema.String,
+  search_queries: Schema.Array(Schema.String),
+  session_id: Schema.String,
+})
+const McpRequest = <F extends Schema.Struct.Fields>(args: Schema.Struct<F>) =>
+  Schema.Struct({
+    jsonrpc: Schema.Literal("2.0"),
+    id: Schema.Literal(1),
+    method: Schema.Literal("tools/call"),
+    params: Schema.Struct({ name: Schema.String, arguments: args }),
+  })
+
+const exaUrl = (apiKey: string | undefined) => {
+  if (!apiKey) return EXA_URL
+  const url = new URL(EXA_URL)
+  url.searchParams.set("exaApiKey", apiKey)
+  return url.toString()
+}
+
+const callMcp = <F extends Schema.Struct.Fields>(
+  http: HttpClient.HttpClient,
+  url: string,
+  tool: string,
+  args: Schema.Struct<F>,
+  value: Schema.Struct.Type<F>,
+  headers: Record<string, string> = {},
+) =>
+  Effect.gen(function* () {
+    const request = yield* HttpClientRequest.post(url).pipe(
+      HttpClientRequest.accept("application/json, text/event-stream"),
+      HttpClientRequest.setHeaders(headers),
+      HttpClientRequest.schemaBodyJson(McpRequest(args))({
+        jsonrpc: "2.0" as const,
+        id: 1 as const,
+        method: "tools/call" as const,
+        params: { name: tool, arguments: value },
+      }),
+    )
+    return yield* Effect.gen(function* () {
+      const response = yield* HttpClient.filterStatusOk(http).execute(request)
+      const body = yield* collectBoundedResponseBody(
+        response,
+        MAX_RESPONSE_BYTES,
+        () => new Error(`${tool} response exceeded ${MAX_RESPONSE_BYTES} bytes`),
+      )
+      return yield* parseResponse(body.toString("utf8"))
+    }).pipe(
+      Effect.timeoutOrElse({
+        duration: Duration.seconds(25),
+        orElse: () => Effect.fail(new Error(`${tool} request timed out`)),
+      }),
+    )
+  })
+
 const Output = Schema.Struct({
-  provider: Integration.ID,
+  provider: Provider,
   text: Schema.String,
-  metadata: Schema.optional(Schema.Json),
 })
 
 export const Plugin = {
   id: "opencode.tool.websearch",
   effect: Effect.fn("WebSearchTool.Plugin")(function* (ctx: PluginContext) {
+    const http = yield* HttpClient.HttpClient
+    const config = yield* ConfigService
     const permission = yield* PermissionV2.Service
-    const websearch = yield* WebSearch.Service
 
     yield* ctx.tool
       .transform((draft) =>
@@ -40,28 +203,54 @@ export const Plugin = {
             input: Input,
             output: Output,
             toModelOutput: ({ output }) => [{ type: "text", text: output.text }],
-            execute: (input, context) =>
-              Effect.gen(function* () {
+            execute: (input, context) => {
+              const provider = selectProvider(context.sessionID, config, config.provider)
+              return Effect.gen(function* () {
                 yield* permission.assert({
                   action: name,
                   resources: [input.query],
                   save: ["*"],
-                  metadata: input,
+                  metadata: { ...input, provider },
                   sessionID: context.sessionID,
                   agent: context.agent,
                   source: { type: "tool", messageID: context.assistantMessageID, callID: context.toolCallID },
                 })
-                const result = yield* websearch.query({ ...input, sessionID: context.sessionID })
+
+                const text =
+                  provider === "exa"
+                    ? yield* callMcp(http, exaUrl(config.exaApiKey), "web_search_exa", ExaArgs, {
+                        query: input.query,
+                        type: input.type || "auto",
+                        numResults: input.numResults || 8,
+                        livecrawl: input.livecrawl || "fallback",
+                        contextMaxCharacters: input.contextMaxCharacters,
+                      })
+                    : yield* callMcp(
+                        http,
+                        PARALLEL_URL,
+                        "web_search",
+                        ParallelArgs,
+                        {
+                          objective: input.query,
+                          search_queries: [input.query],
+                          session_id: context.sessionID,
+                          // V2 invocation context does not safely expose the model yet.
+                        },
+                        {
+                          "User-Agent": `opencode/${InstallationVersion}`,
+                          ...(config.parallelApiKey ? { Authorization: `Bearer ${config.parallelApiKey}` } : {}),
+                        },
+                      )
                 return {
-                  provider: result.providerID,
-                  text: result.text || NO_RESULTS,
-                  metadata: result.metadata,
+                  provider,
+                  text: text ?? NO_RESULTS,
                 }
               }).pipe(
                 Effect.mapError(
                   (error) => new ToolFailure({ message: `Unable to search the web for ${input.query}`, error }),
                 ),
-              ),
+              )
+            },
           }),
         ),
       )

packages/core/src/websearch.ts

@@ -1,249 +0,0 @@
-export * as WebSearch from "./websearch"
-
-import { WebSearch } from "@opencode-ai/schema/websearch"
-import { Config as ConfigSchema } from "@opencode-ai/schema/config"
-import { Context, Effect, Layer, Schema, Semaphore, Stream } from "effect"
-import path from "node:path"
-import { Config } from "./config"
-import { ConfigGlobal } from "./config/global"
-import { ConfigWebSearch } from "./config/websearch"
-import { makeLocationNode } from "./effect/app-node"
-import { EventV2 } from "./event"
-import { Form } from "./form"
-import { Global } from "./global"
-import { Integration } from "./integration"
-import { truthy } from "./flag/flag"
-
-export const Input = WebSearch.Input
-export type Input = WebSearch.Input
-
-export const ProviderOutput = WebSearch.ProviderOutput
-export type ProviderOutput = WebSearch.ProviderOutput
-
-export const Result = WebSearch.Result
-export type Result = WebSearch.Result
-
-export class ProviderRequiredError extends Schema.TaggedErrorClass<ProviderRequiredError>()(
-  "WebSearch.ProviderRequired",
-  {},
-) {}
-
-export class ProviderNotFoundError extends Schema.TaggedErrorClass<ProviderNotFoundError>()("WebSearch.ProviderNotFound", {
-  providerID: Integration.ID,
-}) {}
-
-export class ConnectionRequiredError extends Schema.TaggedErrorClass<ConnectionRequiredError>()(
-  "WebSearch.ConnectionRequired",
-  { providerID: Integration.ID },
-) {}
-
-export class CancelledError extends Schema.TaggedErrorClass<CancelledError>()("WebSearch.Cancelled", {}) {}
-
-export class RequestError extends Schema.TaggedErrorClass<RequestError>()("WebSearch.Request", {
-  providerID: Integration.ID,
-  cause: Schema.Defect(),
-}) {}
-
-export type Error =
-  | ProviderRequiredError
-  | ProviderNotFoundError
-  | ConnectionRequiredError
-  | CancelledError
-  | RequestError
-
-export interface QueryInput extends Input {
-  readonly sessionID?: string
-}
-
-export interface Interface {
-  readonly selected: () => Effect.Effect<Integration.ID | undefined>
-  readonly select: (providerID: Integration.ID) => Effect.Effect<void, ProviderNotFoundError>
-  readonly query: (input: QueryInput) => Effect.Effect<Result, Error>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/v2/WebSearch") {}
-
-const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const config = yield* Config.Service
-    const configGlobal = yield* ConfigGlobal.Service
-    const events = yield* EventV2.Service
-    const forms = yield* Form.Service
-    const global = yield* Global.Service
-    const integrations = yield* Integration.Service
-    const onboarding = Semaphore.makeUnsafe(1)
-    const decodeOutput = Schema.decodeUnknownEffect(ProviderOutput)
-    const globalConfigPath = path.resolve(global.config)
-    let pendingProviderID: Integration.ID | undefined
-
-    const requireProvider = (
-      providers: Map<Integration.ID, Integration.WebSearchImplementation>,
-      providerID: Integration.ID,
-    ) => {
-      const provider = providers.get(providerID)
-      return provider ? Effect.succeed(provider) : Effect.fail(new ProviderNotFoundError({ providerID }))
-    }
-
-    const globalProviderID = Effect.fn("WebSearch.globalProviderID")(function* () {
-      const entries = (yield* config.entries()).filter(
-        (entry) => entry.type === "document" && entry.path && path.dirname(entry.path) === globalConfigPath,
-      )
-      return Config.latest(entries, "websearch")?.provider
-    })
-
-    const selected = Effect.fn("WebSearch.selected")(function* () {
-      return pendingProviderID ?? (yield* globalProviderID())
-    })
-
-    const saveProvider = Effect.fn("WebSearch.saveProvider")(function* (providerID: Integration.ID) {
-      pendingProviderID = providerID
-      yield* configGlobal.update(["websearch"], new ConfigWebSearch.Info({ provider: providerID })).pipe(
-        Effect.tapError(() => Effect.sync(() => (pendingProviderID = undefined))),
-        Effect.orDie,
-      )
-    })
-
-    yield* events.subscribe(ConfigSchema.Event.Updated).pipe(
-      Stream.runForEach(() =>
-        globalProviderID().pipe(
-          Effect.tap((providerID) =>
-            Effect.sync(() => {
-              if (providerID === pendingProviderID) pendingProviderID = undefined
-            }),
-          ),
-          Effect.ignore,
-        ),
-      ),
-      Effect.forkScoped,
-    )
-
-    const ask = Effect.fn("WebSearch.ask")(function* (
-      providers: Map<Integration.ID, Integration.WebSearchImplementation>,
-      sessionID: string,
-    ) {
-      if (providers.size === 0) return yield* new ProviderRequiredError()
-      const infos = new Map((yield* integrations.list()).map((integration) => [integration.id, integration]))
-      const state = yield* forms
-        .ask({
-          sessionID,
-          title: "Choose a web search provider",
-          metadata: { kind: "websearch.provider" },
-          mode: "form",
-          fields: [
-            {
-              key: "provider",
-              title: "Provider",
-              description: "This becomes your default and can be changed later from Connect integration.",
-              type: "string",
-              required: true,
-              custom: false,
-              options: Array.from(providers.values())
-                .flatMap((provider) => {
-                  const info = infos.get(provider.integrationID)
-                  if (!info) return []
-                  const disconnected = provider.connection === "optional" ? "Keyless available" : "Connection required"
-                  return [{ info, description: info.connections.length ? "Connected" : disconnected }]
-                })
-                .toSorted((a, b) => a.info.name.localeCompare(b.info.name))
-                .map(({ info, description }) => ({
-                  value: info.id,
-                  label: info.name,
-                  description,
-                })),
-            },
-          ],
-        })
-        .pipe(Effect.orDie)
-      if (state.status === "cancelled") return yield* new CancelledError()
-      const answer = state.answer.provider
-      if (typeof answer !== "string") return yield* new ProviderRequiredError()
-      return yield* requireProvider(providers, Integration.ID.make(answer))
-    })
-
-    const connect = Effect.fn("WebSearch.connect")(function* (
-      provider: Integration.WebSearchImplementation,
-      sessionID?: string,
-    ) {
-      const active = yield* integrations.connection.active(provider.integrationID)
-      if (active || provider.connection === "optional") return active
-      if (!sessionID) return yield* new ConnectionRequiredError({ providerID: provider.integrationID })
-      const state = yield* forms
-        .ask({
-          sessionID,
-          title: `Connect ${provider.integrationID}`,
-          metadata: { kind: "integration.connection" },
-          mode: "integration",
-          integrationID: provider.integrationID,
-        })
-        .pipe(Effect.orDie)
-      if (state.status === "cancelled") return yield* new CancelledError()
-      const connected = yield* integrations.connection.active(provider.integrationID)
-      if (!connected) return yield* new ConnectionRequiredError({ providerID: provider.integrationID })
-      return connected
-    })
-
-    const resolve = Effect.fn("WebSearch.resolve")(function* (input: QueryInput) {
-      const providers = new Map(
-        (yield* integrations.websearch.list()).map((provider) => [provider.integrationID, provider]),
-      )
-      if (input.providerID) return yield* requireProvider(providers, input.providerID)
-      const configuredProviderID = Config.latest(yield* config.entries(), "websearch")?.provider
-      if (configuredProviderID) return yield* requireProvider(providers, configuredProviderID)
-      if (process.env.OPENCODE_WEBSEARCH_PROVIDER) {
-        return yield* requireProvider(providers, Integration.ID.make(process.env.OPENCODE_WEBSEARCH_PROVIDER))
-      }
-      if (truthy("OPENCODE_ENABLE_PARALLEL") || truthy("OPENCODE_EXPERIMENTAL_PARALLEL")) {
-        return yield* requireProvider(providers, Integration.ID.make("parallel"))
-      }
-      if (truthy("OPENCODE_EXPERIMENTAL") || truthy("OPENCODE_ENABLE_EXA") || truthy("OPENCODE_EXPERIMENTAL_EXA")) {
-        return yield* requireProvider(providers, Integration.ID.make("exa"))
-      }
-      const providerID = yield* selected()
-      const provider = providerID ? providers.get(providerID) : undefined
-      if (provider) return provider
-      const sessionID = input.sessionID
-      if (!sessionID) return yield* new ProviderRequiredError()
-      return yield* onboarding.withPermit(
-        Effect.gen(function* () {
-          const current = yield* selected()
-          const selectedProvider = current ? providers.get(current) : undefined
-          if (selectedProvider) return selectedProvider
-          const provider = yield* ask(providers, sessionID)
-          yield* connect(provider, sessionID)
-          yield* saveProvider(provider.integrationID)
-          return provider
-        }),
-      )
-    })
-
-    return Service.of({
-      selected,
-      select: Effect.fn("WebSearch.select")(function* (providerID) {
-        const provider = yield* integrations.websearch.get(providerID)
-        if (!provider) return yield* new ProviderNotFoundError({ providerID })
-        yield* saveProvider(providerID)
-      }),
-      query: Effect.fn("WebSearch.query")(function* (input) {
-        const provider = yield* resolve(input)
-        const connection = yield* connect(provider, input.sessionID)
-        const credential = connection
-          ? yield* integrations.connection
-              .resolve(connection)
-              .pipe(Effect.mapError((cause) => new RequestError({ providerID: provider.integrationID, cause })))
-          : undefined
-        const output = yield* provider.execute(input, { credential, sessionID: input.sessionID }).pipe(
-          Effect.flatMap(decodeOutput),
-          Effect.mapError((cause) => new RequestError({ providerID: provider.integrationID, cause })),
-        )
-        return new Result({ providerID: provider.integrationID, ...output })
-      }),
-    })
-  }),
-)
-
-export const node = makeLocationNode({
-  service: Service,
-  layer,
-  deps: [Config.node, ConfigGlobal.node, EventV2.node, Form.node, Global.node, Integration.node],
-})

packages/core/test/aisdk.test.ts

@@ -2,7 +2,7 @@ import type { LanguageModelV3CallOptions } from "@ai-sdk/provider"
 import { AISDK } from "@opencode-ai/core/aisdk"
 import { ModelV2 } from "@opencode-ai/core/model"
 import { ProviderV2 } from "@opencode-ai/core/provider"
-import { LLM, Message } from "@opencode-ai/llm"
+import { LLM } from "@opencode-ai/llm"
 import { LLMClient } from "@opencode-ai/llm/route"
 import { expect } from "bun:test"
 import { Effect } from "effect"
@@ -67,54 +67,3 @@ it.effect("projects request settings, headers, and body overlays", () =>
     expect(body).toEqual({ safety_setting: "strict" })
   }),
 )
-
-it.effect("projects replay metadata onto AI SDK prompt parts", () =>
-  Effect.gen(function* () {
-    const aisdk = yield* AISDK.Service
-    yield* aisdk.hook.sdk((event) => {
-      event.sdk = { languageModel: () => ({ provider: event.model.providerID }) }
-    })
-
-    const resolved = yield* aisdk.model(model("@ai-sdk/anthropic"))
-    expect(resolved.route.providerMetadataKey).toBe("anthropic")
-    const prepared = yield* LLMClient.prepare<LanguageModelV3CallOptions>(
-      LLM.request({
-        model: resolved,
-        messages: [
-          Message.assistant([
-            { type: "reasoning", text: "Think", providerMetadata: { anthropic: { signature: "signed" } } },
-            {
-              type: "tool-call",
-              id: "hosted",
-              name: "web_search",
-              input: { query: "Effect" },
-              providerExecuted: true,
-              providerMetadata: { anthropic: { blockType: "server_tool_use" } },
-            },
-          ]),
-        ],
-      }),
-    )
-
-    expect(prepared.body.prompt).toEqual([
-      {
-        role: "assistant",
-        content: [
-          {
-            type: "reasoning",
-            text: "Think",
-            providerOptions: { anthropic: { signature: "signed" } },
-          },
-          {
-            type: "tool-call",
-            toolCallId: "hosted",
-            toolName: "web_search",
-            input: { query: "Effect" },
-            providerExecuted: true,
-            providerOptions: { anthropic: { blockType: "server_tool_use" } },
-          },
-        ],
-      },
-    ])
-  }),
-)

packages/core/test/catalog.test.ts

@@ -1,5 +1,4 @@
 import { describe, expect } from "bun:test"
-import { Money } from "@opencode-ai/schema/money"
 import { Effect, Fiber, Layer, Stream } from "effect"
 import { Catalog } from "@opencode-ai/core/catalog"
 import { Integration } from "@opencode-ai/core/integration"
@@ -299,31 +298,13 @@ describe("CatalogV2", () => {
         catalog.model.update(providerID, ModelV2.ID.make("cheap-large"), (model) => {
           model.capabilities.input = ["text"]
           model.capabilities.output = ["text"]
-          model.cost = [
-            {
-              input: Money.USDPerMillionTokens.make(1),
-              output: Money.USDPerMillionTokens.make(1),
-              cache: {
-                read: Money.USDPerMillionTokens.zero,
-                write: Money.USDPerMillionTokens.zero,
-              },
-            },
-          ]
+          model.cost = [{ input: 1, output: 1, cache: { read: 0, write: 0 } }]
           model.time.released = Date.now()
         })
         catalog.model.update(providerID, ModelV2.ID.make("expensive-mini"), (model) => {
           model.capabilities.input = ["text"]
           model.capabilities.output = ["text"]
-          model.cost = [
-            {
-              input: Money.USDPerMillionTokens.make(10),
-              output: Money.USDPerMillionTokens.make(10),
-              cache: {
-                read: Money.USDPerMillionTokens.zero,
-                write: Money.USDPerMillionTokens.zero,
-              },
-            },
-          ]
+          model.cost = [{ input: 10, output: 10, cache: { read: 0, write: 0 } }]
           model.time.released = Date.now()
         })
       })

packages/core/test/config/command.test.ts

@@ -4,7 +4,6 @@ import { describe, expect } from "bun:test"
 import { Effect, PubSub, Schema, Stream } from "effect"
 import { Config as ConfigSchema } from "@opencode-ai/schema/config"
 import { CommandV2 } from "@opencode-ai/core/command"
-import { AgentV2 } from "@opencode-ai/core/agent"
 import { Config } from "@opencode-ai/core/config"
 import { ConfigCommandPlugin } from "@opencode-ai/core/config/plugin/command"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
@@ -88,7 +87,7 @@ Review files`,
               name: "review",
               template: "Review files",
               description: "File review",
-              agent: AgentV2.ID.make("reviewer"),
+              agent: "reviewer",
               model: {
                 providerID: ProviderV2.ID.make("anthropic"),
                 id: ModelV2.ID.make("claude"),

packages/core/test/config/config.test.ts

@@ -4,7 +4,6 @@ import { describe, expect } from "bun:test"
 import { Effect, Fiber, Layer, PubSub, Schema, Stream } from "effect"
 import { FastCheck } from "effect/testing"
 import { Config } from "@opencode-ai/core/config"
-import { ConfigGlobal } from "@opencode-ai/core/config/global"
 import { ConfigModel } from "@opencode-ai/core/config/model"
 import { Config as ConfigSchema } from "@opencode-ai/schema/config"
 import { ConfigProvider } from "@opencode-ai/core/config/provider"
@@ -23,7 +22,6 @@ import { AbsolutePath } from "@opencode-ai/core/schema"
 import { location } from "../fixture/location"
 import { tmpdir } from "../fixture/tmpdir"
 import { testEffect } from "../lib/effect"
-import { parse } from "jsonc-parser"
 
 const it = testEffect(Layer.empty)
 const selection = Schema.decodeUnknownSync(ConfigModel.Selection)
@@ -60,37 +58,6 @@ const provider = {
 }
 
 describe("Config", () => {
-  it.live("updates the global JSONC config without removing comments", () =>
-    Effect.acquireRelease(
-      Effect.promise(() => tmpdir()),
-      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-    ).pipe(
-      Effect.flatMap((tmp) =>
-        Effect.gen(function* () {
-          const global = path.join(tmp.path, "global")
-          const file = path.join(global, "opencode.jsonc")
-          yield* Effect.promise(async () => {
-            await fs.mkdir(global, { recursive: true })
-            await fs.writeFile(file, `// user config\n{\n  "username": "tester"\n}\n`)
-          })
-
-          const config = yield* ConfigGlobal.Service
-          yield* config.update(["websearch"], { provider: "exa" })
-
-          const text = yield* Effect.promise(() => Bun.file(file).text())
-          expect(text).toContain("// user config")
-          expect(parse(text)).toEqual({ username: "tester", websearch: { provider: "exa" } })
-        }).pipe(
-          Effect.provide(
-            AppNodeBuilder.build(LayerNode.group([ConfigGlobal.node]), [
-              [Global.node, Global.layerWith({ config: path.join(tmp.path, "global") })],
-            ]),
-          ),
-        ),
-      ),
-    ),
-  )
-
   it.live("reloads external config and publishes directory updates", () =>
     Effect.acquireRelease(
       Effect.promise(() => tmpdir()),

packages/core/test/config/plugin.test.ts

@@ -273,9 +273,9 @@ function withLocation<A, E, R>(
 function mutablePlugin(description: string) {
   const plugin = pathToFileURL(path.join(import.meta.dir, "../../../plugin/src/v2/promise/index.ts")).href
   return `
-import { Plugin } from ${JSON.stringify(plugin)}
+import { define } from ${JSON.stringify(plugin)}
 
-export default Plugin.define({
+export default EffectPlugin.define({
   id: "mutable-plugin",
   setup: async (ctx) => {
     await ctx.agent.transform((agents) => {

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

@@ -1,5 +1,4 @@
 import { describe, expect } from "bun:test"
-import { Money } from "@opencode-ai/schema/money"
 import { Effect, Schema } from "effect"
 import { Catalog } from "@opencode-ai/core/catalog"
 import { Config } from "@opencode-ai/core/config"
@@ -254,17 +253,7 @@ describe("ConfigProviderPlugin.Plugin", () => {
         expect(model.capabilities).toEqual({ tools: true, input: ["text"], output: ["text"] })
         expect(model.enabled).toBe(false)
         expect(model.limit).toEqual({ context: 100, output: 75 })
-        expect(model.cost).toEqual([
-          {
-            input: Money.USDPerMillionTokens.make(1),
-            output: Money.USDPerMillionTokens.make(2),
-            cache: {
-              read: Money.USDPerMillionTokens.zero,
-              write: Money.USDPerMillionTokens.zero,
-            },
-            tier: undefined,
-          },
-        ])
+        expect(model.cost).toEqual([{ input: 1, output: 2, cache: { read: 0, write: 0 }, tier: undefined }])
         expect(model.settings).toEqual({ baseURL: "https://example.test", retained: true })
         expect(model.headers).toEqual({ first: "first", shared: "last", last: "last" })
         expect(model.variants?.map((variant) => variant.id)).toEqual([

packages/core/test/database-migration.test.ts

@@ -4,7 +4,7 @@ import { fileURLToPath } from "url"
 import path from "path"
 import { SqliteClient } from "@effect/sql-sqlite-bun"
 import { EffectDrizzleSqlite } from "@opencode-ai/effect-drizzle-sqlite"
-import { Effect, Layer, Schema } from "effect"
+import { Effect, Layer } from "effect"
 import { eq, inArray, sql } from "drizzle-orm"
 import { DatabaseMigration } from "@opencode-ai/core/database/migration"
 import { migrations } from "@opencode-ai/core/database/migration.gen"
@@ -17,7 +17,6 @@ import simplifyIntegrationCredentialsMigration from "@opencode-ai/core/database/
 import simplifySessionInputMigration from "@opencode-ai/core/database/migration/20260622202450_simplify_session_input"
 import resetSessionEventsMigration from "@opencode-ai/core/database/migration/20260703200000_reset_v2_session_events"
 import durableSessionInboxMigration from "@opencode-ai/core/database/migration/20260707010146_durable_session_inbox"
-import migratePrelaunchV2StateMigration from "@opencode-ai/core/database/migration/20260707120000_migrate_prelaunch_v2_state"
 import renameInstructionsMigration from "@opencode-ai/core/database/migration/20260705180000_rename_instructions"
 import addSessionForkMigration from "@opencode-ai/core/database/migration/20260706223930_add-session-fork"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
@@ -27,7 +26,6 @@ import { ProjectV2 } from "@opencode-ai/core/project"
 import { ProjectTable } from "@opencode-ai/core/project/sql"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { SessionSchema } from "@opencode-ai/core/session/schema"
-import { SessionMessage } from "@opencode-ai/core/session/message"
 import { SessionTable } from "@opencode-ai/core/session/sql"
 import sessionMetadataMigration from "@opencode-ai/core/database/migration/20260511173437_session-metadata"
 import type { SqlClient as SqlClientService } from "effect/unstable/sql/SqlClient"
@@ -44,256 +42,6 @@ const run = <A, E>(effect: Effect.Effect<A, E, SqlClientService>) =>
 const makeDb = EffectDrizzleSqlite.makeWithDefaults()
 
 describe("DatabaseMigration", () => {
-  test("migrates pre-launch V2 state in place", async () => {
-    await run(
-      Effect.gen(function* () {
-        const db = yield* makeDb
-        yield* db.run(
-          sql`CREATE TABLE session_message (id text PRIMARY KEY, session_id text NOT NULL, type text NOT NULL, seq integer NOT NULL, time_created integer NOT NULL, time_updated integer NOT NULL, data text NOT NULL)`,
-        )
-        yield* db.run(
-          sql`CREATE TABLE session_input (id text PRIMARY KEY, session_id text NOT NULL, type text NOT NULL, prompt text, delivery text, admitted_seq integer NOT NULL, promoted_seq integer, time_created integer NOT NULL)`,
-        )
-        yield* db.run(
-          sql`CREATE TABLE event (id text PRIMARY KEY, aggregate_id text NOT NULL, seq integer NOT NULL, created integer NOT NULL, type text NOT NULL, data text NOT NULL)`,
-        )
-        yield* db.run(
-          sql`CREATE TABLE event_sequence (aggregate_id text PRIMARY KEY, seq integer NOT NULL, owner_id text)`,
-        )
-        yield* db.run(
-          sql`CREATE TABLE instruction_checkpoint (session_id text PRIMARY KEY, baseline text NOT NULL, snapshot text NOT NULL, baseline_seq integer NOT NULL)`,
-        )
-        const messages = [
-          ["msg_skill", "skill", { name: "effect", text: "Use Effect", time: { created: 1 } }],
-          [
-            "msg_shell",
-            "shell",
-            {
-              shell: { id: "sh_old", command: "pwd", status: "exited", exit: 0, cwd: "/tmp" },
-              output: { output: "/tmp", cursor: 4, size: 4, truncated: false },
-              time: { created: 2, completed: 3 },
-            },
-          ],
-          [
-            "msg_assistant",
-            "assistant",
-            {
-              agent: "build",
-              model: { id: "model", providerID: "provider" },
-              content: [
-                {
-                  type: "tool",
-                  id: "call_old",
-                  name: "read",
-                  provider: "removed",
-                  state: { status: "pending", input: '{"path":"README.md"}', title: "removed" },
-                  time: { created: 3 },
-                },
-              ],
-              time: { created: 3 },
-            },
-          ],
-          [
-            "msg_failed",
-            "compaction",
-            {
-              status: "failed",
-              reason: "manual",
-              summary: "removed",
-              recent: "removed",
-              time: { created: 4 },
-            },
-          ],
-          [
-            "msg_queued",
-            "compaction",
-            { status: "queued", reason: "manual", summary: "", recent: "", time: { created: 5 } },
-          ],
-          [
-            "msg_synthetic",
-            "synthetic",
-            { sessionID: "ses_test", text: "context", description: "source", time: { created: 6 } },
-          ],
-          [
-            "msg_running",
-            "compaction",
-            { status: "running", reason: "auto", summary: "partial", recent: "recent", time: { created: 7 } },
-          ],
-          [
-            "msg_completed",
-            "compaction",
-            { status: "completed", reason: "auto", summary: "summary", recent: "recent", time: { created: 8 } },
-          ],
-        ] as const
-        for (const [id, type, data] of messages)
-          yield* db.run(
-            sql`INSERT INTO session_message VALUES (${id}, 'ses_test', ${type}, 1, 10, 11, ${JSON.stringify(data)})`,
-          )
-        yield* db.run(
-          sql`INSERT INTO session_input VALUES ('msg_queued', 'ses_test', 'compaction', NULL, NULL, 4, NULL, 5)`,
-        )
-        yield* db.run(sql`INSERT INTO event_sequence VALUES ('ses_test', 9, 'owner')`)
-        yield* db.run(sql`INSERT INTO instruction_checkpoint VALUES ('ses_test', 'baseline', '{"source":"value"}', 7)`)
-        const events = [
-          ["evt_skill", 1, 101, "session.skill.activated.1", { sessionID: "ses_test", name: "effect", text: "Use" }],
-          ["evt_started", 2, 102, "session.compaction.started.1", { sessionID: "ses_test", reason: "auto" }],
-          ["evt_delta", 3, 103, "session.compaction.delta.1", { sessionID: "ses_test", text: "partial" }],
-          ["evt_failed", 4, 104, "session.compaction.failed.1", { sessionID: "ses_test" }],
-          [
-            "evt_revert",
-            5,
-            105,
-            "session.revert.staged.1",
-            {
-              sessionID: "ses_test",
-              revert: {
-                messageID: "msg_skill",
-                snapshot: "tree",
-                diff: "removed",
-                files: [{ path: "src/a.ts", patch: "@@", additions: 1, deletions: 0, status: "modified" }],
-              },
-            },
-          ],
-          [
-            "evt_skill_current",
-            6,
-            106,
-            "session.skill.activated.2",
-            { sessionID: "ses_test", id: "effect-id", name: "Effect", text: "Use" },
-          ],
-        ] as const
-        for (const [id, seq, created, type, data] of events)
-          yield* db.run(
-            sql`INSERT INTO event VALUES (${id}, 'ses_test', ${seq}, ${created}, ${type}, ${JSON.stringify(data)})`,
-          )
-
-        yield* DatabaseMigration.applyOnly(db, [migratePrelaunchV2StateMigration])
-
-        const rows = yield* db.all<{
-          id: string
-          type: string
-          seq: number
-          time_created: number
-          time_updated: number
-          data: string
-        }>(sql`SELECT id, type, seq, time_created, time_updated, data FROM session_message ORDER BY id`)
-        for (const row of rows)
-          Schema.decodeUnknownSync(SessionMessage.Info)({ ...JSON.parse(row.data), id: row.id, type: row.type })
-        expect(rows.every((row) => row.seq === 1 && row.time_created === 10 && row.time_updated === 11)).toBe(true)
-        expect(rows.map((row) => [row.id, JSON.parse(row.data)])).toEqual([
-          [
-            "msg_assistant",
-            expect.objectContaining({
-              content: [expect.objectContaining({ state: { status: "streaming", input: '{"path":"README.md"}' } })],
-            }),
-          ],
-          ["msg_completed", expect.objectContaining({ status: "completed", summary: "summary", recent: "recent" })],
-          [
-            "msg_failed",
-            {
-              time: { created: 4 },
-              status: "failed",
-              reason: "manual",
-              error: {
-                type: "compaction.failed",
-                message: "Compaction failed before recording an error",
-              },
-            },
-          ],
-          ["msg_running", expect.objectContaining({ status: "running", summary: "partial", recent: "recent" })],
-          ["msg_shell", expect.objectContaining({ shellID: "sh_old", command: "pwd", status: "exited", exit: 0 })],
-          ["msg_skill", { time: { created: 1 }, skill: "effect", name: "effect", text: "Use Effect" }],
-          ["msg_synthetic", { time: { created: 6 }, text: "context", description: "source" }],
-        ])
-        expect(yield* db.get(sql`SELECT * FROM session_input`)).toEqual({
-          id: "msg_queued",
-          session_id: "ses_test",
-          type: "compaction",
-          prompt: null,
-          delivery: null,
-          admitted_seq: 4,
-          promoted_seq: null,
-          time_created: 5,
-        })
-        const migratedEvents = yield* db.all<{
-          id: string
-          aggregate_id: string
-          seq: number
-          created: number
-          type: string
-          data: string
-        }>(sql`SELECT * FROM event ORDER BY seq`)
-        expect(migratedEvents.map((event) => ({ ...event, data: JSON.parse(event.data) }))).toEqual([
-          {
-            id: "evt_skill",
-            aggregate_id: "ses_test",
-            seq: 1,
-            created: 101,
-            type: "session.skill.activated.1",
-            data: { sessionID: "ses_test", id: "effect", name: "effect", text: "Use" },
-          },
-          {
-            id: "evt_started",
-            aggregate_id: "ses_test",
-            seq: 2,
-            created: 102,
-            type: "session.compaction.started.1",
-            data: { sessionID: "ses_test", reason: "auto", recent: "" },
-          },
-          {
-            id: "evt_failed",
-            aggregate_id: "ses_test",
-            seq: 4,
-            created: 104,
-            type: "session.compaction.failed.1",
-            data: {
-              sessionID: "ses_test",
-              reason: "auto",
-              error: {
-                type: "compaction.failed",
-                message: "Compaction failed before recording an error",
-              },
-            },
-          },
-          {
-            id: "evt_revert",
-            aggregate_id: "ses_test",
-            seq: 5,
-            created: 105,
-            type: "session.revert.staged.1",
-            data: {
-              sessionID: "ses_test",
-              revert: {
-                messageID: "msg_skill",
-                snapshot: "tree",
-                files: [{ file: "src/a.ts", patch: "@@", additions: 1, deletions: 0, status: "modified" }],
-              },
-            },
-          },
-          {
-            id: "evt_skill_current",
-            aggregate_id: "ses_test",
-            seq: 6,
-            created: 106,
-            type: "session.skill.activated.1",
-            data: { sessionID: "ses_test", id: "effect-id", name: "Effect", text: "Use" },
-          },
-        ])
-        expect(yield* db.get(sql`SELECT * FROM event_sequence`)).toEqual({
-          aggregate_id: "ses_test",
-          seq: 9,
-          owner_id: "owner",
-        })
-        expect(yield* db.get(sql`SELECT * FROM instruction_checkpoint`)).toEqual({
-          session_id: "ses_test",
-          baseline: "baseline",
-          snapshot: '{"source":"value"}',
-          baseline_seq: 7,
-        })
-      }),
-    )
-  })
-
   test("resets incompatible V2 Session event history", async () => {
     await run(
       Effect.gen(function* () {

packages/core/test/form.test.ts

@@ -4,7 +4,6 @@ import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/core/effect/layer-node"
 import { EventV2 } from "@opencode-ai/core/event"
 import { Form } from "@opencode-ai/core/form"
-import { Integration } from "@opencode-ai/core/integration"
 import { SessionSchema } from "@opencode-ai/core/session/schema"
 import { testEffect } from "./lib/effect"
 
@@ -60,27 +59,6 @@ describe("Form", () => {
     }),
   )
 
-  it.effect("uses an empty reply to complete an integration form", () =>
-    Effect.gen(function* () {
-      const service = yield* Form.Service
-      const created = yield* service.create({
-        sessionID: "ses_test",
-        mode: "integration",
-        integrationID: Integration.ID.make("exa"),
-      })
-
-      const invalid = yield* service.reply({ id: created.id, answer: { connected: true } }).pipe(Effect.flip)
-      expect(invalid).toEqual(
-        new Form.InvalidAnswerError({
-          id: created.id,
-          message: "Integration forms must be answered with an empty answer",
-        }),
-      )
-      yield* service.reply({ id: created.id, answer: {} })
-      expect(yield* service.state(created.id)).toEqual({ status: "answered", answer: {} })
-    }),
-  )
-
   it.effect("gates required fields and rejects inactive answers via when", () =>
     Effect.gen(function* () {
       const service = yield* Form.Service

packages/core/test/git.test.ts

@@ -146,7 +146,7 @@ describe("Git trees", () => {
         RelativePath.make("scope/tracked.txt"),
       ])
       const diffs = yield* git.tree.diff({ repository, from: before, to: after, context: 1 })
-      expect(diffs.map((item) => [item.file, item.status])).toEqual([
+      expect(diffs.map((item) => [item.path, item.status])).toEqual([
         [RelativePath.make("scope/added.txt"), "added"],
         [RelativePath.make("scope/tracked.txt"), "modified"],
       ])
@@ -154,7 +154,7 @@ describe("Git trees", () => {
       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]?.file).toBe(RelativePath.make("scope/tracked.txt"))
+      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")

packages/core/test/lib/tool.ts

@@ -6,7 +6,6 @@ import { Tool } from "@opencode-ai/core/tool/tool"
 import { Tools } from "@opencode-ai/core/tool/tools"
 import type { Context as PluginContext } from "@opencode-ai/plugin/v2/effect/plugin"
 import { Effect, type Scope } from "effect"
-import { host } from "../plugin/host"
 
 export const toolIdentity = {
   agent: AgentV2.ID.make("build"),
@@ -49,7 +48,7 @@ export const registerToolPlugin = <R>(plugin: {
 }): Effect.Effect<void, never, R | Tools.Service | Scope.Scope> =>
   Effect.gen(function* () {
     const tools = yield* Tools.Service
-    const context = host({
+    const context: Pick<PluginContext, "tool"> = {
       tool: {
         transform: (callback) =>
           Effect.gen(function* () {
@@ -72,8 +71,8 @@ export const registerToolPlugin = <R>(plugin: {
           }),
         hook: () => Effect.die("registerToolPlugin does not support tool hooks"),
       },
-    })
-    yield* plugin.effect(context)
+    }
+    yield* plugin.effect(context as PluginContext)
   })
 
 export const settleTool = (registry: ToolRegistry.Interface, input: ToolRegistry.ExecuteInput, model = testModel) =>

packages/core/test/location-layer.test.ts

@@ -3,7 +3,6 @@ import path from "path"
 import { describe, expect } from "bun:test"
 import { Config } from "@opencode-ai/schema/config"
 import { Plugin } from "@opencode-ai/schema/plugin"
-import { Money } from "@opencode-ai/schema/money"
 import { Context, DateTime, Effect, Equal, Hash, RcMap, Schema, Stream } from "effect"
 import { Plugin as EffectPlugin } from "@opencode-ai/plugin/v2/effect"
 import { AgentV2 } from "@opencode-ai/core/agent"
@@ -291,7 +290,6 @@ describe("LocationServiceMap", () => {
             "edit",
             "glob",
             "grep",
-            "patch",
             "question",
             "read",
             "shell",
@@ -309,7 +307,6 @@ describe("LocationServiceMap", () => {
             "edit",
             "glob",
             "grep",
-            "patch",
             "question",
             "read",
             "shell",
@@ -357,7 +354,7 @@ describe("LocationServiceMap", () => {
                   id: ModelV2.ID.make("chat"),
                   providerID: ProviderV2.ID.make("unavailable"),
                 },
-                cost: Money.USD.zero,
+                cost: 0,
                 tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
                 time: { created: DateTime.makeUnsafe(0), updated: DateTime.makeUnsafe(0) },
                 location,
@@ -406,7 +403,7 @@ describe("LocationServiceMap", () => {
                   providerID: ProviderV2.ID.make("aliased"),
                   variant: ModelV2.VariantID.make("high"),
                 },
-                cost: Money.USD.zero,
+                cost: 0,
                 tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
                 time: { created: DateTime.makeUnsafe(0), updated: DateTime.makeUnsafe(0) },
                 location,

packages/core/test/mcp.test.ts

@@ -155,10 +155,6 @@ function resourceMcpLayer(url: string) {
             complete: unusedIntegration,
             cancel: unusedIntegration,
           },
-          websearch: {
-            list: unusedIntegration,
-            get: unusedIntegration,
-          },
         }),
         Layer.mock(Credential.Service, {}),
       ),

packages/core/test/plugin/host.ts

@@ -1,22 +1,16 @@
-import { Plugin } from "@opencode-ai/plugin/v2/effect"
-import type { IntegrationDefinition, IntegrationMethodRegistration } from "@opencode-ai/plugin/v2/effect/integration"
+import type { Context as PluginContext } from "@opencode-ai/plugin/v2/effect/plugin"
 import { AgentV2 } from "@opencode-ai/core/agent"
 import { Catalog } from "@opencode-ai/core/catalog"
 import { Credential } from "@opencode-ai/core/credential"
 import { Integration } from "@opencode-ai/core/integration"
 import { ModelV2 } from "@opencode-ai/core/model"
 import { ProviderV2 } from "@opencode-ai/core/provider"
-import type {
-  CredentialOAuth,
-  IntegrationEnvMethod,
-  IntegrationKeyMethod,
-  IntegrationOAuthMethod,
-} from "@opencode-ai/sdk/v2/types"
+import type { IntegrationEnvMethod, IntegrationKeyMethod, IntegrationOAuthMethod } from "@opencode-ai/sdk/v2/types"
 import { Effect, Stream } from "effect"
 
-type Overrides = Partial<Omit<Plugin.Context, "options">>
+type Overrides = Partial<Omit<PluginContext, "options">>
 
-export function host(overrides: Overrides = {}): Plugin.Context {
+export function host(overrides: Overrides = {}): PluginContext {
   return {
     options: {},
     agent: overrides.agent ?? {
@@ -59,7 +53,6 @@ export function host(overrides: Overrides = {}): Plugin.Context {
         complete: () => Effect.die("unused integration.attempt.complete"),
         cancel: () => Effect.die("unused integration.attempt.cancel"),
       },
-      register: () => Effect.die("unused integration.register"),
       transform: () => Effect.die("unused integration.transform"),
       reload: () => Effect.die("unused integration.reload"),
       connection: {
@@ -90,14 +83,12 @@ export function host(overrides: Overrides = {}): Plugin.Context {
       prompt: () => Effect.die("unused session.prompt"),
       command: () => Effect.die("unused session.command"),
       interrupt: () => Effect.die("unused session.interrupt"),
-      // Plugins register session hooks during setup, so a bare host accepts the
-      // registration; the callback only runs when a test triggers the request pipeline.
-      hook: () => Effect.succeed({ dispose: Effect.void }),
+      hook: () => Effect.die("unused session.hook"),
     },
   }
 }
 
-export function agentHost(agent: AgentV2.Interface): Plugin.Context["agent"] {
+export function agentHost(agent: AgentV2.Interface): PluginContext["agent"] {
   return {
     list: () => Effect.die("unused agent.list"),
     reload: agent.reload,
@@ -122,7 +113,7 @@ export function agentHost(agent: AgentV2.Interface): Plugin.Context["agent"] {
   }
 }
 
-export function catalogHost(catalog: Catalog.Interface): Plugin.Context["catalog"] {
+export function catalogHost(catalog: Catalog.Interface): PluginContext["catalog"] {
   return {
     provider: {
       list: () => Effect.die("unused catalog.provider.list"),
@@ -194,7 +185,7 @@ export function catalogHost(catalog: Catalog.Interface): Plugin.Context["catalog
   }
 }
 
-export function integrationHost(integration: Integration.Interface): Plugin.Context["integration"] {
+export function integrationHost(integration: Integration.Interface): PluginContext["integration"] {
   return {
     list: () => Effect.die("unused integration.list"),
     get: () => Effect.die("unused integration.get"),
@@ -215,7 +206,6 @@ export function integrationHost(integration: Integration.Interface): Plugin.Cont
           connection.type === "credential" ? { ...connection, id: Credential.ID.make(connection.id) } : connection,
         ),
     },
-    register: (definition) => integration.transform((draft) => registerIntegration(draft, definition)),
     transform: (callback) =>
       integration.transform((draft) =>
         callback({
@@ -228,7 +218,72 @@ export function integrationHost(integration: Integration.Interface): Plugin.Cont
           remove: (id) => draft.remove(Integration.ID.make(id)),
           method: {
             list: (id) => draft.method.list(Integration.ID.make(id)).map(method),
-            update: (input) => draft.method.update(methodImplementation(input)),
+            update: (input) => {
+              if ("authorize" in input) {
+                const methodID = Integration.MethodID.make(input.method.id)
+                const refresh = input.refresh
+                draft.method.update({
+                  integrationID: Integration.ID.make(input.integrationID),
+                  method: { ...input.method, id: methodID },
+                  authorize: (inputs) =>
+                    input.authorize(inputs).pipe(
+                      Effect.map((authorization) => {
+                        if (authorization.mode === "auto") {
+                          return {
+                            ...authorization,
+                            callback: authorization.callback.pipe(
+                              Effect.map((credential) =>
+                                Credential.OAuth.make({
+                                  ...credential,
+                                  methodID: Integration.MethodID.make(credential.methodID),
+                                }),
+                              ),
+                            ),
+                          }
+                        }
+                        return {
+                          ...authorization,
+                          callback: (code: string) =>
+                            authorization.callback(code).pipe(
+                              Effect.map((credential) =>
+                                Credential.OAuth.make({
+                                  ...credential,
+                                  methodID: Integration.MethodID.make(credential.methodID),
+                                }),
+                              ),
+                            ),
+                        }
+                      }),
+                    ),
+                  ...(refresh
+                    ? {
+                        refresh: (value: Credential.OAuth) =>
+                          refresh(value).pipe(
+                            Effect.map((next) =>
+                              Credential.OAuth.make({
+                                ...next,
+                                methodID: Integration.MethodID.make(next.methodID),
+                              }),
+                            ),
+                          ),
+                      }
+                    : {}),
+                  ...(input.label ? { label: input.label } : {}),
+                })
+                return
+              }
+              if (input.method.type === "env") {
+                draft.method.update({
+                  integrationID: Integration.ID.make(input.integrationID),
+                  method: { ...input.method, names: [...input.method.names] },
+                })
+                return
+              }
+              draft.method.update({
+                integrationID: Integration.ID.make(input.integrationID),
+                method: input.method,
+              })
+            },
             remove: (id, item) => draft.method.remove(Integration.ID.make(id), internalMethod(item)),
           },
         }),
@@ -236,72 +291,6 @@ export function integrationHost(integration: Integration.Interface): Plugin.Cont
   }
 }
 
-function registerIntegration(draft: Integration.Draft, definition: IntegrationDefinition) {
-  const integrationID = Integration.ID.make(definition.id)
-  draft.update(integrationID, (integration) => (integration.name = definition.name))
-  for (const item of definition.methods ?? []) {
-    if (item.type === "env") {
-      draft.method.update(methodImplementation({ integrationID: definition.id, method: item }))
-      continue
-    }
-    if (item.type === "key") {
-      draft.method.update(methodImplementation({ integrationID: definition.id, method: item }))
-      continue
-    }
-    const { authorize, refresh, credentialLabel, ...method } = item
-    draft.method.update(
-      methodImplementation({
-        integrationID: definition.id,
-        method,
-        authorize,
-        ...(refresh ? { refresh } : {}),
-        ...(credentialLabel ? { label: credentialLabel } : {}),
-      }),
-    )
-  }
-  if (!definition.websearch) return
-  draft.websearch.update({
-    integrationID,
-    connection: definition.websearch.connection,
-    execute: definition.websearch.execute,
-  })
-}
-
-function methodImplementation(input: IntegrationMethodRegistration): Integration.Implementation {
-  if ("authorize" in input) {
-    const refresh = input.refresh
-    return {
-      integrationID: Integration.ID.make(input.integrationID),
-      method: { ...input.method, id: Integration.MethodID.make(input.method.id) },
-      authorize: (inputs) =>
-        input.authorize(inputs).pipe(
-          Effect.map((authorization) => {
-            if (authorization.mode === "auto") {
-              return { ...authorization, callback: authorization.callback.pipe(Effect.map(oauthCredential)) }
-            }
-            return {
-              ...authorization,
-              callback: (code: string) => authorization.callback(code).pipe(Effect.map(oauthCredential)),
-            }
-          }),
-        ),
-      ...(refresh ? { refresh: (value: Credential.OAuth) => refresh(value).pipe(Effect.map(oauthCredential)) } : {}),
-      ...(input.label ? { label: input.label } : {}),
-    }
-  }
-  if (input.method.type === "env") {
-    return {
-      integrationID: Integration.ID.make(input.integrationID),
-      method: { ...input.method, names: [...input.method.names] },
-    }
-  }
-  return { integrationID: Integration.ID.make(input.integrationID), method: input.method }
-}
-
-function oauthCredential(value: CredentialOAuth) {
-  return Credential.OAuth.make({ ...value, methodID: Integration.MethodID.make(value.methodID) })
-}
-
 function method(value: Integration.Method) {
   if (value.type === "env") return { type: value.type, names: [...value.names] }
   if (value.type === "key") return { type: value.type, label: value.label }

packages/core/test/plugin/models-dev.test.ts

@@ -1,6 +1,5 @@
 import path from "path"
 import { describe, expect } from "bun:test"
-import { Money } from "@opencode-ai/schema/money"
 import { Effect, Layer } from "effect"
 import { Catalog } from "@opencode-ai/core/catalog"
 import { Integration } from "@opencode-ai/core/integration"
@@ -52,31 +51,23 @@ describe("ModelsDevPlugin", () => {
                   temperature: true,
                   tool_call: true,
                   cost: {
-                    input: Money.USDPerMillionTokens.make(2.5),
-                    output: Money.USDPerMillionTokens.make(15),
+                    input: 2.5,
+                    output: 15,
                     tiers: [
                       {
                         tier: { type: "context", size: 272_000 },
-                        input: Money.USDPerMillionTokens.make(3),
-                        output: Money.USDPerMillionTokens.make(18),
-                        cache_read: Money.USDPerMillionTokens.make(0.25),
+                        input: 3,
+                        output: 18,
+                        cache_read: 0.25,
                       },
                     ],
-                    context_over_200k: {
-                      input: Money.USDPerMillionTokens.make(5),
-                      output: Money.USDPerMillionTokens.make(22.5),
-                      cache_read: Money.USDPerMillionTokens.make(0.5),
-                    },
+                    context_over_200k: { input: 5, output: 22.5, cache_read: 0.5 },
                   },
                   limit: { context: 1_050_000, input: 922_000, output: 128_000 },
                   experimental: {
                     modes: {
                       fast: {
-                        cost: {
-                          input: Money.USDPerMillionTokens.make(5),
-                          output: Money.USDPerMillionTokens.make(30),
-                          cache_read: Money.USDPerMillionTokens.make(0.5),
-                        },
+                        cost: { input: 5, output: 30, cache_read: 0.5 },
                         provider: {
                           headers: { "x-mode": "fast" },
                           body: { service_tier: "priority" },
@@ -116,31 +107,18 @@ describe("ModelsDevPlugin", () => {
         variants: [],
       })
       expect(fast?.cost).toEqual([
-        {
-          input: Money.USDPerMillionTokens.make(5),
-          output: Money.USDPerMillionTokens.make(30),
-          cache: {
-            read: Money.USDPerMillionTokens.make(0.5),
-            write: Money.USDPerMillionTokens.zero,
-          },
-        },
+        { input: 5, output: 30, cache: { read: 0.5, write: 0 } },
         {
           tier: { type: "context", size: 272_000 },
-          input: Money.USDPerMillionTokens.make(3),
-          output: Money.USDPerMillionTokens.make(18),
-          cache: {
-            read: Money.USDPerMillionTokens.make(0.25),
-            write: Money.USDPerMillionTokens.zero,
-          },
+          input: 3,
+          output: 18,
+          cache: { read: 0.25, write: 0 },
         },
         {
           tier: { type: "context", size: 200_000 },
-          input: Money.USDPerMillionTokens.make(5),
-          output: Money.USDPerMillionTokens.make(22.5),
-          cache: {
-            read: Money.USDPerMillionTokens.make(0.5),
-            write: Money.USDPerMillionTokens.zero,
-          },
+          input: 5,
+          output: 22.5,
+          cache: { read: 0.5, write: 0 },
         },
       ])
     }),

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

@@ -1,7 +1,6 @@
 import { describe, expect } from "bun:test"
 import { Effect } from "effect"
 import { AgentV2 } from "@opencode-ai/core/agent"
-import { Integration } from "@opencode-ai/core/integration"
 import { PluginV2 } from "@opencode-ai/core/plugin"
 import { PluginHost } from "@opencode-ai/core/plugin/host"
 import { PluginPromise } from "@opencode-ai/core/plugin/promise"
@@ -94,35 +93,4 @@ describe("fromPromise", () => {
       expect(yield* agents.get(AgentV2.ID.make("temp"))).toBeUndefined()
     }),
   )
-
-  it.effect("adapts promise web search capability execution", () =>
-    Effect.gen(function* () {
-      const integrations = yield* Integration.Service
-      const plugin = yield* PluginV2.Service
-      const host = yield* PluginHost.make(plugin)
-      const promisePlugin = Plugin.define({
-        id: "promise-websearch",
-        setup: async (ctx) => {
-          await ctx.integration.register({
-            id: "promise-websearch",
-            name: "Promise Web Search",
-            methods: [{ type: "env", names: ["PROMISE_WEBSEARCH_KEY"] }],
-            websearch: {
-              connection: "optional",
-              execute: async (input) => ({ text: `promise: ${input.query}` }),
-            },
-          })
-        },
-      })
-
-      yield* PluginPromise.fromPromise(promisePlugin).effect(host)
-      expect(yield* integrations.get(Integration.ID.make("promise-websearch"))).toMatchObject({
-        name: "Promise Web Search",
-        methods: [{ type: "env", names: ["PROMISE_WEBSEARCH_KEY"] }],
-      })
-      const provider = yield* integrations.websearch.get(Integration.ID.make("promise-websearch"))
-      if (!provider) return yield* Effect.die("Expected promise web search provider")
-      expect(yield* provider.execute({ query: "effect" }, {})).toEqual({ text: "promise: effect" })
-    }),
-  )
 })

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

@@ -1,5 +1,4 @@
 import { AISDK } from "@opencode-ai/core/aisdk"
-import { Money } from "@opencode-ai/schema/money"
 import { describe, expect } from "bun:test"
 import type { LanguageModelV3 } from "@ai-sdk/provider"
 import { Effect } from "effect"
@@ -186,16 +185,7 @@ describe("OpenAIPlugin", () => {
           draft.package = item.package
         })
         catalog.model.update(item.id, ModelV2.ID.make("gpt-5.5"), (model) => {
-          model.cost = [
-            {
-              input: Money.USDPerMillionTokens.make(1),
-              output: Money.USDPerMillionTokens.make(2),
-              cache: {
-                read: Money.USDPerMillionTokens.make(0.1),
-                write: Money.USDPerMillionTokens.zero,
-              },
-            },
-          ]
+          model.cost = [{ input: 1, output: 2, cache: { read: 0.1, write: 0 } }]
         })
         catalog.model.update(item.id, ModelV2.ID.make("gpt-5.5-pro"), () => {})
         catalog.model.update(item.id, ModelV2.ID.make("gpt-4.1"), () => {})

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

@@ -1,5 +1,4 @@
 import { describe, expect } from "bun:test"
-import { Money } from "@opencode-ai/schema/money"
 import { Effect } from "effect"
 import { Catalog } from "@opencode-ai/core/catalog"
 import { Credential } from "@opencode-ai/core/credential"
@@ -66,16 +65,7 @@ function withEnv<A, E, R>(vars: Record<string, string | undefined>, effect: () =
   )
 }
 
-const cost = (input: number, output = 0) => [
-  {
-    input: Money.USDPerMillionTokens.make(input),
-    output: Money.USDPerMillionTokens.make(output),
-    cache: {
-      read: Money.USDPerMillionTokens.zero,
-      write: Money.USDPerMillionTokens.zero,
-    },
-  },
-]
+const cost = (input: number, output = 0) => [{ input, output, cache: { read: 0, write: 0 } }]
 
 describe("OpencodePlugin", () => {
   it.effect("registers account and service account methods", () =>

packages/core/test/plugin/skill.test.ts

@@ -37,19 +37,17 @@ describe("SkillPlugin.Plugin", () => {
         Effect.provide(NodeFileSystem.layer),
       )
       const skills = yield* skill.list()
-      const report = skills.find((item) => item.id === "report")
+      const report = skills.find((item) => item.name === "report")
 
       expect(skills).toContainEqual(
         expect.objectContaining({
-          id: "opencode",
-          name: "OpenCode",
+          name: "opencode",
           description: expect.stringContaining("any question about OpenCode itself"),
         }),
       )
       expect(skills).toContainEqual(
         expect.objectContaining({
-          id: "report",
-          name: "Report",
+          name: "report",
           description: expect.stringContaining("opencode issue"),
         }),
       )

packages/core/test/plugin/websearch-fixture.ts

@@ -1,41 +0,0 @@
-import { Effect, Layer } from "effect"
-import { HttpClient, HttpClientResponse } from "effect/unstable/http"
-import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
-import { LayerNode } from "@opencode-ai/core/effect/layer-node"
-import { Credential } from "@opencode-ai/core/credential"
-import { EventV2 } from "@opencode-ai/core/event"
-import { Integration } from "@opencode-ai/core/integration"
-import { testEffect } from "../lib/effect"
-
-export interface WebSearchRequest {
-  readonly url: string
-  readonly headers: Record<string, string>
-  readonly body: unknown
-}
-
-export const requests: WebSearchRequest[] = []
-export const response = { body: "" }
-
-export function resetWebSearchFixture(body: string) {
-  requests.length = 0
-  response.body = body
-}
-
-const http = Layer.succeed(
-  HttpClient.HttpClient,
-  HttpClient.make((request) =>
-    Effect.sync(() => {
-      if (request.body._tag !== "Uint8Array") throw new Error(`Unexpected request body: ${request.body._tag}`)
-      requests.push({
-        url: request.url,
-        headers: request.headers,
-        body: JSON.parse(new TextDecoder().decode(request.body.body)),
-      })
-      return HttpClientResponse.fromWeb(request, new Response(response.body, { status: 200 }))
-    }),
-  ),
-)
-
-export const webSearchIntegrationTest = testEffect(
-  Layer.merge(AppNodeBuilder.build(LayerNode.group([Integration.node, Credential.node, EventV2.node])), http),
-)

packages/core/test/plugin/websearch.test.ts

@@ -1,158 +0,0 @@
-import { beforeEach, describe, expect } from "bun:test"
-import { Effect } from "effect"
-import { Credential } from "@opencode-ai/core/credential"
-import { Integration } from "@opencode-ai/core/integration"
-import { WebSearchExa } from "@opencode-ai/core/plugin/websearch/exa"
-import { WebSearchParallel } from "@opencode-ai/core/plugin/websearch/parallel"
-import { host, integrationHost } from "./host"
-import { requests, resetWebSearchFixture, webSearchIntegrationTest } from "./websearch-fixture"
-
-beforeEach(() => {
-  resetWebSearchFixture(
-    `event: message\ndata: ${JSON.stringify({
-      jsonrpc: "2.0",
-      id: 1,
-      result: { content: [{ type: "text", text: "search results", _meta: { searchTime: 123 } }] },
-    })}\n\n`,
-  )
-})
-
-const it = webSearchIntegrationTest
-
-describe("built-in web search integrations", () => {
-  it.effect("registers and disposes an atomic web search integration", () =>
-    Effect.gen(function* () {
-      const integrations = yield* Integration.Service
-      const registration = yield* integrationHost(integrations).register({
-        id: "test-websearch",
-        name: "Test Web Search",
-        methods: [{ type: "key", label: "API key" }],
-        websearch: {
-          connection: "required",
-          execute: (input) => Effect.succeed({ text: input.query }),
-        },
-      })
-
-      expect(yield* integrations.get(Integration.ID.make("test-websearch"))).toMatchObject({
-        name: "Test Web Search",
-        methods: [{ type: "key", label: "API key" }],
-        websearch: { connection: "required" },
-      })
-      yield* registration.dispose
-      expect(yield* integrations.get(Integration.ID.make("test-websearch"))).toBeUndefined()
-    }),
-  )
-
-  it.effect("registers Exa with its MCP schema", () =>
-    Effect.gen(function* () {
-      const integrations = yield* Integration.Service
-      yield* WebSearchExa.Plugin.effect(host({ integration: integrationHost(integrations) }))
-
-      const info = yield* integrations.get(Integration.ID.make("exa"))
-      expect(info).toMatchObject({
-        id: "exa",
-        name: "Exa",
-        methods: [{ type: "key" }, { type: "env", names: ["EXA_API_KEY"] }],
-        websearch: { connection: "optional" },
-      })
-      const provider = yield* integrations.websearch.get(Integration.ID.make("exa"))
-      if (!provider) return yield* Effect.die("Expected Exa web search provider")
-      expect(
-        yield* provider.execute(
-          { query: "effect typescript" },
-          { credential: Credential.Key.make({ type: "key", key: "exa secret" }) },
-        ),
-      ).toEqual({ text: "search results", metadata: { searchTime: 123 } })
-      expect(requests).toEqual([
-        {
-          url: `${WebSearchExa.endpoint}?exaApiKey=exa+secret`,
-          headers: expect.any(Object),
-          body: {
-            jsonrpc: "2.0",
-            id: 1,
-            method: "tools/call",
-            params: {
-              name: "web_search_exa",
-              arguments: { query: "effect typescript", numResults: 8 },
-            },
-          },
-        },
-      ])
-    }),
-  )
-
-  it.effect("registers Parallel and keeps its credential in the authorization header", () =>
-    Effect.gen(function* () {
-      resetWebSearchFixture(
-        JSON.stringify({
-          jsonrpc: "2.0",
-          id: 1,
-          result: {
-            content: [{ type: "text", text: "search results" }],
-            structuredContent: {
-              search_id: "search_1",
-              results: [
-                {
-                  url: "https://effect.website",
-                  title: "Effect",
-                  publish_date: null,
-                  excerpts: ["Effect documentation"],
-                },
-              ],
-              warnings: null,
-              usage: [{ name: "sku_search", count: 1 }],
-              session_id: "ses_parallel",
-            },
-          },
-        }),
-      )
-      const integrations = yield* Integration.Service
-      yield* WebSearchParallel.Plugin.effect(host({ integration: integrationHost(integrations) }))
-      const provider = yield* integrations.websearch.get(Integration.ID.make("parallel"))
-      if (!provider) return yield* Effect.die("Expected Parallel web search provider")
-
-      const output = yield* provider.execute(
-        { query: "effect layers" },
-        {
-          sessionID: "ses_parallel",
-          credential: Credential.Key.make({ type: "key", key: "parallel-secret" }),
-        },
-      )
-      expect(output).toEqual({
-        text: "search results",
-        metadata: {
-          search_id: "search_1",
-          results: [
-            {
-              url: "https://effect.website",
-              title: "Effect",
-              publish_date: null,
-              excerpts: ["Effect documentation"],
-            },
-          ],
-          warnings: null,
-          usage: [{ name: "sku_search", count: 1 }],
-          session_id: "ses_parallel",
-        },
-      })
-      expect(requests[0]).toMatchObject({
-        url: WebSearchParallel.endpoint,
-        headers: { authorization: "Bearer parallel-secret" },
-        body: {
-          jsonrpc: "2.0",
-          id: 1,
-          method: "tools/call",
-          params: {
-            name: "web_search",
-            arguments: {
-              objective: "effect layers",
-              search_queries: ["effect layers"],
-              session_id: "ses_parallel",
-            },
-          },
-        },
-      })
-      expect(JSON.stringify(output)).not.toContain("parallel-secret")
-    }),
-  )
-})

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

@@ -15,7 +15,6 @@ import { AbsolutePath } from "@opencode-ai/core/schema"
 import { SessionV2 } from "@opencode-ai/core/session"
 import { SessionCompaction } from "@opencode-ai/core/session/compaction"
 import { SessionEvent } from "@opencode-ai/core/session/event"
-import { SessionInput } from "@opencode-ai/core/session/input"
 import { SessionMessage } from "@opencode-ai/core/session/message"
 import { Prompt } from "@opencode-ai/schema/prompt"
 import { SessionProjector } from "@opencode-ai/core/session/projector"
@@ -105,10 +104,13 @@ describe("SessionV2.compact", () => {
 
       expect(second.id).toBe(first.id)
       expect(requests).toHaveLength(0)
-      expect(yield* SessionInput.pendingCompaction((yield* Database.Service).db, created.id)).toMatchObject({
-        id: first.id,
+      expect((yield* session.context(created.id)).find((message) => message.id === first.id)).toMatchObject({
+        type: "compaction",
+        status: "queued",
+        reason: "manual",
+        summary: "",
+        recent: "",
       })
-      expect((yield* session.context(created.id)).find((message) => message.id === first.id)).toBeUndefined()
     }),
   )
 })

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

@@ -141,13 +141,7 @@ it.effect("manual compaction summarizes short context instead of no-op", () =>
       .subscribe(SessionEvent.Compaction.Delta)
       .pipe(Stream.take(1), Stream.runCollect, Effect.forkScoped)
     yield* Effect.yieldNow
-    expect(
-      yield* compaction.compactManual({
-        session,
-        messages: [userMessage],
-        inputID: SessionMessage.ID.make("msg_manual_compaction"),
-      }),
-    ).toBe(true)
+    expect(yield* compaction.compactManual({ session, messages: [userMessage] })).toBe(true)
     expect(Array.from(yield* Fiber.join(delta)).map((event) => event.data.text)).toEqual(["manual summary"])
 
     expect(requests).toHaveLength(1)

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

@@ -1,7 +1,6 @@
 import { describe, expect } from "bun:test"
 import path from "path"
 import { DateTime, Effect, Layer, Stream } from "effect"
-import { Money } from "@opencode-ai/schema/money"
 import { AgentV2 } from "@opencode-ai/core/agent"
 import { asc, eq } from "drizzle-orm"
 import { Database } from "@opencode-ai/core/database/database"
@@ -211,7 +210,7 @@ describe("SessionV2.create", () => {
       expect(forked.parentID).toBeUndefined()
       expect(forkContext).toMatchObject([
         { type: "user", text: "First" },
-        { type: "synthetic", text: "parent note" },
+        { type: "synthetic", text: "parent note", sessionID: forked.id },
       ])
       expect(forkContext.map((message) => message.id)).not.toEqual(parentContext.map((message) => message.id))
       expect(history).toHaveLength(1)
@@ -274,14 +273,14 @@ describe("SessionV2.create", () => {
       yield* events.publish(SessionEvent.Step.Started, {
         sessionID: parent.id,
         assistantMessageID,
-        agent: AgentV2.ID.make("build"),
+        agent: "build",
         model,
       })
       yield* events.publish(SessionEvent.Step.Ended, {
         sessionID: parent.id,
         assistantMessageID,
         finish: "stop",
-        cost: Money.USD.make(0.75),
+        cost: 0.75,
         tokens: { input: 6, output: 3, reasoning: 1, cache: { read: 2, write: 1 } },
       })
 
@@ -534,7 +533,7 @@ describe("SessionV2.create", () => {
 
         const messages = yield* session.messages({ sessionID: created.id, order: "asc" })
         const shell = messages.find((message): message is SessionMessage.Shell => message.type === "shell")
-        expect(shell).toMatchObject({ type: "shell", command: "echo hello", status: "exited", exit: 0 })
+        expect(shell).toMatchObject({ type: "shell", shell: { command: "echo hello", status: "exited", exit: 0 } })
         expect(shell?.output?.output).toContain("hello")
         expect(shell?.output?.truncated).toBe(false)
         expect(shell?.time.completed).toBeDefined()
@@ -554,8 +553,8 @@ describe("SessionV2.create", () => {
 
         const messages = yield* session.messages({ sessionID: created.id, order: "asc" })
         const shell = messages.find((message): message is SessionMessage.Shell => message.type === "shell")
-        expect(shell).toMatchObject({ type: "shell", command: "false", status: "exited" })
-        expect(shell?.exit).not.toBe(0)
+        expect(shell).toMatchObject({ type: "shell", shell: { command: "false", status: "exited" } })
+        expect(shell?.shell.exit).not.toBe(0)
         expect(shell?.time.completed).toBeDefined()
       }),
     ),
@@ -566,7 +565,7 @@ describe("SessionV2.create", () => {
       const session = yield* SessionV2.Service
       const created = yield* session.create({ location })
 
-      yield* session.switchAgent({ sessionID: created.id, agent: AgentV2.ID.make("plan") })
+      yield* session.switchAgent({ sessionID: created.id, agent: "plan" })
 
       expect(yield* session.get(created.id)).toMatchObject({ agent: "plan" })
       expect(
@@ -581,7 +580,7 @@ describe("SessionV2.create", () => {
       const missing = SessionV2.ID.make("ses_missing_agent_switch")
 
       expect(
-        yield* session.switchAgent({ sessionID: missing, agent: AgentV2.ID.make("plan") }).pipe(
+        yield* session.switchAgent({ sessionID: missing, agent: "plan" }).pipe(
           Effect.flip,
           Effect.map((error) => error._tag),
         ),

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

@@ -303,6 +303,7 @@ describe("SessionInstructions", () => {
     const synthetic = SessionMessage.Synthetic.make({
       id: SessionMessage.ID.make("msg_synthetic"),
       type: "synthetic",
+      sessionID: SessionV2.ID.make("ses_test"),
       text: "Instructions from: /repo/sub/AGENTS.md\ncontent",
       description: "Loaded /repo/sub/AGENTS.md",
       metadata: { instruction: { paths: ["/repo/sub/AGENTS.md"] } },